Uses of Class
eu.bandm.tools.ramus.runtime2.Expression

Packages that use Expression

Package	Description
eu.bandm.tools.lljava.codec
eu.bandm.tools.lljava.parser
eu.bandm.tools.ramus.runtime2

Uses of Expression in eu.bandm.tools.lljava.codec

Fields in eu.bandm.tools.lljava.codec declared as Expression

Modifier and Type	Field	Description
static final Expression<SourceId,SignatureParser.TokenType,LLJava.PrimitiveTypeExpr>	SignatureParser.baseType
final Expression<SourceId,SignatureParser.TokenType,Consumer<LLJava.Class>>	SignatureParser.classSignature
final Expression<SourceId,SignatureParser.TokenType,LLJava.ClassTypeExpr>	SignatureParser.classTypeSignature
final Expression<SourceId,SignatureParser.TokenType,Consumer<LLJava.Field>>	SignatureParser.fieldSignature
final Expression<SourceId,SignatureParser.TokenType,String>	SignatureParser.identifier
final Expression<SourceId,SignatureParser.TokenType,LLJava.TypeExpr>	SignatureParser.javaTypeSignature
final Expression<SourceId,SignatureParser.TokenType,Consumer<LLJava.Method>>	SignatureParser.methodSignature
final Expression<SourceId,SignatureParser.TokenType,LLJava.ReferenceTypeExpr>	SignatureParser.referenceTypeSignature
final Expression<SourceId,SignatureParser.TokenType,LLJava.ResultExpr>	SignatureParser.resultSignature
final Expression<SourceId,SignatureParser.TokenType,LLJava.ClassTypeExpr>	SignatureParser.throwsSignature
final Expression<SourceId,SignatureParser.TokenType,LLJava.TypeParameter>	SignatureParser.typeParameter
final Expression<SourceId,SignatureParser.TokenType,List<LLJava.TypeParameter>>	SignatureParser.typeParameters
final Expression<SourceId,SignatureParser.TokenType,LLJava.ClassTypeExpr>	SignatureParser.typeVariableSignature
final Expression<SourceId,SignatureParser.TokenType,LLJava.VoidExpr>	SignatureParser.voidSignature

Methods in eu.bandm.tools.lljava.codec that return Expression

Modifier and Type	Method	Description
final Expression<SourceId,SignatureParser.TokenType,LLJava.ClassTypeExpr>	SignatureParser.classTypeSignature(Expression<SourceId,SignatureParser.TokenType,LLJava.ReferenceTypeExpr> referenceTypeSignature)
final Expression<SourceId,SignatureParser.TokenType,List<LLJava.TypeArgument>>	SignatureParser.typeArguments(Expression<SourceId,SignatureParser.TokenType,LLJava.ReferenceTypeExpr> referenceTypeSignature)

Methods in eu.bandm.tools.lljava.codec with parameters of type Expression

Modifier and Type	Method	Description
final Expression<SourceId,SignatureParser.TokenType,LLJava.ClassTypeExpr>	SignatureParser.classTypeSignature(Expression<SourceId,SignatureParser.TokenType,LLJava.ReferenceTypeExpr> referenceTypeSignature)
protected <A> void	SignatureParser.parseSignature(String signature, Expression<SourceId,SignatureParser.TokenType,Consumer<A>> expr, A target)
final Expression<SourceId,SignatureParser.TokenType,List<LLJava.TypeArgument>>	SignatureParser.typeArguments(Expression<SourceId,SignatureParser.TokenType,LLJava.ReferenceTypeExpr> referenceTypeSignature)

Uses of Expression in eu.bandm.tools.lljava.parser

Fields in eu.bandm.tools.lljava.parser declared as Expression

