Dyad (QDL root module 1.6.0 API)

java.lang.Object
- org.qdl_lang.expressions.ExpressionImpl
- - org.qdl_lang.expressions.Dyad

All Implemented Interfaces:

Serializable, ExpressionNode, ExpressionInterface, HasResultInterface, Statement

Direct Known Subclasses:

ComparisonDyad
```
public class Dyad
extends ExpressionImpl
```
Created by Jeff Gaynor
on 1/13/20 at 3:47 PM

See Also:

Serialized Form

Field Summary
- Fields inherited from class org.qdl_lang.expressions.ExpressionImpl
  arguments, result, valence
- Fields inherited from interface org.qdl_lang.statements.ExpressionInterface
  ALL_INDICES_NODE, ALT_IF_NODE, ASSIGNMENT_NODE, CLOSED_SLICE_NODE, COMPARISON_DYAD_NODE, CONSTANT_NODE, DYAD_NODE, DYADIC_FUNCTION_REFERENCE_NODE, EXPRESSION_STEM_NODE, EXPRESSION_STEM2_NODE, FUNCTION_REFERENCE_NODE, LAMBDA_DEFINITION_NODE, LIST_NODE, MODULE_NODE, MONAD_NODE, NILAD_NODE, OPEN_SLICE_NODE, PARENTHESIZED_NODE, PARSE_EXPRESSION_BLOCK_NODE, PARSE_STATEMENT_BLOCK_NODE, POLYAD_NODE, QDL_NULL_NODE, SELECT_NODE, SET_NODE, STEM_ENTRY_NODE, STEM_EXTRACTION_NODE, STEM_NODE, UNKNOWN_NODE, VARIABLE_NODE

Constructor Summary

Constructors
Constructor	Description
`Dyad(int operatorType)`
`Dyad(int operatorType, ExpressionNode leftNode, ExpressionNode rightNode)`
`Dyad(int operatorType, TokenPosition tokenPosition)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`Object`	`evaluate(State state)`
`ExpressionInterface`	`getLeftArgument()`
`int`	`getNodeType()`	QDL is not strongly typed but Java is, so each node type should have a unique integer and conditionals should use that, not the instanceof operator.
`ExpressionInterface`	`getRightArgument()`
`boolean`	`isUnary()`	Demotes that this is actually a unary operator that is converted to dyadic by the interpreter.
`ExpressionNode`	`makeCopy()`
`void`	`setLeftArgument(ExpressionInterface node)`
`void`	`setRightArgument(ExpressionInterface node)`
`void`	`setUnary(boolean unary)`

Methods inherited from class org.qdl_lang.expressions.ExpressionImpl
evalArg, evalLastArg, evaluatedArgs, getAlias, getArgAt, getArgCount, getArguments, getEvaluatedArgs, getLastArg, getOperatorType, getResult, getResultType, getSourceCode, getTokenPosition, hasAlias, hasEvaluatedArgs, hasTokenPosition, isEvaluated, isSizeQuery, setAlias, setArguments, setEvaluated, setEvaluatedArgs, setOperatorType, setResult, setResultType, setSizeQuery, setSourceCode, setTokenPosition, toString

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

Dyad

public Dyad(int operatorType,
            TokenPosition tokenPosition)

Dyad
```
public Dyad(int operatorType)
```

Dyad

public Dyad(int operatorType,
            ExpressionNode leftNode,
            ExpressionNode rightNode)

Method Detail
- isUnary
```
public boolean isUnary()
```
  Demotes that this is actually a unary operator that is converted to dyadic by the interpreter.
  
  Returns:
- setUnary
```
public void setUnary(boolean unary)
```
- evaluate
```
public Object evaluate(State state)
```
- getLeftArgument
```
public ExpressionInterface getLeftArgument()
```
- getRightArgument
```
public ExpressionInterface getRightArgument()
```
- setLeftArgument
```
public void setLeftArgument(ExpressionInterface node)
```
- setRightArgument
```
public void setRightArgument(ExpressionInterface node)
```
- makeCopy
```
public ExpressionNode makeCopy()
```
- getNodeType
```
public int getNodeType()
```
  Description copied from interface: ExpressionInterface
  
  QDL is not strongly typed but Java is, so each node type should have a unique integer and conditionals should use that, not the instanceof operator. This allows for efficient programming with switch statements rather than a bevy of conditionals (potentially each of which gets done even if the correct case has been handled).
  
  Returns: