Type Members

1.  sealed trait AbbrevForwardStep extends ForwardStep
2.  sealed trait AdditionOp extends XPathElem with LeafElem
3.  sealed trait AdditiveExpr extends SimpleRangeExpr

   Additive expression.

   Additive expression. Addition/subtraction is left-associative.

4.  sealed trait AndExpr extends SimpleOrExpr

   And-expression.

   And-expression. The "and" operator is associative, so the AST could have been left-associative or right-associative.

5.  sealed trait Argument extends XPathElem
6.  final case class ArgumentList(arguments: IndexedSeq[Argument]) extends Postfix with Product with Serializable
7.  sealed trait ArrayConstructor extends PrimaryExpr
8.  sealed trait ArrayTest extends ItemType
9.  sealed trait ArrowExpr extends SimpleCastExpr

   Arrow expression.

   Arrow expression. The arrow operator is left-associative.

10.  final case class ArrowFunctionCall(arrowFunctionSpecifier: ArrowFunctionSpecifier, argumentList: ArgumentList) extends XPathElem with Product with Serializable
11.  sealed trait ArrowFunctionSpecifier extends XPathElem
12.  final case class AtomicOrUnionType(tpe: EQName) extends ItemType with LeafElem with Product with Serializable
13.  final case class AttributeAxisAbbrevForwardStep(nodeTest: NodeTest) extends AbbrevForwardStep with Product with Serializable
14.  final case class AttributeNameAndTypeTest(name: EQName, tpe: EQName) extends AttributeTest with LeafElem with Product with Serializable
15.  final case class AttributeNameTest(name: EQName) extends AttributeTest with LeafElem with Product with Serializable
16.  sealed trait AttributeTest extends KindTest
17.  final case class AttributeTypeTest(tpe: EQName) extends AttributeTest with LeafElem with Product with Serializable
18.  sealed trait AxisStep extends StepExpr

    Axis step.

    Axis step. For example: "child::book[@pageCount > 800]". The "[]" operator for adding predicates is left-associative.

19.  final case class BracedUriLiteral(namespaceOption: Option[String]) extends Product with Serializable

    Braced URI literal.

20.  sealed trait CastExpr extends SimpleCastableExpr
21.  sealed trait CastableExpr extends SimpleTreatExpr
22.  sealed trait Comp extends XPathElem with LeafElem
23.  sealed trait ComparisonExpr extends SimpleAndExpr

    Comparison expression, where the optional comparison operator is a value comparison operator, general comparison operator or node comparison operator.

