Index

Modules: pon2, pon2/app, pon2/app/color, pon2/app/generate, pon2/app/ide, pon2/app/ide/web, pon2/app/key, pon2/app/marathon, pon2/app/marathon/web, pon2/app/nazopuyo, pon2/app/permute, pon2/app/simulator, pon2/app/simulator/web, pon2/app/solve, pon2/core, pon2/core/cell, pon2/core/field, pon2/core/fieldtype, pon2/core/fqdn, pon2/core/mark, pon2/core/moveresult, pon2/core/nazopuyo, pon2/core/notice, pon2/core/pair, pon2/core/pairposition, pon2/core/position, pon2/core/puyopuyo, pon2/core/requirement, pon2/core/rule, pon2/private/app/generate, pon2/private/app/ide/web/answer, pon2/private/app/ide/web/controller, pon2/private/app/ide/web/pagination, pon2/private/app/ide/web/progress, pon2/private/app/ide/web/settings, pon2/private/app/ide/web/webworker, pon2/private/app/marathon/common, pon2/private/app/marathon/web/controller, pon2/private/app/marathon/web/pagination, pon2/private/app/marathon/web/searchbar, pon2/private/app/marathon/web/searchresult, pon2/private/app/marathon/web/simulator, pon2/private/app/misc, pon2/private/app/permute, pon2/private/app/simulator/common, pon2/private/app/simulator/web/controller, pon2/private/app/simulator/web/field, pon2/private/app/simulator/web/immediatepairs, pon2/private/app/simulator/web/messages, pon2/private/app/simulator/web/operating, pon2/private/app/simulator/web/pairs, pon2/private/app/simulator/web/palette, pon2/private/app/simulator/web/requirement, pon2/private/app/simulator/web/select, pon2/private/app/simulator/web/share, pon2/private/app/solve, pon2/private/core/field/avx2/binary, pon2/private/core/field/avx2/disappearresult, pon2/private/core/field/avx2/main, pon2/private/core/field/binary, pon2/private/core/mark, pon2/private/intrinsic, pon2/private/main/web, pon2/private/misc, pon2/private/unionfind, pon2/private/webworker.

API symbols

`$`:

• field: proc `$`(self: TsuField or WaterField): string
• nazopuyo: proc `$`[F: TsuField or WaterField](self: NazoPuyo[F]): string
• pairposition: proc `$`(pairPosition: PairPosition): string
• pairposition: proc `$`(pairsPositions: PairsPositions): string
• puyopuyo: proc `$`[F: TsuField or WaterField](self: PuyoPuyo[F]): string
• requirement: proc `$`(self: Requirement): string

`*`:

• binary: proc `*`(field1, field2: BinaryField): BinaryField

`+=`:

• binary: proc `+=`(self: var BinaryField; field: BinaryField)

`+`:

• binary: proc `+`(field1, field2: BinaryField): BinaryField

`-=`:

• binary: proc `-=`(self: var BinaryField; field: BinaryField)

`-`:

• binary: proc `-`(self, field: BinaryField): BinaryField

`==`:

• nazopuyo: proc `==`(nazo1, nazo2: NazoPuyoWrap): bool
• field: proc `==`(field1: TsuField; field2: WaterField): bool
• field: proc `==`(field1: WaterField; field2: TsuField): bool
• nazopuyo: proc `==`(nazo1: NazoPuyo[TsuField]; nazo2: NazoPuyo[WaterField]): bool
• nazopuyo: proc `==`(nazo1: NazoPuyo[WaterField]; nazo2: NazoPuyo[TsuField]): bool
• puyopuyo: proc `==`(self: PuyoPuyo[TsuField]; puyoPuyo: PuyoPuyo[WaterField]): bool
• puyopuyo: proc `==`(self: PuyoPuyo[WaterField]; field: PuyoPuyo[TsuField]): bool
• binary: proc `==`(field1, field2: BinaryField): bool

`[]=`:

• binary: proc `[]=`(self: var BinaryField; row: Row; col: Column; which: WhichColor)
• main: proc `[]=`(self: var (TsuField or WaterField); row: Row; col: Column; cell: Cell)

`[]`:

• binary: proc `[]`(self: BinaryField; row: Row; col: Column): WhichColor
• main: proc `[]`(self: TsuField or WaterField; row: Row; col: Column): Cell

`xor`:

• binary: proc `xor`(field1, field2: BinaryField): BinaryField

Accept:

• mark: MarkResult.Accept

AirHeight:

• fieldtype: const AirHeight

AirRow:

• fieldtype: type AirRow

airTrimmed:

• binary: proc airTrimmed(self: BinaryField): BinaryField

AllDoublePositions:

• position: const AllDoublePositions

AllPairsCount:

• common: const AllPairsCount

allPairsPositionsSeq:

• permute: proc allPairsPositionsSeq[F: TsuField or WaterField](nazo: NazoPuyo[F]; fixMoves: openArray[Positive]; allowDouble: bool; allowLastDouble: bool): seq[ PairsPositions]

AllPositions:

• position: const AllPositions

AnswerData:

• ide: object AnswerData

answerData:

• ide: proc answerData(self: Ide): AnswerData

answerSimulator:

• ide: proc answerSimulator(self: Ide): Simulator

assignToWorker:

• webworker: proc assignToWorker(task: WorkerTask)

asyncLoadData:

• marathon: proc asyncLoadData(self: Marathon; completeHandler: () -> void = () => (discard ))

asyncPermute:

• webworker: proc asyncPermute[F: TsuField or WaterField](nazo: NazoPuyo[F]; results: ref seq[ Option[PairsPositions]]; pairsPositionsSeq: seq[PairsPositions]; fixMoves: seq[Positive]; allowDouble: bool; allowLastDouble: bool; parallelCount: Positive = 6)

asyncSolve:

• webworker: proc asyncSolve[F: TsuField or WaterField](nazo: NazoPuyo[F]; results: ref seq[seq[SolveAnswer]]; showProgress = false; earlyStopping: static bool = false; parallelCount: Positive = 6)

axis:

• pair: proc axis(self: Pair): Cell

axis=:

• pair: proc axis=(self: var Pair; color: ColorPuyo)

axisColumn:

• position: proc axisColumn(self: Position): Column

backward:

• simulator: proc backward(self: Simulator; toStable = true)

BinaryField:

• binary: type BinaryField

canPrune:

• solve: proc canPrune[F: TsuField or WaterField](node: Node[F]; reqKind: static RequirementKind; reqColor: static RequirementColor; firstCall: static bool = false): bool

