Uses of Class
net.hydromatic.morel.ast.AstNode

Packages that use AstNode

Package	Description
net.hydromatic.morel	Standard ML interpreter, implemented in Java.
net.hydromatic.morel.ast	Abstract syntax tree.
net.hydromatic.morel.compile	Validates programs (represented as AstNode), deduces their type, and compiles them into code that can be evaluated.

Uses of AstNode in net.hydromatic.morel

Methods in net.hydromatic.morel with parameters of type AstNode

Modifier and Type	Method	Description
(package private) void	Main.SubShell.command(AstNode statement, Consumer<String> outLines)

Uses of AstNode in net.hydromatic.morel.ast

Subclasses of AstNode in net.hydromatic.morel.ast

Modifier and Type	Class	Description
static class	Ast.Aggregate	Call to an aggregate function in a compute clause.
static class	Ast.AnnotatedExp	Parse tree node of an expression annotated with a type.
static class	Ast.AnnotatedPat	Pattern that is a pattern annotated with a type.
static class	Ast.Apply	Application of a function to its argument.
static class	Ast.AsPat	Layered pattern.
static class	Ast.Case	Case expression.
static class	Ast.CompositeType	Not really a type, just a way for the parser to represent the type arguments to a type constructor.
static class	Ast.Compute	A compute step in a from expression.
static class	Ast.Con0Pat	Type constructor pattern with no argument.
static class	Ast.ConPat	Type constructor pattern with an argument.
static class	Ast.Current	Parse tree node of the "current" reference.
static class	Ast.DatatypeBind	Parse tree node of a datatype binding.
static class	Ast.DatatypeDecl	Parse tree node of a datatype declaration.
static class	Ast.Decl	Base class for declarations.
static class	Ast.Distinct	A distinct step in a from expression.
static class	Ast.Except	An except step in a from expression.
static class	Ast.Exists	Exists expression.
static class	Ast.Exp	Base class of expression ASTs.
static class	Ast.Fn	Lambda expression.
static class	Ast.Forall	Forall expression.
static class	Ast.From	From expression.
static class	Ast.FromStep	A step in a from expression - where, group or order.
static class	Ast.FunBind	One of the branches (separated by 'and') in a 'fun' function declaration.
static class	Ast.FunctionType	Function type.
static class	Ast.FunDecl	Parse tree node of a function declaration.
static class	Ast.FunMatch	One of the branches (separated by '|') in a 'fun' function declaration.
static class	Ast.Group	A group step in a from expression.
static class	Ast.Id	Parse tree node of an identifier.
static class	Ast.IdPat	Named pattern, the pattern analog of the Ast.Id expression.
static class	Ast.If	"If ... else" expression.
static class	Ast.InfixCall	Call to an infix operator.
static class	Ast.InfixPat	Pattern build from an infix operator applied to two patterns.
static class	Ast.Intersect	An intersect step in a from expression.
static class	Ast.Into	An into step in a from expression.
static class	Ast.Let	"Let" expression.
static class	Ast.ListExp	List expression.
static class	Ast.ListPat	List pattern, the pattern analog of the Ast.ListExp expression.
static class	Ast.Literal	Parse tree node of a literal (constant).
static class	Ast.LiteralPat	Literal pattern, the pattern analog of the Ast.Literal expression.
static class	Ast.Match	Match.
static class	Ast.NamedType	Parse tree for a named type (e.g.
static class	Ast.Order	An order step in a from expression.
static class	Ast.Ordinal	Parse tree node of the "ordinal" reference.
static class	Ast.OverDecl	Parse tree node of an overload declaration.
static class	Ast.Pat	Base class for a pattern.
static class	Ast.PrefixCall	Call to a prefix operator.
static class	Ast.Query	Base class for "from", "exists" or "forall" expression.
static class	Ast.Record	Record.
static class	Ast.RecordPat	Record pattern.
static class	Ast.RecordSelector	Parse tree node of a record selector.
static class	Ast.RecordType	Parse tree node of a record type.
static class	Ast.Require	A require step in a forall expression.
static class	Ast.Scan	A scan (e.g.
static class	Ast.SetStep	Base class for a step that is a set operation (union, intersect, except).
static class	Ast.Skip	A skip step in a from expression.
static class	Ast.Take	A take step in a from expression.
static class	Ast.Through	An through step in a from expression.
static class	Ast.Tuple	Tuple.
static class	Ast.TuplePat	Tuple pattern, the pattern analog of the Ast.Tuple expression.
static class	Ast.TupleType	Tuple type.
static class	Ast.TyCon	Type constructor.
static class	Ast.Type	Base class for parse tree nodes that represent types.
static class	Ast.TyVar	Parse tree node of a type variable.
static class	Ast.Union	A union step in a from expression.
static class	Ast.Unorder	An unorder step in a from expression.
static class	Ast.ValBind	Value bind.
static class	Ast.ValDecl	Parse tree node of a value declaration.
static class	Ast.Where	A where step in a from expression.
static class	Ast.WildcardPat	Wildcard pattern.
static class	Ast.Yield	A yield step in a from expression.
static class	Core.Aggregate	Call to an aggregate function in a compute clause.
static class	Core.Apply	Application of a function to its argument.
static class	Core.AsPat	Layered pattern.
(package private) static class	Core.BaseNode	Abstract base class of Core nodes.
static class	Core.Case	Case expression.
static class	Core.Con0Pat	Type constructor pattern with no argument.
static class	Core.ConPat	Type constructor pattern with an argument.
static class	Core.DatatypeDecl	Datatype declaration.
static class	Core.Decl	Base class for declarations.
static class	Core.Except	An except clause in a from expression.
static class	Core.Exp	Base class of core expressions.
static class	Core.Fn	Lambda expression.
static class	Core.From	From expression.
static class	Core.FromStep	A step in a from expression - where, group or order.
static class	Core.Group	A group clause in a from expression.
static class	Core.Id	Reference to a variable.
static class	Core.IdPat	Named pattern.
static class	Core.Intersect	An intersect clause in a from expression.
static class	Core.Let	"Let" expression.
static class	Core.ListPat	List pattern.
static class	Core.Literal	Code of a literal (constant).
static class	Core.LiteralPat	Literal pattern, the pattern analog of the Core.Literal expression.
static class	Core.Local	"Local" expression.
static class	Core.Match	Match.
static class	Core.NamedPat	Base class for named patterns (Core.IdPat and Core.AsPat).
static class	Core.NonRecValDecl	Non-recursive value declaration.
static class	Core.Order	An order clause in a from expression.
static class	Core.OverDecl	Overloaded operator declaration.
static class	Core.Pat	Base class for a pattern.
static class	Core.RecordPat	Record pattern.
static class	Core.RecordSelector	Record selector function.
static class	Core.RecValDecl	Recursive value declaration.
static class	Core.Scan	A join or v in listExpr or v = expr clause in a from expression.
static class	Core.SetStep	Base class of Core.Except, Core.Intersect, Core.Union.
static class	Core.Skip	A skip clause in a from expression.
static class	Core.Take	A take clause in a from expression.
static class	Core.Tuple	Tuple expression.
static class	Core.TuplePat	Tuple pattern, the pattern analog of the Core.Tuple expression.
static class	Core.Union	A union clause in a from expression.
static class	Core.Unorder	Step that converts the stream to an unordered collection.
static class	Core.ValDecl	Abstract (recursive or non-recursive) value declaration.
static class	Core.Where	A where clause in a from expression.
static class	Core.WildcardPat	Wildcard pattern.
static class	Core.Yield	Step that computes an expression.

Methods in net.hydromatic.morel.ast with type parameters of type AstNode

Modifier and Type	Method	Description
protected <E extends AstNode> void	Visitor.accept(E e)	For use as a method reference.
protected <E extends AstNode> List<E>	Shuttle.visitList(List<E> nodes)
protected <K, E extends AstNode> Map<K,E>	Shuttle.visitMap(Map<K,E> nodes)
protected <K, E extends AstNode> SortedMap<K,E>	Shuttle.visitSortedMap(SortedMap<K,E> nodes)

Methods in net.hydromatic.morel.ast that return AstNode

Modifier and Type	Method	Description
AstNode	Ast.Aggregate.accept(Shuttle shuttle)
AstNode	Ast.Compute.accept(Shuttle shuttle)
AstNode	Ast.Distinct.accept(Shuttle shuttle)
AstNode	Ast.Except.accept(Shuttle shuttle)
AstNode	Ast.Group.accept(Shuttle shuttle)
AstNode	Ast.Intersect.accept(Shuttle shuttle)
AstNode	Ast.Into.accept(Shuttle shuttle)
AstNode	Ast.Order.accept(Shuttle shuttle)
AstNode	Ast.Require.accept(Shuttle shuttle)
AstNode	Ast.Skip.accept(Shuttle shuttle)
AstNode	Ast.Take.accept(Shuttle shuttle)
AstNode	Ast.Through.accept(Shuttle shuttle)
AstNode	Ast.TyCon.accept(Shuttle shuttle)
AstNode	Ast.Union.accept(Shuttle shuttle)
AstNode	Ast.Unorder.accept(Shuttle shuttle)
AstNode	Ast.ValBind.accept(Shuttle shuttle)
AstNode	Ast.Where.accept(Shuttle shuttle)
AstNode	Ast.Yield.accept(Shuttle shuttle)
abstract AstNode	AstNode.accept(Shuttle shuttle)	Accepts a shuttle, calling the Shuttle.visit(net.hydromatic.morel.ast.Ast.Literal) method appropriate to the type of this node, and returning the result.
AstNode	Core.BaseNode.accept(Shuttle shuttle)
protected AstNode	Shuttle.visit(Ast.Aggregate aggregate)
protected AstNode	Shuttle.visit(Ast.Compute compute)
protected AstNode	Shuttle.visit(Ast.Distinct distinct)
protected AstNode	Shuttle.visit(Ast.Except except)
protected AstNode	Shuttle.visit(Ast.Group group)
protected AstNode	Shuttle.visit(Ast.Intersect intersect)
protected AstNode	Shuttle.visit(Ast.Into into)
protected AstNode	Shuttle.visit(Ast.Order order)
protected AstNode	Shuttle.visit(Ast.Require require)
protected AstNode	Shuttle.visit(Ast.Skip skip)
protected AstNode	Shuttle.visit(Ast.Take take)
protected AstNode	Shuttle.visit(Ast.Through through)
protected AstNode	Shuttle.visit(Ast.TyCon tyCon)
protected AstNode	Shuttle.visit(Ast.Union union)
protected AstNode	Shuttle.visit(Ast.Unorder unorder)
protected AstNode	Shuttle.visit(Ast.Where where)
protected AstNode	Shuttle.visit(Ast.Yield yield)

Methods in net.hydromatic.morel.ast with parameters of type AstNode

Modifier and Type	Method	Description
AstWriter	AstWriter.append(AstNode node, int left, int right)	Appends a parse tree node.
AstWriter	AstWriter.binary(String left, AstNode a0, String mid, AstNode a1, int right)	Appends a call to a binary operator (e.g.
AstWriter	AstWriter.binary(String left, AstNode a0, String mid, AstNode a1, String right)	Appends a call to a binary operator (e.g.
AstWriter	AstWriter.infix(int left, AstNode a0, Op op, AstNode a1, int right)	Appends a call to an infix operator.
AstWriter	AstWriter.prefix(int left, Op op, AstNode a, int right)	Appends a call to an prefix operator.

Method parameters in net.hydromatic.morel.ast with type arguments of type AstNode

Modifier and Type	Method	Description
AstWriter	AstWriter.appendAll(Iterable<? extends AstNode> nodes, int left, Op op, int right)	Appends a list of parse tree nodes.
AstWriter	AstWriter.appendAll(Iterable<? extends AstNode> list, String sep)	Appends a list of parse tree nodes separated by sep.
AstWriter	AstWriter.appendAll(Iterable<? extends AstNode> list, String start, String sep, String end)	Appends a list of parse tree nodes separated by sep, and also with prefix and suffix: start node0 sep node1 ... sep nodeN end.
AstWriter	AstWriter.appendAll(Iterable<? extends AstNode> list, String start, String sep, String end, String empty)	Appends a list of parse tree nodes separated by sep, and also with prefix and suffix: start node0 sep node1 ... sep nodeN end.
Pos	Pos.plusAll(@NonNull List<? extends AstNode> nodes)
static Pos	Pos.sum(List<? extends AstNode> nodes)

Uses of AstNode in net.hydromatic.morel.compile

Fields in net.hydromatic.morel.compile with type parameters of type AstNode

Modifier and Type	Field	Description
private final Map<AstNode,Unifier.Term>	TypeResolver.map
private final Map<AstNode,Unifier.Term>	TypeMap.nodeTypeTerms

Methods in net.hydromatic.morel.compile with type parameters of type AstNode

Modifier and Type	Method	Description
private <E extends AstNode> E	TypeResolver.reg(E node, Unifier.Term term)	Registers that an AST node maps to a type term.
private <E extends AstNode> E	TypeResolver.reg(E node, Unifier.Variable variable, Unifier.Term term)	Registers that an AST node maps to a type term and is equivalent to a variable.

Methods in net.hydromatic.morel.compile that return AstNode

Modifier and Type	Method	Description
private AstNode	TypeResolver.deduceValBindType(TypeResolver.TypeEnv env, Ast.ValBind valBind, PairList<Ast.IdPat,Unifier.Term> termMap, Unifier.Variable vPat)

Methods in net.hydromatic.morel.compile with parameters of type AstNode

Modifier and Type	Method	Description
static Analyzer.Analysis	Analyzer.analyze(TypeSystem typeSystem, Environment env, AstNode node)	Analyzes an expression.
private Set<String>	CalciteCompiler.getRelationalVariables(Environment env, Set<String> nameSet, AstNode node)
Type	TypeMap.getType(AstNode node)	Returns an AST node's data type.
@Nullable Type	TypeMap.getTypeOpt(AstNode node)	Returns an AST node's data type, or null if no type is known.
boolean	TypeMap.hasType(AstNode node)	Returns whether an AST node has a type.
static Function<String,RuntimeException>	TypeResolver.TypeEnv.onlyValidInQuery(AstNode node)	Exception factory where a missing symbol is because we are not in a query.
static Function<String,RuntimeException>	TypeResolver.TypeEnv.oops(AstNode node)	Exception factory where a missing symbol is an internal error.
static CompiledStatement	Compiles.prepareStatement(TypeSystem typeSystem, Session session, Environment env, AstNode statement, @Nullable Calcite calcite, Consumer<CompileException> warningConsumer, Tracer tracer)	Validates and compiles a statement (expression or declaration), and compiles it to code that can be evaluated by the interpreter.
static Ast.Decl	Compiles.toDecl(AstNode statement)	Converts an expression or declaration to a declaration.
static Ast.ValDecl	Compiles.toValDecl(AstNode statement)	Converts an expression or value declaration to a value declaration.
(package private) @Nullable SortedSet<String>	TypeMap.typeFieldNames(AstNode node)	Returns the field names if an AST node has a type that is a record or a tuple, otherwise null.
boolean	TypeMap.typeIsVariable(AstNode node)	Returns whether an AST node's type will be a type variable.
static TypeResolver.Resolved	Compiles.validateExpression(AstNode statement, Map<Prop,Object> propMap, Map<String,ForeignValue> valueMap, Consumer<CompileException> warningConsumer)	Validates an expression or declaration, deducing its type and perhaps rewriting the expression to a form that can more easily be compiled.

Constructor parameters in net.hydromatic.morel.compile with type arguments of type AstNode

Modifier	Constructor	Description
(package private)	TypeMap(TypeSystem typeSystem, Map<AstNode,Unifier.Term> nodeTypeTerms, Unifier.Substitution substitution)