24.  final case class CompoundAdditiveExpr(init: AdditiveExpr, op: AdditionOp, lastMultiplicativeExpr: MultiplicativeExpr) extends AdditiveExpr with Product with Serializable
25.  final case class CompoundAndExpr(firstComparisonExpr: ComparisonExpr, remainingComparisonExprs: NonEmptyVector[ComparisonExpr]) extends AndExpr with Product with Serializable
26.  final case class CompoundArrowExpr(unaryExpr: UnaryExpr, arrowFunctionCalls: NonEmptyVector[ArrowFunctionCall]) extends ArrowExpr with Product with Serializable
27.  final case class CompoundCastExpr(arrowExpr: ArrowExpr, singleType: SingleType) extends CastExpr with Product with Serializable
28.  final case class CompoundCastableExpr(castExpr: CastExpr, singleType: SingleType) extends CastableExpr with Product with Serializable
29.  final case class CompoundComparisonExpr(stringConcatExpr1: StringConcatExpr, comp: Comp, stringConcatExpr2: StringConcatExpr) extends ComparisonExpr with Product with Serializable
30.  final case class CompoundExpr(firstExprSingle: ExprSingle, remainingExprSingleSeq: NonEmptyVector[ExprSingle]) extends Expr with Product with Serializable
31.  final case class CompoundInstanceOfExpr(treatExpr: TreatExpr, sequenceType: SequenceType) extends InstanceOfExpr with Product with Serializable
32.  final case class CompoundIntersectExceptExpr(init: IntersectExceptExpr, op: IntersectExceptOp, lastInstanceOfExpr: InstanceOfExpr) extends IntersectExceptExpr with Product with Serializable
33.  final case class CompoundMultiplicativeExpr(init: MultiplicativeExpr, op: MultiplicativeOp, lastUnionExpr: UnionExpr) extends MultiplicativeExpr with Product with Serializable
34.  final case class CompoundOrExpr(firstAndExpr: AndExpr, remainingAndExprs: NonEmptyVector[AndExpr]) extends OrExpr with Product with Serializable
35.  final case class CompoundPostfixExpr(primaryExpr: PrimaryExpr, postfixes: NonEmptyVector[Postfix]) extends PostfixExpr with Product with Serializable
36.  final case class CompoundRangeExpr(additiveExpr1: AdditiveExpr, additiveExpr2: AdditiveExpr) extends RangeExpr with Product with Serializable
37.  final case class CompoundRelativePathExpr(init: RelativePathExpr, op: StepOp, lastStepExpr: StepExpr) extends RelativePathExpr with Product with Serializable
38.  final case class CompoundSimpleMapExpr(firstPathExpr: PathExpr, remainingPathExprs: NonEmptyVector[PathExpr]) extends SimpleMapExpr with Product with Serializable
39.  final case class CompoundStringConcatExpr(firstRangeExpr: RangeExpr, remainingRangeExprs: NonEmptyVector[RangeExpr]) extends StringConcatExpr with Product with Serializable
40.  final case class CompoundTreatExpr(castableExpr: CastableExpr, sequenceType: SequenceType) extends TreatExpr with Product with Serializable
41.  final case class CompoundUnaryExpr(ops: NonEmptyVector[UnaryOp], valueExpr: ValueExpr) extends UnaryExpr with Product with Serializable
42.  final case class CompoundUnionExpr(firstIntersectExceptExpr: IntersectExceptExpr, remainingIntersectExceptExprs: NonEmptyVector[IntersectExceptExpr]) extends UnionExpr with Product with Serializable
43.  final case class CurlyArrayConstructor(expr: EnclosedExpr) extends ArrayConstructor with Product with Serializable
44.  final case class DataPITest(data: StringLiteral) extends PITest with Product with Serializable
45.  final case class DecimalLiteral(value: BigDecimal) extends NumericLiteral with LeafElem with Product with Serializable
46.  sealed trait DocumentTest extends KindTest
47.  final case class DocumentTestContainingElementTest(elementTest: ElementTest) extends DocumentTest with Product with Serializable
48.  final case class DocumentTestContainingSchemaElementTest(schemaElementTest: SchemaElementTest) extends DocumentTest with Product with Serializable
49.  final case class DoubleLiteral(value: Double) extends NumericLiteral with LeafElem with Product with Serializable
50.  sealed trait EQName extends AnyRef

    EQName, so either a URIQualifiedName or a QName.

51.  final case class EQNameAsArrowFunctionSpecifier(eqName: EQName) extends ArrowFunctionSpecifier with LeafElem with Product with Serializable
52.  final case class ElementNameAndTypeTest(name: EQName, tpe: EQName) extends ElementTest with LeafElem with Product with Serializable
53.  final case class ElementNameTest(name: EQName) extends ElementTest with LeafElem with Product with Serializable
54.  sealed trait ElementTest extends KindTest
55.  final case class ElementTypeTest(tpe: EQName) extends ElementTest with LeafElem with Product with Serializable
56.  final case class EnclosedExpr(exprOption: Option[Expr]) extends XPathElem with Product with Serializable

    Optional expression enclosed in braces.

57.  final case class ExactlyOneSequenceType(itemType: ItemType) extends SequenceType with Product with Serializable
58.  sealed trait Expr extends XPathExpr

    Expression, which is a sequence of 1 or more ExprSingle objects, separated by commas.

    Expression, which is a sequence of 1 or more ExprSingle objects, separated by commas. The "comma" operator is associative, so the AST could have been left-associative or right-associative.

