Creates and returns an orphan block with array being its tape substrate's container. See Tape.for.

Double-form optimized version of Block.with.

Single-form optimized version of Block.with.

Loose equality: for two blocks to be loosely equal, their tapes and their dictionaries must be loosely equal.

Supports recursive (reflection) equality, e.g.:

[ ] $: a
a a shove
a first a = "=> true"

Converts this block into the given type. Code execution may be required, hence the need for engine. If failed, same as Form#a.

Adds form to the tape.

Returns a block of forms between b and e, both inclusive. Clamps b and e to bounds.

Binds name to entry in this block's dictionary.

Binds name to form in this block's dictionary.

Returns the form at index in the tape. Dies if index is out of bounds. See Tape#at?.

Makes an OpenEntry called name for code wrapped in Builtin.

Makes an OpenEntry called name for code wrapped in Builtin.

Returns the form at index, or nil.

Adds other to the friendlist of this block.

Returns whether this block implements hook(s) needed for behaving like type. See also: a(type).

Removes all owned dictionary entries in this block.

Returns the amount of forms in this block.

Returns the cursor position in this block.

Deletes the form at index. Does nothing if index is out of bounds.

Deletes the entry corresponding to name form from the dictionary of this block if it exists there. Otherwise, does nothing.

Yields forms from left to right until the block returns true for one, then deletes that form. If the block does not return true for any form, does nothing.

Appends a string description of this form to io.

Sets the block comment of this block to comment in case it doesn't have a comment already.

Setting the comment can also be forced by making force true.

Removes and returns the top form. Dies if none.

Duplicates the form before the cursor, dies if none.

Yields all forms in this block, going from left to right.

Yields entry names and Entry objects from the dictionary of this block.

Yields entry name forms in this block's dictionary.

Yields entry value forms in this block's dictionary.

Yields friends of this block. Asserts each is a block, otherwise, dies (e.g. the user may have mistakenly added some other form).

Explores neighbor blocks of this block, calls payload with each such neighbor block. Records all neighbors it visited in visited.

Explicitly nested (marked as ExN1-2 in the diagram below) neighbor blocks are blocks found in the dictionary and tape of this block (marked as B in the diagram below).

Implicitly nested (marked as ImN1-4 in the diagram below) neighbor blocks are blocks in the tapes and dictionaries of explicitly nested neighbor blocks, and so on, recursively.

┌───────────────────────────────────────┐
│ B                                     │
│  ┌───────────────┐ ┌───────────────┐  │
│  │ ExN1          │ │ ExN2          │  │
│  │ ┌────┐ ┌────┐ │ │ ┌────┐ ┌────┐ │  │
│  │ │ImN1│ │ImN2│ │ │ │ImN3│ │ImN4│ │  │
│  │ └────┘ └────┘ │ │ └────┘ └────┘ │  │
│  │    ...    ... │ │    ...    ... │  │
│  └───────────────┘ └───────────────┘  │
│                                       │
└───────────────────────────────────────┘

Explores neighbor blocks of this block, calls payload with each such neighbor block. Records all neighbors it visited in visited.

Explicitly nested (marked as ExN1-2 in the diagram below) neighbor blocks are blocks found in the dictionary and tape of this block (marked as B in the diagram below).

Implicitly nested (marked as ImN1-4 in the diagram below) neighbor blocks are blocks in the tapes and dictionaries of explicitly nested neighbor blocks, and so on, recursively.

┌───────────────────────────────────────┐
│ B                                     │
│  ┌───────────────┐ ┌───────────────┐  │
│  │ ExN1          │ │ ExN2          │  │
│  │ ┌────┐ ┌────┐ │ │ ┌────┐ ┌────┐ │  │
│  │ │ImN1│ │ImN2│ │ │ │ImN3│ │ImN4│ │  │
│  │ └────┘ └────┘ │ │ └────┘ └────┘ │  │
│  │    ...    ... │ │    ...    ... │  │
│  └───────────────┘ └───────────────┘  │
│                                       │
└───────────────────────────────────────┘

Yields occurrences of the given pattern found in this block. Matching is done using loose equality #==(other).

Explores this block's relatives, i.e., its vertical (parent) and horizontal (friend) hierarchy, calls fetcher on each relative. This process is also known as the exploration of the block graph, where this block is the origin of exploration.

If fetcher returns a value of type T (a non-nil) for the given block, exploration terminates. If fetcher returns nil, exploration continues.

The order of exploration is roughly as follows:

• The first echelon is explored: the parents, friends, and friends of parents of this block are explored.

• The second echelon is explored: the parents, friends, and friends of parents of the blocks in first echelon are explored by recursing on each, effectively allowing lookup that is unlimited in terms of depth.

seen can be used to disable exploration of specific blocks, also blocking off the exploration of their relatives (if they were not otherwise reached already).

skip_self can be set to true to disable calling fetcher for this block. Note that if this block is reached by other means (e.g. as in self -- other -- self), fetcher is still going to be called.

history, a block, can optionally be provided. It will hold all explored blocks leading to the "discovery" of T.

