Stack -package:gi-gtk
Access to GHC's call-stack simulation
Utilities and wrappers for Stack manipulation in JS Land.
In general, functions suffixed with a tick do the actual work,
functions suffixed with an
I are identical to the non-I
versions but work on
Idents
The stack in JS land is held in the special JS array 'h$stack' and the
stack pointer is held in 'h$sp'. The top of the stack thus exists at
'h$stack[h$sp]'. h$stack[h$sp + i] where i > 0, moves deeper into
the stack into older entries, whereas h$stack[h$sp - i] moves towards
the top of the stack.
The stack layout algorithm is slightly peculiar. It makes an effort to
remember recently popped things so that if these values need to be
pushed then they can be quickly. The implementation for this is
storing these values above the stack pointer, and the pushing will
skip slots that we know we will use and fill in slots marked as
unknown. Thus, you may find that our push and pop functions do some
non-traditional stack manipulation such as adding slots in pop or
removing slots in push.
A widget which controls the alignment and size of its child
This is a simple process type that knows how to push back input.
A stack is a cursor onto a window list. The data structure tracks
focus by construction, and the master window is by convention the
top-most item. Focus operations will not reorder the list that results
from flattening the cursor. The structure can be envisaged as:
+-- master: < '7' >
up | [ '2' ]
+--------- [ '3' ]
focus: < '4' >
dn +----------- [ '8' ]
A
Stack can be viewed as a list with a hole punched in it to
make the focused position. Under the zipper/calculus view of such
structures, it is the differentiation of a [a], and integrating it
back has a natural implementation used in
index.
Access to GHC's call-stack simulation
Internal monad for the resolution algorithm
- we keep some state for the list of created values
- we collect the applied functions as Operations
- we might exit with a Left value if we can't build a value
Monadic stack for the resolution algorithm
Utility functions for manipulating Maybe Stacks.