A remainder expression.

Defined via `remainder`. Left-associative.

See also `RemainderAssignmentOperation`
• `Anything`
• `Object`
• `Node`
• `Expression`
• `ValueExpression`
• `Operation`
• `BinaryOperation`
• `ArithmeticOperation`
• `RemainderOperation`
• `RemainderOperation`
• `ArithmeticOperation`
• `BinaryOperation`
• `Operation`
• `ValueExpression`
• `Expression`
• `Node`
• `Object`
• `Anything`

no subtypes hierarchy

 Initializer `RemainderOperation(MultiplyingExpression dividend, UnioningExpression divisor)`Parameters: `dividend`The dividend, or numerator. `divisor`The divisor, or denominator.
 Attributes `children` `shared actual [MultiplyingExpression, UnioningExpression] children`The child nodes of this node. Refines `BinaryOperation.children` ultimately refines `Node.children` `dividend` `shared MultiplyingExpression dividend`The dividend, or numerator. `divisor` `shared UnioningExpression divisor`The divisor, or denominator. `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 MultiplyingExpression leftOperand`The dividend, or numerator. See also `dividend` `operator` `shared actual String operator`The text of the operator. Refines `Operation.operator` `rightOperand` `shared actual UnioningExpression rightOperand`The divisor, or denominator. See also `divisor`
 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 RemainderOperation copy(MultiplyingExpression leftOperand = ..., UnioningExpression 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`