59.  sealed trait ExprSingle extends SimpleExpr

    Expression-single, that is, an expression without any top-level commas.

    Expression-single, that is, an expression without any top-level commas. Most XPath expressions are expression-singles.

60.  final case class ExprSingleArgument(exprSingle: ExprSingle) extends Argument with Product with Serializable
61.  final case class ForExpr(simpleForBindings: NonEmptyVector[SimpleForBinding], returnExpr: ExprSingle) extends ExprSingle with VariableIntroducingExpr with Product with Serializable
62.  sealed trait ForwardAxis extends XPathElem with LeafElem
63.  final case class ForwardAxisStep(step: ForwardStep, predicateList: IndexedSeq[Predicate]) extends AxisStep with Product with Serializable
64.  sealed trait ForwardStep extends XPathElem
65.  final case class FunctionCall(functionName: EQName, argumentList: ArgumentList) extends PrimaryExpr with Product with Serializable
66.  sealed trait FunctionItemExpr extends PrimaryExpr
67.  sealed trait FunctionTest extends ItemType
68.  sealed trait GeneralComp extends Comp
69.  final case class IfExpr(condition: Expr, thenExpr: ExprSingle, elseExpr: ExprSingle) extends ExprSingle with Product with Serializable
70.  final case class InlineFunctionExpr(paramListOption: Option[ParamList], resultTypeOption: Option[SequenceType], body: EnclosedExpr) extends FunctionItemExpr with Product with Serializable
71.  sealed trait InstanceOfExpr extends SimpleIntersectExceptExpr
72.  final case class IntegerLiteral(value: BigInt) extends NumericLiteral with LeafElem with Product with Serializable
73.  sealed trait IntersectExceptExpr extends SimpleUnionExpr

    Intersect or except expression, optionally using the "intersect" or "except" operator.

    Intersect or except expression, optionally using the "intersect" or "except" operator. These operators are left-associative.

74.  sealed trait IntersectExceptOp extends XPathElem with LeafElem
75.  sealed trait ItemType extends XPathElem
76.  sealed trait KeySpecifier extends XPathElem
77.  sealed trait KindTest extends NodeTest
78.  final case class KindTestItemType(kindTest: KindTest) extends ItemType with Product with Serializable
79.  sealed trait LeafElem extends XPathElem

    Any leaf element in the AST of an XPath expression.

80.  final case class LetExpr(simpleLetBindings: NonEmptyVector[SimpleLetBinding], returnExpr: ExprSingle) extends ExprSingle with VariableIntroducingExpr with Product with Serializable
81.  sealed trait Literal extends PrimaryExpr
82.  final case class LocalNameWildcard(localName: NCName) extends Wildcard with LeafElem with Product with Serializable
83.  final case class MapConstructor(entries: IndexedSeq[MapConstructorEntry]) extends PrimaryExpr with Product with Serializable
84.  final case class MapConstructorEntry(keyExpr: ExprSingle, valueExpr: ExprSingle) extends XPathElem with Product with Serializable
85.  sealed trait MapTest extends ItemType
86.  sealed trait MultiplicativeExpr extends SimpleAdditiveExpr

    Multiplicative expression.

    Multiplicative expression. The corresponding multiplication/division operators are left-associative.

87.  sealed trait MultiplicativeOp extends XPathElem with LeafElem
88.  final case class NCName(name: String) extends Product with Serializable

    NCName, that is, a non-colon name.