Cell:

• cell: enum Cell

cellImageSrc:

• misc: proc cellImageSrc(cell: Cell): kstring

chainSatisfied:

• mark: proc chainSatisfied(req: Requirement; moveRes: MoveResult; kind: static RequirementKind): bool

child:

• pair: proc child(self: Pair): Cell

child=:

• pair: proc child=(self: var Pair; color: ColorPuyo)

childColumn:

• position: proc childColumn(self: Position): Column

childDirection:

• position: proc childDirection(self: Position): Direction

children:

• solve: proc children[F: TsuField or WaterField](node: Node[F]; reqKind: static RequirementKind; reqColor: static RequirementColor): seq[ tuple[node: Node[F], position: Position]]

clearColumn:

• binary: proc clearColumn(self: var BinaryField; col: Column)

Color:

• color: object Color

color:

• generate: proc color(self: GenerateRequirement): GenerateRequirementColor
• requirement: proc color(self: Requirement): RequirementColor

color=:

• generate: proc color=(self: var GenerateRequirement; color: GenerateRequirementColor)
• requirement: proc color=(self: var Requirement; color: RequirementColor)

colorConnects:

• moveresult: proc colorConnects(self: MoveResult): seq[int]
• moveresult: proc colorConnects(self: MoveResult; color: ColorPuyo): seq[int]

colorCount:

• moveresult: proc colorCount(self: MoveResult): int
• pair: proc colorCount(self: Pair): int
• pairposition: proc colorCount(pairsPositions: PairsPositions): int
• puyopuyo: proc colorCount[F: TsuField or WaterField](self: PuyoPuyo[F]): int
• disappearresult: proc colorCount(self: DisappearResult): int
• main: proc colorCount(self: TsuField or WaterField): int

colorCounts:

• moveresult: proc colorCounts(self: MoveResult): seq[int]

ColorKinds:

• requirement: const ColorKinds

colorPlaces:

• moveresult: proc colorPlaces(self: MoveResult): seq[int]
• moveresult: proc colorPlaces(self: MoveResult; color: ColorPuyo): seq[int]

ColorPuyo:

• cell: type ColorPuyo

colors:

• moveresult: proc colors(self: MoveResult): set[ColorPuyo]

colorsSeq:

• moveresult: proc colorsSeq(self: MoveResult): seq[set[ColorPuyo]]

Column:

• fieldtype: type Column

column:

• binary: proc column(self: BinaryField; col: Column): BinaryField

completeHandler=:

• webworker: proc completeHandler=(self: Worker; handler: WorkerCompleteHandler)

connect2:

• main: proc connect2[F: TsuField or WaterField](self: F): F
• binary: proc connect2(self: BinaryField): BinaryField

connect2H:

• main: proc connect2H[F: TsuField or WaterField](self: F): F
• binary: proc connect2H(self: BinaryField): BinaryField

connect2V:

• main: proc connect2V[F: TsuField or WaterField](self: F): F
• binary: proc connect2V(self: BinaryField): BinaryField

connect3:

• main: proc connect3[F: TsuField or WaterField](self: F): F
• binary: proc connect3(self: BinaryField): BinaryField

connect3H:

• main: proc connect3H[F: TsuField or WaterField](self: F): F
• binary: proc connect3H(self: BinaryField): BinaryField

connect3L:

• main: proc connect3L[F: TsuField or WaterField](self: F): F
• binary: proc connect3L(self: BinaryField): BinaryField

connect3V:

• main: proc connect3V[F: TsuField or WaterField](self: F): F
• binary: proc connect3V(self: BinaryField): BinaryField

connectionCounts:

• disappearresult: proc connectionCounts(self: DisappearResult): array[ColorPuyo, seq[int]]

copy:

• simulator: proc copy(self: Simulator): Simulator
• pairposition: proc copy(pairsPositions: PairsPositions): PairsPositions
• misc: proc copy[T](deque: Deque[T]): Deque[T]

Dead:

• mark: MarkResult.Dead

decRot:

• misc: proc decRot[T: Ordinal](x: var T)

DefaultColor:

• color: const DefaultColor

DefaultWorkerCompleteHandler:

• webworker: const DefaultWorkerCompleteHandler

DefaultWorkerTask:

• webworker: const DefaultWorkerTask

delete:

• misc: proc delete[T](deque: var Deque[T]; idx: Natural)

deletePairPosition:

• simulator: proc deletePairPosition(self: Simulator)
• simulator: proc deletePairPosition(self: Simulator; idx: Natural)

Direction:

• position: enum Direction

disappear:

• main: proc disappear(self: var (TsuField or WaterField)): DisappearResult

disappearColorSametimeSatisfied:

• mark: proc disappearColorSametimeSatisfied(req: Requirement; moveRes: MoveResult; kind: static RequirementKind): bool

disappearColorSatisfied:

• mark: proc disappearColorSatisfied(req: Requirement; colors: set[ColorPuyo]; kind: static RequirementKind): bool

disappearConnectSatisfied:

• mark: proc disappearConnectSatisfied(req: Requirement; moveRes: MoveResult; kind: static RequirementKind): bool
• mark: proc disappearConnectSatisfied(req: Requirement; moveRes: MoveResult; kind: static RequirementKind; color: static RequirementColor): bool

disappearCountSametimeSatisfied:

• mark: proc disappearCountSametimeSatisfied(req: Requirement; moveRes: MoveResult; kind: static RequirementKind): bool
• mark: proc disappearCountSametimeSatisfied(req: Requirement; moveRes: MoveResult; kind: static RequirementKind; color: static RequirementColor): bool

disappearCountSatisfied:

• mark: proc disappearCountSatisfied(req: Requirement; count: int; kind: static RequirementKind): bool

disappeared:

• binary: proc disappeared(self: BinaryField): BinaryField

disappearPlaceSatisfied:

• mark: proc disappearPlaceSatisfied(req: Requirement; moveRes: MoveResult; kind: static RequirementKind): bool
• mark: proc disappearPlaceSatisfied(req: Requirement; moveRes: MoveResult; kind: static RequirementKind; color: static RequirementColor): bool

DisappearResult:

• disappearresult: object DisappearResult

drop:

• binary: proc drop(self: var BinaryField; mask: DropMask)
• main: proc drop(self: var TsuField)
• main: proc drop(self: var WaterField)

DropMask:

• binary: type DropMask

editing:

• simulator: proc editing(self: Simulator): SimulatorEditing

