Index

Modules: nim_iterator_stream_experiment/collections/seqstack, nim_iterator_stream_experiment/monad/identity, nim_iterator_stream_experiment/monad/io, nim_iterator_stream_experiment/monad/lazymonadlaws, nim_iterator_stream_experiment/monad/monadlaws, nim_iterator_stream_experiment/monad/optional, nim_iterator_stream_experiment/monad/predicate, nim_iterator_stream_experiment/monad/reader, nim_iterator_stream_experiment/optics/lens, nim_iterator_stream_experiment/optics/lenslaws, nim_iterator_stream_experiment/optics/plens, nim_iterator_stream_experiment/stream/loop, nim_iterator_stream_experiment/stream/loop/loopscope, nim_iterator_stream_experiment/stream/loop/loopscope/runonceresult, nim_iterator_stream_experiment/stream/streamsteps, nim_iterator_stream_experiment/streams/ast, nim_iterator_stream_experiment/streams/sequence, nim_iterator_stream_experiment/streams/slice, nim_iterator_stream_experiment/utils/call, nim_iterator_stream_experiment/utils/chain, nim_iterator_stream_experiment/utils/convert, nim_iterator_stream_experiment/utils/default, nim_iterator_stream_experiment/utils/ifelse, nim_iterator_stream_experiment/utils/ignore, nim_iterator_stream_experiment/utils/lambda, nim_iterator_stream_experiment/utils/nimnodes, nim_iterator_stream_experiment/utils/operators, nim_iterator_stream_experiment/utils/pair, nim_iterator_stream_experiment/utils/partialprocs, nim_iterator_stream_experiment/utils/proctypes, nim_iterator_stream_experiment/utils/reducer, nim_iterator_stream_experiment/utils/somenatural, nim_iterator_stream_experiment/utils/unit, nim_iterator_stream_experiment/utils/variables, stream.

API symbols

`==`:

• optional: `==`[T](self, other: Optional[T]): bool

`and`:

• predicate: `and`[T](self, then: Predicate[T]): Predicate[T]

`as`:

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

`not`:

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

`or`:

• predicate: `or`[T](self, `else`: Predicate[T]): Predicate[T]

all:

• stream: all[S; T](self: Stream[S, T]; predicate: Predicate[T]): bool

alwaysFalse:

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

alwaysTrue:

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

any:

• stream: any[S; T](self: Stream[S, T]; predicate: Predicate[T]): bool

apply:

• identity: apply[A; B](self: A; f: A -> B): B
• pair: apply[A1; A2; B1; B2](self: Pair[A1, A2]; f1: A1 -> B1; f2: A2 -> B2): Pair[B1, B2]

ask:

• reader: ask[S](): Reader[S, S]
• reader: ask(S: typedesc): Reader[S, S]

asReader:

• loop: asReader[S](self: Loop[S, Unit]): Reader[S, S]
• loopscope: asReader[S](self: LoopScope[S]): Reader[S, S]
• loopscope: asReader[S](self: LoopScope[S]; body: S -> Unit): Reader[S, S]

AssociativitySpec:

• lazymonadlaws: AssociativitySpec

associativitySpec:

• lazymonadlaws: associativitySpec[A; B; MA; MB; MC; R](initial: A; lift: A -> MA; f: A -> MB; g: B -> MC; runArg: R): AssociativitySpec[ A, B, MA, MB, MC, R]

AssociativitySpec:

• monadlaws: AssociativitySpec

associativitySpec:

• monadlaws: associativitySpec[A; B; MA; MB; MC](initial: A; lift: A -> MA; f: A -> MB; g: B -> MC): AssociativitySpec[ A, B, MA, MB, MC]

bracket:

• io: bracket[A; B](before: IO[A]; between: A -> B; after: A -> Unit): IO[B]

breakIf:

• loopscope: breakIf[S](self: LoopScope[S]; predicate: Predicate[S]): LoopScope[S]

call:

• call: call[T](p: proc (): T {.nimcall.}): T
• call: call[T](p: proc (): T {.closure.}): T
• call: call(p: proc () {.nimcall.})
• call: call(p: proc () {.closure.})
• call: call(p: proc; arg1: untyped; remaining: varargs[untyped]): untyped

