Force produces a strict version of v.

Modules returns the names of the available system modules.

NewSession creates and initializes a session, reading source bytes from the provided sourcer.

OpenBundleModule opens a bundle archive saved by Bundle.Write and parses it into a Module.

ParseAndRegisterModule is like RegisterModule, but parses module from reflow source.

RegisterModule is a hook to register custom reflow intrinsics.

Stdlib returns the type and value environments for reflow's standard library.

ComprEnum is the kind of an enumeration clause.

ComprFilter is the kind of a filter clause.

DeclAssign is an assignment declaration (rvalue expression).

DeclDeclare is a "pure" declaration (type only).

DeclError is an illegal declaration.

DeclType declares a type alias.

ExprApply is function application.

ExprAscribe is an ascription (static type assertion).

ExprBinop is a binary operation.

ExprBlock is a declaration-block.

ExprBuiltin is a builtin expression (e.g., len, zip, unzip).

ExprCompr is a comprehension expression.

ExprCond is a conditional expression.

ExprDeref is a struct derefence expression.

ExprError indicates an erroneous expression (e.g., through a parse error).

ExprExec is an exec expression.

ExprFunc is a function definition.

ExprIdent is an identifier reference.

ExprIndex is an indexing (map or list) expression.

ExprList is a list literal.

ExprLit is a literal value.

ExprMake is a module instantiation expression.

ExprMap is a map literal.

ExprRequires assigns resources to the underlying expression.

ExprStruct is a struct literal.

ExprSwitch is a switch expression.

ExprThunk is a delayed evaluation (expression + environment).

ExprTuple is a tuple literal.

ExprUnop is a unary operation.

ExprVariant is a variant construction expression.

MatchError is an erroneous matcher.

MatchList indexes a list.

MatchListTail indexes the tail of a list.

MatchStruct indexes a struct.

MatchTuple indexes a tuple.

MatchValue matches a value.

MatchVariant matches a variant or, if the variant has an element, indexes the element.

ModeDefault functions are passed arguments that have been evaluated.

ModeDirect functions are passed arguments that have not been evaluated (i.e.

ModeForced functions are passed arguments that have been evaluated and forced.

ParseDecls parses a set of declarations.

ParseExpr parses an expression.

ParseModule parses a module.

ParsePat parses a pattern.

ParseType parses a type.

PatError is an erroneous pattern (e.g., uninitialized or parse error).

PatIdent is an identifier pattern.

PatIgnore is an ignore pattern.

PatList is a list pattern.

PatStruct is a struct pattern.

PatTuple is a tuple pattern.

PatVariant is a variant pattern.

Filesystem is a Sourcer that reads from the local file system.

Bundle represents a self-contained Reflow module.

CaseClause is a single case within a switch expression.

A ComprClause is a single clause in a comprehension expression.

A Decl is a Reflow declaration.

An Expr is a node in Reflow's expression AST.

FieldExpr stores a field name and expression.

A Matcher binds individual pattern components (identifiers) in a pattern.

ModuleImpl defines a Reflow module comprising: a keyspace, a set of parameters, and a set of declarations.

Param holds module parameter metadata.

Parser is a Reflow lexer.

A Pat stores a pattern tree used in destructuring operations.

A PatField stores a field entry in a pattern.

A Session is a compiler session.

SystemFunc is a utility to define a reflow intrinsic.

Template is an exec template and its interpolation arguments.

Module abstracts a Reflow module, having the ability to type check parameters, inspect its type, and mint new instances.

Sourcer is an interface that provides access to Reflow source files.

ComprKind is the type of the kind of a comprehension clause.

DeclKind is the type of declaration.

ExprKind is the kind of an expression.

FuncMode represents the behavior mode for SystemFuncs.

MatchKind is the kind of match performed by a Matcher.

ParserMode determines the lexer's entry behavior.

Path represents a path to a value.

PatKind is the kind of pattern.