editingCell=:

• simulator: proc editingCell=(self: Simulator; cell: Cell)

exist:

• binary: proc exist(self: BinaryField): BinaryField
• binary: proc exist(self: BinaryField; row: Row; col: Column): int
• main: proc exist(self: TsuField or WaterField): BinaryField

expanded:

• binary: proc expanded(self: BinaryField): BinaryField

fieldCellBackgroundColor:

• common: proc fieldCellBackgroundColor(simulator: Simulator; row: Row; col: Column; displayMode = false): Color

filled:

• binary: proc filled(which: WhichColor): BinaryField

flip:

• simulator: proc flip(self: Simulator)

flipFieldH:

• simulator: proc flipFieldH(self: Simulator)

flipFieldV:

• simulator: proc flipFieldV(self: Simulator)

flipH:

• field: proc flipH(self: var (TsuField or WaterField))
• binary: proc flipH(self: var BinaryField)

flippedH:

• binary: proc flippedH(self: BinaryField): BinaryField
• main: proc flippedH[F: TsuField or WaterField](self: F): F

flippedV:

• binary: proc flippedV(self: BinaryField): BinaryField
• main: proc flippedV[F: TsuField or WaterField](self: F): F

flipV:

• field: proc flipV(self: var (TsuField or WaterField))
• binary: proc flipV(self: var BinaryField)

floorBinaryField:

• binary: proc floorBinaryField(): BinaryField

focusAnswer:

• ide: proc focusAnswer(self: Ide): bool

focusSimulator:

• marathon: proc focusSimulator(self: Marathon): bool

forward:

• simulator: proc forward(self: Simulator; replay = false; skip = false)

garbageCount:

• moveresult: proc garbageCount(self: MoveResult): int
• pair: proc garbageCount(self: Pair): int
• pairposition: proc garbageCount(pairsPositions: PairsPositions): int
• puyopuyo: proc garbageCount[F: TsuField or WaterField](self: PuyoPuyo[F]): int
• disappearresult: proc garbageCount(self: DisappearResult): int
• main: proc garbageCount(self: TsuField or WaterField): int

garbageCounts:

• moveresult: proc garbageCounts(self: MoveResult): seq[int]

GarbageRates:

• notice: const GarbageRates

generate:

• generate: proc generate[F: TsuField or WaterField](option: GenerateOption; parallelCount: Positive = processorCount()): NazoPuyo[ F]
• generate: proc generate(option: GenerateOption; rule: Rule; parallelCount: Positive = processorCount()): NazoPuyoWrap
• generate: proc generate(option: GenerateOption; rule: Rule; seed: SomeSignedInt; parallelCount: Positive = processorCount()): NazoPuyoWrap
• generate: proc generate[F: TsuField or WaterField](option: GenerateOption; seed: SomeSignedInt; parallelCount: Positive = processorCount()): NazoPuyo[ F]

GenerateError:

• generate: object GenerateError

GenerateOption:

• generate: object GenerateOption

GenerateRequirement:

• generate: object GenerateRequirement

GenerateRequirementColor:

• generate: enum GenerateRequirementColor

get:

• nazopuyo: template get(self: NazoPuyoWrap; body: untyped): untyped

getMessages:

• common: proc getMessages(simulator: Simulator): tuple[state: string, score: int, noticeGarbages: array[NoticeGarbage, int]]

getRoot:

• unionfind: proc getRoot(self: var UnionFind; node: UnionFindNode): UnionFindNode

getSettings:

• settings: proc getSettings(id: string; moveCount: Positive): tuple[parallelCount: int, fixMoves: seq[Positive], allowDouble: bool, allowLastDouble: bool]

GhostColor:

• color: const GhostColor

Height:

• fieldtype: const Height

Ide:

• ide: type Ide

IdeFqdn:

• fqdn: enum IdeFqdn

ideRenderer:

• web: proc ideRenderer(routerData: RouterData): VNode

immediateDoubleNextPairCell:

• common: proc immediateDoubleNextPairCell(simulator: Simulator; axis: bool): Cell

immediateNextPairCell:

• common: proc immediateNextPairCell(simulator: Simulator; axis: bool): Cell

ImpossibleMove:

• mark: MarkResult.ImpossibleMove

incRot:

• misc: proc incRot[T: Ordinal](x: var T)

initField:

• main: proc initField[F: TsuField or WaterField](): F

initGenerateRequirement:

• generate: proc initGenerateRequirement(kind: RequirementKind; color: GenerateRequirementColor): GenerateRequirement
• generate: proc initGenerateRequirement(kind: RequirementKind; color: GenerateRequirementColor; number: RequirementNumber): GenerateRequirement
• generate: proc initGenerateRequirement(kind: RequirementKind; number: RequirementNumber): GenerateRequirement

initKeyEvent:

• key: proc initKeyEvent(code: string; shift = false; control = false; alt = false; meta = false): KeyEvent

initMoveResult:

• moveresult: proc initMoveResult(chainCount: Natural; disappearCounts: array[Puyo, int]): MoveResult
• moveresult: proc initMoveResult(chainCount: Natural; disappearCounts: array[Puyo, int]; detailDisappearCounts: seq[array[Puyo, int]]): MoveResult
• moveresult: proc initMoveResult(chainCount: Natural; disappearCounts: array[Puyo, int]; detailDisappearCounts: seq[array[Puyo, int]]; fullDisappearCounts: seq[array[ColorPuyo, seq[int]]]): MoveResult

initNazoPuyo:

• nazopuyo: proc initNazoPuyo[F: TsuField or WaterField](): NazoPuyo[F]

initNazoPuyoWrap:

• nazopuyo: proc initNazoPuyoWrap[F: TsuField or WaterField](nazo: NazoPuyo[F]): NazoPuyoWrap

initNode:

• solve: proc initNode[F: TsuField or WaterField](nazo: NazoPuyo[F]): Node[F]

initPair:

• pair: proc initPair(axis, child: ColorPuyo): Pair

initPosition:

• position: proc initPosition(axisCol: Column; childDir: Direction): Position

initPuyoPuyo:

• puyopuyo: proc initPuyoPuyo[F: TsuField or WaterField](): PuyoPuyo[F]

initRequirement:

• requirement: proc initRequirement(kind: RequirementKind; color: RequirementColor): Requirement
• requirement: proc initRequirement(kind: RequirementKind; color: RequirementColor; number: RequirementNumber): Requirement
• requirement: proc initRequirement(kind: RequirementKind; number: RequirementNumber): Requirement

