org.erights.e.elang.syntax
Interface EBuilder

All Superinterfaces:
BaseEBuilder
All Known Implementing Classes:
ENodeBuilder

public interface EBuilder
extends BaseEBuilder

Untamed:


Method Summary
 Object[] accumBody(Object verb, Object rnValue)
          Enabled: Actually does the accumulation into the temporary accumulation variable.
 Object[] accumFor(Object assoc, Object collExpr, Object accumBody)
          Enabled: Use a for-loop to accumulate(java.lang.Object, java.lang.Object) for each member of a collection.
 Object[] accumIf(Object condExpr, Object accumBody)
          Enabled: Use an if-expr to accumulate(java.lang.Object, java.lang.Object) iff a condition is true.
 EExpr accumulate(Object starterExpr, Object accumulator)
          Enabled: Implements the "accumulator" syntax.
 Object[] accumWhile(Object condExpr, Object accumBody)
          Enabled: Use a while-loop to accumulate(java.lang.Object, java.lang.Object) while a condition is true.
 EExpr asBigAs(Object x, Object y)
          Enabled:
 Assoc assoc(Object key, Object value)
          Enabled: Represents a key => value association.
 Pattern atNoun(Object token)
          Enabled: When an at-hole is '@' or '@_'
 Pattern bindDefiner(Object name)
          Enabled: Binds (resolves) a forward declaration.
 Pattern bindDefiner(Object name, Object valueGuardExpr)
          Enabled: Binds (resolves) a forward declaration.
 EExpr call(Object recipientExpr, Object verbPos, String verb, Object args)
          Enabled:
 EExpr classExpr(Object doco, Object classHead, Object mBody)
          Enabled: Supports the deprecated 'class' syntax of old.
 EExpr condAnd(Object left, Object right)
          Enabled: left && right => { if (left) { if (right) { [&nameOut, ...] } else { null } } else { null } } =~ [&nameOut, ...]
 EExpr condOr(Object left, Object right)
          Enabled: left || right => { if (left) { null =~ [right's outNames - left's outNames] [&nameOut, ...] } else if (right) { null =~ [left's outNames - right's outNames] [&nameOut, ...] } else { null } } =~ [&nameOut, ...]
 Matcher delegatex(Object bodyExpr)
          Enabled: delegate{expr} expands to match [verb, args] { E call(expr, verb, args) }
 EExpr dollarNoun(Object token)
          Enabled: When a dollar-hole is '$'
 EExpr doMeta(Object keyword, Object verb, Object args)
          Enabled: Used for pseudo-immediate invocations of the meta or pragma keywords.
 EExpr doMeta(Object keyword, Object verbPos, String verb, Object args)
          Enabled:
 EExpr doMetaSend(Object keyword, Object verb, Object args)
          Enabled: Used for pseudo-eventual invocations of the meta or pragma keywords.
 EExpr doMetaSend(Object keyword, Object verbPos, String verb, Object args)
          Enabled:
 EExpr ejector(Object ejNoun)
          Enabled:
 EExpr ejector(Object ejNoun, Object valExpr)
          Enabled:
 Assoc exporter(Object nounExpr)
          Enabled: '=> nounExpr' expands to '"varName" => nounExpr'
 Pattern finalPattern(Object str)
          Enabled:
 EExpr forward(Object ident)
          Enabled: A forward declaration.
 EExpr forx(Object assoc, Object collExpr, Object mBody)
          Enabled: The for loop has the following expansion: for [kPattern =>] vPattern in collExpr { mBody } expands to escape __break { collExpr iterate(def _(k, v) : any { if (k =~ kPattern && v =~ vPattern) { escape __continue { mBody; null } } }) }
 EExpr geq(Object x, Object y)
          Enabled:
 EExpr get__BREAK()
          Enabled: The expression __break.
 EExpr get__CONTINUE()
          Enabled: The expression __continue.
 EExpr get__RETURN()
          Enabled: The expression __return.
 EExpr getNULL()
          Enabled: The expression null.
 EExpr getVOID()
          Enabled: The expression void.
 EExpr greaterThan(Object x, Object y)
          Enabled:
 EExpr ifx(Object condExpr, Object thenExpr)
          Enabled:
 Assoc importer(Object namerPatt)
          Enabled: '=> namerPatt' expands to '"varName" => namerPatt' and '=> (expr) : namerPatt' expands to '"varName" => (expr) : namerPatt'
 EExpr leq(Object x, Object y)
          Enabled:
 EExpr lessThan(Object x, Object y)
          Enabled:
 EExpr macro(Object macroName, Object optMacroArg, Object macroBody, Object optNextMacro)
          Enabled:
 Astro mangle(Object ident, String suffix)
          Enabled: Mangles an identifier into a variable name by appending a known suffix.
 EExpr map(Object assocList)
          Enabled: [a => b, c => d] expands to __makeMap fromPairs([[a, b], [c, d]).
 Pattern mapPattern(Object assocList, Object optRestPatt)
          Enabled: The pattern
 EExpr methObject(Object decl, Object msgPatt, Object bodyExpr, boolean bindReturn)
          Enabled: For defining an eScript that consists of exactly one method
 EExpr mod(Object val, Object nModulus)
          Enabled:
 EExpr mType(Object doco, Object verb, Object pTypes, Object optRetType)
          Enabled:
 EExpr not(Object x)
          Enabled: Convenience for call(x, "not", list()).
 EExpr object(Object decl, Object script)
          Enabled:
 ObjDecl oDecl(Object optExtends, Object auditors)
          Enabled:
 ObjDecl oDecl(Object doco, Object optOName, Object oldODecl)
          Enabled:
 EExpr oType(Object doco, Object oName, Object mTypes)
          Enabled:
 EExpr oType(Object doco, Object optOName, Object optAudit, Object decl, Object mTypes)
          Enabled:
 Pattern patternEquals(Object eExpr)
          Enabled: (== eExpr) expands to (specimen ? specimen == eExpr)
 Astro prop(Object propertyName)
          Enabled: Used to transform 'a.name' into 'a.getName(args)'.
 EExpr pType(Object optName, Object optType)
          Enabled:
 EExpr quasiExpr(Object syntax, Object quasiList)
          Enabled: syntax`foo $bar baz $zip zorp` expands to syntax_quasiParser \ valueMaker("foo ${0} baz ${1} zorp") \ substitute([bar, zip])
 QuasiLiteralExpr quasiLiteralExpr()
          Enabled: $$ expands to ${0}
 QuasiLiteralExpr quasiLiteralExpr(Object litIndex)
          Enabled:
 QuasiLiteralPatt quasiLiteralPatt(Object litIndex)
          Enabled:
 Pattern quasiPattern(Object syntax, Object quasiList)
          Enabled: syntax`foo $bar baz @zip zorp` expands to q ? (syntax__quasiParser \ matchMaker("foo ${0} baz @{0} zorp") \ matchBind([bar], q) =~ [zip])
 QuasiPatternExpr quasiPatternExpr(Object litIndex)
          Enabled:
 QuasiPatternPatt quasiPatternPatt(Object litIndex)
          Enabled:
 EExpr same(Object x, Object y)
          Enabled:
 EExpr send(Object recipientExpr, Object verbPos, String verb, Object args)
          Enabled:
 EExpr sequence(Object x, Object y)
          Enabled:
 EExpr sequence(Object x, Object y, Object z)
          Enabled:
 Pattern slotDefiner(Object name)
          Enabled:
 EExpr switchx(Object specimen, Object matchers)
          Enabled: switch (eExpr) { match pattern1 { body1 } match pattern2 { body2 } } expands to { def temp = eExpr if (temp =~ pattern1) { body1 } else if (temp =~ pattern2) { body2 } else { throw("no match: " + temp) } }
 EExpr thru(Object start, Object stop)
          Enabled:
 EExpr thunk(Object doco, Object bodyExpr)
          Enabled: Expands to
 EExpr till(Object start, Object bound)
          Enabled:
 EMethodNode to(Object doco, Object msgPatt, Object bodyExpr)
          Enabled:
 EExpr tuple(Object argList)
          Enabled: [x, y, z] expands to __makeList(x, y, z)
 EExpr update(Object lValue, Object verb, Object rnValue)
          Enabled: Expands lValue verb= rnValue to lValue := lValue.verb(rnValue), sort of.
 EExpr uriExpr(Object uriToken)
          Enabled: uriToken must be a URI, and have both protocol and body.
 EExpr uriExpr(Object uriStartToken, Object uriBodyExpr)
          Enabled: uriStartToken must be a URIStart, and must have a protocol, but no body.
 Astro varName(Object ident)
          Enabled: Make vacancies for new temporary variable names.
 Pattern varPattern(Object name)
          Enabled:
 EExpr when(Object headList, Object bodyExpr, Object catchers, Object optFinally)
          Enabled:
 EExpr whilex(Object condExpr, Object bodyExpr)
          Enabled: The while loop expands as follows: while (cond) { body } expands to escape __break { __loop( def _() :boolean { if (cond) { escape __continue { body } true } else { false } }) }
 
Methods inherited from interface org.erights.e.elang.syntax.BaseEBuilder
antiPocket, append, assign, call, cdrPattern, define, escape, finalPattern, hide, ifx, ignore, list, list, list, list, list, listPattern, literal, matchBind, matcher, methHead, method, oDecl, pocket, reserved, send, sequence, slotExpr, suchThat, tryx, varPattern, vTable, with
 

Method Detail

getNULL

public EExpr getNULL()
Enabled: The expression null.

null is bound in the universal scope to the one null value. In E-on-Java, this is the same as Java null.


getVOID

public EExpr getVOID()
Enabled: The expression void.

void is bound in the universal scope to a guard that coerces all values to null.


get__BREAK

public EExpr get__BREAK()
Enabled: The expression __break.

The for and while loop expansions include an escape __break {..., putting a variable of this name into scope. The keyword break expands to a call to __break.


get__CONTINUE

public EExpr get__CONTINUE()
Enabled: The expression __continue.

The for and while loop expansions include an escape __continue {..., putting a variable of this name into scope. The keyword continue expands to a call to __continue.


get__RETURN

public EExpr get__RETURN()
Enabled: The expression __return.

The keyword return expands to a call to __return.


update

public EExpr update(Object lValue,
                    Object verb,
                    Object rnValue)
Enabled: Expands lValue verb= rnValue to lValue := lValue.verb(rnValue), sort of.

When x is a variable name,

   x "verb=" z   expands to   x := x.verb(z)
Otherwise, we need to ensure that the lValue's subexpressions are only evaluated once
  x.v(y...).verb= z
expands to
      def r := x
      def a0 := y
      ...
      r.v(a0...) := r.v(a0...).verb(z)
And then the assignment expansions take it from there.


call

public EExpr call(Object recipientExpr,
                  Object verbPos,
                  String verb,
                  Object args)
Enabled:


send

public EExpr send(Object recipientExpr,
                  Object verbPos,
                  String verb,
                  Object args)
Enabled:


not

public EExpr not(Object x)
Enabled: Convenience for call(x, "not", list()).

Makes the expression x.not()


doMeta

public EExpr doMeta(Object keyword,
                    Object verb,
                    Object args)
Enabled: Used for pseudo-immediate invocations of the meta or pragma keywords.

This is a bit of a syntactic hack, to enable the creation of new special forms without extending the BNF of the language. Rather, if meta or pragma appear as the receiver of what otherwise would have been an immediate-call expression, then the builder should dispatch on the verb and arity of the arguments to figure out what to do.

All other possibilities are reserved for future use.


doMeta

public EExpr doMeta(Object keyword,
                    Object verbPos,
                    String verb,
                    Object args)
Enabled:


doMetaSend

public EExpr doMetaSend(Object keyword,
                        Object verb,
                        Object args)
Enabled: Used for pseudo-eventual invocations of the meta or pragma keywords.

This is a bit of a syntactic hack, to enable the creation of new special forms without extending the BNF of the language. Rather, if meta or pragma appear as the receiver of what otherwise would have been an eventual-send expression, then the builder should dispatch on the verb and arity of the arguments to figure out what to do.

All other possibilities are reserved for future use.


doMetaSend

public EExpr doMetaSend(Object keyword,
                        Object verbPos,
                        String verb,
                        Object args)
Enabled:


classExpr

public EExpr classExpr(Object doco,
                       Object classHead,
                       Object mBody)
Enabled: Supports the deprecated 'class' syntax of old.

Enabled by 'pragma.enable("class-expr")'.

      class foo(patts) :rt {body)
expands to
      def maker$n := def foo {
          to adopt(self, patts) :rt {body}
          to run(params) :rt {
              def self$n := maker$n adopt(self$n, params)
          }
      }
 


condAnd

public EExpr condAnd(Object left,
                     Object right)
Enabled: left && right => { if (left) { if (right) { [&nameOut, ...] } else { null } } else { null } } =~ [&nameOut, ...]


condOr

public EExpr condOr(Object left,
                    Object right)
Enabled: left || right => { if (left) { null =~ [right's outNames - left's outNames] [&nameOut, ...] } else if (right) { null =~ [left's outNames - right's outNames] [&nameOut, ...] } else { null } } =~ [&nameOut, ...]


finalPattern

public Pattern finalPattern(Object str)
Enabled:


varPattern

public Pattern varPattern(Object name)
Enabled:


slotDefiner

public Pattern slotDefiner(Object name)
Enabled:


dollarNoun

public EExpr dollarNoun(Object token)
Enabled: When a dollar-hole is '$'


forward

public EExpr forward(Object ident)
Enabled: A forward declaration.

"def name" expands to

     (def [name, name__Resolver] := Ref.promise(); name__Resolver)
 
The value of a "def name" expression is the Resolver that will resolve 'name', so, for example, '(def name)' can be used in an argument position both to define 'name' and to pass the Resolver as an argument to someone who will resolve it.


bindDefiner

public Pattern bindDefiner(Object name)
Enabled: Binds (resolves) a forward declaration.

"bind name" expands to

     temp ? (name__Resolver.resolve(temp); true)
 


bindDefiner

public Pattern bindDefiner(Object name,
                           Object valueGuardExpr)
Enabled: Binds (resolves) a forward declaration.

"bind name :valueGuard" expands to

     temp :valueGuard ? (name__Resolver.resolve(temp); true)
 


oDecl

public ObjDecl oDecl(Object optExtends,
                     Object auditors)
Enabled:


oDecl

public ObjDecl oDecl(Object doco,
                     Object optOName,
                     Object oldODecl)
Enabled:


object

public EExpr object(Object decl,
                    Object script)
Enabled:


delegatex

public Matcher delegatex(Object bodyExpr)
Enabled: delegate{expr} expands to match [verb, args] { E call(expr, verb, args) }


ejector

public EExpr ejector(Object ejNoun)
Enabled:


ejector

public EExpr ejector(Object ejNoun,
                     Object valExpr)
Enabled:


forx

public EExpr forx(Object assoc,
                  Object collExpr,
                  Object mBody)
Enabled: The for loop has the following expansion: for [kPattern =>] vPattern in collExpr { mBody } expands to escape __break { collExpr iterate(def _(k, v) : any { if (k =~ kPattern && v =~ vPattern) { escape __continue { mBody; null } } }) }

Parameters:
assoc - An Assoc of kPattern and a vPattern.
collExpr - Evaluates to the collection to be iterated (to be sent the "iterate" message).
mBody - The body of the for-loop.
Returns:
The expression for computing the for-loop.

accumulate

public EExpr accumulate(Object starterExpr,
                        Object accumulator)
Enabled: Implements the "accumulator" syntax.

The "accumulator" syntax has most of the advantages of list comprehension (from Haskell and Python), but is more E-like. For example, with this property enabled, one can write:

     [] for i in 1..5 { + i**2 }
 
to accumulate the list [ 1, 4, 9, 16, 25 ]. This expands into
 {
     var accum_n := []
     for i in 1..5 {
         accum_n += { i**2 }
     }
     accum_n
 }
 
Note that this is more flexible but more verbose than a list comprehension, and less flexible and comparably verbose to a Smalltalk injection.

More formally, the transformation is from

     starterExpr accumulator
 
to
 {
     var accum_n := starter-expr
     accumExpr
     accum_n
 }
 
where accumulator is one of accumFor(java.lang.Object, java.lang.Object, java.lang.Object), accumIf(java.lang.Object, java.lang.Object), or accumWhile(java.lang.Object, java.lang.Object). They each have an accumBody parameter. The corresponding argument is one of accumFor(java.lang.Object, java.lang.Object, java.lang.Object), accumIf(java.lang.Object, java.lang.Object), accumWhile(java.lang.Object, java.lang.Object), or accumBody(java.lang.Object, java.lang.Object), and returns a pair of the name of the temporary variable (shown as "accum-n" above) and an expression (shown as "accumExpr" above).

Parameters:
starterExpr - The initial value to be accumulated on to.
accumulator - A pair of a temp-name and an accumExpr.
Returns:
An expression that evaluates to the accumulated value.

accumFor

public Object[] accumFor(Object assoc,
                         Object collExpr,
                         Object accumBody)
Enabled: Use a for-loop to accumulate(java.lang.Object, java.lang.Object) for each member of a collection.

Parameters:
assoc - An Assoc of a key-pattern and a value-pattern.
collExpr - Evaluates to the collection to be iterated (to be sent the "iterate" message).
accumBody - A pair of a temp-name and an accumExpr.
Returns:
A pair of a temp-name and the obvious for-loop EExpr.

accumIf

public Object[] accumIf(Object condExpr,
                        Object accumBody)
Enabled: Use an if-expr to accumulate(java.lang.Object, java.lang.Object) iff a condition is true.


accumWhile

public Object[] accumWhile(Object condExpr,
                           Object accumBody)
Enabled: Use a while-loop to accumulate(java.lang.Object, java.lang.Object) while a condition is true.


accumBody

public Object[] accumBody(Object verb,
                          Object rnValue)
Enabled: Actually does the accumulation into the temporary accumulation variable.

Parameters:
verb - The messageName that says how the temporary should be updated.
rnValue - The argument-list for computing a new value.
Returns:
A pair of a new temp-name and the expression
    temp-name verb= rnValue

ifx

public EExpr ifx(Object condExpr,
                 Object thenExpr)
Enabled:


lessThan

public EExpr lessThan(Object x,
                      Object y)
Enabled:


leq

public EExpr leq(Object x,
                 Object y)
Enabled:


asBigAs

public EExpr asBigAs(Object x,
                     Object y)
Enabled:


geq

public EExpr geq(Object x,
                 Object y)
Enabled:


greaterThan

public EExpr greaterThan(Object x,
                         Object y)
Enabled:


till

public EExpr till(Object start,
                  Object bound)
Enabled:


thru

public EExpr thru(Object start,
                  Object stop)
Enabled:


macro

public EExpr macro(Object macroName,
                   Object optMacroArg,
                   Object macroBody,
                   Object optNextMacro)
Enabled:


map

public EExpr map(Object assocList)
Enabled: [a => b, c => d] expands to __makeMap fromPairs([[a, b], [c, d]).

This exapansion satisfies the requirement that it preserves order.


mapPattern

public Pattern mapPattern(Object assocList,
                          Object optRestPatt)
Enabled: The pattern
    [k1 => v1, ...
where kn is an expression and v1 is a pattern, expands to
    m1 ? m1.optExtract(k1) =~ [v1, ...]
If the original ends in "| restPatt", then restPatt is used in the final "..." in the expansion. Otherwise, the final "..." is filled with 'mn ? mn.size() == 0'.

To support default values, an individual association can also be

    k1 else (defaultExpr1) => v1
which will expand using
    m1.extract(k1, defaultExpr1)
If k1 isn't in the table, then the value of defaultExpr1 is matched against v1 rather than failing.

Note that this expansion carefully preserves left-to-right order, so latter patterns and expressions can use bindings and side effects produced by earlier ones. In particular, if execution gets as far as a defaultExpr, it is evaluated whether or not its value is used.


assoc

public Assoc assoc(Object key,
                   Object value)
Enabled: Represents a key => value association.

It depends on context whether either key of value is an expression or a pattern.


exporter

public Assoc exporter(Object nounExpr)
Enabled: '=> nounExpr' expands to '"varName" => nounExpr'


importer

public Assoc importer(Object namerPatt)
Enabled: '=> namerPatt' expands to '"varName" => namerPatt' and '=> (expr) : namerPatt' expands to '"varName" => (expr) : namerPatt'


mod

public EExpr mod(Object val,
                 Object nModulus)
Enabled:


thunk

public EExpr thunk(Object doco,
                   Object bodyExpr)
Enabled: Expands to
     def _() :any { bodyExpr }
 


to

public EMethodNode to(Object doco,
                      Object msgPatt,
                      Object bodyExpr)
Enabled:


methObject

public EExpr methObject(Object decl,
                        Object msgPatt,
                        Object bodyExpr,
                        boolean bindReturn)
Enabled: For defining an eScript that consists of exactly one method


patternEquals

public Pattern patternEquals(Object eExpr)
Enabled: (== eExpr) expands to (specimen ? specimen == eExpr)


atNoun

public Pattern atNoun(Object token)
Enabled: When an at-hole is '@' or '@_'


quasiExpr

public EExpr quasiExpr(Object syntax,
                       Object quasiList)
Enabled: syntax`foo $bar baz $zip zorp` expands to syntax_quasiParser \ valueMaker("foo ${0} baz ${1} zorp") \ substitute([bar, zip])


quasiLiteralExpr

public QuasiLiteralExpr quasiLiteralExpr()
Enabled: $$ expands to ${0}


quasiLiteralExpr

public QuasiLiteralExpr quasiLiteralExpr(Object litIndex)
Enabled:


quasiLiteralPatt

public QuasiLiteralPatt quasiLiteralPatt(Object litIndex)
Enabled:


quasiPattern

public Pattern quasiPattern(Object syntax,
                            Object quasiList)
Enabled: syntax`foo $bar baz @zip zorp` expands to q ? (syntax__quasiParser \ matchMaker("foo ${0} baz @{0} zorp") \ matchBind([bar], q) =~ [zip])


quasiPatternExpr

public QuasiPatternExpr quasiPatternExpr(Object litIndex)
Enabled:


quasiPatternPatt

public QuasiPatternPatt quasiPatternPatt(Object litIndex)
Enabled:


same

public EExpr same(Object x,
                  Object y)
Enabled:


sequence

public EExpr sequence(Object x,
                      Object y)
Enabled:


sequence

public EExpr sequence(Object x,
                      Object y,
                      Object z)
Enabled:


switchx

public EExpr switchx(Object specimen,
                     Object matchers)
Enabled: switch (eExpr) { match pattern1 { body1 } match pattern2 { body2 } } expands to { def temp = eExpr if (temp =~ pattern1) { body1 } else if (temp =~ pattern2) { body2 } else { throw("no match: " + temp) } }


tuple

public EExpr tuple(Object argList)
Enabled: [x, y, z] expands to __makeList(x, y, z)


uriExpr

public EExpr uriExpr(Object uriToken)
Enabled: uriToken must be a URI, and have both protocol and body.

<http:foo> expands to http__uriGetter["foo"]. <x:foo> expands to file__uriGetter["x:foo"].


uriExpr

public EExpr uriExpr(Object uriStartToken,
                     Object uriBodyExpr)
Enabled: uriStartToken must be a URIStart, and must have a protocol, but no body.

<http: expr> expands to http__uriGetter[expr] <x: expr> expands to file__uriGetter["x:" + expr]


whilex

public EExpr whilex(Object condExpr,
                    Object bodyExpr)
Enabled: The while loop expands as follows: while (cond) { body } expands to escape __break { __loop( def _() :boolean { if (cond) { escape __continue { body } true } else { false } }) }


oType

public EExpr oType(Object doco,
                   Object oName,
                   Object mTypes)
Enabled:


oType

public EExpr oType(Object doco,
                   Object optOName,
                   Object optAudit,
                   Object decl,
                   Object mTypes)
Enabled:


mType

public EExpr mType(Object doco,
                   Object verb,
                   Object pTypes,
                   Object optRetType)
Enabled:


pType

public EExpr pType(Object optName,
                   Object optType)
Enabled:


varName

public Astro varName(Object ident)
Enabled: Make vacancies for new temporary variable names.

Parameters:
ident - An Astro representing the identifier as it appears in the source code.
Returns:
The variable name as far as the program is concerned. So long as ident doesn't have the form of a temporary variable name, this will be the same as ident.

mangle

public Astro mangle(Object ident,
                    String suffix)
Enabled: Mangles an identifier into a variable name by appending a known suffix.

Parameters:
ident - An Astro representing the identifier as it appears in the source code.
Returns:
The resulting variable name for use in the program.

prop

public Astro prop(Object propertyName)
Enabled: Used to transform 'a.name' into 'a.getName(args)'.

'name' is changed into 'Name' using the standard JavaBeans rule: 'toUpperCase' is applied to the name[0].

As a result of the assignment conversion rules, 'a.name := y' is trasformed into 'a.setName(y)'

Parameters:
propertyName - An Astro representing the identifier as it appears in the source code.
Returns:
The resulting verb for use in the program.

when

public EExpr when(Object headList,
                  Object bodyExpr,
                  Object catchers,
                  Object optFinally)
Enabled:



comments?