chain:

• plens: chain[SR; R1; W1; SW; R2; W2](self: PLens[SR, R1, W1, SW]; other: PLens[R1, R2, W2, W1]): PLens[ SR, R2, W2, SW]
• chain: chain[A; B; C](f: A -> B; g: B -> C): A -> C
• chain: chain[A; B](f: () -> A; g: A -> B): () -> B

chars:

• sequence: chars(s: string): Stream[SeqStep, char]

checkAssociativity:

• lazymonadlaws: checkAssociativity[A; B; MA; MB; MC; R](spec: AssociativitySpec[A, B, MA, MB, MC, R]): bool
• monadlaws: checkAssociativity[A; B; MA; MB; MC](spec: AssociativitySpec[A, B, MA, MB, MC]): bool

checkDoubleWriteLaw:

• lenslaws: checkDoubleWriteLaw[S; T](lens: Lens[S, T]; spec: DoubleWriteSpec[S, T]): bool

checkIdentityLaw:

• lenslaws: checkIdentityLaw[S; T](lens: Lens[S, T]; spec: IdentitySpec[S]): bool

checkLeftIdentity:

• lazymonadlaws: checkLeftIdentity[A; MA; MB; R](spec: LeftIdentitySpec[A, MA, MB, R]): bool
• monadlaws: checkLeftIdentity[A; MA; MB](spec: LeftIdentitySpec[A, MA, MB]): bool

checkLensLaws:

• lenslaws: checkLensLaws[S; T](lens: Lens[S, T]; spec: LensLawsSpec[S, T]): bool

checkMonadLaws:

• lazymonadlaws: checkMonadLaws[LA; LMA; LMB; LR; RT; RM; RR; AA; AB; AMA; AMB; AMC; AR](spec: MonadLawsSpec[ LA, LMA, LMB, LR, RT, RM, RR, AA, AB, AMA, AMB, AMC, AR]): bool
• monadlaws: checkMonadLaws[LA; LMA; LMB; RT; RM; AA; AB; AMA; AMB; AMC]( spec: MonadLawsSpec[LA, LMA, LMB, RT, RM, AA, AB, AMA, AMB, AMC]): bool

checkRetentionLaw:

• lenslaws: checkRetentionLaw[S; T](lens: Lens[S, T]; spec: RetentionSpec[S, T]): bool

checkRightIdentity:

• lazymonadlaws: checkRightIdentity[T; M; R](spec: RightIdentitySpec[T, M, R]): bool
• monadlaws: checkRightIdentity[T; M](spec: RightIdentitySpec[T, M]): bool

children:

• ast: children(n: NimNode): Stream[NimNodeStep, NimNode]

childrenReverse:

• ast: childrenReverse(n: NimNode): Stream[NimNodeStep, NimNode]

condition:

• stream: condition[S; T](X: typedesc[Stream[S, T]]): Lens[X, Condition[S]]
• loop: condition[S; T](X: typedesc[Loop[S, T]]): Lens[X, Condition[S]]

Condition:

• loopscope: Condition

condition:

• loopscope: condition[T](predicate: Predicate[T]): Condition[T]
• loopscope: condition[S](X: typedesc[LoopScope[S]]): Lens[X, Condition[S]]

convert:

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

count:

• stream: count[S; T; N: SomeNatural](self: Stream[S, T]): N
• stream: count[S; T](self: Stream[S, T]; N: typedesc[SomeNatural]): N:type
• streamsteps: count[S; N: SomeNatural](X: typedesc[LimitStep[S, N]]): Lens[X, N]
• streamsteps: count[S; N: SomeNatural](X: typedesc[SkipStep[S, N]]): Lens[X, N]

current:

• slice: current[T](S: typedesc[SliceStep[T]]): Lens[S, T]

default:

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

divFloat:

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

divInt:

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

doNothing:

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

DoubleWriteSpec:

• lenslaws: DoubleWriteSpec

doubleWriteSpec:

• lenslaws: doubleWriteSpec[S; T](input: S; first: T; second: T): DoubleWriteSpec[S, T]

dropWhile:

• stream: dropWhile[S; T](self: Stream[S, T]; predicate: Predicate[T]): () -> Stream[S, T]
• loop: dropWhile[S; T](self: Loop[S, T]; predicate: Predicate[T]): Reader[S, S]

emptyLoop:

• loop: emptyLoop(S: typedesc; T: typedesc): Loop[S, T]

emptyLoopScope:

• loopscope: emptyLoopScope(S: typedesc): LoopScope[S]

EmptyStep:

• streamsteps: EmptyStep

emptyStep:

• streamsteps: emptyStep(): EmptyStep

emptyStream:

• stream: emptyStream(T: typedesc): Stream[EmptyStep, T]

equal:

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

filter:

• optional: filter[T](self: Optional[T]; predicate: Predicate[T]): Optional[T]
• stream: filter[S; T](self: Stream[S, T]; predicate: Predicate[T]): Stream[S, T]

findFirst:

• stream: findFirst[S; T](self: Stream[S, T]): Optional[T]
• stream: findFirst[S; T](self: Stream[S, T]; predicate: Predicate[T]): Optional[T]

firstChild:

• nimnodes: firstChild(self: NimNode): NimNode

flatMap:

• io: flatMap[A; B](self: IO[A]; f: A -> IO[B]): IO[B]
• optional: flatMap[A; B](self: Optional[A]; f: A -> Optional[B]): Optional[B]
• reader: flatMap[S; A; B](self: Reader[S, A]; f: A -> Reader[S, B]): Reader[S, B]

forEach:

• stream: forEach[S; T](self: Stream[S, T]; action: T -> Unit): Unit

generate:

• ast: generate(self: PreOrderStep): NimNode

generating:

• loop: generating[S; T](scope: LoopScope[S]; generator: Generator[S, T]): Loop[S, T]

generator:

• stream: generator[S; A](X: typedesc[Stream[S, A]]; B: typedesc): PLens[X, Generator[S, A], Generator[S, B], Stream[S, B]]
• stream: generator[S; T](X: typedesc[Stream[S, T]]): Lens[X, Generator[S, T]]

Generator:

• loop: Generator

generator:

• loop: generator[S; T](g: Reader[S, T]): Generator[S, T]
• loop: generator[S; A](X: typedesc[Loop[S, A]]; B: typedesc): PLens[X, Generator[S, A], Generator[S, B], Loop[S, B]]
• loop: generator[S; T](X: typedesc[Loop[S, T]]): Lens[X, Generator[S, T]]

greater:

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

greaterOrEq:

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

hasMore:

• ast: hasMore(self: PreOrderStep): bool

high:

• slice: high[T](self: Slice[T]): T
• nimnodes: high(self: NimNode): NimNodeIndex

IdentitySpec:

• lenslaws: IdentitySpec

identitySpec:

• lenslaws: identitySpec[S](expected: S): IdentitySpec[S]

ifElse:

• predicate: ifElse[A; B](self: Predicate[A]; then, `else`: A -> B): Reader[A, B]
• ifelse: ifElse[T](condition: bool; then, `else`: () -> T): T

ifNone:

• optional: ifNone[A; B](self: Optional[A]; then: () -> B; `else`: A -> B): B

ifSome:

• optional: ifSome[A; B](self: Optional[A]; then: A -> B; `else`: () -> B): B

ignore:

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

indexes:

• ast: indexes(n: NimNode): Stream[NimNodeStep, NimNodeIndex]
• sequence: indexes[T](s: seq[T]): Stream[SeqStep, SeqIndex]
• sequence: indexes(s: string): Stream[SeqStep, SeqIndex]

indexesReverse:

• ast: indexesReverse(n: NimNode): Stream[NimNodeStep, NimNodeIndex]

infinite:

• loopscope: infinite[S](stepper: Stepper[S]): LoopScope[S]

infiniteLoop:

• loop: infiniteLoop[S; T](stepper: S -> S; generator: Generator[S, T]): Loop[S, T]
• loop: infiniteLoop[S; T](stepper: Stepper[S]; generator: Generator[S, T]): Loop[S, T]

Initializer:

• stream: Initializer

initializer:

• stream: initializer[T](self: IO[T]): Initializer[T]

initialStep:

• stream: initialStep[S; T](X: typedesc[Stream[S, T]]): Lens[X, Initializer[S]]

initPreOrder:

• ast: initPreOrder(root: NimNode): PreOrderStep

IO:

• io: IO

isConsumed:

• streamsteps: isConsumed(X: typedesc[SingleStep]): Lens[X, bool]

isEmpty:

• seqstack: isEmpty[T](self: SeqStack[T]): bool

isNone:

• optional: isNone[T: Nilable](self: Optional[T]): bool
• optional: isNone[T: not Nilable](self: Optional[T]): bool

isSome:

• optional: isSome[T](self: Optional[T]): bool

isUnderscore:

• partialprocs: isUnderscore(n: NimNode): bool

item:

• runonceresult: item[S; A](X: typedesc[RunOnceResult[S, A]]; B: typedesc): PLens[X, Optional[A], Optional[B], RunOnceResult[S, B]]
• runonceresult: item[S; T](X: typedesc[RunOnceResult[S, T]]): Lens[X, Optional[T]]
• streamsteps: item[S; T](X: typedesc[TakeWhileStep[S, T]]): Lens[X, Optional[T]]

items:

• sequence: items[T](s: seq[T]): Stream[SeqStep, T]
• slice: items[T: Ordinal](s: Slice[T]): Stream[SliceStep[T], T]

itemsReverse:

• slice: itemsReverse[T: Ordinal](s: Slice[T]): Stream[SliceStep[T], T]

itemType:

• stream: itemType[S; T; ](self: Stream[S, T]): typedesc[T]
• stream: itemType[S; T; ](X: typedesc[Stream[S, T]]): typedesc[T]
• loop: itemType[S; T; ](self: Loop[S, T]): typedesc[T]
• loop: itemType[S; T; ](X: typedesc[Loop[S, T]]): typedesc[T]

itself:

• identity: itself[T](value: T): T

lambda:

• lambda: lambda[T; ](expr: T): proc

LazyMonad:

• lazymonadlaws: LazyMonad

LeftIdentitySpec:

• lazymonadlaws: LeftIdentitySpec

leftIdentitySpec:

• lazymonadlaws: leftIdentitySpec[A; MA; MB; R](initial: A; lift: A -> MA; f: A -> MB; runArg: R): LeftIdentitySpec[ A, MA, MB, R]

LeftIdentitySpec:

• monadlaws: LeftIdentitySpec

leftIdentitySpec:

• monadlaws: leftIdentitySpec[A; MA; MB](initial: A; lift: A -> MA; f: A -> MB): LeftIdentitySpec[A, MA, MB]

len:

• seqstack: len[T](self: SeqStack[T]): Natural

Lens:

• lens: Lens

lens:

• plens: lens[SR; R; W; SW](reader: MemberReader[SR, R]; writer: MemberUpdater[SR, W, SW]): PLens[ SR, R, W, SW]

LensLawsSpec:

• lenslaws: LensLawsSpec

lensLawsSpec:

• lenslaws: lensLawsSpec[S; T](identity: IdentitySpec[S]; retention: RetentionSpec[S, T]; doubleWrite: DoubleWriteSpec[S, T]): LensLawsSpec[S, T]

less:

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

lessOrEq:

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

limit:

• stream: limit[S; T; N: SomeNatural](self: Stream[S, T]; n: N): Stream[LimitStep[S, N], T]

LimitStep:

• streamsteps: LimitStep

limitStep:

• streamsteps: limitStep[S; N: SomeNatural](step: S; count: N): LimitStep[S, N]

local:

• reader: local[S; T](self: Reader[S, T]; f: S -> S): Reader[S, T]

loop:

• stream: loop[S; A](X: typedesc[Stream[S, A]]; B: typedesc): PLens[X, Loop[S, A], Loop[S, B], Stream[S, B]]
• stream: loop[S; T](X: typedesc[Stream[S, T]]): Lens[X, Loop[S, T]]

Loop:

• loop: Loop

looped:

• loopscope: looped[S](condition: Condition[S]; stepper: S -> S): LoopScope[S]
• loopscope: looped[S](condition: Condition[S]; stepper: Stepper[S]): LoopScope[S]

LoopScope:

• loopscope: LoopScope

low:

• slice: low[T](self: Slice[T]): T
• nimnodes: low(self: NimNode): NimNodeIndex