89.  sealed trait NameTest extends NodeTest
90.  final case class NamedFunctionRef(functionName: EQName, arity: BigInt) extends FunctionItemExpr with LeafElem with Product with Serializable
91.  final case class NamedKeySpecifier(ncName: NCName) extends KeySpecifier with LeafElem with Product with Serializable
92.  final case class NamespaceWildcard(bracedUriLiteral: BracedUriLiteral) extends Wildcard with LeafElem with Product with Serializable
93.  final case class NillableElementNameAndTypeTest(name: EQName, tpe: EQName) extends ElementTest with LeafElem with Product with Serializable
94.  final case class NillableElementTypeTest(tpe: EQName) extends ElementTest with LeafElem with Product with Serializable
95.  sealed trait NodeComp extends Comp
96.  sealed trait NodeTest extends XPathElem
97.  final case class NonAbbrevForwardStep(forwardAxis: ForwardAxis, nodeTest: NodeTest) extends ForwardStep with Product with Serializable
98.  final case class NonAbbrevReverseStep(reverseAxis: ReverseAxis, nodeTest: NodeTest) extends ReverseStep with Product with Serializable
99.  final case class NonEmptySingleType(name: EQName) extends SingleType with LeafElem with Product with Serializable
100.  sealed trait NumericLiteral extends Literal
101.  final case class OneOrMoreSequenceType(itemType: ItemType) extends SequenceType with Product with Serializable
102.  sealed trait OrExpr extends ExprSingle

     Or-expression.

     Or-expression. The "or" operator is associative, so the AST could have been left-associative or right-associative.

103.  sealed trait PITest extends KindTest
104.  final case class Param(paramName: EQName, typeDeclarationOption: Option[TypeDeclaration]) extends XPathElem with Product with Serializable
105.  final case class ParamList(params: IndexedSeq[Param]) extends XPathElem with Product with Serializable
106.  final case class ParenthesizedExpr(exprOption: Option[Expr]) extends PrimaryExpr with Product with Serializable
107.  final case class ParenthesizedExprAsArrowFunctionSpecifier(parenthesizedExpr: ParenthesizedExpr) extends ArrowFunctionSpecifier with Product with Serializable
108.  final case class ParenthesizedExprKeySpecifier(parenthesizedExpr: ParenthesizedExpr) extends KeySpecifier with Product with Serializable
109.  final case class ParenthesizedItemType(itemType: ItemType) extends ItemType with Product with Serializable
110.  sealed trait PathExpr extends SimpleSimpleMapExpr

     Path expression, so a relative path expression possibly preceded by "/" or "//" (or the expression "/" itself).

     Path expression, so a relative path expression possibly preceded by "/" or "//" (or the expression "/" itself). Path expressions are used to locate nodes within trees.

111.  final case class PathExprStartingWithDoubleSlash(relativePathExpr: RelativePathExpr) extends PathExpr with Product with Serializable
112.  final case class PathExprStartingWithSingleSlash(relativePathExpr: RelativePathExpr) extends PathExpr with Product with Serializable
113.  final case class PositionalKeySpecifier(integerLiteral: IntegerLiteral) extends KeySpecifier with Product with Serializable
114.  sealed trait Postfix extends XPathElem
115.  sealed trait PostfixExpr extends StepExpr

     Postfix expression, which is a primary expression succeeded by 0 or more predicates, arguments lists and/or lookups.

     Postfix expression, which is a primary expression succeeded by 0 or more predicates, arguments lists and/or lookups. Note that lookup (the "?" operator) is left-associative.

116.  final case class PostfixLookup(keySpecifier: KeySpecifier) extends Postfix with Product with Serializable
117.  final case class PotentiallyEmptySingleType(name: EQName) extends SingleType with LeafElem with Product with Serializable
118.  final case class Predicate(expr: Expr) extends Postfix with Product with Serializable
119.  final case class PrefixWildcard(prefix: NCName) extends Wildcard with LeafElem with Product with Serializable
120.  sealed trait PrimaryExpr extends SimplePostfixExpr

     Primary expression, which are the basic primitives of the language.

     Primary expression, which are the basic primitives of the language. Examples are literals, variable references, function calls etc. Note that primary expressions can be rather simple but they do not have to be simple. For example, function calls can have arguments that are themselves quite complex expressions.

121.  final case class QuantifiedExpr(quantifier: Quantifier, simpleBindings: NonEmptyVector[SimpleBindingInQuantifiedExpr], satisfiesExpr: ExprSingle) extends ExprSingle with VariableIntroducingExpr with Product with Serializable
122.  sealed trait Quantifier extends XPathElem with LeafElem
123.  sealed trait RangeExpr extends SimpleStringConcatExpr

     Range expression, where the optional range uses keyword "to" as operator.

