Uses of Class
orc.ast.simple.expression.Expression

Packages that use Expression

orc.ast.extended.declaration
orc.ast.extended.declaration.def
orc.ast.extended.declaration.type
orc.ast.extended.expression
orc.ast.extended.pattern
orc.ast.simple.expression

Uses of Expression in orc.ast.extended.declaration

Methods in orc.ast.extended.declaration that return Expression

Expression	SiteDeclaration.bindto(Expression target)
Expression	ValDeclaration.bindto(Expression target)
Expression	ClassDeclaration.bindto(Expression target)
Expression	DefsDeclaration.bindto(Expression target)
Expression	IncludeDeclaration.bindto(Expression target)
abstract Expression	Declaration.bindto(Expression target)

Methods in orc.ast.extended.declaration with parameters of type Expression

Expression	SiteDeclaration.bindto(Expression target)
Expression	ValDeclaration.bindto(Expression target)
Expression	ClassDeclaration.bindto(Expression target)
Expression	DefsDeclaration.bindto(Expression target)
Expression	IncludeDeclaration.bindto(Expression target)
abstract Expression	Declaration.bindto(Expression target)

Uses of Expression in orc.ast.extended.declaration.def

Methods in orc.ast.extended.declaration.def that return Expression

Expression

Clause.simplify(java.util.List<Variable> formals, Expression otherwise) Simplify a clause.

Methods in orc.ast.extended.declaration.def with parameters of type Expression

Expression

Clause.simplify(java.util.List<Variable> formals, Expression otherwise) Simplify a clause.

Uses of Expression in orc.ast.extended.declaration.type

Methods in orc.ast.extended.declaration.type that return Expression

Expression	TypeDeclaration.bindto(Expression target)
Expression	TypeAliasDeclaration.bindto(Expression target)
Expression	DatatypeDeclaration.bindto(Expression target)

Methods in orc.ast.extended.declaration.type with parameters of type Expression

Expression	TypeDeclaration.bindto(Expression target)
Expression	TypeAliasDeclaration.bindto(Expression target)
Expression	DatatypeDeclaration.bindto(Expression target)

Uses of Expression in orc.ast.extended.expression

Methods in orc.ast.extended.expression that return Expression

Expression	Expression.Arg.bind(Expression e) Wraps a binder around the given expression if needed.
Expression	ListExpr.simplify()
Expression	Lambda.simplify()
Expression	Atomic.simplify()
Expression	HasType.simplify()
Expression	Otherwise.simplify()
Expression	Throw.simplify()
Expression	NilExpr.simplify()
Expression	ConsExpr.simplify()
Expression	Stop.simplify()
Expression	Dot.simplify()
Expression	Pruning.simplify()
Expression	Isolated.simplify()
Expression	Sequential.simplify()
Expression	Name.simplify()
Expression	Let.simplify()
Expression	Parallel.simplify()
Expression	Declare.simplify()
Expression	Literal.simplify()
Expression	Field.simplify()
Expression	Call.simplify()
Expression	IfThenElse.simplify()
Expression	Catch.simplify()
abstract Expression	Expression.simplify() Simplify an expression which occurs in a call (non-nested) position.
Expression	AssertType.simplify()

Methods in orc.ast.extended.expression with parameters of type Expression

Expression

Expression.Arg.bind(Expression e) Wraps a binder around the given expression if needed.

Uses of Expression in orc.ast.extended.pattern

Fields in orc.ast.extended.pattern declared as Expression

Expression

Attachment.e

Methods in orc.ast.extended.pattern that return Expression

Expression	Attachment.attach(Expression f)
Expression	Attachment.attach(Expression f, Type t)
static Expression	Pattern.caseof(Variable arg, Variable s, Expression succ, Expression fail) Constructs an optional case statement.
static Expression	Pattern.compare(Argument s, Argument t) Construct an expression comparing two arguments.
static Expression	Pattern.fail() Return a default expression to use in case a pattern match fails.
Expression	PatternSimplifier.filter()
static Expression	Pattern.lift(Variable x) Lifts a partial function to a total function, using the ; combinator to detect a refusal to respond, and publishing optional values instead of values.
static Expression	Pattern.nth(Argument s, int i) Construct an expression which publishes the ith element of tuple s.
Expression	PatternSimplifier.target(Variable u, Expression g)
static Expression	Pattern.trycons(Argument s) Constructs an expression which will try to deconstruct an argument as if it were a list.
static Expression	Pattern.trynil(Argument s) Constructs an expression which tests whether the argument s can be treated as an empty list (nil).
static Expression	Pattern.trysize(Argument s, int n) Construct an expression to determine whether the argument s may be viewed as a tuple of size n.
static Expression	Pattern.unapply(Argument m, Argument s) Construct an expression which tries to find the inverse of the site m, and apply it to s.

Methods in orc.ast.extended.pattern with parameters of type Expression

void	PatternSimplifier.assign(Variable s, Expression e)
Expression	Attachment.attach(Expression f)
Expression	Attachment.attach(Expression f, Type t)
static Expression	Pattern.caseof(Variable arg, Variable s, Expression succ, Expression fail) Constructs an optional case statement.
Expression	PatternSimplifier.target(Variable u, Expression g)

