A scale expression.

Defined via `scale`. Right-associative.

Examples:

```2 ** vector
brakeFactor ** velocity
```

The scale operation is special because the receiver of the method invocation by which it is defined is the right-hand side, not the left-hand side. In other words, `lhs ** rhs` corresponds to

```rhs.scale(lhs)
```

while e. g. `lhs * rhs` corresponds to

```lhs.times(rhs)
```

(the qualifier and argument swapped places).

• `Anything`
• `Object`
• `Node`
• `Expression`
• `ValueExpression`
• `Operation`
• `BinaryOperation`
• `ScaleOperation`
• `ScaleOperation`
• `BinaryOperation`
• `Operation`
• `ValueExpression`
• `Expression`
• `Node`
• `Object`
• `Anything`

no subtypes hierarchy

 Initializer `ScaleOperation(MultiplyingExpression factor, ScalingExpression scalable)`Parameters: `factor`The factor by which the `scalable` is scaled `scalable`The `Scalable` being scaled
 Attributes `children` `shared actual [MultiplyingExpression, ScalingExpression] children`The child nodes of this node. Refines `BinaryOperation.children` ultimately refines `Node.children` `factor` `shared MultiplyingExpression factor`The factor by which the `scalable` is scaled `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 factor by which the `scalable` is scaled See also `factor` `operator` `shared actual String operator`The text of the operator. Refines `Operation.operator` `rightOperand` `shared actual ScalingExpression rightOperand`The `Scalable` being scaled See also `scalable` `scalable` `shared ScalingExpression scalable`The `Scalable` being scaled
 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 ScaleOperation copy(MultiplyingExpression leftOperand = ..., ScalingExpression 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`