124.  sealed trait RelativePathExpr extends PathExpr

     Relative path expression, consisting of a number of step expressions separated by step operators ("/" and "//").

     Relative path expression, consisting of a number of step expressions separated by step operators ("/" and "//"). These step operators are left-associative.

125.  sealed trait ReverseAxis extends XPathElem with LeafElem
126.  final case class ReverseAxisStep(step: ReverseStep, predicateList: IndexedSeq[Predicate]) extends AxisStep with Product with Serializable
127.  sealed trait ReverseStep extends XPathElem
128.  final case class SchemaAttributeTest(name: EQName) extends KindTest with LeafElem with Product with Serializable
129.  final case class SchemaElementTest(name: EQName) extends KindTest with LeafElem with Product with Serializable
130.  sealed trait SequenceType extends XPathElem
131.  final case class SimpleAbbrevForwardStep(nodeTest: NodeTest) extends AbbrevForwardStep with Product with Serializable
132.  sealed trait SimpleAdditiveExpr extends AdditiveExpr
133.  sealed trait SimpleAndExpr extends AndExpr
134.  sealed trait SimpleArrowExpr extends ArrowExpr
135.  final case class SimpleBindingInQuantifiedExpr(varName: EQName, expr: ExprSingle) extends VariableBinding with Product with Serializable
136.  sealed trait SimpleCastExpr extends CastExpr
137.  sealed trait SimpleCastableExpr extends CastableExpr
138.  sealed trait SimpleComparisonExpr extends ComparisonExpr
139.  sealed trait SimpleExpr extends Expr
140.  final case class SimpleForBinding(varName: EQName, expr: ExprSingle) extends VariableBinding with Product with Serializable
141.  sealed trait SimpleInstanceOfExpr extends InstanceOfExpr
142.  sealed trait SimpleIntersectExceptExpr extends IntersectExceptExpr
143.  final case class SimpleLetBinding(varName: EQName, expr: ExprSingle) extends VariableBinding with Product with Serializable
144.  sealed trait SimpleMapExpr extends ValueExpr

     Simple map expression, using the optional map operator ("!").

     Simple map expression, using the optional map operator ("!"). This operator is left-associative.

145.  sealed trait SimpleMultiplicativeExpr extends MultiplicativeExpr
146.  final case class SimpleNameTest(name: EQName) extends NameTest with LeafElem with Product with Serializable
147.  sealed trait SimpleOrExpr extends OrExpr
148.  sealed trait SimplePostfixExpr extends PostfixExpr
149.  sealed trait SimpleRangeExpr extends RangeExpr
150.  sealed trait SimpleRelativePathExpr extends RelativePathExpr
151.  sealed trait SimpleSimpleMapExpr extends SimpleMapExpr
152.  sealed trait SimpleStringConcatExpr extends StringConcatExpr
153.  sealed trait SimpleTreatExpr extends TreatExpr
154.  sealed trait SimpleUnaryExpr extends UnaryExpr
155.  sealed trait SimpleUnionExpr extends UnionExpr
156.  sealed trait SingleType extends XPathElem
157.  final case class SquareArrayConstructor(members: IndexedSeq[ExprSingle]) extends ArrayConstructor with Product with Serializable
158.  sealed trait StepExpr extends SimpleRelativePathExpr

     Single step in an absolute or relative path expression.

     Single step in an absolute or relative path expression. Note that step expressions are either postfix expressions or axis steps.

159.  sealed trait StepOp extends XPathElem with LeafElem
160.  sealed trait StringConcatExpr extends SimpleComparisonExpr

     String concatenation expression, where the optional string concatenation uses the "||" operator.

     String concatenation expression, where the optional string concatenation uses the "||" operator. String concatenation is left-associative.