map:

• io: map[A; B](self: IO[A]; f: A -> B): IO[B]
• optional: map[A; B](self: Optional[A]; f: A -> B): Optional[B]
• reader: map[S; A; B](self: Reader[S, A]; f: A -> B): Reader[S, B]
• stream: map[S; A; B](self: Stream[S, A]; f: A -> B): Stream[S, B]
• loop: map[S; A; B](self: Loop[S, A]; f: A -> B): Loop[S, B]
• reducer: map[R; T](self: Reducer[R, T]; f: R -> R): Reducer[R, T]

mapSteps:

• stream: mapSteps[SA; SB; T](self: Stream[SA, T]; extractor: SB -> SA; stepperMapper: Stepper[SA] -> Stepper[SB]; initialStepMapper: SA -> SB): Stream[SB, T]
• loop: mapSteps[SA; SB; T](self: Loop[SA, T]; extractor: SB -> SA; stepperMapper: Stepper[SA] -> Stepper[SB]): Loop[SB, T]
• loop: mapSteps[SA; SB; T](self: Loop[SA, T]; extractor: SB -> SA; wrapper: SA -> SB): Loop[SB, T]
• loopscope: mapSteps[SA; SB](self: LoopScope[SA]; conditionMapper: Condition[SA] -> Condition[SB]; stepperMapper: Stepper[SA] -> Stepper[SB]): LoopScope[SB]
• loopscope: mapSteps[SA; SB](self: LoopScope[SA]; extractor: SB -> SA; stepperMapper: Stepper[SA] -> Stepper[SB]): LoopScope[SB]
• loopscope: mapSteps[SA; SB](self: LoopScope[SA]; extractor: SB -> SA; wrapper: SA -> SB): LoopScope[SB]

MemberReader:

• plens: MemberReader

memberType:

• lens: memberType[S; T; ](self: Lens[S, T]): typedesc[T]
• lens: memberType[S; T; ](X: typedesc[Lens[S, T]]): typedesc[T]

MemberUpdater:

• plens: MemberUpdater

merge:

• stream: merge[SA; A; SB; B](self: Stream[SA, A]; other: Stream[SB, B]): Stream[Pair[SA, SB], Pair[A, B]]
• loop: merge[SA; A; SB; B](self: Loop[SA, A]; other: Loop[SB, B]): Loop[Pair[SA, SB], Pair[A, B]]
• loopscope: merge[SA; SB](self: LoopScope[SA]; other: LoopScope[SB]): LoopScope[Pair[SA, SB]]

minus:

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

modify:

• plens: modify[SR; R; W; SW](self: PLens[SR, R, W, SW]; f: R -> W): Reader[SR, SW]
• plens: modify[SR; R; W; SW](state: SR; lens: PLens[SR, R, W, SW]; f: R -> W): SW
• variables: modify[T](self: var T; f: T -> T): var T

modulo:

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

MonadLawsSpec:

• lazymonadlaws: MonadLawsSpec

monadLawsSpec:

• lazymonadlaws: monadLawsSpec[LA; LMA; LMB; LR; RT; RM; RR; AA; AB; AMA; AMB; AMC; AR]( leftIdentity: LeftIdentitySpec[LA, LMA, LMB, LR]; rightIdentity: RightIdentitySpec[RT, RM, RR]; associativity: AssociativitySpec[AA, AB, AMA, AMB, AMC, AR]): MonadLawsSpec[LA, LMA, LMB, LR, RT, RM, RR, AA, AB, AMA, AMB, AMC, AR]

MonadLawsSpec:

• monadlaws: MonadLawsSpec

monadLawsSpec:

• monadlaws: monadLawsSpec[LA; LMA; LMB; RT; RM; AA; AB; AMA; AMB; AMC]( leftIdentity: LeftIdentitySpec[LA, LMA, LMB]; rightIdentity: RightIdentitySpec[RT, RM]; associativity: AssociativitySpec[AA, AB, AMA, AMB, AMC]): MonadLawsSpec[LA, LMA, LMB, RT, RM, AA, AB, AMA, AMB, AMC]

mult:

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

newLambda:

• partialprocs: newLambda(params: seq[NimNode]; body: NimNode; returnType: NimNode): NimNode

