Package-level declarations

Primitive: Declare method as abstract. This identifies responsibility for definitions that want to be concrete.

Primitive: Declare method as abstract. This identifies responsibility for definitions that want to be concrete.

Primitive: Add a type restriction function.

Primitive: Add a type restriction function.

Primitive: Alias a name to another name.

Primitive: Does the method have a unique definition for the specified tuple of parameter types?

Primitive: Answer whether precedence restrictions have been defined (yet) for this bundle.

Primitive: Answer a message bundle's message parts (a tuple of strings).

Primitive: Answer the number of arguments expected by the specified method.

Primitive: Answer the current precedence restrictions for this bundle.

Primitive: Answer a set of all currently defined definitions for the true message name represented by bundle. This includes abstract signatures and forward signatures.

Primitive: Copy all macros from the first A_Atom's A_Bundle into the second A_Atom's A_Bundle. Fail if the second bundle has an incompatible signature, or if there are duplicates with the same signature. Only copy the macros that are visible in the current module, or were defined by the system.

Primitive: Answer this definition's body's type.

Primitive: Lookup the unique definition in the specified message bundle's method by the tuple of parameter types.

Primitive: Answer a string describing why the given string is unsuitable as a message name. If the given string is actually suitable, answer the empty string.

Primitive: Does a method exist with the specified true name?

Primitive: Forward declare a method (for recursion or mutual recursion).

Primitive: Forward declare a method (for recursion or mutual recursion).

Primitive: Message precedence declaration with tuple of sets of messages to exclude for each argument position. Note that the tuple's elements should correspond with occurrences of underscore in the method names, not with the (top-level) arguments of the method. This distinction is only apparent when guillemet notation is used to accept tuples of arguments.

Primitive: Message precedence declaration with tuple of sets of messages to exclude for each argument position. Note that the tuple's elements should correspond with occurrences of underscore in the method names, not with the (top-level) arguments of the method. This distinction is only apparent when guillemet notation is used to accept tuples of arguments.

Primitive: Answer the true name associated with the given message bundle. This is generally only used when Avail code is saving or loading Avail code in the object dumper / loader.

Primitive: Define a concrete method implementation.

Primitive: Answer this method signature's body.

Primitive: Answer the definitions of the specified method.

Primitive: Answer the method associated with the given true name.

Primitive: Treating the argument as a method name, answer whether it contains groups.

Primitive: Treating the string argument as a method name, answer the number of arguments expected for a valid send of the name.

Primitive: Seal the named method at the specified signature. No further definitions may be added below this signature.

Primitive: Seal the named method at the specified signature. No further definitions may be added below this signature.

Primitive: Seal the named A_Method at each existing definition. Ignore macros and forward definitions.

Primitive: Answer all seals placed upon the specified method.

Primitive: Answer a tuple of restriction functions that would run for a call site for the specified method and tuple of argument types.

Primitive: Simple lexer definition. The first argument is the lexer name (an atom). The second argument is a (stable, pure) filter function which takes a character and answers true if the lexer should run when that character is encountered in the input, otherwise false. The third argument is the body function, which takes a character, the source string, and the current (one-based) index into it. It may invoke a primitive to accept zero or more lexings and/or a primitive to reject the lexing with a diagnostic message.

Primitive: Simple macro definition. The first argument is the macro name, and the second argument is a tuple of functions returning ⊤, one for each occurrence of a section sign (§) in the macro name. The third argument is the function to invoke for the complete macro. It is constrained to answer a method.

Primitive: Simple macro definition. The first argument is the macro name, and the second argument is a tuple of functions returning ⊤, one for each occurrence of a section sign (§) in the macro name. The third argument is the function to invoke for the complete macro. It is constrained to answer a phrase.

Primitive: Add a method definition, given a string for which to look up the corresponding atom in the current module and the function which will act as the body of the method definition. An optional (tuple of size 0 or 1) styling function can also be provided.

Primitive: This private primitive, which we will call the "restriction primitive", acts as the body of a semantic restriction that gets generated any time a method definition is added where the body function is some primitive that can be folded (which we'll call the "foldable primitive" to distinguish it from the restriction primitive). The signature of the semantic restriction body is arranged to accept subtypes of the argument types of the foldable primitive function – which are already constrained by the foldable primitive itself.