code: private Expr parseLambdaConstant(EnclosingScope scope, boolean terminated) {
  		int start = index;
  		match(Ampersand);
  		Name name = parseName(scope);
  		Tuple<Type> parameters;
  		// Check whether or not parameters are supplied
  		if (tryAndMatch(terminated, LeftBrace) != null) {
  			// Yes, parameters are supplied!
  			ArrayList<Type> tmp = new ArrayList<>();
  			boolean firstTime = true;
  			while (eventuallyMatch(RightBrace) == null) {
  				int p_start = index;
  				if (!firstTime) {
  					match(Comma);
  				}
  				firstTime = false;
  				Type type = parseType(scope);
  				tmp.add(type);
  			}
  			parameters = new Tuple<>(tmp);
  		} else {
  			// No, parameters are not supplied.
  			parameters = new Tuple<>();
  		}
  		Decl.Link link = new Decl.Link<Decl.Callable>(name);
  		Decl.Binding<Type.Callable, Decl.Callable> binding = new Decl.Binding<>(link, new Tuple<>());
  		return annotateSourceLocation(new Expr.LambdaAccess(binding, parameters), start);
  	}
docs: Parse an address expression, which has the form:
  
  <pre>
  TermExpr::= ...
  | '&' Identifier [ '(' Type (',' Type)* ')']
  </pre>
  
  @param scope
  The enclosing scope for this statement, which determines the
  set of visible (i.e. declared) variables and also the current
  indentation level.
  @param terminated
  This indicates that the expression is known to be terminated
  (or not). An expression that's known to be terminated is one
  which is guaranteed to be followed by something. This is
  important because it means that we can ignore any newline
  characters encountered in parsing this expression, and that
  we'll never overrun the end of the expression (i.e. because
  there's guaranteed to be something which terminates this
  expression). A classic situation where terminated is true is
  when parsing an expression surrounded in braces. In such case,
  we know the right-brace will always terminate this expression.
  
  @return