next:

• ast: next(self: PreOrderStep): PreOrderStep
• operators: next[T: Ordinal](x: T): T

Nilable:

• optional: Nilable

NimNodeIndex:

• nimnodes: NimNodeIndex

NimNodeStep:

• ast: NimNodeStep

none:

• stream: none[S; T](self: Stream[S, T]; predicate: Predicate[T]): bool

onClose:

• stream: onClose[S; T](self: Stream[S, T]; callback: () -> Unit): Stream[S, T]

OnCloseEvent:

• stream: OnCloseEvent

onCloseEvent:

• stream: onCloseEvent[T](self: Reader[T, Unit]): OnCloseEvent[T]
• stream: onCloseEvent[S; T](X: typedesc[Stream[S, T]]): Lens[X, OnCloseEvent[S]]

Optional:

• optional: Optional

ordinals:

• slice: ordinals[T: Ordinal](s: Slice[T]): Stream[SignedSliceStep, T]

ordinalsReverse:

• slice: ordinalsReverse[T: Ordinal](s: Slice[T]): Stream[SignedSliceStep, T]

Pair:

• pair: Pair

pair:

• pair: pair[A; B](first: A; second: B): Pair[A, B]

pairs:

• ast: pairs(n: NimNode): Stream[NimNodeStep, tuple[index: NimNodeIndex, node: NimNode]]
• sequence: pairs[T](s: seq[T]): Stream[SeqStep, tuple[index: SeqIndex, item: T]]
• sequence: pairs(s: string): Stream[SeqStep, tuple[index: SeqIndex, item: char]]

partial:

• partialprocs: partial(call: untyped{call}): untyped

partialParamPrefix:

• partialprocs: partialParamPrefix(): string

partialTypedParamPrefix:

• partialprocs: partialTypedParamPrefix(): string

peek:

• stream: peek[S; T](self: Stream[S, T]; f: T -> Unit): Stream[S, T]

PLens:

• plens: PLens

plus:

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

plus1:

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

pop:

• seqstack: pop[T](self: SeqStack[T]): tuple[stack: SeqStack[T], popped: Optional[T]]

Predicate:

• predicate: Predicate

PreOrderStep:

• ast: PreOrderStep

preOrderStep:

• ast: preOrderStep(stack: SeqStack[NimNode]; current: Optional[NimNode]): PreOrderStep

prev:

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

push:

• seqstack: push[T](self: SeqStack[T]; item: T): SeqStack[T]

read:

• plens: read[SR; R; W; SW](self: PLens[SR, R, W, SW]): Reader[SR, R]
• plens: read[SR; R; W; SW](state: SR; lens: PLens[SR, R, W, SW]): R
• variables: read[T](self: var T): T

Reader:

• reader: Reader

readMemberType:

• plens: readMemberType[SR; R; W; SW; ](self: PLens[SR, R, W, SW]): typedesc[R]
• plens: readMemberType[SR; R; W; SW; ](X: typedesc[PLens[SR, R, W, SW]]): typedesc[R]

readStateType:

• plens: readStateType[SR; R; W; SW; ](self: PLens[SR, R, W, SW]): typedesc[SR]
• plens: readStateType[SR; R; W; SW; ](X: typedesc[PLens[SR, R, W, SW]]): typedesc[SR]

reduce:

• stream: reduce[S; T; R](self: Stream[S, T]; reducer: Reducer[R, T]; initialResult: R): R
• pair: reduce[A; B; R](self: Pair[A, B]; reducer: (A, B) -> R): R

reduceIfNotEmpty:

• stream: reduceIfNotEmpty[S; T; R](self: Stream[S, T]; reducer: Reducer[R, T]; initialResult: () -> R): Optional[R]

Reducer:

• reducer: Reducer

RetentionSpec:

• lenslaws: RetentionSpec

retentionSpec:

• lenslaws: retentionSpec[S; T](input: S; expected: T): RetentionSpec[S, T]

returnType:

• proctypes: returnType(T: typedesc[proc]): typedesc
• proctypes: returnType(p: proc): typedesc

RightIdentitySpec:

• lazymonadlaws: RightIdentitySpec

rightIdentitySpec:

• lazymonadlaws: rightIdentitySpec[T; M; R](expected: T; lift: T -> M; runArg: R): RightIdentitySpec[T, M, R]

RightIdentitySpec:

• monadlaws: RightIdentitySpec

rightIdentitySpec:

• monadlaws: rightIdentitySpec[T; M](expected: T; lift: T -> M): RightIdentitySpec[T, M]

run:

• io: run[T](self: IO[T]): T
• reader: run[S; T](self: Reader[S, T]; state: S): T
• stream: run[S](self: Stream[S, Unit]): Unit
• loop: run[S](self: Loop[S, Unit]; initial: S): S
• loopscope: run[S](self: LoopScope[S]; initial: S): S
• loopscope: run[S](self: LoopScope[S]; initial: S; body: S -> Unit): S
• reducer: run[R; T](self: Reducer[R, T]; reduction: R; item: T): R

runOnce:

• loop: runOnce[S; T](self: Loop[S, T]; start: S): RunOnceResult[S, T]
• loopscope: runOnce[S; T](self: LoopScope[S]; start: S; body: S -> T): RunOnceResult[S, T]

RunOnceResult:

• runonceresult: RunOnceResult

runOnceResult:

• runonceresult: runOnceResult[S; T](step: S; item: Optional[T]): RunOnceResult[S, T]

scope:

• stream: scope[S; T](X: typedesc[Stream[S, T]]): Lens[X, LoopScope[S]]
• loop: scope[S; T](X: typedesc[Loop[S, T]]): Lens[X, LoopScope[S]]

secondChild:

• nimnodes: secondChild(self: NimNode): NimNode

SeqIndex:

• sequence: SeqIndex

SeqStack:

• seqstack: SeqStack

seqStack:

• seqstack: seqStack[T](s: seq[T]): SeqStack[T]
• seqstack: seqStack(T: typedesc): SeqStack[T]
• seqstack: seqStack[T](): SeqStack[T]

SeqStep:

• sequence: SeqStep

SignedSliceStep:

• slice: SignedSliceStep

signedSliceStep:

• slice: signedSliceStep[T: Ordinal](i: T): SignedSliceStep

SignedSliceStepIndex:

• slice: SignedSliceStepIndex

singleItemStream:

• stream: singleItemStream[T](item: () -> T): Stream[SingleStep, T]

SingleStep:

• streamsteps: SingleStep

singleStep:

• streamsteps: singleStep(consumed: bool): SingleStep

skip:

• stream: skip[S; T; N: SomeNatural](self: Stream[S, T]; n: N): () -> Stream[S, T]

SkipStep:

• streamsteps: SkipStep

skipStep:

• streamsteps: skipStep[S; N: SomeNatural](step: S; count: N): SkipStep[S, N]

slice:

• slice: slice[T](low, high: T): Slice[T]

SliceStep:

• slice: SliceStep

sliceStep:

• slice: sliceStep[T](i: T): SliceStep[T]

sliceStepSigned:

• slice: sliceStepSigned[T: Ordinal](i: T): SignedSliceStep

SomeNatural:

• somenatural: SomeNatural

startingAt:

• stream: startingAt[S; T](loop: Loop[S, T]; initialStep: Initializer[S]): Stream[S, T]
• stream: startingAt[S; T](loop: Loop[S, T]; initialStep: Initializer[S]; onCloseEvent: OnCloseEvent[S]): Stream[S, T]

stateType:

• lens: stateType[S; T; ](self: Lens[S, T]): typedesc[S]
• lens: stateType[S; T; ](X: typedesc[Lens[S, T]]): typedesc[S]

step:

• runonceresult: step[S; T](X: typedesc[RunOnceResult[S, T]]): Lens[X, S]
• runonceresult: step[SA; T](X: typedesc[RunOnceResult[SA, T]]; SB: typedesc): PLens[X, SA, SB, RunOnceResult[SB, T]]
• streamsteps: step[S; N: SomeNatural](X: typedesc[LimitStep[S, N]]): Lens[X, S]
• streamsteps: step[S; N: SomeNatural](X: typedesc[SkipStep[S, N]]): Lens[X, S]
• streamsteps: step[S; T](X: typedesc[TakeWhileStep[S, T]]): Lens[X, S]