Modifier and Type	Field	Description
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.AbstractMethodBody>	LLJavaGrammar.abstractMethodBody
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation>	LLJavaGrammar.annotation
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.AnnotationValue>	LLJavaGrammar.annotationValue
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ArrayAccess>	LLJavaGrammar.arrayExpr
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.TypeExpr>	LLJavaGrammar.baseType
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block>	LLJavaGrammar.block
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.BooleanLiteral>	LLJavaGrammar.booleanLiteral
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Cast>	LLJavaGrammar.castInstruction
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.CharLiteral>	LLJavaGrammar.charLiteral
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassAnnotationValue>	LLJavaGrammar.classAnnotationValue
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Class>	LLJavaGrammar.classDefinition
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassExpr>	LLJavaGrammar.classLiteral
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassReference>	LLJavaGrammar.classReference
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr>	LLJavaGrammar.classType
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Cmp>	LLJavaGrammar.cmpInstruction
final Expression<SourceId,LLJavaLexer.TokenType,Boolean>	LLJavaGrammar.cmpOperator
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.CodeMethodBody>	LLJavaGrammar.codeMethodBody
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Condition>	LLJavaGrammar.condition
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ConstantAnnotationValue>	LLJavaGrammar.constantAnnotationValue
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.DefaultMethodBody>	LLJavaGrammar.defaultMethodBody
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.DimensionExpr>	LLJavaGrammar.dimensionExpr
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.DoubleLiteral>	LLJavaGrammar.doubleLiteral
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.EnumAnnotationValue>	LLJavaGrammar.enumAnnotationValue
final Expression<SourceId,LLJavaLexer.TokenType,List<LLJava.ClassReference>>	LLJavaGrammar.exceptions
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Field>	LLJavaGrammar.fieldDefinition
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.FieldReference>	LLJavaGrammar.fieldReference
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.FloatLiteral>	LLJavaGrammar.floatLiteral
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Get>	LLJavaGrammar.getInstruction
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Goto>	LLJavaGrammar.gotoInstruction
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.GotoInterval>	LLJavaGrammar.gotoInterval
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.GotoPoint>	LLJavaGrammar.gotoReference
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Id>	LLJavaGrammar.id
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Inc>	LLJavaGrammar.incInstruction
final Expression<SourceId,LLJavaLexer.TokenType,Optional<LLJava.Literal>>	LLJavaGrammar.initializer
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Instanceof>	LLJavaGrammar.instanceofInstruction
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.IntLiteral>	LLJavaGrammar.intLiteral
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation>	LLJavaGrammar.invisibleAnnotation
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Invoke>	LLJavaGrammar.invokeInstruction
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Invoke>	LLJavaGrammar.invokeInstructionNonrecursive
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Label>	LLJavaGrammar.label
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Literal>	LLJavaGrammar.literal
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.LoadableExpr>	LLJavaGrammar.loadable
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.LoadArgument>	LLJavaGrammar.loadArgument
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Load>	LLJavaGrammar.loadInstruction
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Name>	LLJavaGrammar.localName
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Local>	LLJavaGrammar.localVariable
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.LongLiteral>	LLJavaGrammar.longLiteral
final Expression<SourceId,LLJavaLexer.TokenType,List<LLJava.Class>>	LLJavaGrammar.main
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Member>	LLJavaGrammar.memberDefinition
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MemberDynamicName>	LLJavaGrammar.memberDynamicName
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MemberFullName>	LLJavaGrammar.memberFullName
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MemberStaticName>	LLJavaGrammar.memberStaticName
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MethodBody>	LLJavaGrammar.methodBody
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Method>	LLJavaGrammar.methodDefinition
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MethodHandleExpr>	LLJavaGrammar.methodHandle
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MethodHandleTarget>	LLJavaGrammar.methodHandleTarget
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Parameter>	LLJavaGrammar.methodParameter
final Expression<SourceId,LLJavaLexer.TokenType,List<LLJava.Parameter>>	LLJavaGrammar.methodParameters
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MethodReference>	LLJavaGrammar.methodReference
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MethodReference>	LLJavaGrammar.methodReferenceNonrecursive
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MethodReferenceParameter>	LLJavaGrammar.methodReferenceParameter
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MethodTypeExpr>	LLJavaGrammar.methodType
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Modifier>	LLJavaGrammar.modifier
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ModifierExpr>	LLJavaGrammar.modifierExpr
final Expression<SourceId,LLJavaLexer.TokenType,List<LLJava.ModifierExpr>>	LLJavaGrammar.modifiers
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.New>	LLJavaGrammar.newInstruction
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.NullLiteral>	LLJavaGrammar.nullLiteral
final Expression<SourceId,LLJavaLexer.TokenType,LLJavaLexer.TokenType>	LLJavaGrammar.operator
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.PrimitiveType>	LLJavaGrammar.primitiveType
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.PrimitiveTypeExpr>	LLJavaGrammar.primitiveTypeExpr
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Put>	LLJavaGrammar.putInstruction
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.QualId>	LLJavaGrammar.qualId
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.QualId>	LLJavaGrammar.qualifier
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ResultExpr>	LLJavaGrammar.result
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ReturnsExpr>	LLJavaGrammar.returnsResult
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.SimpleModifierExpr>	LLJavaGrammar.simpleModifierExpr
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.StoreArgument>	LLJavaGrammar.storeArgument
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Store>	LLJavaGrammar.storeInstruction
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.StringLiteral>	LLJavaGrammar.stringLiteral
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassReference>	LLJavaGrammar.superclass
final Expression<SourceId,LLJavaLexer.TokenType,List<LLJava.ClassReference>>	LLJavaGrammar.superinterfaces
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.This>	LLJavaGrammar.thisExpr
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.TypeExpr>	LLJavaGrammar.type
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.TypeParameter>	LLJavaGrammar.typeParameter
final Expression<SourceId,LLJavaLexer.TokenType,List<LLJava.TypeParameter>>	LLJavaGrammar.typeParameters
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.VariableRef>	LLJavaGrammar.variableReference
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.VoidExpr>	LLJavaGrammar.voidResult

Methods in eu.bandm.tools.lljava.parser that return Expression

Modifier and Type	Method	Description
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.angle(Expression<SourceId,LLJavaLexer.TokenType,A> body)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation>	LLJavaGrammar.annotation(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.AnnotationValue>	LLJavaGrammar.annotationValue(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.AnnotationValue>	LLJavaGrammar.annotationValue(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation, Expression<SourceId,LLJavaLexer.TokenType,LLJava.AnnotationValue> annotationValue)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ArrayAnnotationValue>	LLJavaGrammar.arrayAnnotationValue(Expression<SourceId,LLJavaLexer.TokenType,LLJava.AnnotationValue> annotationValue)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block>	LLJavaGrammar.block(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.brace(Expression<SourceId,LLJavaLexer.TokenType,A> body)
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.bracket(Expression<SourceId,LLJavaLexer.TokenType,A> body)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Handler>	LLJavaGrammar.catchHandler(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr>	LLJavaGrammar.classType(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.CodeInterval>	LLJavaGrammar.codeInterval(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.CodePoint>	LLJavaGrammar.codeReference(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,List<A>>	LLJavaGrammar.comma(Expression<SourceId,LLJavaLexer.TokenType,A> body)
protected Expression<SourceId,LLJavaLexer.TokenType,Void>	LLJavaGrammar.command(LLJavaLexer.TokenType type)
protected <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.command(LLJavaLexer.TokenType type, Expression<SourceId,LLJavaLexer.TokenType,A> operand)
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.constant(LLJavaLexer.TokenType type, A value)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.DynamicExpr>	LLJavaGrammar.dynamicReference(Expression<SourceId,LLJavaLexer.TokenType,LLJava.LoadableExpr> loadable)
final Expression<SourceId,LLJavaLexer.TokenType,Map.Entry<LLJava.Id,LLJava.AnnotationValue>>	LLJavaGrammar.elementValuePair(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation)
final Expression<SourceId,LLJavaLexer.TokenType,List<Map.Entry<LLJava.Id,LLJava.AnnotationValue>>>	LLJavaGrammar.elementValuePairs(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation)
protected Expression<SourceId,LLJavaLexer.TokenType,Boolean>	LLJavaGrammar.flag(LLJavaLexer.TokenType type, Parser.Pragma... pragmas)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.If>	LLJavaGrammar.ifInstruction(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.InlineInterval>	LLJavaGrammar.inlineInterval(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.InlinePoint>	LLJavaGrammar.inlineReference(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Instruction>	LLJavaGrammar.instruction(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.LoadableExpr>	LLJavaGrammar.loadable(Expression<SourceId,LLJavaLexer.TokenType,LLJava.LoadableExpr> loadable)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.LowerTypeBound>	LLJavaGrammar.lowerTypeBound(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MemberDynamicName>	LLJavaGrammar.memberDynamicName(Expression<SourceId,LLJavaLexer.TokenType,LLJava.LoadableExpr> loadable)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.NestedAnnotationValue>	LLJavaGrammar.nestedAnnotationValue(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation)
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.paren(Expression<SourceId,LLJavaLexer.TokenType,A> body)
protected <A1, A2, R extends LLJava.Node> Expression<SourceId,LLJavaLexer.TokenType,R>	LLJavaGrammar.simple(BiFunction<? super A1,? super A2,? extends R> constructor, AbstractExpression<SourceId,LLJavaLexer.TokenType,A1> arg1, AbstractExpression<SourceId,LLJavaLexer.TokenType,A2> arg2)
protected <A, R extends LLJava.Node> Expression<SourceId,LLJavaLexer.TokenType,R>	LLJavaGrammar.simple(Function<? super A,? extends R> constructor, AbstractExpression<SourceId,LLJavaLexer.TokenType,A> arg1)
protected <R extends LLJava.Node> Expression<SourceId,LLJavaLexer.TokenType,R>	LLJavaGrammar.simple(Supplier<? extends R> constructor, LLJavaLexer.TokenType... types)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Statement>	LLJavaGrammar.statement(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Case>	LLJavaGrammar.switchCase(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Switch>	LLJavaGrammar.switchInstruction(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Try>	LLJavaGrammar.tryInstruction(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.TypeArgument>	LLJavaGrammar.typeArgument(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,List<LLJava.TypeArgument>>	LLJavaGrammar.typeArguments(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.TypeBound>	LLJavaGrammar.typeBound(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
protected static Expression<SourceId,LLJavaLexer.TokenType,Content<SourceId,LLJavaLexer.TokenType>>	LLJavaGrammar.unparsedLiteral(LLJavaLexer.TokenType... types)
protected static Expression<SourceId,LLJavaLexer.TokenType,String>	LLJavaGrammar.unparsedLiteralText(LLJavaLexer.TokenType... types)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.UpperTypeBound>	LLJavaGrammar.upperTypeBound(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Wildcard>	LLJavaGrammar.wildcard(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)

Methods in eu.bandm.tools.lljava.parser with parameters of type Expression

Modifier and Type	Method	Description
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.angle(Expression<SourceId,LLJavaLexer.TokenType,A> body)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation>	LLJavaGrammar.annotation(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.AnnotationValue>	LLJavaGrammar.annotationValue(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.AnnotationValue>	LLJavaGrammar.annotationValue(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation, Expression<SourceId,LLJavaLexer.TokenType,LLJava.AnnotationValue> annotationValue)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ArrayAnnotationValue>	LLJavaGrammar.arrayAnnotationValue(Expression<SourceId,LLJavaLexer.TokenType,LLJava.AnnotationValue> annotationValue)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block>	LLJavaGrammar.block(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.brace(Expression<SourceId,LLJavaLexer.TokenType,A> body)
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.bracket(Expression<SourceId,LLJavaLexer.TokenType,A> body)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Handler>	LLJavaGrammar.catchHandler(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr>	LLJavaGrammar.classType(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.CodeInterval>	LLJavaGrammar.codeInterval(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.CodePoint>	LLJavaGrammar.codeReference(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,List<A>>	LLJavaGrammar.comma(Expression<SourceId,LLJavaLexer.TokenType,A> body)
protected <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.command(LLJavaLexer.TokenType type, Expression<SourceId,LLJavaLexer.TokenType,A> operand)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.DynamicExpr>	LLJavaGrammar.dynamicReference(Expression<SourceId,LLJavaLexer.TokenType,LLJava.LoadableExpr> loadable)
final Expression<SourceId,LLJavaLexer.TokenType,Map.Entry<LLJava.Id,LLJava.AnnotationValue>>	LLJavaGrammar.elementValuePair(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation)
final Expression<SourceId,LLJavaLexer.TokenType,List<Map.Entry<LLJava.Id,LLJava.AnnotationValue>>>	LLJavaGrammar.elementValuePairs(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.If>	LLJavaGrammar.ifInstruction(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.InlineInterval>	LLJavaGrammar.inlineInterval(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.InlinePoint>	LLJavaGrammar.inlineReference(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Instruction>	LLJavaGrammar.instruction(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.LoadableExpr>	LLJavaGrammar.loadable(Expression<SourceId,LLJavaLexer.TokenType,LLJava.LoadableExpr> loadable)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.LowerTypeBound>	LLJavaGrammar.lowerTypeBound(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MemberDynamicName>	LLJavaGrammar.memberDynamicName(Expression<SourceId,LLJavaLexer.TokenType,LLJava.LoadableExpr> loadable)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.NestedAnnotationValue>	LLJavaGrammar.nestedAnnotationValue(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation)
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.paren(Expression<SourceId,LLJavaLexer.TokenType,A> body)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Statement>	LLJavaGrammar.statement(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Case>	LLJavaGrammar.switchCase(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Switch>	LLJavaGrammar.switchInstruction(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Try>	LLJavaGrammar.tryInstruction(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.TypeArgument>	LLJavaGrammar.typeArgument(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,List<LLJava.TypeArgument>>	LLJavaGrammar.typeArguments(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.TypeBound>	LLJavaGrammar.typeBound(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.UpperTypeBound>	LLJavaGrammar.upperTypeBound(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Wildcard>	LLJavaGrammar.wildcard(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)

Uses of Expression in eu.bandm.tools.ramus.runtime2

Fields in eu.bandm.tools.ramus.runtime2 declared as Expression

Modifier and Type	Field	Description
(package private) static final Expression<Void,HonnefDemo.TokenType,HonnefDemo.SExpr>	HonnefDemo.main
(package private) static final Expression<Void,HonnefDemo.TokenType,HonnefDemo.SExpr>	HonnefDemo.sexpr
(package private) static final Expression<Void,HonnefDemo.TokenType,HonnefDemo.Symbol>	HonnefDemo.symbol
(package private) static final Expression<Void,HonnefDemo.TokenType,Content<Void,HonnefDemo.TokenType>>	HonnefDemo.symbol0

Methods in eu.bandm.tools.ramus.runtime2 that return Expression

Modifier and Type	Method	Description
static <D, T, A> Expression<D,T,A>	Expression.access(Class<A> type, Object key)
<B, C> Expression<D,T,C>	Expression.andThenCombining(Expression<D,T,B> other, BiFunction<? super A,? super B,? extends C> pair)
<B> Expression<D,T,B>	Expression.andThenDependent(Expression<D,T,Function<? super A,? extends B>> other)
Expression<D,T,A>	Expression.append(Parser<D,T> suffix)
Expression<D,T,A>	Expression.append(T suffix)
final Expression<D,T,A>	Expression.append(T... prefix)
Expression<D,T,A>	Expression.assigning(Object key)
static <D, T, A> Expression<D,T,A>	Expression.choice(Expression<D,T,? extends A>... alts)
static <D, T, A1> Expression<D,T,Unit>	Reducer.collect(Reducer.Collector1<D,A1> coll, AbstractExpression<D,T,? extends A1> arg1)
static <D, T, A1, A2> Expression<D,T,Unit>	Reducer.collect(Reducer.Collector2<D,A1,A2> coll, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2)
static <D, T, A1, A2, A3> Expression<D,T,Unit>	Reducer.collect(Reducer.Collector3<D,A1,A2,A3> coll, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3)
static <D, T, A1, A2, A3, A4> Expression<D,T,Unit>	Reducer.collect(Reducer.Collector4<D,A1,A2,A3,A4> coll, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4)
static <D, T, A1, A2, A3, A4, A5> Expression<D,T,Unit>	Reducer.collect(Reducer.Collector5<D,A1,A2,A3,A4,A5> coll, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4, AbstractExpression<D,T,? extends A5> arg5)
static <D, T, A1, A2, A3, A4, A5, A6> Expression<D,T,Unit>	Reducer.collect(Reducer.Collector6<D,A1,A2,A3,A4,A5,A6> coll, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4, AbstractExpression<D,T,? extends A5> arg5, AbstractExpression<D,T,? extends A6> arg6)
static <D, T, A1, A2, A3, A4, A5, A6, A7> Expression<D,T,Unit>	Reducer.collect(Reducer.Collector7<D,A1,A2,A3,A4,A5,A6,A7> coll, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4, AbstractExpression<D,T,? extends A5> arg5, AbstractExpression<D,T,? extends A6> arg6, AbstractExpression<D,T,? extends A7> arg7)
static <D, T, A> Expression<D,T,A>	Expression.constant(Parser<D,T> syntax, A value)
static <D, T, A> Expression<D,T,A>	Expression.constant(T type, A value)
static <D, T, A> Expression<D,T,A>	Expression.constant(T type, String text, A value)
static <D, T, A> Expression<D,T,A>	Expression.constantEpsilon(A value)
static <D, T> Expression<D,T,Content<D,T>>	Expression.content(Parser<D,T> syntax)
static <D, T> Expression<D,T,Content<D,T>>	Expression.content(T... types)
static <D, T, A> Expression<D,T,A>	Expression.counit(A value)
(package private) static final Expression<Void,HonnefDemo.TokenType,List<HonnefDemo.SExpr>>	HonnefDemo.elems(Expression<Void,HonnefDemo.TokenType,HonnefDemo.SExpr> sexpr)
static <D, T, A> Expression<D,T,A>	Expression.fix(Function<Expression<D,T,A>,Expression<D,T,A>> loop)
Expression<D,T,A>	Expression.guard(Predicate<? super A> condition, Function<? super A,List<SimpleMessage<D>>> error)
static <D, T, A> Expression<D,T,A>	Expression.ifThenElse(T type, Expression<D,T,? extends A> thenBranch, Expression<D,T,? extends A> elseBranch)
(package private) static final Expression<Void,HonnefDemo.TokenType,HonnefDemo.LList>	HonnefDemo.list(Expression<Void,HonnefDemo.TokenType,HonnefDemo.SExpr> sexpr)
static <D, T, A> Expression<D,T,A>	Expression.lookahead(Map<T,Expression<D,T,? extends A>> map)
static <D, T, A> Expression<D,T,A>	Expression.lookup(Class<A> type, Map<T,? extends A> model)
static <D, T, A> Expression<D,T,A>	Expression.lookup(Map<T,? extends A> model)
<B> Expression<D,T,B>	Expression.map(Function<? super A,? extends B> fun)
<B> Expression<D,T,Map.Entry<A,B>>	Expression.mapsTo(Expression<D,T,B> other)
Expression<D,T,A>	Expression.mapSyntax(Function<? super Parser<D,T>,? extends Parser<D,T>> fun)
Expression<D,T,Optional<A>>	Expression.optional(Parser.Pragma... pragmas)
Expression<D,T,Optional<A>>	Expression.optional(T defaultType)
Expression<D,T,A>	Expression.orElse(A defaultValue, Parser.Pragma... pragmas)
Expression<D,T,A>	Expression.orElse(Expression<D,T,A> other)
Expression<D,T,A>	Expression.orElseGet(Supplier<? extends A> defaultValue, Parser.Pragma... pragmas)
Expression<D,T,List<A>>	Expression.plus(Parser.Pragma... pragmas)
Expression<D,T,List<A>>	Expression.plus(Parser<D,T> sep, Parser.Pragma... pragmas)
Expression<D,T,List<A>>	Expression.plus(T sep, Parser.Pragma... pragmas)
Expression<D,T,A>	Expression.prepend(Parser<D,T> prefix)
Expression<D,T,A>	Expression.prepend(T prefix)
final Expression<D,T,A>	Expression.prepend(T... suffix)
static <D, T, A1, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor1<D,A1,? extends R> cons, AbstractExpression<D,T,? extends A1> arg1)	Creates a compound expression for AST nodes with one parsed argument.
static <D, T, A1, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor1<D,A1,? extends R> cons, Fragment<D,T,? extends A1> arg1)	Creates a compound expression for AST nodes with one parsed argument.
static <D, T, A1, A2, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor2<D,A1,A2,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2)
static <D, T, A1, A2, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor2<D,A1,A2,R> cons, Fragment<D,T,? extends A1> arg1, Fragment<D,T,? extends A2> arg2)
static <D, T, A1, A2, A3, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor3<D,A1,A2,A3,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3)
static <D, T, A1, A2, A3, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor3<D,A1,A2,A3,R> cons, Fragment<D,T,? extends A1> arg1, Fragment<D,T,? extends A2> arg2, Fragment<D,T,? extends A3> arg3)
static <D, T, A1, A2, A3, A4, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor4<D,A1,A2,A3,A4,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4)
static <D, T, A1, A2, A3, A4, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor4<D,A1,A2,A3,A4,R> cons, Fragment<D,T,? extends A1> arg1, Fragment<D,T,? extends A2> arg2, Fragment<D,T,? extends A3> arg3, Fragment<D,T,? extends A4> arg4)
static <D, T, A1, A2, A3, A4, A5, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor5<D,A1,A2,A3,A4,A5,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4, AbstractExpression<D,T,? extends A5> arg5)
static <D, T, A1, A2, A3, A4, A5, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor5<D,A1,A2,A3,A4,A5,R> cons, Fragment<D,T,? extends A1> arg1, Fragment<D,T,? extends A2> arg2, Fragment<D,T,? extends A3> arg3, Fragment<D,T,? extends A4> arg4, Fragment<D,T,? extends A5> arg5)
static <D, T, A1, A2, A3, A4, A5, A6, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor6<D,A1,A2,A3,A4,A5,A6,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4, AbstractExpression<D,T,? extends A5> arg5, AbstractExpression<D,T,? extends A6> arg6)
static <D, T, A1, A2, A3, A4, A5, A6, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor6<D,A1,A2,A3,A4,A5,A6,R> cons, Fragment<D,T,? extends A1> arg1, Fragment<D,T,? extends A2> arg2, Fragment<D,T,? extends A3> arg3, Fragment<D,T,? extends A4> arg4, Fragment<D,T,? extends A5> arg5, Fragment<D,T,? extends A6> arg6)
static <D, T, A1, A2, A3, A4, A5, A6, A7, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor7<D,A1,A2,A3,A4,A5,A6,A7,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4, AbstractExpression<D,T,? extends A5> arg5, AbstractExpression<D,T,? extends A6> arg6, AbstractExpression<D,T,? extends A7> arg7)
static <D, T, A1, A2, A3, A4, A5, A6, A7, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor7<D,A1,A2,A3,A4,A5,A6,A7,R> cons, Fragment<D,T,? extends A1> arg1, Fragment<D,T,? extends A2> arg2, Fragment<D,T,? extends A3> arg3, Fragment<D,T,? extends A4> arg4, Fragment<D,T,? extends A5> arg5, Fragment<D,T,? extends A6> arg6, Fragment<D,T,? extends A7> arg7)
static <D, T, A1, R> Expression<D,T,R>	Reducer.reduce(Reducer.Constructor1<D,A1,? extends R> cons, AbstractExpression<D,T,? extends A1> arg1)	Creates a compound expression for AST nodes with one parsed argument.
static <D, T, A1, A2, R> Expression<D,T,R>	Reducer.reduce(Reducer.Constructor2<D,A1,A2,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2)
static <D, T, A1, A2, A3, R> Expression<D,T,R>	Reducer.reduce(Reducer.Constructor3<D,A1,A2,A3,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3)
static <D, T, A1, A2, A3, A4, R> Expression<D,T,R>	Reducer.reduce(Reducer.Constructor4<D,A1,A2,A3,A4,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4)
static <D, T, A1, A2, A3, A4, A5, R> Expression<D,T,R>	Reducer.reduce(Reducer.Constructor5<D,A1,A2,A3,A4,A5,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4, AbstractExpression<D,T,? extends A5> arg5)
static <D, T, A1, A2, A3, A4, A5, A6, R> Expression<D,T,R>	Reducer.reduce(Reducer.Constructor6<D,A1,A2,A3,A4,A5,A6,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4, AbstractExpression<D,T,? extends A5> arg5, AbstractExpression<D,T,? extends A6> arg6)
static <D, T, A1, A2, A3, A4, A5, A6, A7, R> Expression<D,T,R>	Reducer.reduce(Reducer.Constructor7<D,A1,A2,A3,A4,A5,A6,A7,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4, AbstractExpression<D,T,? extends A5> arg5, AbstractExpression<D,T,? extends A6> arg6, AbstractExpression<D,T,? extends A7> arg7)
(package private) static final Expression<Void,HonnefDemo.TokenType,HonnefDemo.SExpr>	HonnefDemo.sexpr(Expression<Void,HonnefDemo.TokenType,HonnefDemo.SExpr> sexpr)
Expression<D,T,List<A>>	Expression.star(Parser.Pragma... pragmas)
Expression<D,T,List<A>>	Expression.star(Parser<D,T> sep, Parser.Pragma... pragmas)
Expression<D,T,List<A>>	Expression.star(T sep, Parser.Pragma... pragmas)
static <D, T> Expression<D,T,T>	Expression.type(T... types)
static <D, T> Expression<D,T,Void>	Expression.unit()
static <D, T> Expression<D,T,Void>	Expression.unit(Parser<D,T> syntax)
static <D, T> Expression<D,T,Void>	Expression.unit(T... types)
Expression<D,T,A>	Expression.withScope(Map<Object,? extends Data> initializers)
Expression<D,T,A>	Expression.wrap(Parser<D,T> prefix, Parser<D,T> suffix)
Expression<D,T,A>	Expression.wrap(T prefix, T suffix)

Methods in eu.bandm.tools.ramus.runtime2 with parameters of type Expression

Modifier and Type	Method	Description
<B, C> Expression<D,T,C>	Expression.andThenCombining(Expression<D,T,B> other, BiFunction<? super A,? super B,? extends C> pair)
<B> Expression<D,T,B>	Expression.andThenDependent(Expression<D,T,Function<? super A,? extends B>> other)
static <D, T, A> Expression<D,T,A>	Expression.choice(Expression<D,T,? extends A>... alts)
(package private) static final Expression<Void,HonnefDemo.TokenType,List<HonnefDemo.SExpr>>	HonnefDemo.elems(Expression<Void,HonnefDemo.TokenType,HonnefDemo.SExpr> sexpr)
static <D, T, A> Expression<D,T,A>	Expression.ifThenElse(T type, Expression<D,T,? extends A> thenBranch, Expression<D,T,? extends A> elseBranch)
(package private) static final Expression<Void,HonnefDemo.TokenType,HonnefDemo.LList>	HonnefDemo.list(Expression<Void,HonnefDemo.TokenType,HonnefDemo.SExpr> sexpr)
<B> Expression<D,T,Map.Entry<A,B>>	Expression.mapsTo(Expression<D,T,B> other)
Expression<D,T,A>	Expression.orElse(Expression<D,T,A> other)
(package private) static final Expression<Void,HonnefDemo.TokenType,HonnefDemo.SExpr>	HonnefDemo.sexpr(Expression<Void,HonnefDemo.TokenType,HonnefDemo.SExpr> sexpr)
(package private) static <A> List<A>	Parser.Test.test(Expression<Void,Parser.Test.TokenType,A> expr, Parser.Test.TokenType... input)

Method parameters in eu.bandm.tools.ramus.runtime2 with type arguments of type Expression

Modifier and Type	Method	Description
static <D, T, A> Expression<D,T,A>	Expression.fix(Function<Expression<D,T,A>,Expression<D,T,A>> loop)
static <D, T, A> Expression<D,T,A>	Expression.fix(Function<Expression<D,T,A>,Expression<D,T,A>> loop)
static <D, T, A> Expression<D,T,A>	Expression.lookahead(Map<T,Expression<D,T,? extends A>> map)