161.  final case class StringLiteral(value: String) extends Literal with LeafElem with Product with Serializable
162.  final case class TargetPITest(target: NCName) extends PITest with LeafElem with Product with Serializable
163.  sealed trait TreatExpr extends SimpleInstanceOfExpr
164.  final case class TypeDeclaration(tpe: SequenceType) extends XPathElem with Product with Serializable
165.  final case class TypedArrayTest(elementType: SequenceType) extends ArrayTest with Product with Serializable
166.  final case class TypedFunctionTest(argumentTypes: IndexedSeq[SequenceType], resultType: SequenceType) extends FunctionTest with Product with Serializable
167.  final case class TypedMapTest(keyType: AtomicOrUnionType, valueType: SequenceType) extends MapTest with Product with Serializable
168.  sealed trait UnaryExpr extends SimpleArrowExpr

     Unary expression.

     Unary expression. The corresponding unary operators are right-associative.

169.  final case class UnaryLookup(keySpecifier: KeySpecifier) extends PrimaryExpr with Product with Serializable
170.  sealed trait UnaryOp extends XPathElem with LeafElem
171.  sealed trait UnionExpr extends SimpleMultiplicativeExpr

     Union expression, where the optional union uses operator "union" or "|".

     Union expression, where the optional union uses operator "union" or "|". The union operator is associative, so the AST could have been left-associative or right-associative.

172.  sealed trait ValueComp extends Comp
173.  sealed trait ValueExpr extends SimpleUnaryExpr
174.  final case class VarRef(varName: EQName) extends PrimaryExpr with LeafElem with Product with Serializable
175.  final case class VarRefAsArrowFunctionSpecifier(varRef: VarRef) extends ArrowFunctionSpecifier with Product with Serializable
176.  sealed trait VariableBinding extends XPathElem

     Binding of a variable name to an expression.

177.  sealed trait VariableIntroducingExpr extends XPathElem

     XPathElem that can introduce one or more variable bindings.

178.  sealed trait Wildcard extends NameTest
179.  sealed trait XPathElem extends ElemLike[XPathElem]

     XPath 3.1 AST.

     XPath 3.1 AST. The root of the type hierarchy is XPathElem. It offers the ElemApi query API.

     The requirements on this AST are as follows:

     • It must represent the syntax tree of a successfully parsed XPath expression
     • It is not annotated with more semantic information, like type information that is not included in the XPath expression
     • It does not know anything about the context in which it runs, like bound namespaces etc.
     • It is rich enough to be able to serialize the AST back to XPath, knowing exactly where to place parentheses, braces, etc.
     • It should help evaluation, so it should model operator associativity and precedence correctly, where feasible
     • It must be readable in that object composition trees are not unnecessarily deep and therefore hard to comprehend
     • Serialization of the AST to XPath may lead to differences in whitespace (and operator aliases), but other than that the result must be the same
     • The AST class hierarchy does not have to use the exact same names as the XPath grammar
     • Instances of the AST classes are easy to create in an ad-hoc manner, so they contain no parsing state
     • The AST classes are case classes, with value equality and good support for pattern matching

     It would be natural for the AST types to have IS-A relationships modeled as type inheritance, and HAS-A relationships modeled as composition. Where feasible, this approach has been followed. Consequently, sealed trait inheritance has been used a lot (IS-A instead of HAS-A), and unnecessarily deep object trees are prevented in this way.

     Having such an AST of a successfully parsed XPath expression, it must be easy to reliably find used namespace prefixes, for example.

     The AST, as well as the parser, were developed using the XPath 3.1 specification as input. In particular, see https://www.w3.org/TR/xpath-31/#id-grammar and https://www.w3.org/TR/xpath-31/#id-precedence-order. Note that the grammar in isolation does not clearly convey left or right associativity of operators, so the extra information about operator precedence and associativity is essential for understanding the "structure" of compound expressions.

     TODO Improve several class names.

180.  sealed trait XPathExpr extends XPathElem

     XPath expression.

181.  final case class ZeroOrMoreSequenceType(itemType: ItemType) extends SequenceType with Product with Serializable
182.  final case class ZeroOrOneSequenceType(itemType: ItemType) extends SequenceType with Product with Serializable