Explores this block's relatives, i.e., its vertical (parent) and horizontal (friend) hierarchy, calls fetcher on each relative. This process is also known as the exploration of the block graph, where this block is the origin of exploration.

If fetcher returns a value of type T (a non-nil) for the given block, exploration terminates. If fetcher returns nil, exploration continues.

The order of exploration is roughly as follows:

• The first echelon is explored: the parents, friends, and friends of parents of this block are explored.

• The second echelon is explored: the parents, friends, and friends of parents of the blocks in first echelon are explored by recursing on each, effectively allowing lookup that is unlimited in terms of depth.

seen can be used to disable exploration of specific blocks, also blocking off the exploration of their relatives (if they were not otherwise reached already).

skip_self can be set to true to disable calling fetcher for this block. Note that if this block is reached by other means (e.g. as in self -- other -- self), fetcher is still going to be called.

history, a block, can optionally be provided. It will hold all explored blocks leading to the "discovery" of T.

Generates and returns a description for the stack effect of this form.

For blocks and builtins, tries to extract a ( ... -- ... ) (but see EFFECT_PATTERN) from their corresponding comment. If could not extract or no comment, returns 'a block' for blocks and 'native code' for builtins.

Drops and returns the form after the cursor. Dies if cursor is at the end.

Returns the amount of entries owned by (defined in) this block.

Returns the dictionary entry for name, or dies.

See each_relative for a detailed description of lookup order etc.

Returns the dictionary entry for name, or nil.

See each_relative for a detailed description of lookup order etc.

Returns the dictionary entry corresponding to name. Does not traverse the block hierarchy.

Returns whether this block's (and this block's only) dictionary has an entry corresponding to name.

Returns the value form for an entry with the given name, or nil if no such entry exists.

Returns whether this block has a comment.

Returns whether this block has a dict.

Returns whether this store has an entry with the given name.

Returns whether this block has any friends.

Returns whether this block has a parent, friends, or both.

Returns whether this block has a tape.

Imports entries from donor to this block's dictionary by mutating this block's dictionary.

Returns whether the tape of this block includes other, as per loose equality #==(other).

Adds form after the cursor.

Creates and returns an instance of this block, under the given parent.

See Tape#next?.

Schedules this block for execution in engine using the safe scheduling method (see Engine#schedule). Optionally, a stack block may be provided (otherwise, the engine's current stack is used).

Returns whether name opens its value form, as defined in this store. Dies if name is not defined in this store.

Holds a reference to the parent block (them all in a linked list of ancestors).

Holds a reference to the parent block (them all in a linked list of ancestors).

Holds a reference to the parent block (them all in a linked list of ancestors).

Mutably adds forms before the cursor in forms block's tape after the cursor in this block's tape.

Returns a tuple that consists of the dictionary entry corresponding to name, followed by the path block which holds all blocks leading to the entry.

Returns nil if name could not be found.

In general works like #entry_for and friends, the only difference being that it also tracks and returns the path. The latter makes this method slightly slower that #entry_for.

Returns the prototype of this block. Block instances return their prototype (AST) blocks, AST blocks return themselves.

Returns the prototype of this block. Block instances return their prototype (AST) blocks, AST blocks return themselves.

Returns the prototype of this block. Block instances return their prototype (AST) blocks, AST blocks return themselves.

Returns whether name pushes its value form, as defined in this store. Dies if name is not defined in this store.

Replaces this block's tape with other's.

Yields all forms in this block, going from right to left.

Schedules an instance of this block for execution, with stack set as the stack that will be used by the instance during execution.

Moves the cursor of the instance before the first form so that the entire block will be executed by engine.

Schedules this block for execution, with stack set as the stack that will be used by this block during execution.

Moves the cursor before the first form so that the entire block will be executed by engine.

Returns a shallow copy of this block.

Slices this block at cursor. This results in two halves, which are consequently returned.

Parses all forms in string source, and adds them to this block.

Sorts this block's tape inplace, calls cmp comparator proc for each form pair for a comparison integer -1, 0, or 1.

Appends a string representation of this block to io in which only forms in the negative and positive vicinity of this block's cursor are present, and the word before the cursor is emphasized.

Does not respect MAX_COUNT_TO_S. Does not display quotes. Does not display nested blocks.

Submits value form to an entry with the given name. Returns nil if no such entry exists.

Swaps two forms before the cursor, dies if none.

Returns form after cursor, and moves cursor past it.

Similar to #eject, but doesn't modify the block.

Moves tape cursor to index. Dies if index is out of bounds. See Tape#to?.

Builds and returns a dictionary block for this block.

Dictionary block is an orphan block whose dictionary is a shallow copy of this block's dictionary; and whose tape is empty.

Returns this form's quote representation.

Builds and returns a tape block for this block.

Tape block is an orphan block whose tape is a shallow copy of this block's tape; and whose dictionary is empty.

Returns the top form, dies if none.

Returns the top form, or nil if none.

Removes other from the friendlist of this block.