Uses of Class
orc.ast.simple.argument.Variable

Packages that use Variable

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

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

Fields in orc.ast.extended.declaration.def declared as Variable

protected Variable

AggregateDef.var

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

Variable

AggregateDef.getVar()

Method parameters in orc.ast.extended.declaration.def with type arguments of type Variable

Expression

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

Uses of Variable in orc.ast.extended.expression

Fields in orc.ast.extended.expression declared as Variable

Variable

Temporary.v

Constructors in orc.ast.extended.expression with parameters of type Variable

Temporary(Variable v)

Uses of Variable in orc.ast.extended.pattern

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

Variable

Attachment.v

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

void	PatternSimplifier.ascribe(Variable s, Type t)
void	PatternSimplifier.assign(Variable s, Expression e)
static Expression	Pattern.caseof(Variable arg, Variable s, Expression succ, Expression fail) Constructs an optional case statement.
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.
PatternSimplifier	Pattern.process(Variable fragment) A different entry point for process, taking only a source variable.
void	WildcardPattern.process(Variable fragment, PatternSimplifier visitor)
void	VariablePattern.process(Variable fragment, PatternSimplifier visitor)
void	TypedPattern.process(Variable fragment, PatternSimplifier visitor)
void	TuplePattern.process(Variable fragment, PatternSimplifier visitor)
abstract void	Pattern.process(Variable fragment, PatternSimplifier visitor) Visit a pattern recursively, creating two products: An expression that will examine a value to determine whether it matches a pattern, building an output tuple of all value fragments which will be bound to variables.
void	NilPattern.process(Variable fragment, PatternSimplifier visitor)
void	LiteralPattern.process(Variable fragment, PatternSimplifier visitor)
void	ListPattern.process(Variable fragment, PatternSimplifier visitor)
void	EqPattern.process(Variable fragment, PatternSimplifier visitor)
void	ConsPattern.process(Variable fragment, PatternSimplifier visitor)
void	CallPattern.process(Variable fragment, PatternSimplifier visitor)
void	AsPattern.process(Variable fragment, PatternSimplifier visitor)
void	PatternSimplifier.require(Variable s)
void	PatternSimplifier.subst(Variable s, FreeVariable x)
Expression	PatternSimplifier.target(Variable u, Expression g)

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

Attachment(Variable v, Expression e)

Uses of Variable in orc.ast.simple.argument

Method parameters in orc.ast.simple.argument with type arguments of type Variable

void	Variable.addFree(java.util.Set<Variable> freeset)
void	Argument.addFree(java.util.Set<Variable> freeset)
Argument	Variable.convert(Env<Variable> vars)
Argument	Site.convert(Env<Variable> vars)
Argument	FreeVariable.convert(Env<Variable> vars)
Argument	Field.convert(Env<Variable> vars)
Argument	Constant.convert(Env<Variable> vars)
abstract Argument	Argument.convert(Env<Variable> vars) Convert to DeBruijn index.
static java.util.List<Argument>	Argument.convertAll(java.util.List<Argument> as, Env<Variable> vars)

Uses of Variable in orc.ast.simple.expression

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

Variable

Def.name

Fields in orc.ast.simple.expression with type parameters of type Variable

java.util.List<Variable>

Def.formals

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

java.util.Set<Variable>	WithLocation.vars()
java.util.Set<Variable>	Throw.vars()
java.util.Set<Variable>	Stop.vars()
java.util.Set<Variable>	Sequential.vars()
java.util.Set<Variable>	Pruning.vars()
java.util.Set<Variable>	Parallel.vars()
java.util.Set<Variable>	Otherwise.vars()
java.util.Set<Variable>	Let.vars()
java.util.Set<Variable>	HasType.vars()
abstract java.util.Set<Variable>	Expression.vars() Find the set of all Variables (note: not FreeVariables) that are not bound within this expression.
java.util.Set<Variable>	Def.vars()
java.util.Set<Variable>	DeclareType.vars()
java.util.Set<Variable>	DeclareDefs.vars()
java.util.Set<Variable>	Catch.vars()
java.util.Set<Variable>	Call.vars()

Methods in orc.ast.simple.expression with parameters of type Variable

Expression

Expression.subvar(Variable v, FreeVariable x) Performs the substitution [v/x], replacing occurrences of the free variable x with the nameless variable v.

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

Expression	WithLocation.convert(Env<Variable> vars, Env<TypeVariable> typevars)
Expression	Throw.convert(Env<Variable> vars, Env<TypeVariable> typevars)
Expression	Stop.convert(Env<Variable> vars, Env<TypeVariable> typevars)
Expression	Sequential.convert(Env<Variable> vars, Env<TypeVariable> typevars)
Expression	Pruning.convert(Env<Variable> vars, Env<TypeVariable> typevars)
Expression	Parallel.convert(Env<Variable> vars, Env<TypeVariable> typevars)
Expression	Otherwise.convert(Env<Variable> vars, Env<TypeVariable> typevars)
Expression	Let.convert(Env<Variable> vars, Env<TypeVariable> typevars)
Expression	HasType.convert(Env<Variable> vars, Env<TypeVariable> typevars)
abstract Expression	Expression.convert(Env<Variable> vars, Env<TypeVariable> typevars) Converts abstract syntax tree into a serializable form, used to generate portable .oil (Orc Intermediate Language) files.
Def	Def.convert(Env<Variable> vars, Env<TypeVariable> typevars)
Expression	DeclareType.convert(Env<Variable> vars, Env<TypeVariable> typevars)
Expression	DeclareDefs.convert(Env<Variable> vars, Env<TypeVariable> typevars)
Expression	Catch.convert(Env<Variable> vars, Env<TypeVariable> typevars)
Expression	Call.convert(Env<Variable> vars, Env<TypeVariable> typevars)
static java.util.List<Def>	Def.convertAll(java.util.List<Def> ds, Env<Variable> vars, Env<TypeVariable> typevars) Convenience method, to apply convert to a list of defs.
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.

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

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.

Pruning(Expression left, Expression right, Variable v)

Sequential(Expression left, Expression right, Variable v)

Constructor parameters in orc.ast.simple.expression with type arguments of type Variable

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.