initUnionFind:

• unionfind: proc initUnionFind(size: Natural): UnionFind

initXLink:

• misc: proc initXLink(text = ""; hashTag = ""; uri = initUri()): Uri

insert:

• main: proc insert(self: var TsuField; row: Row; col: Column; cell: Cell)
• main: proc insert(self: var WaterField; row: Row; col: Column; cell: Cell)
• misc: proc insert[T](deque: var Deque[T]; item: sink T; idx = 0.Natural)

invalidPositions:

• field: proc invalidPositions(self: TsuField or WaterField): set[Position]
• binary: proc invalidPositions(self: BinaryField): set[Position]

isDead:

• field: proc isDead(self: TsuField or WaterField): bool
• binary: proc isDead(self: BinaryField; rule: Rule): bool

isDouble:

• pair: proc isDouble(self: Pair): bool

isMobile:

• misc: proc isMobile(): bool

isReady:

• marathon: proc isReady(self: Marathon): bool

isSupported:

• requirement: proc isSupported(self: Requirement): bool

isZero:

• binary: proc isZero(self: BinaryField): bool

KeyEvent:

• key: object KeyEvent

kind:

• generate: proc kind(self: GenerateRequirement): RequirementKind
• simulator: proc kind(self: Simulator): SimulatorKind
• requirement: proc kind(self: Requirement): RequirementKind

kind=:

• generate: proc kind=(self: var GenerateRequirement; kind: RequirementKind)
• simulator: proc kind=(self: Simulator; kind: SimulatorKind)
• requirement: proc kind=(self: var Requirement; kind: RequirementKind)

Marathon:

• marathon: type Marathon

MarathonMatchResult:

• marathon: object MarathonMatchResult

mark:

• mark: proc mark[F: TsuField or WaterField](nazo: NazoPuyo[F]): MarkResult
• mark: proc mark[F: TsuField or WaterField](nazo: NazoPuyo[F]; positions: Deque[Position]): MarkResult
• mark: proc mark[F: TsuField or WaterField](nazo: NazoPuyo[F]; positions: openArray[Position]): MarkResult
• mark: proc mark[F: TsuField or WaterField](nazo: NazoPuyo[F]; pairsPositions: PairsPositions): MarkResult

MarkResult:

• mark: enum MarkResult

match:

• marathon: proc match(self: Marathon; prefix: string)

matchResult:

• marathon: proc matchResult(self: Marathon): MarathonMatchResult

MatchResultPairsCountPerPage:

• common: const MatchResultPairsCountPerPage

merge:

• unionfind: proc merge(self: var UnionFind; node1, node2: UnionFindNode)

mode:

• simulator: proc mode(self: Simulator): SimulatorMode

mode=:

• simulator: proc mode=(self: Simulator; mode: SimulatorMode)

move:

• field: proc move(self: var (TsuField or WaterField); pair: Pair; pos: Position): MoveResult
• field: proc move(self: var (TsuField or WaterField); pairPos: PairPosition): MoveResult
• puyopuyo: proc move[F: TsuField or WaterField](self: var PuyoPuyo[F]): MoveResult
• puyopuyo: proc move[F: TsuField or WaterField](self: var PuyoPuyo[F]; pos: Position): MoveResult

move0:

• field: proc move0(self: var (TsuField or WaterField); pair: Pair; pos: Position): MoveResult
• field: proc move0(self: var (TsuField or WaterField); pairPos: PairPosition): MoveResult
• puyopuyo: proc move0[F: TsuField or WaterField](self: var PuyoPuyo[F]): MoveResult
• puyopuyo: proc move0[F: TsuField or WaterField](self: var PuyoPuyo[F]; pos: Position): MoveResult

move1:

• field: proc move1(self: var (TsuField or WaterField); pair: Pair; pos: Position): MoveResult
• field: proc move1(self: var (TsuField or WaterField); pairPos: PairPosition): MoveResult
• puyopuyo: proc move1[F: TsuField or WaterField](self: var PuyoPuyo[F]): MoveResult
• puyopuyo: proc move1[F: TsuField or WaterField](self: var PuyoPuyo[F]; pos: Position): MoveResult

move2:

• field: proc move2(self: var (TsuField or WaterField); pair: Pair; pos: Position): MoveResult
• field: proc move2(self: var (TsuField or WaterField); pairPos: PairPosition): MoveResult
• puyopuyo: proc move2[F: TsuField or WaterField](self: var PuyoPuyo[F]): MoveResult
• puyopuyo: proc move2[F: TsuField or WaterField](self: var PuyoPuyo[F]; pos: Position): MoveResult

moveCount:

• nazopuyo: proc moveCount[F: TsuField or WaterField](self: NazoPuyo[F]): int

moveCursorDown:

• simulator: proc moveCursorDown(self: Simulator)

moveCursorLeft:

• simulator: proc moveCursorLeft(self: Simulator)

moveCursorRight:

• simulator: proc moveCursorRight(self: Simulator)

moveCursorUp:

• simulator: proc moveCursorUp(self: Simulator)

movedLeft:

• position: proc movedLeft(self: Position): Position

movedRight:

• position: proc movedRight(self: Position): Position

moveLeft:

• position: proc moveLeft(self: var Position)

moveOperatingPositionLeft:

• simulator: proc moveOperatingPositionLeft(self: Simulator)

moveOperatingPositionRight:

• simulator: proc moveOperatingPositionRight(self: Simulator)

MoveResult:

• moveresult: object MoveResult

moveRight:

• position: proc moveRight(self: var Position)

movingCompleted:

• puyopuyo: proc movingCompleted[F: TsuField or WaterField](self: PuyoPuyo[F]): bool

NativeAssetsDir:

• misc: const NativeAssetsDir

NazoPuyo:

• nazopuyo: object NazoPuyo

NazoPuyoWrap:

• nazopuyo: object NazoPuyoWrap

nazoPuyoWrap:

• simulator: proc nazoPuyoWrap(self: Simulator): NazoPuyoWrap

nazoPuyoWrapBeforeMoves:

• simulator: proc nazoPuyoWrapBeforeMoves(self: Simulator): NazoPuyoWrap

needPairPointer:

• common: proc needPairPointer(simulator: Simulator; idx: Natural): bool

newAnswerSimulatorNode:

• answer: proc newAnswerSimulatorNode(ide: Ide; id: string): VNode

newControllerNode:

• controller: proc newControllerNode(simulator: Simulator): VNode

newCopyButtonHandler:

• misc: proc newCopyButtonHandler(copyStr: () -> string; id: string; disableMs = 500.Natural): () -> void

newDisplayNode:

• share: proc newDisplayNode(simulator: Simulator; id: string): VNode

newEditorControllerNode:

• controller: proc newEditorControllerNode(ide: Ide; settingsId: string): VNode

newEditorPaginationNode:

• pagination: proc newEditorPaginationNode(ide: Ide): VNode

newEditorProgressBarNode:

• progress: proc newEditorProgressBarNode(ide: Ide): VNode

newEditorSettingsNode:

• settings: proc newEditorSettingsNode(ide: Ide; id: string): VNode

newFieldNode:

• field: proc newFieldNode(simulator: Simulator; displayMode = false): VNode

newIde:

• ide: proc newIde(): Ide
• ide: proc newIde(simulator: Simulator): Ide

newIdeNode:

• web: proc newIdeNode(self: Ide; setKeyHandler = true; wrapSection = true; id = ""): VNode

newImmediatePairsNode:

• immediatepairs: proc newImmediatePairsNode(simulator: Simulator): VNode

newKeyboardEventHandler:

• web: proc newKeyboardEventHandler(self: Ide): (event: Event) -> void
• web: proc newKeyboardEventHandler(self: Marathon): (event: Event) -> void

newMarathon:

• marathon: proc newMarathon(rng = initRand()): Marathon

newMarathonFocusControllerNode:

• controller: proc newMarathonFocusControllerNode(marathon: Marathon): VNode

newMarathonNode:

• web: proc newMarathonNode(self: Marathon; setKeyHandler = true; wrapSection = true; id = ""): VNode

newMarathonPaginationNode:

• pagination: proc newMarathonPaginationNode(marathon: Marathon): VNode

newMarathonPlayControllerNode:

• controller: proc newMarathonPlayControllerNode(marathon: Marathon): VNode

newMarathonSearchBarNode:

• searchbar: proc newMarathonSearchBarNode(marathon: Marathon; id: string): VNode

newMarathonSearchResultNode:

• searchresult: proc newMarathonSearchResultNode(marathon: Marathon): VNode

newMarathonSimulatorNode:

• simulator: proc newMarathonSimulatorNode(marathon: Marathon; id: string): VNode

newMessagesNode:

• messages: proc newMessagesNode(simulator: Simulator): VNode

newOperatingNode:

• operating: proc newOperatingNode(simulator: Simulator): VNode

newPairsNode:

• pairs: proc newPairsNode(simulator: Simulator; displayMode = false; showPositions = true): VNode

newPaletteNode:

• palette: proc newPaletteNode(simulator: Simulator): VNode

newRequirementNode:

• requirement: proc newRequirementNode(simulator: Simulator; id: string; displayMode = false): VNode

newSelectNode:

• select: proc newSelectNode(simulator: Simulator): VNode

newShareNode:

• share: proc newShareNode(simulator: Simulator; id: string; onlyEditorButton: bool): VNode

newSimulator:

• simulator: proc newSimulator[F: TsuField or WaterField](mode = Play): Simulator
• simulator: proc newSimulator[F: TsuField or WaterField](nazo: NazoPuyo[F]; mode = Play): Simulator
• simulator: proc newSimulator(nazoPuyoWrap: NazoPuyoWrap; mode = Play): Simulator
• simulator: proc newSimulator[F: TsuField or WaterField](puyoPuyo: PuyoPuyo[F]; mode = Play): Simulator

newSimulatorNode:

• web: proc newSimulatorNode(self: Simulator; wrapSection = true; id = ""; isAnswer = false): VNode

newWorker:

• webworker: proc newWorker(): Worker

nextAnswer:

• ide: proc nextAnswer(self: Ide)

nextResultPage:

• marathon: proc nextResultPage(self: Marathon)

NoColorKinds:

• requirement: const NoColorKinds

Node:

• solve: object Node

noneCount:

• field: proc noneCount(self: TsuField or WaterField): int

NoNumberKinds:

• requirement: const NoNumberKinds

notDisappeared:

• disappearresult: proc notDisappeared(self: DisappearResult): bool

NoticeGarbage:

• notice: enum NoticeGarbage

noticeGarbageCounts:

• moveresult: proc noticeGarbageCounts(self: MoveResult; rule: Rule): array[NoticeGarbage, int]
• notice: proc noticeGarbageCounts(score: Natural; rule: Rule; useComet = false): array[ NoticeGarbage, int]

noticeGarbageImageSrc:

• misc: proc noticeGarbageImageSrc(notice: NoticeGarbage): kstring

NoticeGarbageNoneImageSrc:

• misc: const NoticeGarbageNoneImageSrc

NotSupport:

• mark: MarkResult.NotSupport

number:

• generate: proc number(self: GenerateRequirement): RequirementNumber
• requirement: proc number(self: Requirement): RequirementNumber

number=:

• generate: proc number=(self: var GenerateRequirement; number: RequirementNumber)
• requirement: proc number=(self: var Requirement; number: RequirementNumber)

NumberKinds:

• requirement: const NumberKinds

operate:

• ide: proc operate(self: Ide; event: KeyEvent): bool
• marathon: proc operate(self: Marathon; event: KeyEvent): bool
• simulator: proc operate(self: Simulator; event: KeyEvent): bool

operatingIndex:

• simulator: proc operatingIndex(self: Simulator): int

operatingPairCell:

• common: proc operatingPairCell(simulator: Simulator; idx: range[-1 .. 1]; col: Column): Cell

operatingPosition:

• simulator: proc operatingPosition(self: Simulator): Position

Pair:

• pair: enum Pair

pairCellBackgroundColor:

• common: proc pairCellBackgroundColor(simulator: Simulator; idx: Natural; axis: bool): Color

PairPosition:

• pairposition: object PairPosition

PairsPositions:

• pairposition: type PairsPositions

pairsPositions=:

• simulator: proc pairsPositions=(self: Simulator; pairsPositions: PairsPositions)

parseBinaryField:

• binary: proc parseBinaryField(arr: array[Row, array[Column, WhichColor]]): BinaryField

parseCell:

• cell: proc parseCell(str: string): Cell

parseField:

• field: proc parseField[F: TsuField or WaterField](str: string): F
• field: proc parseField[F: TsuField or WaterField](query: string; fqdn: IdeFqdn): F
• main: proc parseField[F: TsuField or WaterField](arr: array[Row, array[Column, Cell]]): F

parseIde:

• ide: proc parseIde(uri: Uri): Ide

parseNazoPuyo:

• nazopuyo: proc parseNazoPuyo[F: TsuField or WaterField](str: string): NazoPuyo[F]
• nazopuyo: proc parseNazoPuyo[F: TsuField or WaterField](query: string; fqdn: IdeFqdn): NazoPuyo[ F]

parseNode:

• solve: proc parseNode[F: TsuField or WaterField](str: string): Node[F]

parsePair:

• pair: proc parsePair(str: string): Pair
• pair: proc parsePair(query: string; fqdn: IdeFqdn): Pair

parsePairPosition:

• pairposition: proc parsePairPosition(str: string): PairPosition
• pairposition: proc parsePairPosition(query: string; fqdn: IdeFqdn): PairPosition

parsePairsPositions:

• pairposition: proc parsePairsPositions(str: string): PairsPositions
• pairposition: proc parsePairsPositions(query: string; fqdn: IdeFqdn): PairsPositions

parsePosition:

• position: proc parsePosition(str: string): Position
• position: proc parsePosition(query: string; fqdn: IdeFqdn): Position

parsePuyoPuyo:

• puyopuyo: proc parsePuyoPuyo[F: TsuField or WaterField](str: string): PuyoPuyo[F]
• puyopuyo: proc parsePuyoPuyo[F: TsuField or WaterField](query: string; fqdn: IdeFqdn): PuyoPuyo[ F]

parseRequirement:

• requirement: proc parseRequirement(str: string): Requirement
• requirement: proc parseRequirement(query: string; fqdn: IdeFqdn): Requirement

parseRule:

• rule: proc parseRule(str: string): Rule

parseSimulator:

• simulator: proc parseSimulator(query: string; fqdn: IdeFqdn): Simulator
• simulator: proc parseSimulator(uri: Uri): Simulator

parseSomeInt:

• misc: proc parseSomeInt[T: SomeNumber or Natural or Positive](val: char): T
• misc: proc parseSomeInt[T: SomeNumber or Natural or Positive](val: string): T

permute:

• ide: proc permute(self: Ide; fixMoves: seq[Positive]; allowDouble: bool; allowLastDouble: bool; parallelCount = when defined(js): 6 else: max(1, countProcessors()))
• permute: iterator permute[F: TsuField or WaterField](nazo: NazoPuyo[F]; fixMoves: seq[Positive]; allowDouble: bool; allowLastDouble: bool; showProgress: static bool = false; parallelCount: Positive = when true: 1 else: max(1, countProcessors())): PairsPositions

Permute:

• webworker: TaskKind.Permute

permuting:

• ide: proc permuting(self: Ide): bool

pext:

• intrinsic: proc pext(a, mask: uint16): uint16
• intrinsic: proc pext(a, mask: uint32): uint32
• intrinsic: proc pext(a, mask: uint64): uint64

play:

• marathon: proc play(self: Marathon; onlyMatched = true)
• marathon: proc play(self: Marathon; pairsIdx: Natural)

Pon2Fqdn:

• fqdn: const Pon2Fqdn

Pon2RootDir:

• misc: const Pon2RootDir

Pon2Version:

• misc: const Pon2Version

popcnt:

• binary: proc popcnt(self: BinaryField): int
• binary: proc popcnt(self: BinaryField; color: static range[0 .. 1]): int

Position:

• position: enum Position

positions:

• simulator: proc positions(self: Simulator): Deque[Position]

positions=:

• simulator: proc positions=(self: Simulator; positions: Deque[Position])
• pairposition: proc positions=(pairsPositions: var PairsPositions; positions: Deque[Position])

prevAnswer:

• ide: proc prevAnswer(self: Ide)

prevResultPage:

• marathon: proc prevResultPage(self: Marathon)

processorCount:

• misc: proc processorCount(): int

prod:

• binary: proc prod(field1, field2, field3: BinaryField): BinaryField

product2:

• misc: proc product2[T](x: openArray[seq[T]]): seq[seq[T]]

progressBarData:

• ide: proc progressBarData(self: Ide): tuple[now: int, total: int]

put:

• field: proc put(self: var (TsuField or WaterField); pairPos: PairPosition)
• main: proc put(self: var TsuField; pair: Pair; pos: Position)
• main: proc put(self: var WaterField; pair: Pair; pos: Position)

Puyo:

• cell: type Puyo

puyoCount:

• moveresult: proc puyoCount(self: MoveResult): int
• moveresult: proc puyoCount(self: MoveResult; puyo: Puyo): int
• pair: proc puyoCount(self: Pair): int
• pair: proc puyoCount(self: Pair; puyo: Puyo): int
• pairposition: proc puyoCount(pairsPositions: PairsPositions): int
• pairposition: proc puyoCount(pairsPositions: PairsPositions; puyo: Puyo): int
• puyopuyo: proc puyoCount[F: TsuField or WaterField](self: PuyoPuyo[F]): int
• puyopuyo: proc puyoCount[F: TsuField or WaterField](self: PuyoPuyo[F]; puyo: Puyo): int
• disappearresult: proc puyoCount(self: DisappearResult): int
• disappearresult: proc puyoCount(self: DisappearResult; puyo: Puyo): int
• main: proc puyoCount(self: TsuField or WaterField): int
• main: proc puyoCount(self: TsuField or WaterField; puyo: Puyo): int

puyoCounts:

• moveresult: proc puyoCounts(self: MoveResult): seq[int]
• moveresult: proc puyoCounts(self: MoveResult; puyo: Puyo): seq[int]

PuyoPuyo:

• puyopuyo: object PuyoPuyo

redo:

• simulator: proc redo(self: Simulator)

removeSqueeze:

• main: proc removeSqueeze(self: var TsuField; row: Row; col: Column)
• main: proc removeSqueeze(self: var WaterField; row: Row; col: Column)

Requirement:

• requirement: object Requirement

RequirementColor:

• requirement: enum RequirementColor

requirementColor=:

• simulator: proc requirementColor=(self: Simulator; color: RequirementColor)

RequirementKind:

• requirement: enum RequirementKind

requirementKind=:

• simulator: proc requirementKind=(self: Simulator; kind: RequirementKind)

RequirementNumber:

• requirement: type RequirementNumber

requirementNumber=:

• simulator: proc requirementNumber=(self: Simulator; num: RequirementNumber)

RequirementQueryKeys:

• requirement: const RequirementQueryKeys

reset:

• simulator: proc reset(self: Simulator)

rotatedLeft:

• position: proc rotatedLeft(self: Position): Position

rotatedRight:

• position: proc rotatedRight(self: Position): Position

rotateLeft:

• position: proc rotateLeft(self: var Position)

rotateOperatingPositionLeft:

• simulator: proc rotateOperatingPositionLeft(self: Simulator)

rotateOperatingPositionRight:

• simulator: proc rotateOperatingPositionRight(self: Simulator)

rotateRight:

• position: proc rotateRight(self: var Position)

Row:

• fieldtype: type Row

row:

• binary: proc row(self: BinaryField; row: Row): BinaryField

rule:

• nazopuyo: proc rule(self: NazoPuyoWrap): Rule
• simulator: proc rule(self: Simulator): Rule
• field: proc rule[F: TsuField or WaterField](self: F): Rule
• nazopuyo: proc rule[F: TsuField or WaterField](self: NazoPuyo[F]): Rule
• puyopuyo: proc rule[F: TsuField or WaterField](self: PuyoPuyo[F]): Rule

Rule:

• rule: enum Rule

rule=:

• nazopuyo: proc rule=(self: var NazoPuyoWrap; rule: Rule)
• simulator: proc rule=(self: Simulator; rule: Rule)

run:

• webworker: proc run(self: Worker; args: varargs[string])

runKeyboardEventHandler:

• web: proc runKeyboardEventHandler(self: Ide; event: Event): bool
• web: proc runKeyboardEventHandler(self: Ide; event: KeyEvent): bool
• web: proc runKeyboardEventHandler(self: Marathon; event: Event): bool
• web: proc runKeyboardEventHandler(self: Marathon; event: KeyEvent): bool

sameGroup:

• unionfind: proc sameGroup(self: var UnionFind; node1, node2: UnionFindNode): bool

sample:

• misc: proc sample[T](rng: var Rand; arr: openArray[T]; count: Natural): seq[T]

score:

• simulator: proc score(self: Simulator): int
• moveresult: proc score(self: MoveResult): int

SelectColor:

• color: const SelectColor

shiftDown:

• field: proc shiftDown(self: var (TsuField or WaterField))

shiftDownWithoutTrim:

• binary: proc shiftDownWithoutTrim(self: var BinaryField; amount: static int32 = 1)

shiftedDown:

• main: proc shiftedDown[F: TsuField or WaterField](self: F): F
• binary: proc shiftedDown(self: BinaryField): BinaryField

shiftedDownWithoutTrim:

• binary: proc shiftedDownWithoutTrim(self: BinaryField; amount: static int32 = 1): BinaryField

shiftedLeft:

• main: proc shiftedLeft[F: TsuField or WaterField](self: F): F
• binary: proc shiftedLeft(self: BinaryField): BinaryField

shiftedLeftWithoutTrim:

• binary: proc shiftedLeftWithoutTrim(self: BinaryField): BinaryField

shiftedRight:

• main: proc shiftedRight[F: TsuField or WaterField](self: F): F
• binary: proc shiftedRight(self: BinaryField): BinaryField

shiftedRightWithoutTrim:

• binary: proc shiftedRightWithoutTrim(self: BinaryField): BinaryField

shiftedUp:

• main: proc shiftedUp[F: TsuField or WaterField](self: F): F
• binary: proc shiftedUp(self: BinaryField): BinaryField

shiftedUpWithoutTrim:

• binary: proc shiftedUpWithoutTrim(self: BinaryField; amount: static int32 = 1): BinaryField

shiftFieldDown:

• simulator: proc shiftFieldDown(self: Simulator)

shiftFieldLeft:

• simulator: proc shiftFieldLeft(self: Simulator)

shiftFieldRight:

• simulator: proc shiftFieldRight(self: Simulator)

shiftFieldUp:

• simulator: proc shiftFieldUp(self: Simulator)

shiftLeft:

• field: proc shiftLeft(self: var (TsuField or WaterField))

shiftLeftWithoutTrim:

• binary: proc shiftLeftWithoutTrim(self: var BinaryField)

shiftRight:

• field: proc shiftRight(self: var (TsuField or WaterField))

shiftRightWithoutTrim:

• binary: proc shiftRightWithoutTrim(self: var BinaryField)

shiftUp:

• field: proc shiftUp(self: var (TsuField or WaterField))

shiftUpWithoutTrim:

• binary: proc shiftUpWithoutTrim(self: var BinaryField; amount: static int32 = 1)

ShownNoticeGarbageCount:

• common: const ShownNoticeGarbageCount

simulator:

• ide: proc simulator(self: Ide): Simulator
• marathon: proc simulator(self: Marathon): Simulator

Simulator:

• simulator: type Simulator

SimulatorEditing:

• simulator: object SimulatorEditing

SimulatorKind:

• simulator: enum SimulatorKind

SimulatorMode:

• simulator: enum SimulatorMode

SimulatorState:

• simulator: enum SimulatorState

SimulatorUriPath:

• simulator: const SimulatorUriPath

SkipMove:

• mark: MarkResult.SkipMove

solve:

• ide: proc solve(self: Ide; parallelCount: Positive = when defined(js): 6 else: max(1, countProcessors()))
• solve: proc solve[F: TsuField or WaterField](nazo: NazoPuyo[F]; showProgress: static bool = false; earlyStopping: static bool = false; parallelCount: Positive = processorCount()): seq[ SolveAnswer]

Solve:

• webworker: TaskKind.Solve

solve:

• solve: proc solve[F: TsuField or WaterField](node: Node[F]; moveCount: Positive; earlyStopping: static bool = false): seq[ SolveAnswer]
• solve: proc solve[F: TsuField or WaterField](node: Node[F]; moveCount: Positive; reqKind: static RequirementKind; reqColor: static RequirementColor; earlyStopping: static bool): seq[SolveAnswer]

SolveAnswer:

• solve: type SolveAnswer

solving:

• ide: proc solving(self: Ide): bool

split:

• generate: proc split(rng: var Rand; total: Natural; ratios: openArray[Option[Natural]]): seq[ int]
• generate: proc split(rng: var Rand; total: Natural; chunkCount: Positive; allowZeroChunk: bool): seq[ int]

state:

• simulator: proc state(self: Simulator): SimulatorState

sum:

• binary: proc sum(field1, field2, field3: BinaryField): BinaryField
• binary: proc sum(field1, field2, field3, field4: BinaryField): BinaryField
• binary: proc sum(field1, field2, field3, field4, field5: BinaryField): BinaryField
• binary: proc sum(field1, field2, field3, field4, field5, field6: BinaryField): BinaryField
• binary: proc sum(field1, field2, field3, field4, field5, field6, field7, field8: BinaryField): BinaryField

