RHSOperator<'Op, 'Aux, 'Expr, 'T, 'State, 'Input, 'InputSlice> (XParsec) | XParsec

RHSOperator<'Op, 'Aux, 'Expr, 'T, 'State, 'Input, 'InputSlice> Type

Namespace: XParsec.OperatorParsing
Assembly: XParsec.dll
Base Type: obj

Union cases

Union case	Description
`Indexer(op, parseOp, leftPower, closeOp, parseCloseOp, parseInnerExpr, completeIndexer)` Full Usage: `Indexer(op, parseOp, leftPower, closeOp, parseCloseOp, parseInnerExpr, completeIndexer)` Parameters: op : `'Op` parseOp : `Parser<'Op, 'T, 'State, 'Input, 'InputSlice>` leftPower : `byte<MeasureProduct<bp, MeasureOne>>` closeOp : `'Op` parseCloseOp : `Parser<'Op, 'T, 'State, 'Input, 'InputSlice>` parseInnerExpr : `Parser<'Aux, 'T, 'State, 'Input, 'InputSlice>` completeIndexer : `'Expr -> 'Op -> 'Aux -> 'Op -> 'Expr`	op : `'Op` parseOp : `Parser<'Op, 'T, 'State, 'Input, 'InputSlice>` leftPower : `byte<MeasureProduct<bp, MeasureOne>>` closeOp : `'Op` parseCloseOp : `Parser<'Op, 'T, 'State, 'Input, 'InputSlice>` parseInnerExpr : `Parser<'Aux, 'T, 'State, 'Input, 'InputSlice>` completeIndexer : `'Expr -> 'Op -> 'Aux -> 'Op -> 'Expr`
`InfixLeft(op, parseOp, leftPower, completeInfix)` Full Usage: `InfixLeft(op, parseOp, leftPower, completeInfix)` Parameters: op : `'Op` parseOp : `Parser<'Op, 'T, 'State, 'Input, 'InputSlice>` leftPower : `byte<MeasureProduct<bp, MeasureOne>>` completeInfix : `'Expr -> 'Op -> 'Expr -> 'Expr`	op : `'Op` parseOp : `Parser<'Op, 'T, 'State, 'Input, 'InputSlice>` leftPower : `byte<MeasureProduct<bp, MeasureOne>>` completeInfix : `'Expr -> 'Op -> 'Expr -> 'Expr`
`InfixMapped(op, parseOp, leftPower, parseRight, complete)` Full Usage: `InfixMapped(op, parseOp, leftPower, parseRight, complete)` Parameters: op : `'Op` parseOp : `Parser<'Op, 'T, 'State, 'Input, 'InputSlice>` leftPower : `byte<MeasureProduct<bp, MeasureOne>>` parseRight : `Parser<'Aux, 'T, 'State, 'Input, 'InputSlice>` complete : `'Expr -> 'Op -> 'Aux -> 'Expr`	A generalized infix operator where the Right-Hand Side is NOT necessarily an expression. It uses a specific parser `parseRight` and maps the result into the 'Expr. Used for Member Access (.), Type Checks (is/as), or rigid syntax. op : `'Op` parseOp : `Parser<'Op, 'T, 'State, 'Input, 'InputSlice>` leftPower : `byte<MeasureProduct<bp, MeasureOne>>` parseRight : `Parser<'Aux, 'T, 'State, 'Input, 'InputSlice>` complete : `'Expr -> 'Op -> 'Aux -> 'Expr`
`InfixNary(op, parseOp, leftPower, completeNary)` Full Usage: `InfixNary(op, parseOp, leftPower, completeNary)` Parameters: op : `'Op` parseOp : `Parser<'Op, 'T, 'State, 'Input, 'InputSlice>` leftPower : `byte<MeasureProduct<bp, MeasureOne>>` completeNary : `ResizeArray<'Expr> -> ResizeArray<'Op> -> 'Expr`	Used for operators like the Tuple comma (,) which are technically "Not Associative" in type theory (creating a flat list rather than nested pairs) but strictly require chaining in the parser. op : `'Op` parseOp : `Parser<'Op, 'T, 'State, 'Input, 'InputSlice>` leftPower : `byte<MeasureProduct<bp, MeasureOne>>` completeNary : `ResizeArray<'Expr> -> ResizeArray<'Op> -> 'Expr`
`InfixNonAssociative(op, parseOp, leftPower, completeInfix)` Full Usage: `InfixNonAssociative(op, parseOp, leftPower, completeInfix)` Parameters: op : `'Op` parseOp : `Parser<'Op, 'T, 'State, 'Input, 'InputSlice>` leftPower : `byte<MeasureProduct<bp, MeasureOne>>` completeInfix : `'Expr -> 'Op -> 'Expr -> 'Expr`	op : `'Op` parseOp : `Parser<'Op, 'T, 'State, 'Input, 'InputSlice>` leftPower : `byte<MeasureProduct<bp, MeasureOne>>` completeInfix : `'Expr -> 'Op -> 'Expr -> 'Expr`
`InfixRight(op, parseOp, leftPower, completeInfix)` Full Usage: `InfixRight(op, parseOp, leftPower, completeInfix)` Parameters: op : `'Op` parseOp : `Parser<'Op, 'T, 'State, 'Input, 'InputSlice>` leftPower : `byte<MeasureProduct<bp, MeasureOne>>` completeInfix : `'Expr -> 'Op -> 'Expr -> 'Expr`	op : `'Op` parseOp : `Parser<'Op, 'T, 'State, 'Input, 'InputSlice>` leftPower : `byte<MeasureProduct<bp, MeasureOne>>` completeInfix : `'Expr -> 'Op -> 'Expr -> 'Expr`
`Postfix(op, parseOp, leftPower, completePostfix)` Full Usage: `Postfix(op, parseOp, leftPower, completePostfix)` Parameters: op : `'Op` parseOp : `Parser<'Op, 'T, 'State, 'Input, 'InputSlice>` leftPower : `byte<MeasureProduct<bp, MeasureOne>>` completePostfix : `'Expr -> 'Op -> 'Expr`	op : `'Op` parseOp : `Parser<'Op, 'T, 'State, 'Input, 'InputSlice>` leftPower : `byte<MeasureProduct<bp, MeasureOne>>` completePostfix : `'Expr -> 'Op -> 'Expr`
`Ternary(op, parseOp, leftPower, parseTernaryOp, completeTernary)` Full Usage: `Ternary(op, parseOp, leftPower, parseTernaryOp, completeTernary)` Parameters: op : `'Op` parseOp : `Parser<'Op, 'T, 'State, 'Input, 'InputSlice>` leftPower : `byte<MeasureProduct<bp, MeasureOne>>` parseTernaryOp : `Parser<'Op, 'T, 'State, 'Input, 'InputSlice>` completeTernary : `'Expr -> 'Op -> 'Expr -> 'Op -> 'Expr -> 'Expr`	op : `'Op` parseOp : `Parser<'Op, 'T, 'State, 'Input, 'InputSlice>` leftPower : `byte<MeasureProduct<bp, MeasureOne>>` parseTernaryOp : `Parser<'Op, 'T, 'State, 'Input, 'InputSlice>` completeTernary : `'Expr -> 'Op -> 'Expr -> 'Op -> 'Expr -> 'Expr`

Instance members

Instance member	Description
`this.IsIndexer` Full Usage: `this.IsIndexer` Returns: `bool`	Returns: `bool`
`this.IsInfixLeft` Full Usage: `this.IsInfixLeft` Returns: `bool`	Returns: `bool`
`this.IsInfixMapped` Full Usage: `this.IsInfixMapped` Returns: `bool`	Returns: `bool`
`this.IsInfixNary` Full Usage: `this.IsInfixNary` Returns: `bool`	Returns: `bool`
`this.IsInfixNonAssociative` Full Usage: `this.IsInfixNonAssociative` Returns: `bool`	Returns: `bool`
`this.IsInfixRight` Full Usage: `this.IsInfixRight` Returns: `bool`	Returns: `bool`
`this.IsPostfix` Full Usage: `this.IsPostfix` Returns: `bool`	Returns: `bool`
`this.IsTernary` Full Usage: `this.IsTernary` Returns: `bool`	Returns: `bool`