Index

Modules: funcynim, funcynim/chain, funcynim/convert, funcynim/curry, funcynim/default, funcynim/fold, funcynim/ignore, funcynim/into, funcynim/itself, funcynim/nimnodes, funcynim/operators, funcynim/partialproc, funcynim/partialproc/private/dsl, funcynim/partialproc/private/dsl/common/ast/call, funcynim/partialproc/private/dsl/common/ast/dot_expr, funcynim/partialproc/private/dsl/common/call_style, funcynim/partialproc/private/dsl/common/call_styles/classic, funcynim/partialproc/private/dsl/common/call_styles/command, funcynim/partialproc/private/dsl/common/call_styles/infix, funcynim/partialproc/private/dsl/common/call_styles/method, funcynim/partialproc/private/dsl/common/call_styles/prefix, funcynim/partialproc/private/dsl/common/call_styles/subscript, funcynim/partialproc/private/dsl/generator, funcynim/partialproc/private/dsl/generator/arg_bind_list, funcynim/partialproc/private/dsl/lexer, funcynim/partialproc/private/dsl/lexer/lexed_call, funcynim/partialproc/private/dsl/lexer/token, funcynim/partialproc/private/dsl/lexer/tokenizer, funcynim/partialproc/private/dsl/parser, funcynim/partialproc/private/dsl/parser/parsed_arg, funcynim/partialproc/private/dsl/parser/parsed_call, funcynim/partialproc/private/dsl/parser/partial_param, funcynim/partialproc/private/dsl/unpacker, funcynim/partialproc/private/dsl/unpacker/unpacked_call, funcynim/predicate, funcynim/proctypes, funcynim/proctypes/private/bracket_expr, funcynim/proctypes/private/proc_typedesc, funcynim/proctypes/private/typedesc_expr, funcynim/run, funcynim/unit, funcynim/variables.

API symbols

`<<`:

• chain: proc `<<`[A; B; C](left: B -> C; right: A -> B): A -> C

`>>`:

• chain: proc `>>`[A; B; C](left: A -> B; right: B -> C): A -> C

`[]`:

• bracket_expr: proc `[]`(self: BracketExpr; i: Natural): NimNode

`and`:

• predicate: proc `and`[T](left, right: Predicate[T]): Predicate[T]

`not`:

• predicate: proc `not`[T](self: Predicate[T]): Predicate[T]

`or`:

• predicate: proc `or`[T](left, right: Predicate[T]): Predicate[T]

accessed:

• subscript: proc accessed(self: SubscriptCall): NimNode

alwaysFalse:

• predicate: proc alwaysFalse[T](_: T): bool

alwaysTrue:

• predicate: proc alwaysTrue[T](_: T): bool

ArgBindList:

• arg_bind_list: object ArgBindList

argBindList:

• arg_bind_list: proc argBindList(params, args: seq[NimNode]): ArgBindList

args:

• classic: proc args(self: ClassicCall): seq[NimNode]
• command: proc args(self: CommandCall): seq[NimNode]
• subscript: proc args(self: SubscriptCall): seq[NimNode]
• arg_bind_list: proc args(self: ArgBindList): seq[NimNode]
• lexed_call: proc args(self: LexedCall): seq[Token]
• parsed_call: proc args(self: ParsedCall): seq[ParsedArg]
• unpacked_call: proc args(self: UnpackedCall): seq[NimNode]

bindPartialArgs:

• arg_bind_list: proc bindPartialArgs(self: seq[ParsedArg]): ArgBindList

BracketExpr:

• bracket_expr: object BracketExpr

bracketExpr:

• bracket_expr: proc bracketExpr(self: NimNode): BracketExpr

Call:

• call: object Call

called:

• classic: proc called(self: ClassicCall): NimNode
• command: proc called(self: CommandCall): NimNode
• method: proc called(self: MethodCall): NimNode
• lexed_call: proc called(self: LexedCall): NimNode
• parsed_call: proc called(self: ParsedCall): NimNode
• unpacked_call: proc called(self: UnpackedCall): NimNode

CallStyle:

• call_style: enum CallStyle

chain:

• chain: proc chain[A; B; C](self: A -> B; next: B -> C): A -> C

Classic:

• call_style: CallStyle.Classic

ClassicCall:

• classic: object ClassicCall

classicCall:

• classic: proc classicCall(self: NimNode): ClassicCall

combine:

• predicate: proc combine[T](left: Predicate[T]; right: Predicate[T]; combiner: (right: bool) -> ((left: bool) -> bool)): Predicate[T]
• predicate: proc combine[T](left: Predicate[T]; right: Predicate[T]; combiner: (left: bool, right: bool) -> bool): Predicate[T]

Command:

• call_style: CallStyle.Command

CommandCall:

• command: object CommandCall

commandCall:

• command: proc commandCall(self: NimNode): CommandCall

compose:

• chain: proc compose[A; B; C](self: B -> C; prev: A -> B): A -> C

convert:

• convert: proc convert[A; B](a: A): B
• convert: proc convert[A](a: A; B: typedesc): B:type

curry:

• curry: template curry(self: untyped{nkProcDef | nkFuncDef}): auto
• curry: template curry(self: untyped{nkLambda}): auto

default:

• default: proc default[T](): T
• unit: proc default(T: typedesc[Unit]): Unit

described:

• typedesc_expr: proc described(self: TypedescExpr): NimNode

divFloat:

• operators: proc divFloat[T: SomeFloat](x, y: T): T

divInt:

• operators: proc divInt[T: SomeInteger](x, y: T): T

doNothing:

• unit: proc doNothing[T](_: T): Unit

DotExpr:

• dot_expr: object DotExpr

dotExpr:

• dot_expr: proc dotExpr(self: NimNode): DotExpr

equal:

• operators: proc equal[T](x, y: T): bool

firstChild:

• nimnodes: proc firstChild(self: NimNode): NimNode

fold:

• fold: proc fold[T](self: bool; then, else: Unit -> T): T
• token: proc fold[T](self: Token; onUnknown: NimNode -> T; onQuestionPrefix: string -> T; onQuestionColonPrefix: NimNode -> T; onQUestionColonInfix: ParamSpec -> T): T
• parsed_arg: proc fold[T](self: ParsedArg; onUnknown: NimNode -> T; onPartial: PartialParam -> T): T
• predicate: proc fold[A; B](self: Predicate[A]; then, else: A -> B): A -> B

generateLambda:

• generator: proc generateLambda(self: ParsedCall): NimNode

greater:

• operators: proc greater[T](x, y: T): bool

greaterOrEq:

• operators: proc greaterOrEq[T](x, y: T): bool

high:

• nimnodes: proc high(self: NimNode): NimNodeIndex

ignore:

• ignore: proc ignore[T](_: T)

Infix:

• call_style: CallStyle.Infix

InfixCall:

• infix: object InfixCall

infixCall:

• infix: proc infixCall(self: NimNode): InfixCall

into:

• into: proc into[A; B](self: A; f: A -> B): B

isDotExpr:

• call: proc isDotExpr(self: Call): bool

itself:

• itself: proc itself[T](self: T): T

left:

• call: proc left(self: Call): NimNode
• dot_expr: proc left(self: DotExpr): NimNode
• infix: proc left(self: InfixCall): NimNode
• bracket_expr: proc left(self: BracketExpr): NimNode

less:

• operators: proc less[T](x, y: T): bool

lessOrEq:

• operators: proc lessOrEq[T](x, y: T): bool

lex:

• lexer: proc lex(self: UnpackedCall): LexedCall

LexedCall:

• lexed_call: object LexedCall

lexedCall:

• lexed_call: proc lexedCall(called: NimNode; style: CallStyle; args: openArray[Token]): LexedCall

logicAnd:

• operators: proc logicAnd(x, y: bool): bool

logicNot:

• operators: proc logicNot(x: bool): bool

logicOr:

• operators: proc logicOr(x, y: bool): bool

low:

• nimnodes: proc low(self: NimNode): NimNodeIndex

Method:

• call_style: CallStyle.Method

MethodCall:

• method: object MethodCall

methodCall:

• method: proc methodCall(self: NimNode): MethodCall

minus:

• operators: proc minus[T](x, y: T): T

modify:

• variables: proc modify[T](self: var T; f: T -> T): var T
• variables: proc modify[T](self: var T; f: var T -> Unit): var T

modulo:

• operators: proc modulo[T: SomeInteger](x, y: T): T

mult:

• operators: proc mult[T](x, y: T): T

name:

• partial_param: proc name(self: PartialParam): string

next:

• operators: proc next[T: Ordinal](x: T): T

NimNodeIndex:

• nimnodes: type NimNodeIndex

ofProc:

• proc_typedesc: proc ofProc(self: TypedescExpr): ProcTypedesc

ofTypedesc:

• typedesc_expr: proc ofTypedesc(self: BracketExpr): TypedescExpr

on:

• method: proc on(self: MethodCall): NimNode

operand:

• prefix: proc operand(self: PrefixCall): NimNode

operator:

• infix: proc operator(self: InfixCall): NimNode
• prefix: proc operator(self: PrefixCall): NimNode

params:

• arg_bind_list: proc params(self: ArgBindList): seq[NimNode]

ParamSpec:

• token: tuple ParamSpec

paramType:

• proctypes: macro paramType(T: type proc; i: static Natural): type
• proctypes: template paramType(p: proc; i: static Natural): type
• proc_typedesc: proc paramType(self: ProcTypedesc; i: Natural): NimNode

parse:

• parser: proc parse(self: LexedCall): ParsedCall

ParsedArg:

• parsed_arg: object ParsedArg

ParsedCall:

• parsed_call: object ParsedCall

parsedCall:

• parsed_call: proc parsedCall(called: NimNode; style: CallStyle; args: openArray[ParsedArg]): ParsedCall

partial:

• partialproc: macro partial(call: untyped{call | (nkCall | nkCommand | nkPrefix | nkInfix)}): proc
• partialproc: macro partial(expr: untyped{nkBracketExpr}): proc