sum2:

• misc: proc sum2[T: SomeNumber or Natural](arr: openArray[T]): T

swap:

• pair: proc swap(self: var Pair)

swapped:

• pair: proc swapped(self: Pair): Pair

TaskKind:

• webworker: enum TaskKind

toArray:

• binary: proc toArray(self: BinaryField): array[Row, array[Column, WhichColor]]
• main: proc toArray(self: TsuField or WaterField): array[Row, array[Column, Cell]]

toColorCode:

• color: proc toColorCode(color: Color): kstring

toDropMask:

• binary: proc toDropMask(existField: BinaryField): DropMask

toggle:

• misc: proc toggle(b: var bool)

toggleFocus:

• ide: proc toggleFocus(self: Ide)
• marathon: proc toggleFocus(self: Marathon)
• simulator: proc toggleFocus(self: Simulator)

toggleInserting:

• simulator: proc toggleInserting(self: Simulator)

toKeyEvent:

• key: proc toKeyEvent(event: KeyboardEvent): KeyEvent

toPairsPositions:

• common: proc toPairsPositions(str: string): PairsPositions

toSet2:

• misc: template toSet2(iter: untyped): untyped

toStr:

• solve: proc toStr[F: TsuField or WaterField](node: Node[F]): string

toTsuField:

• field: proc toTsuField(self: TsuField): TsuField
• main: proc toTsuField(self: WaterField): TsuField

toTsuNazoPuyo:

• nazopuyo: proc toTsuNazoPuyo[F: TsuField or WaterField](self: NazoPuyo[F]): NazoPuyo[TsuField]

toTsuPuyoPuyo:

• puyopuyo: proc toTsuPuyoPuyo[F: TsuField or WaterField](self: PuyoPuyo[F]): PuyoPuyo[TsuField]

toUri:

• ide: proc toUri(self: Ide; withPositions = true; fqdn = Pon2): Uri
• simulator: proc toUri(self: Simulator; withPositions = true; fqdn = Pon2): Uri

toUriQuery:

• simulator: proc toUriQuery(self: Simulator; withPositions = true; fqdn = Pon2): string
• field: proc toUriQuery(self: TsuField or WaterField; fqdn = Pon2): string
• nazopuyo: proc toUriQuery[F: TsuField or WaterField](self: NazoPuyo[F]; fqdn = Pon2): string
• pair: proc toUriQuery(self: Pair; fqdn = Pon2): string
• pairposition: proc toUriQuery(pairPosition: PairPosition; fqdn = Pon2): string
• pairposition: proc toUriQuery(pairsPositions: PairsPositions; fqdn = Pon2): string
• position: proc toUriQuery(self: Position; fqdn = Pon2): string
• puyopuyo: proc toUriQuery[F: TsuField or WaterField](self: PuyoPuyo[F]; fqdn = Pon2): string
• requirement: proc toUriQuery(self: Requirement; fqdn = Pon2): string

toWaterField:

• field: proc toWaterField(self: WaterField): WaterField
• main: proc toWaterField(self: TsuField): WaterField

toWaterNazoPuyo:

• nazopuyo: proc toWaterNazoPuyo[F: TsuField or WaterField](self: NazoPuyo[F]): NazoPuyo[ WaterField]

toWaterPuyoPuyo:

• puyopuyo: proc toWaterPuyoPuyo[F: TsuField or WaterField](self: PuyoPuyo[F]): PuyoPuyo[ WaterField]

toXLink:

• common: proc toXLink(simulator: Simulator; withPositions: bool): Uri

trimmed:

• binary: proc trimmed(self: BinaryField): BinaryField

TsuField:

• main: object TsuField

tsuInsert:

• binary: proc tsuInsert(self: var BinaryField; row: Row; col: Column; which: WhichColor)

tsuRemoveSqueeze:

• binary: proc tsuRemoveSqueeze(self: var BinaryField; row: Row; col: Column)

undo:

• simulator: proc undo(self: Simulator)

UnionFind:

• unionfind: object UnionFind

UnionFindNode:

• unionfind: type UnionFindNode

UseAvx2:

• intrinsic: const UseAvx2

UseBmi2:

• intrinsic: const UseBmi2

validDoublePositions:

• field: proc validDoublePositions(self: TsuField or WaterField): set[Position]
• binary: proc validDoublePositions(self: BinaryField): set[Position]

validPositions:

• field: proc validPositions(self: TsuField or WaterField): set[Position]
• binary: proc validPositions(self: BinaryField): set[Position]

visible:

• binary: proc visible(self: BinaryField): BinaryField

WaterColor:

• color: const WaterColor

waterDropped:

• binary: proc waterDropped(waterDropExistField, dropField, waterDropField: BinaryField): BinaryField

WaterField:

• main: object WaterField

WaterHeight:

• fieldtype: const WaterHeight

waterHighField:

• binary: proc waterHighField(): BinaryField

waterInsert:

• binary: proc waterInsert(self: var BinaryField; row: Row; col: Column; which: WhichColor)

waterRemoveSqueeze:

• binary: proc waterRemoveSqueeze(self: var BinaryField; row: Row; col: Column)

WaterRow:

• fieldtype: type WaterRow

WebAssetsDir:

• misc: const WebAssetsDir

WhichColor:

• binary: object WhichColor

Width:

• fieldtype: const Width

willDisappear:

• main: proc willDisappear(self: TsuField or WaterField): bool
• binary: proc willDisappear(self: BinaryField): bool

willDrop:

• field: proc willDrop(self: TsuField or WaterField): bool

Worker:

• webworker: type Worker

WorkerCompleteHandler:

• webworker: type WorkerCompleteHandler

WorkerReturnCode:

• webworker: enum WorkerReturnCode

WorkerTask:

• webworker: type WorkerTask

writeCell:

• simulator: proc writeCell(self: Simulator; cell: Cell)
• simulator: proc writeCell(self: Simulator; idx: Natural; axis: bool)
• simulator: proc writeCell(self: Simulator; row: Row; col: Column)

WrongAnswer:

• mark: MarkResult.WrongAnswer

zeroBinaryField:

• binary: proc zeroBinaryField(): BinaryField

zip:

• misc: iterator zip[T, U, V](s1: openArray[T]; s2: openArray[U]; s3: openArray[V]): (T, U, V)