Constructors in orc.ast.extended.pattern with parameters of type Expression

Attachment(Variable v, Expression e)

Uses of Expression in orc.ast.simple.expression

Subclasses of Expression in orc.ast.simple.expression

class	Atomic
class	Call
class	Catch
class	DeclareDefs
class	DeclareType A syntactic type declaration.
class	HasType An expression with an ascribed syntactic type.
class	Isolated The "isolated" keyword.
class	Let
class	Otherwise
class	Parallel
class	Pruning
class	Sequential
class	Stop
class	Throw
class	WithLocation Annotate an expression with a source location.

Fields in orc.ast.simple.expression declared as Expression

Expression	HasType.body
Expression	DeclareType.body
Expression	DeclareDefs.body
Expression	Def.body

Methods in orc.ast.simple.expression that return Expression

Expression	Expression.subMap(java.util.Map<FreeVariable,? extends Argument> m) Perform a set of substitutions defined by a map.
Expression	Atomic.subst(Argument a, FreeVariable x)
Expression	HasType.subst(Argument a, FreeVariable x)
Expression	DeclareType.subst(Argument a, FreeVariable x)
Expression	Otherwise.subst(Argument a, FreeVariable x)
Expression	Throw.subst(Argument a, FreeVariable x)
Expression	Stop.subst(Argument a, FreeVariable x)
Expression	Pruning.subst(Argument a, FreeVariable x)
Expression	Isolated.subst(Argument a, FreeVariable x)
Expression	DeclareDefs.subst(Argument a, FreeVariable x)
Expression	Let.subst(Argument a, FreeVariable x)
Expression	Parallel.subst(Argument a, FreeVariable x)
Expression	WithLocation.subst(Argument a, FreeVariable x)
Expression	Call.subst(Argument a, FreeVariable x)
Expression	Catch.subst(Argument a, FreeVariable x)
abstract Expression	Expression.subst(Argument a, FreeVariable x) Performs the substitution [a/x], replacing occurrences of the free variable x with the new argument a (which could be any argument, including another variable).
Expression	Atomic.subst(Type T, FreeTypeVariable X)
Expression	HasType.subst(Type T, FreeTypeVariable X)
Expression	DeclareType.subst(Type T, FreeTypeVariable X)
Expression	Otherwise.subst(Type T, FreeTypeVariable X)
Expression	Throw.subst(Type T, FreeTypeVariable X)
Expression	Stop.subst(Type T, FreeTypeVariable X)
Expression	Pruning.subst(Type T, FreeTypeVariable X)
Expression	Isolated.subst(Type T, FreeTypeVariable X)
Expression	Sequential.subst(Type T, FreeTypeVariable X)
Expression	DeclareDefs.subst(Type T, FreeTypeVariable X)
Expression	Let.subst(Type T, FreeTypeVariable X)
Expression	Parallel.subst(Type T, FreeTypeVariable X)
Expression	WithLocation.subst(Type T, FreeTypeVariable X)
Expression	Call.subst(Type T, FreeTypeVariable X)
Expression	Catch.subst(Type T, FreeTypeVariable X)
abstract Expression	Expression.subst(Type T, FreeTypeVariable X) Performs the substitution [T/X], replacing occurrences of the free type variable X with the type T (which could be any type, including another variable).
Expression	Expression.subvar(TypeVariable U, FreeTypeVariable X) Performs the substitution [U/X], replacing occurrences of the free type variable X with the nameless type variable U.
Expression	Expression.subvar(Variable v, FreeVariable x) Performs the substitution [v/x], replacing occurrences of the free variable x with the nameless variable v.

Methods in orc.ast.simple.expression that return types with arguments of type Expression

static java.util.List<Expression>

Expression.substAll(java.util.List<Expression> es, Argument a, FreeVariable x) Convenience method, to apply a substitution to a list of expressions.

Method parameters in orc.ast.simple.expression with type arguments of type Expression

static java.util.List<Expression>	Expression.convertAll(java.util.List<Expression> es, Env<Variable> vars, Env<TypeVariable> typevars) Convenience method, to apply convert to a list of expressions.
static java.util.List<Expression>	Expression.substAll(java.util.List<Expression> es, Argument a, FreeVariable x) Convenience method, to apply a substitution to a list of expressions.

Constructors in orc.ast.simple.expression with parameters of type Expression

Atomic(Expression body)

Catch(Def handlerDef, Expression tryBlock)

DeclareDefs(java.util.List<Def> defs, Expression body)

DeclareType(Type type, TypeVariable name, Expression body)

Def(Variable name, java.util.List<Variable> formals, Expression body, java.util.List<TypeVariable> typeParams, java.util.List<Type> argTypes, Type resultType, SourceLocation location)
Note that the constructor takes a bound Var as a name parameter.

HasType(Expression body, Type type, boolean checkable)

Isolated(Expression body)

Otherwise(Expression left, Expression right)

Parallel(Expression left, Expression right)

Pruning(Expression left, Expression right, Variable v)

Sequential(Expression left, Expression right, Variable v)

Throw(Expression exception)

WithLocation(Expression expr, SourceLocation location)