partialArg:

• parsed_arg: proc partialArg(param: PartialParam): ParsedArg

PartialParam:

• partial_param: object PartialParam

partialParam:

• partial_param: proc partialParam(typeExpr: NimNode): PartialParam
• partial_param: proc partialParam(name: string): PartialParam
• partial_param: proc partialParam(name: string; typeExpr: NimNode): PartialParam

plus:

• operators: proc plus[T](x, y: T): T

plus1:

• operators: proc plus1[T](x: T): T

Predicate:

• predicate: type Predicate

Prefix:

• call_style: CallStyle.Prefix

PrefixCall:

• prefix: object PrefixCall

prefixCall:

• prefix: proc prefixCall(self: NimNode): PrefixCall

prev:

• operators: proc prev[T: Ordinal](x: T): T

ProcTypedesc:

• proc_typedesc: object ProcTypedesc

questionColonInfix:

• token: proc questionColonInfix(ident, typeExpr: NimNode): Token
• token: proc questionColonInfix(spec: ParamSpec): Token

questionColonPrefixToken:

• token: proc questionColonPrefixToken(expr: NimNode): Token

questionPrefixToken:

• token: proc questionPrefixToken(ident: NimNode): Token
• token: proc questionPrefixToken(ident: string): Token

read:

• variables: proc read[T](self: var T): T

remainingArgs:

• method: proc remainingArgs(self: MethodCall): seq[NimNode]

resultType:

• proctypes: macro resultType(T: type proc): type
• proctypes: template resultType(p: proc): type

returnType:

• proc_typedesc: proc returnType(self: ProcTypedesc): NimNode

right:

• dot_expr: proc right(self: DotExpr): NimNode
• infix: proc right(self: InfixCall): NimNode

run:

• run: proc run[T](self: Unit -> T): T
• run: proc run[A; B](self: A -> B; arg: A): B
• run: proc run[T](self: () -> T): T

secondChild:

• nimnodes: proc secondChild(self: NimNode): NimNode

style:

• lexed_call: proc style(self: LexedCall): CallStyle
• parsed_call: proc style(self: ParsedCall): CallStyle
• unpacked_call: proc style(self: UnpackedCall): CallStyle

Subscript:

• call_style: CallStyle.Subscript

SubscriptCall:

• subscript: object SubscriptCall

subscriptCall:

• subscript: proc subscriptCall(self: NimNode): SubscriptCall

test:

• predicate: proc test[T](self: Predicate[T]; value: T): bool

to:

• convert: proc to[A; B](a: A): B
• convert: proc to[A](a: A; B: typedesc): B:type

toAst:

• call: proc toAst(self: Call): NimNode
• classic: proc toAst(self: ClassicCall): NimNode
• infix: proc toAst(self: InfixCall): NimNode
• prefix: proc toAst(self: PrefixCall): NimNode
• subscript: proc toAst(self: SubscriptCall): NimNode
• bracket_expr: proc toAst(self: BracketExpr): NimNode
• proc_typedesc: proc toAst(self: ProcTypedesc): NimNode
• typedesc_expr: proc toAst(self: TypedescExpr): NimNode

toCall:

• call: proc toCall(self: NimNode): Call

Token:

• token: object Token

tokenize:

• tokenizer: proc tokenize(arg: NimNode): Token

translate:

• dsl: proc translate(self: ClassicCall): NimNode
• dsl: proc translate(self: CommandCall): NimNode
• dsl: proc translate(self: InfixCall): NimNode
• dsl: proc translate(self: MethodCall): NimNode
• dsl: proc translate(self: PrefixCall): NimNode
• dsl: proc translate(self: SubscriptCall): NimNode
• dsl: proc translate(self: UnpackedCall): NimNode

TypedescExpr:

• typedesc_expr: object TypedescExpr

typeExpr:

• partial_param: proc typeExpr(self: PartialParam): NimNode

Unit:

• unit: tuple Unit

unit:

• unit: proc unit(): Unit

unknownArg:

• parsed_arg: proc unknownArg(ast: NimNode): ParsedArg

unknownToken:

• token: proc unknownToken(ast: NimNode): Token

unpack:

• unpacker: proc unpack(self: ClassicCall): UnpackedCall
• unpacker: proc unpack(self: CommandCall): UnpackedCall
• unpacker: proc unpack(self: InfixCall): UnpackedCall
• unpacker: proc unpack(self: MethodCall): UnpackedCall
• unpacker: proc unpack(self: PrefixCall): UnpackedCall
• unpacker: proc unpack(self: SubscriptCall): UnpackedCall

UnpackedCall:

• unpacked_call: object UnpackedCall

unpackedCall:

• unpacked_call: proc unpackedCall(called: NimNode; style: CallStyle; args: openArray[NimNode]): UnpackedCall

with:

• curry: proc with[A; B; C](curried: A -> (B -> C); arg: A): B -> C

write:

• variables: proc write[T](self: var T; value: T): var T