An exponentiation expression.

Defined via `power`. Right-associative.

Examples:

```sideLength^dimension
e^x
```
• `Anything`
• `Object`
• `Node`
• `Expression`
• `ValueExpression`
• `Operation`
• `BinaryOperation`
• `ArithmeticOperation`
• `ExponentiationOperation`
• `ExponentiationOperation`
• `ArithmeticOperation`
• `BinaryOperation`
• `Operation`
• `ValueExpression`
• `Expression`
• `Node`
• `Object`
• `Anything`

no subtypes hierarchy

 Initializer `ExponentiationOperation(PrePostfixingExpression base, ExponentiatingExpression exponent)`Parameters: `base`The base expression. `exponent`The exponent or power expression.
 Attributes `base` `shared PrePostfixingExpression base`The base expression. `children` `shared actual [PrePostfixingExpression, ExponentiatingExpression] children`The child nodes of this node. Refines `BinaryOperation.children` ultimately refines `Node.children` `exponent` `shared ExponentiatingExpression exponent`The exponent or power expression. `hash` `shared actual Integer hash`The hash value of the value, which allows the value to be an element of a hash-based set or key of a hash-based map. Implementations must respect the constraint that: if `x==y` then `x.hash==y.hash`. Therefore, a class which refines `equals` must also refine `hash`. Because the `Integer` type is platform-dependent a compiler for a given platform is permitted to further manipulate the calculated hash for an object, and the resulting hash may differ between platforms. Refines `Object.hash` `leftOperand` `shared actual PrePostfixingExpression leftOperand`The base expression. See also `base` `operator` `shared actual String operator`The text of the operator. Refines `Operation.operator` `rightOperand` `shared actual ExponentiatingExpression rightOperand`The exponent or power expression. See also `exponent`
 Inherited Attributes Attributes inherited from: `BinaryOperation` Attributes inherited from: `Expression``children` Attributes inherited from: `Node` Attributes inherited from: `Object``hash`, `string` Attributes inherited from: `Operation`
 Methods `copy` `shared ExponentiationOperation copy(PrePostfixingExpression leftOperand = ..., ExponentiatingExpression rightOperand = ...)`Parameters: `leftOperand = this.leftOperand``rightOperand = this.rightOperand` `equals` `shared actual Boolean equals(Object that)`Determine if two values are equal. Implementations should respect the constraints that: if `x===y` then `x==y` (reflexivity), if `x==y` then `y==x` (symmetry), if `x==y` and `y==z` then `x==z` (transitivity). Furthermore it is recommended that implementations ensure that if `x==y` then `x` and `y` have the same concrete class. A class which explicitly refines `equals()` is said to support value equality, and the equality operator `==` is considered much more meaningful for such classes than for a class which simply inherits the default implementation of identity equality from `Identifiable`. Refines `Object.equals` `transform` `shared actual Result transform(Transformer transformer)`Transform this node with the given `transformer` by calling the appropriate `transformX` method on the transformer. If you have a `Node node` that’s actually an `LIdentifier` instance, then the runtime will call `LIdentifier.transform`; therefore, this method is by nature narrowing. This means that if `transformer` is a `NarrowingTransformer`, calling `node.transform(transformer)` is equivalent to calling `transformer.transformNode(node)`. On the other hand, if `transformer` is a `WideningTransformer`, then the two operations are very different. Refines `Node.transform` `visit` `shared actual void visit(Visitor visitor)`Visit this node with the given `visitor`. Calls the appropriate `visitX` method on the visitor. Refines `Node.visit`
 Inherited Methods Methods inherited from: `Node` Methods inherited from: `Object``equals`