stepper:

• stream: stepper[S; T](X: typedesc[Stream[S, T]]): Lens[X, Stepper[S]]
• loop: stepper[S; T](X: typedesc[Loop[S, T]]): Lens[X, Stepper[S]]

Stepper:

• loopscope: Stepper

stepper:

• loopscope: stepper[S](reader: Reader[S, S]): Stepper[S]
• loopscope: stepper[S](X: typedesc[LoopScope[S]]): Lens[X, Stepper[S]]

stepType:

• stream: stepType[S; T; ](self: Stream[S, T]): typedesc[S]
• stream: stepType[S; T; ](X: typedesc[Stream[S, T]]): typedesc[S]
• loop: stepType[S; T; ](self: Loop[S, T]): typedesc[S]
• loop: stepType[S; T; ](X: typedesc[Loop[S, T]]): typedesc[S]
• loopscope: stepType[S; ](self: LoopScope[S]): typedesc[S]
• loopscope: stepType[S; ](X: typedesc[LoopScope[S]]): typedesc[S]

Stream:

• stream: Stream

sum:

• stream: sum[S; N](self: Stream[S, N]): N

takeWhile:

• stream: takeWhile[S; T](self: Stream[S, T]; predicate: Predicate[T]): Stream[ TakeWhileStep[S, T], T]

TakeWhileStep:

• streamsteps: TakeWhileStep

takeWhileStep:

• streamsteps: takeWhileStep[S; T](step: S; item: Optional[T]): TakeWhileStep[S, T]

test:

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

toIO:

• io: toIO[T](value: T): IO[T]

toNone:

• optional: toNone[T](): Optional[T]
• optional: toNone(T: typedesc[not Nilable]): Optional[T]
• optional: toNone(T: typedesc[Nilable]): Optional[T]

toOptional:

• optional: toOptional[T: Nilable](value: T): Optional[T]

top:

• seqstack: top[T](self: SeqStack[T]): Optional[T]

toReader:

• reader: toReader[S; T](value: T): Reader[S, T]
• reader: toReader[T](value: T; S: typedesc): Reader[S, T]

toSome:

• optional: toSome[T: Nilable](value: T): Optional[T]
• optional: toSome[T: not Nilable](value: T): Optional[T]

traversePreOrder:

• ast: traversePreOrder(root: NimNode): Stream[PreOrderStep, NimNode]

tryBracket:

• io: tryBracket[A; B](before: IO[A]; `try`: A -> B; `finally`: A -> Unit): IO[B]

unbox:

• optional: unbox[T](self: Optional[T]): T

UnboxError:

• optional: UnboxError

unboxOr:

• optional: unboxOr[T](self: Optional[T]; `else`: () -> T): T

Unit:

• unit: Unit

unit:

• unit: unit(): Unit

valueType:

• optional: valueType[T; ](self: Optional[T]): typedesc[T]
• optional: valueType[T; ](X: typedesc[Optional[T]]): typedesc[T]

write:

• plens: write[SR; R; W; SW](self: PLens[SR, R, W, SW]; value: () -> W): Reader[SR, SW]
• plens: write[SR; R; W; SW](state: SR; lens: PLens[SR, R, W, SW]; value: W): SW
• variables: write[T](self: var T; value: T): var T

writtenMemberType:

• plens: writtenMemberType[SR; R; W; SW; ](self: PLens[SR, R, W, SW]): typedesc[W]
• plens: writtenMemberType[SR; R; W; SW; ](X: typedesc[PLens[SR, R, W, SW]]): typedesc[W]

writtenStateType:

• plens: writtenStateType[SR; R; W; SW; ](self: PLens[SR, R, W, SW]): typedesc[SW]
• plens: writtenStateType[SR; R; W; SW; ](X: typedesc[PLens[SR, R, W, SW]]): typedesc[SW]

zip:

• stream: zip[SA; A; SB; B](self: Stream[SA, A]; other: Stream[SB, B]): Stream[ZipStep[SA, SB], Pair[A, B]]

ZipStep:

• streamsteps: ZipStep

zipStep:

• streamsteps: zipStep[SA; SB](left: SA; right: SB): ZipStep[SA, SB]