Index

Documents: API naming design, Contributing, DrNim User Guide, Embedded Stack Trace Profiler (ESTP) User Guide, Hot code reloading, Internals of the Nim Compiler, Nim Backend Integration, Nim Compiler User Guide, Nim Destructors and Move Semantics, Nim DocGen Tools Guide, Nim Documentation Overview, Nim Enhancement Proposal #1 - Standard Library Style Guide, Nim Experimental Features, Nim IDE Integration Guide, Nim IDE Integration Guide, Nim maintenance script, Nim Manual, Nim Standard Library, Nim Tutorial (Part I), Nim Tutorial (Part II), Nim Tutorial (Part III), Nim's Memory Management, nimgrep User's manual, niminst User's manual, NimScript, Packaging Nim, rst, Source Code Filters, Testament, Tools available with Nim.

Modules: algorithm, asciitables, assertions, asyncdispatch, asyncfile, asyncftpclient, asyncfutures, asynchttpserver, asyncjs, asyncmacro, asyncnet, asyncstreams, atomics, base64, bitops, bitops_utils, browsers, cgi, chains, channels_builtin, colors, compilesettings, complex, cookies, coro, cpuinfo, cpuload, critbits, cstrutils, db_common, db_mysql, db_odbc, db_postgres, db_sqlite, dbutils, decls, decode_helpers, deques, diff, digitsutils, distros, docstyle, dollars, dom, dynlib, editdistance, effecttraits, encodings, endians, enumerate, enumutils, epoll, exitprocs, fenv, genasts, gitutils, globs, hashes, heapqueue, highlite, hotcodereloading, htmlgen, htmlparser, httpclient, httpcore, importutils, inotify, intsets, io, isolation, iterators, jsbigints, jsconsole, jscore, jsfetch, jsffi, jsformdata, jsheaders, json, jsonutils, jsre, jsutils, kqueue, lenientops, lexbase, linenoise, lists, locks, logging, logic, macrocache, macros, manual_experimental_strictnotnil, marshal, math, md5, memfiles, mersenne, mimetypes, miscdollars, monotimes, nativesockets, net, nimhcr, nimprof, nimscript, nre, oids, options, os, osproc, packedsets, parsecfg, parsecsv, parsejson, parseopt, parsesql, parseutils, parsexml, pathnorm, pegs, posix_utils, punycode, random, rationals, rdstdin, re, refc, registry, reservedmem, rlocks, ropes, rstast, rstgen, rtarrays, segfaults, selectors, sequtils, sets, setutils, sexp, sha1, sharedlist, sharedtables, since, smtp, socketstreams, ssl_certs, ssl_config, stackframes, stats, strbasics, streams, streamwrapper, strformat, strimpl, strmisc, strscans, strtabs, strutils, sugar, sums, sysrand, system, tables, tasks, tempfiles, terminal, threadpool, threads, time_t, times, typeinfo, typetraits, underscored_calls, unicode, unidecode, unittest, uri, util, varints, vmutils, volatile, widestrs, win_setenv, winlean, with, wordwrap, wrapnils, xmlparser, xmltree.

API symbols

`!$`:

• hashes: `!$`(h: Hash): Hash

`!&`:

• hashes: `!&`(h: Hash; val: int): Hash

`!*\`:

• pegs: `!*\`(a: Peg): Peg

`!*`:

• pegs: `!*`(a: Peg): Peg

`!=`:

• system: `!=`(x, y: untyped): untyped

`!`:

• pegs: `!`(a: Peg): Peg

`$$`:

• marshal: `$$`[T](x: T): string

`$`:

• asyncfutures: `$`(stackTraceEntries: seq[StackTraceEntry]): string
• colors: `$`(c: Color): string
• complex: `$`(z: Complex): string
• critbits: `$`[T](c: CritBitTree[T]): string
• deques: `$`[T](deq: Deque[T]): string
• dollars: `$`(x`gensym0: `{}`(int, lit)): string
• dollars: `$`[T, IDX](x: array[IDX, T]): string
• dollars: `$`(x: bool): string
• dollars: `$`(x: char): string
• dollars: `$`(x: cstring): string
• dollars: `$`[Enum: enum](x: Enum): string
• dollars: `$`[T, U](x: HSlice[T, U]): string
• dollars: `$`(x: int): string
• dollars: `$`(x: int64): string
• dollars: `$`[T](x: openArray[T]): string
• dollars: `$`[T](x: seq[T]): string
• dollars: `$`[T](x: set[T]): string
• dollars: `$`(x: string): string
• dollars: `$`[T: tuple | object](x: T): string
• dollars: `$`(t: typedesc): string
• dollars: `$`(x: uint64): string
• dollars: `$`(x`gensym1: `{}`(uint64, lit)): string
• dollars: `$`(x`gensym2: `{}`(int64, lit)): string
• dollars: `$`(x: float | float32): string
• dom: `$`(s: Selection): string
• heapqueue: `$`[T](heap: HeapQueue[T]): string
• httpclient: `$`(data: MultipartData): string
• httpcore: `$`(code: HttpCode): string
• httpcore: `$`(headers: HttpHeaders): string
• jsbigints: `$`(this: JsBigInt): string
• jsfetch: `$`(self: Request | Response | Body | FetchOptions): string
• jsformdata: `$`(self: FormData): string
• jsheaders: `$`(self: Headers): string
• json: `$`(node: JsonNode): string
• jsre: `$`(self: RegExp): string
• lists: `$`[T](L: SomeLinkedCollection[T]): string
• locks: `$`(lock: Lock): string
• macros: `$`(arg: LineInfo): string
• macros: `$`(i: NimIdent): string
• macros: `$`(node: NimNode): string
• macros: `$`(s: NimSym): string
• md5: `$`(d: MD5Digest): string
• memfiles: `$`(ms: MemSlice): string
• monotimes: `$`(t: MonoTime): string
• nativesockets: `$`(p: Port): string
• net: `$`(address: IpAddress): string
• nre: `$`(pattern: RegexMatch): string
• oids: `$`(oid: Oid): string
• options: `$`[T](self: Option[T]): string
• os: `$`(err: OSErrorCode): string
• packedsets: `$`[A](s: PackedSet[A]): string
• parsecfg: `$`(dict: Config): string
• parsesql: `$`(n: SqlNode): string
• pegs: `$`(r: Peg): string
• rationals: `$`[T](x: Rational[T]): string
• ropes: `$`(r: Rope): string
• sets: `$`[A](s: HashSet[A]): string
• sets: `$`[A](s: OrderedSet[A]): string
• sexp: `$`(node: SexpNode): string
• sha1: `$`(self: SecureHash): string
• smtp: `$`(msg: Message): string
• stats: `$`(a: RunningStat): string
• strtabs: `$`(t: StringTableRef): string
• tables: `$`[A](t: CountTable[A]): string
• tables: `$`[A](t: CountTableRef[A]): string
• tables: `$`[A, B](t: OrderedTable[A, B]): string
• tables: `$`[A, B](t: OrderedTableRef[A, B]): string
• tables: `$`[A, B](t: Table[A, B]): string
• tables: `$`[A, B](t: TableRef[A, B]): string
• times: `$`(dt: DateTime): string
• times: `$`(dur: Duration): string
• times: `$`(time: Time): string
• times: `$`(f: TimeFormat): string
• times: `$`(ti: TimeInterval): string
• times: `$`(zone: Timezone): string
• unicode: `$`(rune: Rune): string
• unicode: `$`(runes: seq[Rune]): string
• uri: `$`(u: Uri): string
• widestrs: `$`(s: WideCString): string
• widestrs: `$`(w: WideCString; estimate: int; replacement: int = 0x0000FFFD): string
• xmltree: `$`(n: XmlNode): string

`%%`:

• system: `%%`(x, y: int): int
• system: `%%`(x, y: int16): int16
• system: `%%`(x, y: int32): int32
• system: `%%`(x, y: int64): int64
• system: `%%`(x, y: int8): int8

`%*`:

• json: `%*`(x: untyped): untyped

`%=`:

• jsffi: `%=`(x, y: JsObject): JsObject

`%`:

• jsffi: `%`(x, y: JsObject): JsObject
• json: `%`[T](table: Table[string, T] | OrderedTable[string, T]): JsonNode
• json: `%`(n: BiggestInt): JsonNode
• json: `%`(n: BiggestUInt): JsonNode
• json: `%`(b: bool): JsonNode
• json: `%`(n: float): JsonNode
• json: `%`(n: int): JsonNode
• json: `%`[T](elements: openArray[T]): JsonNode
• json: `%`(keyVals: openArray[tuple[key: string, val: JsonNode]]): JsonNode
• json: `%`[T](opt: Option[T]): JsonNode
• json: `%`(o: ref object): JsonNode
• json: `%`(s: string): JsonNode
• json: `%`[T: object](o: T): JsonNode
• json: `%`(n: uint): JsonNode
• json: `%`(j: JsonNode): JsonNode
• json: `%`(o: enum): JsonNode
• ropes: `%`(frmt: string; args: openArray[Rope]): Rope
• strtabs: `%`(f: string; t: StringTableRef; flags: set[FormatFlag] = {}): string
• strutils: `%`(formatstr: string; a: openArray[string]): string
• strutils: `%`(formatstr, a: string): string

`&=`:

• net: `&=`(socket: Socket; data: typed)
• system: `&=`(x: var string; y: string)
• system: `&=`(x, y: typed)

`&`:

• jsffi: `&`(a, b: cstring): cstring
• pegs: `&`(a: Peg): Peg
• ropes: `&`(a: openArray[Rope]): Rope
• ropes: `&`(a, b: Rope): Rope
• ropes: `&`(a: Rope; b: string): Rope
• ropes: `&`(a: string; b: Rope): Rope
• strformat: `&`(pattern: string{lit}): string
• system: `&`(x, y: char): string
• system: `&`(x: char; y: string): string
• system: `&`[T](x, y: seq[T]): seq[T]
• system: `&`[T](x: seq[T]; y: T): seq[T]
• system: `&`(x: string; y: char): string
• system: `&`(x, y: string): string
• system: `&`[T](x: T; y: seq[T]): seq[T]

`>%`:

• system: `>%`(x, y: untyped): untyped

`>=%`:

• system: `>=%`(x, y: untyped): untyped

`>=`:

• jsffi: `>=`(x, y: JsObject): JsObject
• system: `>=`(x, y: untyped): untyped

`>`:

• jsffi: `>`(x, y: JsObject): JsObject
• system: `>`(x, y: untyped): untyped

`<%`:

• system: `<%`(x, y: int): bool
• system: `<%`(x, y: int16): bool
• system: `<%`(x, y: int32): bool
• system: `<%`(x, y: int64): bool
• system: `<%`(x, y: int8): bool
• unicode: `<%`(a, b: Rune): bool

`<>`:

• xmltree: `<>`(x: untyped): untyped

`<->`:

• logic: `<->`(a, b: bool): bool

`<=%`:

• system: `<=%`(x, y: int): bool
• system: `<=%`(x, y: int16): bool
• system: `<=%`(x, y: int32): bool
• system: `<=%`(x, y: int64): bool
• system: `<=%`(x, y: int8): bool
• unicode: `<=%`(a, b: Rune): bool

`<=`:

• jsbigints: `<=`(x, y: JsBigInt): bool
• jsffi: `<=`(x, y: JsObject): JsObject
• lenientops: `<=`[I: SomeInteger; F: SomeFloat](f: F; i: I): bool
• lenientops: `<=`[I: SomeInteger; F: SomeFloat](i: I; f: F): bool
• monotimes: `<=`(a, b: MonoTime): bool
• packedsets: `<=`[A](s1, s2: PackedSet[A]): bool
• rationals: `<=`(x, y: Rational): bool
• sets: `<=`[A](s, t: HashSet[A]): bool
• system: `<=`(x, y: bool): bool
• system: `<=`(x, y: char): bool
• system: `<=`[Enum: enum](x, y: Enum): bool
• system: `<=`(x, y: float): bool
• system: `<=`(x, y: float32): bool
• system: `<=`(x, y: int): bool
• system: `<=`(x, y: int16): bool
• system: `<=`(x, y: int32): bool
• system: `<=`(x, y: int64): bool
• system: `<=`(x, y: int8): bool
• system: `<=`(x, y: pointer): bool
• system: `<=`[T](x, y: ref T): bool
• system: `<=`[T](x, y: set[T]): bool
• system: `<=`(x, y: string): bool
• system: `<=`[T: tuple](x, y: T): bool
• system: `<=`(x, y: uint): bool
• system: `<=`(x, y: uint16): bool
• system: `<=`(x, y: uint32): bool
• system: `<=`(x, y: uint64): bool
• system: `<=`(x, y: uint8): bool
• times: `<=`(a, b: DateTime): bool
• times: `<=`(a, b: Duration): bool
• times: `<=`(a, b: Time): bool

`<`:

• jsbigints: `<`(x, y: JsBigInt): bool
• jsffi: `<`(x, y: JsObject): JsObject
• lenientops: `<`[I: SomeInteger; F: SomeFloat](f: F; i: I): bool
• lenientops: `<`[I: SomeInteger; F: SomeFloat](i: I; f: F): bool
• monotimes: `<`(a, b: MonoTime): bool
• packedsets: `<`[A](s1, s2: PackedSet[A]): bool
• rationals: `<`(x, y: Rational): bool
• sets: `<`[A](s, t: HashSet[A]): bool
• system: `<`(x, y: bool): bool
• system: `<`(x, y: char): bool
• system: `<`[Enum: enum](x, y: Enum): bool
• system: `<`(x, y: float): bool
• system: `<`(x, y: float32): bool
• system: `<`(x, y: int): bool
• system: `<`(x, y: int16): bool
• system: `<`(x, y: int32): bool
• system: `<`(x, y: int64): bool
• system: `<`(x, y: int8): bool
• system: `<`(x, y: pointer): bool
• system: `<`[T](x, y: ptr T): bool
• system: `<`[T](x, y: ref T): bool
• system: `<`[T](x, y: set[T]): bool
• system: `<`(x, y: string): bool
• system: `<`[T: tuple](x, y: T): bool
• system: `<`(x, y: uint): bool
• system: `<`(x, y: uint16): bool
• system: `<`(x, y: uint32): bool
• system: `<`(x, y: uint64): bool
• system: `<`(x, y: uint8): bool
• times: `<`(a, b: DateTime): bool
• times: `<`(a, b: Duration): bool
• times: `<`(a, b: Time): bool

`'big`:

• jsbigints: `'big`(num: cstring): JsBigInt

`*%`:

• system: `*%`(x, y: int): int
• system: `*%`(x, y: int16): int16
• system: `*%`(x, y: int32): int32
• system: `*%`(x, y: int64): int64
• system: `*%`(x, y: int8): int8

`**`:

• jsbigints: `**`(x, y: JsBigInt): JsBigInt
• jsffi: `**`(x, y: JsObject): JsObject

`*=`:

• complex: `*=`[T](x: var Complex[T]; y: Complex[T])
• jsbigints: `*=`(x: var JsBigInt; y: JsBigInt)
• jsffi: `*=`(x, y: JsObject): JsObject
• rationals: `*=`[T](x: var Rational[T]; y: Rational[T])
• rationals: `*=`[T](x: var Rational[T]; y: T)
• system: `*=`[T: SomeInteger](x: var T; y: T)
• system: `*=`[T: float | float32 | float64](x: var T; y: T)
• times: `*=`(a: var Duration; b: int)

`*`:

• algorithm: `*`(x: int; order: SortOrder): int
• complex: `*`[T](x, y: Complex[T]): Complex[T]
• complex: `*`[T](x: Complex[T]; y: T): Complex[T]
• complex: `*`[T](x: T; y: Complex[T]): Complex[T]
• jsbigints: `*`(x, y: JsBigInt): JsBigInt
• jsffi: `*`(x, y: JsObject): JsObject
• lenientops: `*`[I: SomeInteger; F: SomeFloat](f: F; i: I): F
• lenientops: `*`[I: SomeInteger; F: SomeFloat](i: I; f: F): F
• packedsets: `*`[A](s1, s2: PackedSet[A]): PackedSet[A]
• pegs: `*`(a: Peg): Peg
• rationals: `*`[T](x, y: Rational[T]): Rational[T]
• rationals: `*`[T](x: Rational[T]; y: T): Rational[T]
• rationals: `*`[T](x: T; y: Rational[T]): Rational[T]
• sets: `*`[A](s1, s2: HashSet[A]): HashSet[A]
• system: `*`(x, y: float): float
• system: `*`(x, y: float32): float32
• system: `*`(x, y: int): int
• system: `*`(x, y: int16): int16
• system: `*`(x, y: int32): int32
• system: `*`(x, y: int64): int64
• system: `*`(x, y: int8): int8
• system: `*`[T](x, y: set[T]): set[T]
• system: `*`(x, y: uint): uint
• system: `*`(x, y: uint16): uint16
• system: `*`(x, y: uint32): uint32
• system: `*`(x, y: uint64): uint64
• system: `*`(x, y: uint8): uint8
• times: `*`(a: Duration; b: int64): Duration
• times: `*`(a: int64; b: Duration): Duration

`+%`:

• system: `+%`(x, y: int): int
• system: `+%`(x, y: int16): int16
• system: `+%`(x, y: int32): int32
• system: `+%`(x, y: int64): int64
• system: `+%`(x, y: int8): int8

`++`:

• jsffi: `++`(x: JsObject): JsObject

`+=`:

• atomics: `+=`[T: SomeInteger](location: var Atomic[T]; value: T)
• complex: `+=`[T](x: var Complex[T]; y: Complex[T])
• jsbigints: `+=`(x: var JsBigInt; y: JsBigInt)
• jsffi: `+=`(x, y: JsObject): JsObject
• rationals: `+=`[T](x: var Rational[T]; y: Rational[T])
• rationals: `+=`[T](x: var Rational[T]; y: T)
• stats: `+=`(a: var RunningRegress; b: RunningRegress)
• stats: `+=`(a: var RunningStat; b: RunningStat)
• system: `+=`[T: SomeInteger](x: var T; y: T)
• system: `+=`[T: float | float32 | float64](x: var T; y: T)
• times: `+=`(a: var DateTime; b: Duration)
• times: `+=`(a: var DateTime; b: TimeInterval)
• times: `+=`(d1: var Duration; d2: Duration)
• times: `+=`(t: var Time; b: Duration)
• times: `+=`(t: var Time; b: TimeInterval)
• times: `+=`(a: var TimeInterval; b: TimeInterval)

`+`:

• colors: `+`(a, b: Color): Color
• complex: `+`[T](x, y: Complex[T]): Complex[T]
• complex: `+`[T](x: Complex[T]; y: T): Complex[T]
• complex: `+`[T](x: T; y: Complex[T]): Complex[T]
• jsbigints: `+`(_: JsBigInt): JsBigInt
• jsbigints: `+`(x, y: JsBigInt): JsBigInt
• jsffi: `+`(x, y: JsObject): JsObject
• lenientops: `+`[I: SomeInteger; F: SomeFloat](f: F; i: I): F
• lenientops: `+`[I: SomeInteger; F: SomeFloat](i: I; f: F): F
• monotimes: `+`(a: MonoTime; b: Duration): MonoTime
• packedsets: `+`[A](s1, s2: PackedSet[A]): PackedSet[A]
• pegs: `+`(a: Peg): Peg
• rationals: `+`[T](x, y: Rational[T]): Rational[T]
• rationals: `+`[T](x: Rational[T]; y: T): Rational[T]
• rationals: `+`[T](x: T; y: Rational[T]): Rational[T]
• sets: `+`[A](s1, s2: HashSet[A]): HashSet[A]
• stats: `+`(a, b: RunningRegress): RunningRegress
• stats: `+`(a, b: RunningStat): RunningStat
• system: `+`(x: float): float
• system: `+`(x, y: float): float
• system: `+`(x: float32): float32
• system: `+`(x, y: float32): float32
• system: `+`(x: int): int
• system: `+`(x, y: int): int
• system: `+`(x: int16): int16
• system: `+`(x, y: int16): int16
• system: `+`(x: int32): int32
• system: `+`(x, y: int32): int32
• system: `+`(x: int64): int64
• system: `+`(x, y: int64): int64
• system: `+`(x: int8): int8
• system: `+`(x, y: int8): int8
• system: `+`[T](x, y: set[T]): set[T]
• system: `+`(x, y: uint): uint
• system: `+`(x, y: uint16): uint16
• system: `+`(x, y: uint32): uint32
• system: `+`(x, y: uint64): uint64
• system: `+`(x, y: uint8): uint8
• times: `+`(dt: DateTime; dur: Duration): DateTime
• times: `+`(dt: DateTime; interval: TimeInterval): DateTime
• times: `+`(a, b: Duration): Duration
• times: `+`(a: Time; b: Duration): Time
• times: `+`(time: Time; interval: TimeInterval): Time
• times: `+`(ti1, ti2: TimeInterval): TimeInterval

`-%`:

• system: `-%`(x, y: int): int
• system: `-%`(x, y: int16): int16
• system: `-%`(x, y: int32): int32
• system: `-%`(x, y: int64): int64
• system: `-%`(x, y: int8): int8

`->`:

• logic: `->`(a, b: bool): bool
• sugar: `->`(p, b: untyped): untyped

`-+-`:

• sets: `-+-`[A](s1, s2: HashSet[A]): HashSet[A]

`--`:

• jsffi: `--`(x: JsObject): JsObject
• nimscript: `--`(key: untyped)
• nimscript: `--`(key, val: untyped)

`-=`:

• atomics: `-=`[T: SomeInteger](location: var Atomic[T]; value: T)
• complex: `-=`[T](x: var Complex[T]; y: Complex[T])
• jsbigints: `-=`(x: var JsBigInt; y: JsBigInt)
• jsffi: `-=`(x, y: JsObject): JsObject
• rationals: `-=`[T](x: var Rational[T]; y: Rational[T])
• rationals: `-=`[T](x: var Rational[T]; y: T)
• system: `-=`[T: SomeInteger](x: var T; y: T)
• system: `-=`[T: float | float32 | float64](x: var T; y: T)
• times: `-=`(a: var DateTime; b: Duration)
• times: `-=`(a: var DateTime; b: TimeInterval)
• times: `-=`(dt: var Duration; ti: Duration)
• times: `-=`(t: var Time; b: Duration)
• times: `-=`(t: var Time; b: TimeInterval)
• times: `-=`(a: var TimeInterval; b: TimeInterval)

`-`:

• colors: `-`(a, b: Color): Color
• complex: `-`[T](z: Complex[T]): Complex[T]
• complex: `-`[T](x, y: Complex[T]): Complex[T]
• complex: `-`[T](x: Complex[T]; y: T): Complex[T]
• complex: `-`[T](x: T; y: Complex[T]): Complex[T]
• jsbigints: `-`(this: JsBigInt): JsBigInt
• jsbigints: `-`(x, y: JsBigInt): JsBigInt
• jsffi: `-`(x, y: JsObject): JsObject
• lenientops: `-`[I: SomeInteger; F: SomeFloat](f: F; i: I): F
• lenientops: `-`[I: SomeInteger; F: SomeFloat](i: I; f: F): F
• monotimes: `-`(a: MonoTime; b: Duration): MonoTime
• monotimes: `-`(a, b: MonoTime): Duration
• packedsets: `-`[A](s1, s2: PackedSet[A]): PackedSet[A]
• rationals: `-`[T](x: Rational[T]): Rational[T]
• rationals: `-`[T](x, y: Rational[T]): Rational[T]
• rationals: `-`[T](x: Rational[T]; y: T): Rational[T]
• rationals: `-`[T](x: T; y: Rational[T]): Rational[T]
• sets: `-`[A](s1, s2: HashSet[A]): HashSet[A]
• system: `-`(a, b: AllocStats): AllocStats
• system: `-`(x: float): float
• system: `-`(x, y: float): float
• system: `-`(x: float32): float32
• system: `-`(x, y: float32): float32
• system: `-`(x: int): int
• system: `-`(x, y: int): int
• system: `-`(x: int16): int16
• system: `-`(x, y: int16): int16
• system: `-`(x: int32): int32
• system: `-`(x, y: int32): int32
• system: `-`(x: int64): int64
• system: `-`(x, y: int64): int64
• system: `-`(x: int8): int8
• system: `-`(x, y: int8): int8
• system: `-`[T](x, y: set[T]): set[T]
• system: `-`(x, y: uint): uint
• system: `-`(x, y: uint16): uint16
• system: `-`(x, y: uint32): uint32
• system: `-`(x, y: uint64): uint64
• system: `-`(x, y: uint8): uint8
• times: `-`(dt1, dt2: DateTime): Duration
• times: `-`(dt: DateTime; dur: Duration): DateTime
• times: `-`(dt: DateTime; interval: TimeInterval): DateTime
• times: `-`(a: Duration): Duration
• times: `-`(a, b: Duration): Duration
• times: `-`(a: Time; b: Duration): Time
• times: `-`(a, b: Time): Duration
• times: `-`(time: Time; interval: TimeInterval): Time
• times: `-`(ti: TimeInterval): TimeInterval
• times: `-`(ti1, ti2: TimeInterval): TimeInterval

`.()`:

• jsffi: `.()`[K: cstring; V: proc](obj: JsAssoc[K, V]; field: untyped; args: varargs[untyped]): auto
• jsffi: `.()`(obj: JsObject; field: untyped; args: varargs[JsObject, jsFromAst]): JsObject

`..<`:

• system: `..<`(a, b: int32): int32
• system: `..<`(a, b: int64): int64
• system: `..<`[T](a, b: T): T
• system: `..<`(a, b: uint32): uint32
• system: `..<`(a, b: uint64): uint64
• system: `..<`(a, b: untyped): untyped

`..^`:

• system: `..^`(a, b: untyped): untyped

`..`:

• system: `..`[T](b: sink T): HSlice[int, T]
• system: `..`[T, U](a: sink T; b: sink U): HSlice[T, U]
• system: `..`(a, b: int32): int32
• system: `..`(a, b: int64): int64
• system: `..`[T](a, b: T): T
• system: `..`(a, b: uint32): uint32
• system: `..`(a, b: uint64): uint64

`.=`:

• jsffi: `.=`[K: cstring; V](obj: JsAssoc[K, V]; field: untyped; value: V): untyped
• jsffi: `.=`(obj: JsObject; field, value: untyped): untyped

`.`:

• jsffi: `.`[K: cstring; V](obj: JsAssoc[K, V]; field: untyped): V
• jsffi: `.`(obj: JsObject; field: untyped): JsObject

`/%`:

• system: `/%`(x, y: int): int
• system: `/%`(x, y: int16): int16
• system: `/%`(x, y: int32): int32
• system: `/%`(x, y: int64): int64
• system: `/%`(x, y: int8): int8

`/../`:

• os: `/../`(head, tail: string): string

`//`:

• rationals: `//`[T](num, den: T): Rational[T]

`/=`:

• complex: `/=`[T](x: var Complex[T]; y: Complex[T])
• jsbigints: `/=`(x: var JsBigInt; y: JsBigInt)
• jsffi: `/=`(x, y: JsObject): JsObject
• rationals: `/=`[T](x: var Rational[T]; y: Rational[T])
• rationals: `/=`[T](x: var Rational[T]; y: T)
• system: `/=`(x: var float64; y: float64)
• system: `/=`[T: float | float32](x: var T; y: T)

`/`:

• complex: `/`[T](x, y: Complex[T]): Complex[T]
• complex: `/`[T](x: Complex[T]; y: T): Complex[T]
• complex: `/`[T](x: T; y: Complex[T]): Complex[T]
• jsffi: `/`(x, y: JsObject): JsObject
• lenientops: `/`[I: SomeInteger; F: SomeFloat](f: F; i: I): F
• lenientops: `/`[I: SomeInteger; F: SomeFloat](i: I; f: F): F
• os: `/`(head, tail: string): string
• pegs: `/`(a: varargs[Peg]): Peg
• rationals: `/`[T](x, y: Rational[T]): Rational[T]
• rationals: `/`[T](x: Rational[T]; y: T): Rational[T]
• rationals: `/`[T](x: T; y: Rational[T]): Rational[T]
• system: `/`(x, y: float): float
• system: `/`(x, y: float32): float32
• system: `/`(x, y: int): float
• uri: `/`(x: Uri; path: string): Uri

`=>`:

• sugar: `=>`(p, b: untyped): untyped

`==`:

• asyncdispatch: `==`(x: AsyncFD; y: AsyncFD): bool
• colors: `==`(a, b: Color): bool
• complex: `==`[T](x, y: Complex[T]): bool
• httpcore: `==`(a, b: HttpCode): bool
• httpcore: `==`(rawCode: string; code: HttpCode): bool
• httpcore: `==`(protocol: tuple[orig: string, major, minor: int]; ver: HttpVersion): bool
• jsbigints: `==`(x, y: JsBigInt): bool
• jsffi: `==`(x, y: JsRoot): bool
• json: `==`(a, b: JsonNode): bool
• macros: `==`(a, b: NimIdent): bool
• macros: `==`(a, b: NimNode): bool
• macros: `==`(a, b: NimSym): bool
• md5: `==`(D1, D2: MD5Digest): bool
• memfiles: `==`(x, y: MemSlice): bool
• monotimes: `==`(a, b: MonoTime): bool
• nativesockets: `==`(a, b: Port): bool
• net: `==`(lhs, rhs: IpAddress): bool
• nre: `==`(a, b: Regex): bool
• nre: `==`(a, b: RegexMatch): bool
• oids: `==`(oid1: Oid; oid2: Oid): bool
• options: `==`[T](a, b: Option[T]): bool
• os: `==`(err1, err2: OSErrorCode): bool
• packedsets: `==`[A](s1, s2: PackedSet[A]): bool
• rationals: `==`(x, y: Rational): bool
• rstast: `==`(a, b: FileIndex): bool
• sets: `==`[A](s, t: HashSet[A]): bool
• sets: `==`[A](s, t: OrderedSet[A]): bool
• sexp: `==`(a, b: SexpNode): bool
• sha1: `==`(a, b: SecureHash): bool
• system: `==`(x: typeof(nil) | typeof(nil); y: string): bool
• system: `==`[I, T](x, y: array[I, T]): bool
• system: `==`(x, y: bool): bool
• system: `==`(x, y: char): bool
• system: `==`(x, y: cstring): bool
• system: `==`[Enum: enum](x, y: Enum): bool
• system: `==`(x, y: float): bool
• system: `==`(x, y: float32): bool
• system: `==`(x, y: int): bool
• system: `==`(x, y: int16): bool
• system: `==`(x, y: int32): bool
• system: `==`(x, y: int64): bool
• system: `==`(x, y: int8): bool
• system: `==`[T](x, y: openArray[T]): bool
• system: `==`(x, y: pointer): bool
• system: `==`[T](x, y: ptr T): bool
• system: `==`[T](x, y: ref T): bool
• system: `==`[T](x, y: seq[T]): bool
• system: `==`[T](x, y: set[T]): bool
• system: `==`(x: string; y: typeof(nil) | typeof(nil)): bool
• system: `==`(x, y: string): bool
• system: `==`[T: proc](x, y: T): bool
• system: `==`[T: tuple | object](x, y: T): bool
• system: `==`(x, y: uint): bool
• system: `==`(x, y: uint16): bool
• system: `==`(x, y: uint32): bool
• system: `==`(x, y: uint64): bool
• system: `==`(x, y: uint8): bool
• tables: `==`[A](s, t: CountTable[A]): bool
• tables: `==`[A](s, t: CountTableRef[A]): bool
• tables: `==`[A, B](s, t: OrderedTable[A, B]): bool
• tables: `==`[A, B](s, t: OrderedTableRef[A, B]): bool
• tables: `==`[A, B](s, t: Table[A, B]): bool
• tables: `==`[A, B](s, t: TableRef[A, B]): bool
• times: `==`(a, b: DateTime): bool
• times: `==`(a, b: Duration): bool
• times: `==`(a, b: Time): bool
• times: `==`(zone1, zone2: Timezone): bool
• unicode: `==`(a, b: Rune): bool
• winlean: `==`(x, y: SocketHandle): bool

`=`:

• system: `=`[T](dest: var T; src: T)

`=copy`:

• isolation: `=copy`[T](dest: var Isolated[T]; src: Isolated[T])
• system: `=copy`[T](dest: var T; src: T)
• tasks: `=copy`(x: var Task; y: Task)
• threads: `=copy`*[TArg](x: var Thread[TArg]; y: Thread[TArg])

`=destroy`:

• isolation: `=destroy`[T](dest: var Isolated[T])
• system: `=destroy`[T](x: var T)
• tasks: `=destroy`(t: var Task)

`=sink`:

• isolation: `=sink`[T](dest: var Isolated[T]; src: Isolated[T])
• system: `=sink`[T](x: var T; y: T)

`=trace`:

• system: `=trace`[T](x: var T; env: pointer)

`=~`:

• pegs: `=~`(s: string; pattern: Peg): bool
• re: `=~`(s: string; pattern: Regex): untyped

`?.`:

• wrapnils: `?.`(a: typed): auto

`??.`:

• wrapnils: `??.`(a: typed): Option

`?`:

• pegs: `?`(a: Peg): Peg
• uri: `?`(u: Uri; query: openArray[(string, string)]): Uri

`@`:

• system: `@`[T](a: openArray[T]): seq[T]
• system: `@`[IDX, T](a: sink array[IDX, T]): seq[T]

`[]=`:

• critbits: `[]=`[T](c: var CritBitTree[T]; key: string; val: T)
• deques: `[]=`[T](deq: var Deque[T]; i: BackwardsIndex; x: sink T)
• deques: `[]=`[T](deq: var Deque[T]; i: Natural; val: sink T)
• httpclient: `[]=`(p: MultipartData; name, content: string)
• httpclient: `[]=`(p: MultipartData; name: string; file: tuple[name, contentType, content: string])
• httpcore: `[]=`(headers: HttpHeaders; key: string; value: seq[string])
• httpcore: `[]=`(headers: HttpHeaders; key, value: string)
• jsffi: `[]=`[V](obj: JsAssoc[cstring, V]; field: string; val: V)
• jsffi: `[]=`[K: JsKey; V](obj: JsAssoc[K, V]; field: K; val: V)
• jsffi: `[]=`[T](obj: JsObject; field: cstring; val: T)
• jsffi: `[]=`[T](obj: JsObject; field: int; val: T)
• jsformdata: `[]=`(self: FormData; name, value: cstring)
• jsheaders: `[]=`(self: Headers; key: cstring; value: cstring)
• json: `[]=`(obj: JsonNode; key: string; val: JsonNode)
• jsutils: `[]=`(arr: Float64Array; i: int; v: float)
• macrocache: `[]=`(t: CacheTable; key: string; value: NimNode)
• macros: `[]=`(n: NimNode; i: BackwardsIndex; child: NimNode)
• macros: `[]=`(n: NimNode; i: int; child: NimNode)
• setutils: `[]=`[T](t: var set[T]; key: T; val: bool)
• sharedtables: `[]=`[A, B](t: var SharedTable[A, B]; key: A; val: B)
• strtabs: `[]=`(t: StringTableRef; key, val: string)
• system: `[]=`[Idx, T](a: var array[Idx, T]; i: BackwardsIndex; x: T)
• system: `[]=`[Idx, T; U, V: Ordinal](a: var array[Idx, T]; x: HSlice[U, V]; b: openArray[T])
• system: `[]=`[T](s: var openArray[T]; i: BackwardsIndex; x: T)
• system: `[]=`[T; U, V: Ordinal](s: var seq[T]; x: HSlice[U, V]; b: openArray[T])
• system: `[]=`(s: var string; i: BackwardsIndex; x: char)
• system: `[]=`[T, U: Ordinal](s: var string; x: HSlice[T, U]; b: string)
• system: `[]=`[I: Ordinal; T, S](a: T; i: I; x: sink S)
• system: `[]=`(s: string; i: int; val: char)
• tables: `[]=`[A](t: var CountTable[A]; key: A; val: int)
• tables: `[]=`[A](t: CountTableRef[A]; key: A; val: int)
• tables: `[]=`[A, B](t: var OrderedTable[A, B]; key: A; val: sink B)
• tables: `[]=`[A, B](t: OrderedTableRef[A, B]; key: A; val: sink B)
• tables: `[]=`[A, B](t: var Table[A, B]; key: A; val: sink B)
• tables: `[]=`[A, B](t: TableRef[A, B]; key: A; val: sink B)
• typeinfo: `[]=`(x, y: Any)
• typeinfo: `[]=`(x: Any; i: int; y: Any)
• typeinfo: `[]=`(x: Any; fieldName: string; value: Any)

`[]`:

• critbits: `[]`[T](c: CritBitTree[T]; key: string): T
• critbits: `[]`[T](c: var CritBitTree[T]; key: string): var T
• db_mysql: `[]`(row: InstantRow; col: int): string
• db_odbc: `[]`(row: InstantRow; col: int): string
• db_postgres: `[]`(row: InstantRow; col: int): string
• db_sqlite: `[]`(row: InstantRow; col: int32): string
• deques: `[]`[T](deq: Deque[T]; i: BackwardsIndex): lent T
• deques: `[]`[T](deq: var Deque[T]; i: BackwardsIndex): var T
• deques: `[]`[T](deq: Deque[T]; i: Natural): lent T
• deques: `[]`[T](deq: var Deque[T]; i: Natural): var T
• dom: `[]`(x: Node; idx: int): Element
• heapqueue: `[]`[T](heap: HeapQueue[T]; i: Natural): lent T
• httpcore: `[]`(headers: HttpHeaders; key: string): HttpHeaderValues
• httpcore: `[]`(headers: HttpHeaders; key: string; i: int): string
• jsffi: `[]`[V](obj: JsAssoc[cstring, V]; field: string): V
• jsffi: `[]`[K: JsKey; V](obj: JsAssoc[K, V]; field: K): V
• jsffi: `[]`(obj: JsObject; field: cstring): JsObject
• jsffi: `[]`(obj: JsObject; field: int): JsObject
• jsformdata: `[]`(self: FormData; name: cstring): cstring
• jsheaders: `[]`(self: Headers; key: cstring): cstring
• json: `[]`(node: JsonNode; index: BackwardsIndex): JsonNode
• json: `[]`[U, V](a: JsonNode; x: HSlice[U, V]): JsonNode
• json: `[]`(node: JsonNode; index: int): JsonNode
• json: `[]`(node: JsonNode; name: string): JsonNode
• jsutils: `[]`(arr: BigUint64Array; i: int): JsBigInt
• jsutils: `[]`(arr: Uint32Array; i: int): uint32
• jsutils: `[]`(arr: Uint8Array; i: int): uint8
• macrocache: `[]`(s: CacheSeq; i: int): NimNode
• macrocache: `[]`(t: CacheTable; key: string): NimNode
• macros: `[]`(n: NimNode; i: BackwardsIndex): NimNode
• macros: `[]`[T, U: Ordinal](n: NimNode; x: HSlice[T, U]): seq[NimNode]
• macros: `[]`(n: NimNode; i: int): NimNode
• nre: `[]`(pattern: CaptureBounds; i: int): HSlice[int, int]
• nre: `[]`(pattern: CaptureBounds; name: string): HSlice[int, int]
• nre: `[]`(pattern: Captures; i: int): string
• nre: `[]`(pattern: Captures; name: string): string
• parsesql: `[]`(n: SqlNode; i: BackwardsIndex): SqlNode
• parsesql: `[]`(n: SqlNode; i: int): SqlNode
• reservedmem: `[]`[T](s: ReservedMemSeq[T]; rpos: BackwardsIndex): lent T
• reservedmem: `[]`[T](s: var ReservedMemSeq[T]; rpos: BackwardsIndex): var T
• reservedmem: `[]`[T](s: ReservedMemSeq[T]; pos: Natural): lent T
• reservedmem: `[]`[T](s: var ReservedMemSeq[T]; pos: Natural): var T
• ropes: `[]`(r: Rope; i: int): char
• sets: `[]`[A](s: var HashSet[A]; key: A): var A
• sexp: `[]`(node: SexpNode; index: int): SexpNode
• strtabs: `[]`(t: StringTableRef; key: string): var string
• system: `[]`[Idx, T](a: array[Idx, T]; i: BackwardsIndex): T
• system: `[]`[Idx, T](a: var array[Idx, T]; i: BackwardsIndex): var T
• system: `[]`[Idx, T; U, V: Ordinal](a: array[Idx, T]; x: HSlice[U, V]): seq[T]
• system: `[]`[T](s: openArray[T]; i: BackwardsIndex): T
• system: `[]`[T](s: var openArray[T]; i: BackwardsIndex): var T
• system: `[]`[T; U, V: Ordinal](s: openArray[T]; x: HSlice[U, V]): seq[T]
• system: `[]`(s: string; i: BackwardsIndex): char
• system: `[]`(s: var string; i: BackwardsIndex): var char
• system: `[]`[T, U: Ordinal](s: string; x: HSlice[T, U]): string
• system: `[]`[I: Ordinal; T](a: T; i: I): T
• system: `[]`(s: string; i: int): char
• tables: `[]`[A](t: CountTable[A]; key: A): int
• tables: `[]`[A](t: CountTableRef[A]; key: A): int
• tables: `[]`[A, B](t: OrderedTable[A, B]; key: A): B
• tables: `[]`[A, B](t: var OrderedTable[A, B]; key: A): var B
• tables: `[]`[A, B](t: OrderedTableRef[A, B]; key: A): var B
• tables: `[]`[A, B](t: Table[A, B]; key: A): B
• tables: `[]`[A, B](t: var Table[A, B]; key: A): var B
• tables: `[]`[A, B](t: TableRef[A, B]; key: A): var B
• typeinfo: `[]`(x: Any): Any
• typeinfo: `[]`(x: Any; i: int): Any
• typeinfo: `[]`(x: Any; fieldName: string): Any
• wrapnils: `[]`[T, I](a: Option[T]; i: I): auto
• wrapnils: `[]`[U](a: Option[U]): auto
• xmltree: `[]`(n: XmlNode; i: int): XmlNode
• xmltree: `[]`(n: var XmlNode; i: int): var XmlNode

`^`:

• math: `^`[T: SomeNumber](x: T; y: Natural): T
• system: `^`(x: int): BackwardsIndex
• threadpool: `^`[T](fv: FlowVar[T]): T

`addr`:

• system: `addr`[T](x: var T): ptr T

`and`:

• asyncfutures: `and`[T, Y](fut1: Future[T]; fut2: Future[Y]): Future[void]
• jsbigints: `and`(x, y: JsBigInt): JsBigInt
• jsffi: `and`(x, y: JsObject): JsObject
• system: `and`(x, y: bool): bool
• system: `and`(x, y: int): int
• system: `and`(x, y: int16): int16
• system: `and`(x, y: int32): int32
• system: `and`(x, y: int64): int64
• system: `and`(x, y: int8): int8
• system: `and`(a, b: typedesc): typedesc
• system: `and`(x, y: uint): uint
• system: `and`(x, y: uint16): uint16
• system: `and`(x, y: uint32): uint32
• system: `and`(x, y: uint64): uint64
• system: `and`(x, y: uint8): uint8

`div`:

• htmlgen: `div`(e: varargs[untyped]): untyped
• jsbigints: `div`(x, y: JsBigInt): JsBigInt
• rationals: `div`[T: SomeInteger](x, y: Rational[T]): T
• system: `div`(x, y: int): int
• system: `div`(x, y: int16): int16
• system: `div`(x, y: int32): int32
• system: `div`(x, y: int64): int64
• system: `div`(x, y: int8): int8
• system: `div`(x, y: uint): uint
• system: `div`(x, y: uint16): uint16
• system: `div`(x, y: uint32): uint32
• system: `div`(x, y: uint64): uint64
• system: `div`(x, y: uint8): uint8
• times: `div`(a: Duration; b: int64): Duration

`in`:

• jsffi: `in`(x, y: JsObject): JsObject
• system: `in`(x, y: untyped): untyped

`is`:

• system: `is`[T, S](x: T; y: S): bool

`isnot`:

• system: `isnot`(x, y: untyped): untyped

`mod`:

• jsbigints: `mod`(x, y: JsBigInt): JsBigInt
• math: `mod`(x, y: float32): float32
• math: `mod`(x, y: float64): float64
• rationals: `mod`[T: SomeInteger](x, y: Rational[T]): Rational[T]
• system: `mod`(x, y: int): int
• system: `mod`(x, y: int16): int16
• system: `mod`(x, y: int32): int32
• system: `mod`(x, y: int64): int64
• system: `mod`(x, y: int8): int8
• system: `mod`(x, y: uint): uint
• system: `mod`(x, y: uint16): uint16
• system: `mod`(x, y: uint32): uint32
• system: `mod`(x, y: uint64): uint64
• system: `mod`(x, y: uint8): uint8

`not`:

• jsffi: `not`(x: JsObject): JsObject
• system: `not`(x: bool): bool
• system: `not`(x: int): int
• system: `not`(x: int16): int16
• system: `not`(x: int32): int32
• system: `not`(x: int64): int64
• system: `not`(x: int8): int8
• system: `not`(a: typedesc): typedesc
• system: `not`(x: uint): uint
• system: `not`(x: uint16): uint16
• system: `not`(x: uint32): uint32
• system: `not`(x: uint64): uint64
• system: `not`(x: uint8): uint8

`notin`:

• system: `notin`(x, y: untyped): untyped

`object`:

• htmlgen: `object`(e: varargs[untyped]): untyped

`of`:

• system: `of`[T, S](x: T; y: typedesc[S]): bool

`or`:

• asyncfutures: `or`[T, Y](fut1: Future[T]; fut2: Future[Y]): Future[void]
• jsbigints: `or`(x, y: JsBigInt): JsBigInt
• jsffi: `or`(x, y: JsObject): JsObject
• macros: `or`(x, y: NimNode): NimNode
• system: `or`(x, y: bool): bool
• system: `or`(x, y: int): int
• system: `or`(x, y: int16): int16
• system: `or`(x, y: int32): int32
• system: `or`(x, y: int64): int64
• system: `or`(x, y: int8): int8
• system: `or`(a, b: typedesc): typedesc
• system: `or`(x, y: uint): uint
• system: `or`(x, y: uint16): uint16
• system: `or`(x, y: uint32): uint32
• system: `or`(x, y: uint64): uint64
• system: `or`(x, y: uint8): uint8

`ptr`:

• system: ptr

`ref`:

• system: ref

`shl`:

• jsbigints: `shl`(a, b: JsBigInt): JsBigInt
• system: `shl`(x: int; y: SomeInteger): int
• system: `shl`(x: int16; y: SomeInteger): int16
• system: `shl`(x: int32; y: SomeInteger): int32
• system: `shl`(x: int64; y: SomeInteger): int64
• system: `shl`(x: int8; y: SomeInteger): int8
• system: `shl`(x: uint; y: SomeInteger): uint
• system: `shl`(x: uint16; y: SomeInteger): uint16
• system: `shl`(x: uint32; y: SomeInteger): uint32
• system: `shl`(x: uint64; y: SomeInteger): uint64
• system: `shl`(x: uint8; y: SomeInteger): uint8

`shr`:

• jsbigints: `shr`(a, b: JsBigInt): JsBigInt
• system: `shr`(x: int; y: SomeInteger): int
• system: `shr`(x: int16; y: SomeInteger): int16
• system: `shr`(x: int32; y: SomeInteger): int32
• system: `shr`(x: int64; y: SomeInteger): int64
• system: `shr`(x: int8; y: SomeInteger): int8
• system: `shr`(x: uint; y: SomeInteger): uint
• system: `shr`(x: uint16; y: SomeInteger): uint16
• system: `shr`(x: uint32; y: SomeInteger): uint32
• system: `shr`(x: uint64; y: SomeInteger): uint64
• system: `shr`(x: uint8; y: SomeInteger): uint8

`static`:

• system: static

`template`:

• htmlgen: `template`(e: varargs[untyped]): untyped

`type`:

• system: type

`var`:

• htmlgen: `var`(e: varargs[untyped]): untyped

`xor`:

• jsbigints: `xor`(x, y: JsBigInt): JsBigInt
• system: `xor`(x, y: bool): bool
• system: `xor`(x, y: int): int
• system: `xor`(x, y: int16): int16
• system: `xor`(x, y: int32): int32
• system: `xor`(x, y: int64): int64
• system: `xor`(x, y: int8): int8
• system: `xor`(x, y: uint): uint
• system: `xor`(x, y: uint16): uint16
• system: `xor`(x, y: uint32): uint32
• system: `xor`(x, y: uint64): uint64
• system: `xor`(x, y: uint8): uint8

`{}=`:

• json: `{}=`(node: JsonNode; keys: varargs[string]; value: JsonNode)

`{}`:

• jsffi: `{}`(typ: typedesc; xs: varargs[untyped]): auto
• json: `{}`(node: JsonNode; key: string): JsonNode
• json: `{}`(node: JsonNode; index: varargs[int]): JsonNode
• json: `{}`(node: JsonNode; keys: varargs[string]): JsonNode

`|`:

• system: `|`(a, b: typedesc): typedesc

`||`:

• system: `||`[S, T](a: S; b: T; step: Positive; annotation: static string = "parallel for"): T
• system: `||`[S, T](a: S; b: T; annotation: static string = "parallel for"): T

a:

• htmlgen: a(e: varargs[untyped]): untyped

abbr:

• htmlgen: abbr(e: varargs[untyped]): untyped

abbrev:

• strutils: abbrev(s: string; possibilities: openArray[string]): int

abort:

• dom: abort(f: FileReader)

abortOnError:

• unittest: abortOnError

abs:

• complex: abs[T](z: Complex[T]): T
• jscore: abs(m: MathLib; a: SomeNumber): SomeNumber
• rationals: abs[T](x: Rational[T]): Rational[T]
• system: abs(x: int): int
• system: abs(x: int16): int16
• system: abs(x: int32): int32
• system: abs(x: int64): int64
• system: abs(x: int8): int8
• system: abs[T: float64 | float32](x: T): T
• times: abs(a: Duration): Duration

abs2:

• complex: abs2[T](z: Complex[T]): T

absolute:

• Module os

absolutePath:

• os: absolutePath(path: string; root = getCurrentDir()): string

accept:

• asyncdispatch: accept(socket: AsyncFD; flags = {SafeDisconn}; inheritable = defined(nimInheritHandles)): owned(Future[AsyncFD])
• asyncnet: accept(socket: AsyncSocket; flags = {SafeDisconn}): owned(Future[AsyncSocket])
• nativesockets: accept(fd: SocketHandle; inheritable = defined(nimInheritHandles)): ( SocketHandle, string)
• net: accept(server: Socket; client: var owned(Socket); flags = {SafeDisconn}; inheritable = defined(nimInheritHandles))
• winlean: accept(s: SocketHandle; a: ptr SockAddr; addrlen: ptr SockLen): SocketHandle

acceptAddr:

• asyncdispatch: acceptAddr(socket: AsyncFD; flags = {SafeDisconn}; inheritable = defined(nimInheritHandles)): owned( Future[tuple[address: string, client: AsyncFD]])
• asyncnet: acceptAddr(socket: AsyncSocket; flags = {SafeDisconn}; inheritable = defined(nimInheritHandles)): owned( Future[tuple[address: string, client: AsyncSocket]])
• net: acceptAddr(server: Socket; client: var owned(Socket); address: var string; flags = {SafeDisconn}; inheritable = defined(nimInheritHandles))

AcceptNoClient:

• SslAcceptResult.AcceptNoClient

AcceptNoHandshake:

• SslAcceptResult.AcceptNoHandshake

acceptRequest:

• asynchttpserver: acceptRequest(server: AsyncHttpServer; callback: proc (request: Request): Future[ void] {.closure, gcsafe.}): owned(Future[void])

AcceptSuccess:

• SslAcceptResult.AcceptSuccess

AccessViolationDefect:

• system: AccessViolationDefect

AccessViolationError:

• system: AccessViolationError

acos:

• jscore: acos(m: MathLib; a: SomeNumber): float

acosh:

• jscore: acosh(m: MathLib; a: SomeNumber): float

acquire:

• locks: acquire(lock: var Lock)
• rlocks: acquire(lock: var RLock)

activeDescriptors:

• asyncdispatch: activeDescriptors(): int

add:

• dom: add(c: ClassList; class: cstring)
• httpclient: add(p: MultipartData; xs: MultipartEntries): MultipartData
• httpclient: add(p: MultipartData; name, content: string; filename: string = ""; contentType: string = ""; useStream = true)
• httpcore: add(headers: HttpHeaders; key, value: string)
• jsformdata: add(self: FormData; name: cstring; value: SomeNumber | bool | cstring)
• jsformdata: add(self: FormData; name: cstring; value: SomeNumber | bool | cstring; filename: cstring)
• jsheaders: add(self: Headers; key: cstring; value: cstring)
• json: add(father, child: JsonNode)
• json: add(obj: JsonNode; key: string; val: JsonNode)
• lists: add[T](L: var DoublyLinkedList[T]; n: DoublyLinkedNode[T])
• lists: add[T](L: var DoublyLinkedList[T]; value: T)
• lists: add[T](L: var DoublyLinkedRing[T]; n: DoublyLinkedNode[T])
• lists: add[T](L: var DoublyLinkedRing[T]; value: T)
• lists: add[T](L: var SinglyLinkedList[T]; n: SinglyLinkedNode[T])
• lists: add[T](L: var SinglyLinkedList[T]; value: T)
• lists: add[T](L: var SinglyLinkedRing[T]; n: SinglyLinkedNode[T])
• lists: add[T](L: var SinglyLinkedRing[T]; value: T)
• lists: add[T: SomeLinkedList](a: var T; b: T)
• macrocache: add(s: CacheSeq; value: NimNode)
• macros: add(father, child: NimNode): NimNode
• macros: add(father: NimNode; children: varargs[NimNode]): NimNode
• parsesql: add(father, n: SqlNode)
• reservedmem: add[T](s: var ReservedMemSeq[T]; val: T)
• ropes: add(a: var Rope; b: Rope)
• ropes: add(a: var Rope; b: string)
• rstast: add(father, son: PRstNode)
• rstast: add(father: PRstNode; s: string)
• sexp: add(father, child: SexpNode)
• sharedlist: add[A](x: var SharedList[A]; y: A)
• sharedtables: add[A, B](t: var SharedTable[A, B]; key: A; val: B)
• strbasics: add(x: var string; y: openArray[char])
• system: add(x: var cstring; y: cstring)
• system: add[T](x: var seq[T]; y: openArray[T])
• system: add[T](x: var seq[T]; y: sink T)
• system: add(x: var string; y: char)
• system: add(x: var string; y: cstring)
• system: add(x: var string; y: string)
• tables: add[A, B](t: var OrderedTable[A, B]; key: A; val: sink B)
• tables: add[A, B](t: OrderedTableRef[A, B]; key: A; val: sink B)
• tables: add[A, B](t: var Table[A, B]; key: A; val: sink B)
• tables: add[A, B](t: TableRef[A, B]; key: A; val: sink B)
• unicode: add(s: var string; c: Rune)
• xmltree: add(result: var string; n: XmlNode; indent = 0; indWidth = 2; addNewLines = true)
• xmltree: add(father, son: XmlNode)

addAndFetch:

• system: addAndFetch(p: ptr int; val: int): int

addCallback:

• asyncfutures: addCallback[T](future: Future[T]; cb: proc (future: Future[T]) {.closure, gcsafe.})
• asyncfutures: addCallback(future: FutureBase; cb: proc () {.closure, gcsafe.})

addCompletion:

• linenoise: addCompletion(a2: ptr Completions; a3: cstring)

addEscaped:

• xmltree: addEscaped(result: var string; s: string)

addEscapedChar:

• system: addEscapedChar(s: var string; c: char)

addEvent:

• asyncdispatch: addEvent(ev: AsyncEvent; cb: Callback)

addEventListener:

• dom: addEventListener(et: EventTarget; ev: cstring; cb: proc (ev: Event); options: AddEventListenerOptions)
• dom: addEventListener(et: EventTarget; ev: cstring; cb: proc (ev: Event); useCapture: bool = false)

AddEventListenerOptions:

• dom: AddEventListenerOptions

addExitProc:

• exitprocs: addExitProc(cl: proc () {.closure.})
• exitprocs: addExitProc(cl: proc () {.noconv.})

addf:

• ropes: addf(c: var Rope; frmt: string; args: openArray[Rope])
• strutils: addf(s: var string; formatstr: string; a: varargs[string, `$`])

addFileExt:

• os: addFileExt(filename, ext: string): string

addFiles:

• httpclient: addFiles(p: MultipartData; xs: openArray[tuple[name, file: string]]; mimeDb = newMimetypes(); useStream = true): MultipartData

addFirst:

• deques: addFirst[T](deq: var Deque[T]; item: sink T)

addHandler:

• logging: addHandler(handler: Logger)

addIdentIfAbsent:

• macros: addIdentIfAbsent(dest: NimNode; ident: string)

addIfNotNil:

• rstast: addIfNotNil(father, son: PRstNode)

addInt:

• digitsutils: addInt(result: var string; x: int)
• digitsutils: addInt(result: var string; x: int64)
• digitsutils: addInt(result: var string; x: uint64)

addLast:

• deques: addLast[T](deq: var Deque[T]; item: sink T)

addMoved:

• lists: addMoved[T](a, b: var DoublyLinkedList[T])
• lists: addMoved[T](a, b: var SinglyLinkedList[T])

addNormalizePath:

• pathnorm: addNormalizePath(x: string; result: var string; state: var int; dirSep = DirSep)

addOutputFormatter:

• unittest: addOutputFormatter(formatter: OutputFormatter)

addPragma:

• macros: addPragma(someProc, pragma: NimNode)

addProcess:

• asyncdispatch: addProcess(pid: int; cb: Callback)

addQuitProc:

• system: addQuitProc(quitProc: proc () {.noconv.})

addQuoted:

• system: addQuoted[T](s: var string; x: T)

addRead:

• asyncdispatch: addRead(fd: AsyncFD; cb: Callback)

address:

• htmlgen: address(e: varargs[untyped]): untyped

AddrInfo:

• winlean: AddrInfo

addSep:

• strutils: addSep(dest: var string; sep = ", "; startLen: Natural = 0)

addTimer:

• asyncdispatch: addTimer(timeout: int; oneshot: bool; cb: Callback)

addWrite:

• asyncdispatch: addWrite(fd: AsyncFD; cb: Callback)

advice:

• cpuload: advice(s: var ThreadPoolState): ThreadPoolAdvice

affinity:

• Module threads

AF_INET:

• Domain.AF_INET
• winlean: AF_INET

AF_INET6:

• Domain.AF_INET6
• winlean: AF_INET6

afterCodeReload:

• hotcodereloading: afterCodeReload(body: untyped)

AF_UNIX:

• Domain.AF_UNIX

AF_UNSPEC:

• Domain.AF_UNSPEC
• winlean: AF_UNSPEC

AI_V4MAPPED:

• winlean: AI_V4MAPPED

akArray:

• AnyKind.akArray

akBool:

• AnyKind.akBool

akChar:

• AnyKind.akChar

akCString:

• AnyKind.akCString

akEnum:

• AnyKind.akEnum

akFloat:

• AnyKind.akFloat

akFloat128:

• AnyKind.akFloat128

akFloat32:

• AnyKind.akFloat32

akFloat64:

• AnyKind.akFloat64

akInt:

• AnyKind.akInt

akInt16:

• AnyKind.akInt16

akInt32:

• AnyKind.akInt32

akInt64:

• AnyKind.akInt64

akInt8:

• AnyKind.akInt8

akNone:

• AnyKind.akNone

akObject:

• AnyKind.akObject

akPointer:

• AnyKind.akPointer

akProc:

• AnyKind.akProc

akPtr:

• AnyKind.akPtr

akRange:

• AnyKind.akRange

akRef:

• AnyKind.akRef

akSequence:

• AnyKind.akSequence

akSet:

• AnyKind.akSet

akString:

• AnyKind.akString

akTuple:

• AnyKind.akTuple

akUInt:

• AnyKind.akUInt

akUInt16:

• AnyKind.akUInt16

akUInt32:

• AnyKind.akUInt32

akUInt64:

• AnyKind.akUInt64

akUInt8:

• AnyKind.akUInt8

alert:

• dom: alert(w: Window; msg: cstring)

align:

• strutils: align(s: string; count: Natural; padding = ' '): string
• unicode: align(s: string; count: Natural; padding = ' '.Rune): string

alignLeft:

• strutils: alignLeft(s: string; count: Natural; padding = ' '): string
• unicode: alignLeft(s: string; count: Natural; padding = ' '.Rune): string

alignof:

• system: alignof[T](x: T): int
• system: alignof(x: typedesc): int

alignString:

• strformat: alignString(s: string; minimumWidth: int; align = '\x00'; fill = ' '): string

alignTable:

• asciitables: alignTable(s: string; delim = ' '; fill = ' '; sep = " "): string

alive:

• coro: alive(c: CoroutineRef): bool

all:

• asyncfutures: all[T](futs: varargs[Future[T]]): auto
• sequtils: all[T](s: openArray[T]; pred: proc (x: T): bool {.closure.}): bool

AllChars:

• strutils: AllChars

allCharsInSet:

• strutils: allCharsInSet(s: string; theSet: set[char]): bool

allIt:

• sequtils: allIt(s, pred: untyped): bool

alloc:

• system: alloc(size: Natural): pointer

alloc0:

• system: alloc0(size: Natural): pointer

alloc0Impl:

• system: alloc0Impl(size: Natural): pointer

allocateAndInitializeSid:

• winlean: allocateAndInitializeSid(pIdentifierAuthority: ptr SID_IDENTIFIER_AUTHORITY; nSubAuthorityCount: BYTE; nSubAuthority0: DWORD; nSubAuthority1: DWORD; nSubAuthority2: DWORD; nSubAuthority3: DWORD; nSubAuthority4: DWORD; nSubAuthority5: DWORD; nSubAuthority6: DWORD; nSubAuthority7: DWORD; pSid: ptr PSID): WINBOOL

allocCStringArray:

• system: allocCStringArray(a: openArray[string]): cstringArray

allocImpl:

• system: allocImpl(size: Natural): pointer

allocShared:

• system: allocShared(size: Natural): pointer

allocShared0:

• system: allocShared0(size: Natural): pointer

allocShared0Impl:

• system: allocShared0Impl(size: Natural): pointer

allocSharedImpl:

• system: allocSharedImpl(size: Natural): pointer

AllocStats:

• system: AllocStats

allowEmptyAttribs:

• XmlParseOption.allowEmptyAttribs

allowUnquotedAttribs:

• XmlParseOption.allowUnquotedAttribs

allValues:

• tables: allValues[A, B](t: Table[A, B]; key: A): B

almostEqual:

• math: almostEqual[T: SomeFloat](x, y: T; unitsInLastPlace: Natural = 4): bool

AltSep:

• os: AltSep

AnchorElement:

• dom: AnchorElement

annotation:

• htmlgen: annotation(e: varargs[untyped]): untyped

annotation-xml:

• htmlgen: annotation-xml(e: varargs[untyped]): untyped

ansiBackgroundColorCode:

• terminal: ansiBackgroundColorCode(color: Color): string
• terminal: ansiBackgroundColorCode(color: static[Color]): string

ansiForegroundColorCode:

• terminal: ansiForegroundColorCode(color: Color): string
• terminal: ansiForegroundColorCode(fg: ForegroundColor; bright = false): string
• terminal: ansiForegroundColorCode(color: static[Color]): string
• terminal: ansiForegroundColorCode(fg: static[ForegroundColor]; bright: static[bool] = false): string

ansiResetCode:

• terminal: ansiResetCode

ansiStyleCode:

• terminal: ansiStyleCode(style: int): string
• terminal: ansiStyleCode(style: static[Style]): string
• terminal: ansiStyleCode(style: Style): string

any:

• pegs: any(): Peg
• sequtils: any[T](s: openArray[T]; pred: proc (x: T): bool {.closure.}): bool
• system: any

Any:

• typeinfo: Any

any character:

• Module pegs

any rune:

• Module pegs

anyIt:

• sequtils: anyIt(s, pred: untyped): bool

AnyKind:

• typeinfo: AnyKind

anyRune:

• pegs: anyRune(): Peg

append:

• chains: append(header, node)
• lists: append[T](a: var (SinglyLinkedList[T] | SinglyLinkedRing[T]); b: SinglyLinkedList[T] | SinglyLinkedNode[T] | T)
• lists: append[T](a: var (DoublyLinkedList[T] | DoublyLinkedRing[T]); b: DoublyLinkedList[T] | DoublyLinkedNode[T] | T)

appendChild:

• dom: appendChild(n, child: Node)

appendData:

• dom: appendData(n: Node; data: cstring)

appendMoved:

• lists: appendMoved[T: SomeLinkedList](a, b: var T)

apply:

• sequtils: apply[T](s: var openArray[T]; op: proc (x: var T) {.closure.})
• sequtils: apply[T](s: var openArray[T]; op: proc (x: T): T {.closure.})
• sequtils: apply[T](s: openArray[T]; op: proc (x: T) {.closure.})

applyIt:

• sequtils: applyIt(varSeq, op: untyped)

appType:

• system: appType

arccos:

• complex: arccos[T](z: Complex[T]): Complex[T]
• math: arccos(x: float32): float32
• math: arccos(x: float64): float64

arccosh:

• complex: arccosh[T](z: Complex[T]): Complex[T]
• math: arccosh(x: float32): float32
• math: arccosh(x: float64): float64

arccot:

• complex: arccot[T](z: Complex[T]): Complex[T]
• math: arccot[T: float32 | float64](x: T): T

arccoth:

• complex: arccoth[T](z: Complex[T]): Complex[T]
• math: arccoth[T: float32 | float64](x: T): T

arccsc:

• complex: arccsc[T](z: Complex[T]): Complex[T]
• math: arccsc[T: float32 | float64](x: T): T

arccsch:

• complex: arccsch[T](z: Complex[T]): Complex[T]
• math: arccsch[T: float32 | float64](x: T): T

arcsec:

• complex: arcsec[T](z: Complex[T]): Complex[T]
• math: arcsec[T: float32 | float64](x: T): T

arcsech:

• complex: arcsech[T](z: Complex[T]): Complex[T]
• math: arcsech[T: float32 | float64](x: T): T

arcsin:

• complex: arcsin[T](z: Complex[T]): Complex[T]
• math: arcsin(x: float32): float32
• math: arcsin(x: float64): float64

arcsinh:

• complex: arcsinh[T](z: Complex[T]): Complex[T]
• math: arcsinh(x: float32): float32
• math: arcsinh(x: float64): float64

arctan:

• complex: arctan[T](z: Complex[T]): Complex[T]
• math: arctan(x: float32): float32
• math: arctan(x: float64): float64

arctan2:

• math: arctan2(y, x: float32): float32
• math: arctan2(y, x: float64): float64

arctanh:

• complex: arctanh[T](z: Complex[T]): Complex[T]
• math: arctanh(x: float32): float32
• math: arctanh(x: float64): float64

area:

• htmlgen: area(e: varargs[untyped]): untyped

argc:

• Module os

argv:

• Module os

ariaAttr:

• htmlgen: ariaAttr

ArithmeticDefect:

• system: ArithmeticDefect

ArithmeticError:

• system: ArithmeticError

arity:

• typetraits: arity(t: typedesc): int

array:

• system: array

ArrayBuffer:

• jsutils: ArrayBuffer

article:

• htmlgen: article(e: varargs[untyped]): untyped

Ascending:

• SortOrder.Ascending

ashr:

• system: ashr(x: int; y: SomeInteger): int
• system: ashr(x: int16; y: SomeInteger): int16
• system: ashr(x: int32; y: SomeInteger): int32
• system: ashr(x: int64; y: SomeInteger): int64
• system: ashr(x: int8; y: SomeInteger): int8

aside:

• htmlgen: aside(e: varargs[untyped]): untyped

asin:

• jscore: asin(m: MathLib; a: SomeNumber): float

asinh:

• jscore: asinh(m: MathLib; a: SomeNumber): float

assert:

• assertions: assert(cond: untyped; msg = "")

AssertionDefect:

• system: AssertionDefect

AssertionError:

• system: AssertionError

assign:

• packedsets: assign[A](dest: var PackedSet[A]; src: PackedSet[A])
• typeinfo: assign(x, y: Any)

assignedElements:

• dom: assignedElements(n: HTMLSlotElement; options: SlotOptions): seq[Element]

assignedNodes:

• dom: assignedNodes(n: HTMLSlotElement; options: SlotOptions): seq[Node]

AST:

• Module macros

astGenRepr:

• macros: astGenRepr(n: NimNode): string

astToStr:

• system: astToStr[T](x: T): string

async:

• asyncdispatch: async(prc: untyped): untyped
• asyncjs: async(arg: untyped): untyped
• asyncmacro: async(prc: untyped): untyped

asyncCheck:

• asyncfutures: asyncCheck[T](future: Future[T])

AsyncEvent:

• asyncdispatch: AsyncEvent

AsyncFD:

• asyncdispatch: AsyncFD

AsyncFile:

• asyncfile: AsyncFile

AsyncFtpClient:

• asyncftpclient: AsyncFtpClient

AsyncHttpClient:

• httpclient: AsyncHttpClient

AsyncHttpServer:

• asynchttpserver: AsyncHttpServer

AsyncResponse:

• httpclient: AsyncResponse

AsyncSmtp:

• smtp: AsyncSmtp

AsyncSocket:

• asyncnet: AsyncSocket

atan:

• jscore: atan(m: MathLib; a: SomeNumber): float

atan2:

• jscore: atan2(m: MathLib; a: SomeNumber): float

atanh:

• jscore: atanh(m: MathLib; a: SomeNumber): float

atEnd:

• streams: atEnd(s: Stream): bool

atom:

• strscans: atom(input: string; idx: int; c: char): bool
• strscans: atom(input: string; idx: int; s: set[char]): bool

Atomic:

• atomics: Atomic

atomicDec:

• atomics: atomicDec[T: SomeInteger](location: var Atomic[T]; value: T = 1)
• system: atomicDec(memLoc: var int; x: int = 1): int

AtomicFlag:

• atomics: AtomicFlag

atomicInc:

• atomics: atomicInc[T: SomeInteger](location: var Atomic[T]; value: T = 1)
• system: atomicInc(memLoc: var int; x: int = 1): int

AtomicNodes:

• macros: AtomicNodes

AtomType:

• system: AtomType

attachShadow:

• dom: attachShadow(n: Element): ShadowRoot

AtTarget:

• EventPhase.AtTarget

attr:

• xmltree: attr(n: XmlNode; name: string): string

AttributeNode:

• NodeType.AttributeNode

attrKey:

• parsexml: attrKey(my: XmlParser): string

attrs:

• xmltree: attrs(n: XmlNode): XmlAttributes

attrs=:

• xmltree: attrs=(n: XmlNode; attr: XmlAttributes)

attrsLen:

• xmltree: attrsLen(n: XmlNode): int

attrValue:

• parsexml: attrValue(my: XmlParser): string

audio:

• htmlgen: audio(e: varargs[untyped]): untyped

auth:

• smtp: auth(smtp: AsyncSmtp; username, password: string): owned(Future[void])
• smtp: auth(smtp: Smtp; username, password: string)

author:

• nimscript: author

auto:

• system: auto

autovivification:

• Module json

AuxilaryButton:

• MouseButtons.AuxilaryButton

await:

• asyncdispatch: await[T](f: Future[T]): auto
• asyncdispatch: await(f: typed): untyped
• asyncmacro: await[T](f: Future[T]): auto
• asyncmacro: await(f: typed): untyped

awaitAndThen:

• threadpool: awaitAndThen[T](fv: FlowVar[T]; action: proc (x: T) {.closure.})

b:

• htmlgen: b(e: varargs[untyped]): untyped

back:

• dom: back(h: History)
• dom: back(w: Window)

backend:

• nimscript: backend

BackgroundColor:

• terminal: BackgroundColor

backref:

• pegs: backref(index: range[1 .. MaxSubpatterns]; reverse: bool = false): Peg

backrefIgnoreCase:

• pegs: backrefIgnoreCase(index: range[1 .. MaxSubpatterns]; reverse: bool = false): Peg

backrefIgnoreStyle:

• pegs: backrefIgnoreStyle(index: range[1 .. MaxSubpatterns]; reverse: bool = false): Peg

backslash:

• Backslash

BackwardsIndex:

• system: BackwardsIndex

base:

• htmlgen: base(e: varargs[untyped]): untyped
• typeinfo: base(x: Any): Any

BaseLexer:

• lexbase: BaseLexer

basename:

• macros: basename(a: NimNode): NimNode

baseName:

• Module os

basename=:

• macros: basename=(a: NimNode; val: string)

baseTypeKind:

• typeinfo: baseTypeKind(x: Any): AnyKind

baseTypeSize:

• typeinfo: baseTypeSize(x: Any): int

bdi:

• htmlgen: bdi(e: varargs[untyped]): untyped

bdo:

• htmlgen: bdo(e: varargs[untyped]): untyped

beforeCodeReload:

• hotcodereloading: beforeCodeReload(body: untyped)

between:

• times: between(startDt, endDt: DateTime): TimeInterval

bg8Bit:

• BackgroundColor.bg8Bit

bgBlack:

• BackgroundColor.bgBlack

bgBlue:

• BackgroundColor.bgBlue

bgColor:

• TerminalCmd.bgColor

bgCyan:

• BackgroundColor.bgCyan

bgDefault:

• BackgroundColor.bgDefault

bgGreen:

• BackgroundColor.bgGreen

bgMagenta:

• BackgroundColor.bgMagenta

bgRed:

• BackgroundColor.bgRed

bgWhite:

• BackgroundColor.bgWhite

bgYellow:

• BackgroundColor.bgYellow

big:

• htmlgen: big(e: varargs[untyped]): untyped
• jsbigints: big(integer: cstring): JsBigInt
• jsbigints: big(integer: SomeInteger): JsBigInt

bigEndian:

• Endianness.bigEndian

bigEndian16:

• endians: bigEndian16(outp, inp: pointer)

bigEndian32:

• endians: bigEndian32(outp, inp: pointer)

bigEndian64:

• endians: bigEndian64(outp, inp: pointer)

BiggestFloat:

• system: BiggestFloat

BiggestInt:

• system: BiggestInt

BiggestUInt:

• system: BiggestUInt

BigUint64Array:

• jsutils: BigUint64Array

bin:

• nimscript: bin

BinaryPrefixMode:

• strutils: BinaryPrefixMode

binarySearch:

• algorithm: binarySearch[T, K](a: openArray[T]; key: K; cmp: proc (x: T; y: K): int {.closure.}): int
• algorithm: binarySearch[T](a: openArray[T]; key: T): int

bindAddr:

• asyncnet: bindAddr(socket: AsyncSocket; port = Port(0); address = "")
• nativesockets: bindAddr(socket: SocketHandle; name: ptr SockAddr; namelen: SockLen): cint
• net: bindAddr(socket: Socket; port = Port(0); address = "")

binDir:

• nimscript: binDir

bindMethod:

• jsffi: bindMethod(procedure: typed): auto

bindNull:

• db_sqlite: bindNull(ps: SqlPrepared; paramIdx: int)

bindParam:

• db_sqlite: bindParam(ps: SqlPrepared; paramIdx: int; val: float64)
• db_sqlite: bindParam(ps: SqlPrepared; paramIdx: int; val: int)
• db_sqlite: bindParam(ps: SqlPrepared; paramIdx: int; val: int32)
• db_sqlite: bindParam(ps: SqlPrepared; paramIdx: int; val: int64)
• db_sqlite: bindParam(ps: SqlPrepared; paramIdx: int; val: openArray[byte]; copy = true)
• db_sqlite: bindParam(ps: SqlPrepared; paramIdx: int; val: string; copy = true)

bindParams:

• db_sqlite: bindParams(ps: SqlPrepared; params: varargs[untyped]): untyped

bindSocket:

• winlean: bindSocket(s: SocketHandle; name: ptr SockAddr; namelen: SockLen): cint

bindSym:

• macros: bindSym(ident: string | NimNode; rule: BindSymRule = brClosed): NimNode

BindSymRule:

• macros: BindSymRule

bindUnix:

• asyncnet: bindUnix(socket: AsyncSocket; path: string)
• net: bindUnix(socket: Socket; path: string)

binom:

• math: binom(n, k: int): int

bitand:

• bitops: bitand[T: SomeInteger](x, y: T; z: varargs[T]): T

bitnot:

• bitops: bitnot[T: SomeInteger](x: T): T

bitor:

• bitops: bitor[T: SomeInteger](x, y: T; z: varargs[T]): T

bitslice:

• bitops: bitslice[T: SomeInteger](v: var T; slice: Slice[int])

bitsliced:

• bitops: bitsliced[T: SomeInteger](v: T; slice: Slice[int]): T

BitsRange:

• bitops: BitsRange

bitxor:

• bitops: bitxor[T: SomeInteger](x, y: T; z: varargs[T]): T

Blob:

• dom: Blob

blob:

• Module typetraits

blockquote:

• htmlgen: blockquote(e: varargs[untyped]): untyped

BlockTags:

• htmlparser: BlockTags

blockUntil:

• threadpool: blockUntil(fv: var FlowVarBaseObj)

blockUntilAny:

• threadpool: blockUntilAny(flowVars: openArray[FlowVarBase]): int

blur:

• dom: blur(e: Element)
• dom: blur(w: Window)

body:

• htmlgen: body(e: varargs[untyped]): untyped
• httpclient: body(response: AsyncResponse): Future[string]
• httpclient: body(response: Response): string

Body:

• jsfetch: Body

body:

• macros: body(someProc: NimNode): NimNode

body=:

• macros: body=(someProc: NimNode; val: NimNode)

bool:

• system: bool

boolVal:

• macros: boolVal(n: NimNode): bool

BoundingRect:

• dom: BoundingRect

bounds:

• pegs: bounds(c: Captures; i: range[0 .. 20 - 1]): tuple[first, last: int]

bpColloquial:

• BinaryPrefixMode.bpColloquial

bpIEC:

• BinaryPrefixMode.bpIEC

br:

• htmlgen: br(e: varargs[untyped]): untyped

brClosed:

• BindSymRule.brClosed

brForceOpen:

• BindSymRule.brForceOpen

broadcast:

• locks: broadcast(cond: var Cond)

brOpen:

• BindSymRule.brOpen

BubblingPhase:

• EventPhase.BubblingPhase

BufferSize:

• net: BufferSize

buildCPU:

• nimscript: buildCPU

buildOS:

• nimscript: buildOS

button:

• htmlgen: button(e: varargs[untyped]): untyped

byaddr:

• decls: byaddr(lhs, typ, ex)

BY_HANDLE_FILE_INFORMATION:

• winlean: BY_HANDLE_FILE_INFORMATION

byte:

• system: byte

BYTE:

• winlean: BYTE

ByteAddress:

• system: ByteAddress

c_abort:

• segfaults: c_abort()

CacheCounter:

• macrocache: CacheCounter

CacheSeq:

• macrocache: CacheSeq

CacheTable:

• macrocache: CacheTable

Callback:

• asyncdispatch: Callback

callback=:

• asyncfutures: callback=[T](future: Future[T]; cb: proc (future: Future[T]) {.closure, gcsafe.})
• asyncfutures: callback=(future: FutureBase; cb: proc () {.closure, gcsafe.})
• asyncstreams: callback=[T](future: FutureStream[T]; cb: proc (future: FutureStream[T]) {.closure, gcsafe.})

caller info:

• Module system

CallNodes:

• macros: CallNodes

callsite:

• macros: callsite(): NimNode

callSoon:

• asyncdispatch: callSoon(cbproc: proc () {.gcsafe.})
• asyncfutures: callSoon(cbproc: proc () {.gcsafe.})

cancelAnimationFrame:

• dom: cancelAnimationFrame(w: Window; id: int)

canShare:

• dom: canShare(self: Navigator; data: cstring): bool

canvas:

• htmlgen: canvas(e: varargs[untyped]): untyped

capitalize:

• unicode: capitalize(s: string): string

capitalizeAscii:

• strutils: capitalizeAscii(s: string): string

caption:

• htmlgen: caption(e: varargs[untyped]): untyped

capture:

• pegs: capture(a: Peg = Peg(kind: pkEmpty)): Peg
• sugar: capture(locals: varargs[typed]; body: untyped): untyped

captureBetween:

• parseutils: captureBetween(s: string; first: char; second = '\x00'; start = 0): string

CaptureBounds:

• nre: CaptureBounds

captureBounds:

• nre: captureBounds(pattern: RegexMatch): CaptureBounds

captureCount:

• nre: captureCount(pattern: Regex): int

captureNameId:

• nre: captureNameId(pattern: Regex): Table[string, int]

Captures:

• nre: Captures

captures:

• nre: captures(pattern: RegexMatch): Captures

Captures:

• pegs: Captures

CapturingPhase:

• EventPhase.CapturingPhase

card:

• packedsets: card[A](s: PackedSet[A]): int
• sets: card[A](s: HashSet[A]): int
• sets: card[A](s: OrderedSet[A]): int
• system: card[T](x: set[T]): int

cas:

• system: cas[T: bool | int | ptr](p: ptr T; oldValue, newValue: T): bool

catch:

• asyncjs: catch[T](future: Future[T]; onReject: OnReject): Future[void]

CatchableError:

• system: CatchableError

cbrt:

• jscore: cbrt(m: MathLib; f: SomeFloat): SomeFloat
• math: cbrt(x: float32): float32
• math: cbrt(x: float64): float64

c_calloc:

• segfaults: c_calloc(nmemb, size: csize_t): pointer

cchar:

• system: cchar

cd:

• asyncftpclient: cd(ftp: AsyncFtpClient; dir: string): owned(Future[void])
• nimscript: cd(dir: string)

CDATANode:

• NodeType.CDATANode

cdouble:

• system: cdouble

cdup:

• asyncftpclient: cdup(ftp: AsyncFtpClient): owned(Future[void])

ceil:

• jscore: ceil(m: MathLib; f: SomeFloat): SomeFloat
• math: ceil(x: float32): float32
• math: ceil(x: float64): float64

ceilDiv:

• math: ceilDiv[T: SomeInteger](x, y: T): T

Cell:

• asciitables: Cell

center:

• htmlgen: center(e: varargs[untyped]): untyped
• strutils: center(s: string; width: int; fillChar: char = ' '): string

Certificate:

• net: Certificate

cfgEof:

• CfgEventKind.cfgEof

cfgError:

• CfgEventKind.cfgError

CfgEvent:

• parsecfg: CfgEvent

CfgEventKind:

• parsecfg: CfgEventKind

cfgKeyValuePair:

• CfgEventKind.cfgKeyValuePair

cfgOption:

• CfgEventKind.cfgOption

CfgParser:

• parsecfg: CfgParser

cfgSectionStart:

• CfgEventKind.cfgSectionStart

CFilePtr:

• segfaults: CFilePtr

cfloat:

• system: cfloat

c_fprintf:

• segfaults: c_fprintf(f: CFilePtr; frmt: cstring): cint

c_fputs:

• segfaults: c_fputs(c: cstring; f: CFilePtr): cint

c_free:

• segfaults: c_free(p: pointer)

c_frexp:

• math: c_frexp(x: cdouble; exponent: var cint): cdouble
• math: c_frexp(x: cfloat; exponent: var cint): cfloat

cfSymlinkAsIs:

• CopyFlag.cfSymlinkAsIs

cfSymlinkFollow:

• CopyFlag.cfSymlinkFollow

cfSymlinkIgnore:

• CopyFlag.cfSymlinkIgnore

c_fwrite:

• segfaults: c_fwrite(buf: pointer; size, n: csize_t; f: CFilePtr): cint

CgiError:

• cgi: CgiError

cgiError:

• cgi: cgiError(msg: string)

ch:

• pegs: ch(p: Peg): char

chaining:

• Module with

changeFileExt:

• os: changeFileExt(filename, ext: string): string

Channel:

• channels_builtin: Channel

char:

• system: char

charChoice:

• pegs: charChoice(p: Peg): ref set[char]

charData:

• parsexml: charData(my: XmlParser): string

charSet:

• pegs: charSet(s: set[char]): Peg

check:

• unittest: check(conditions: untyped): untyped

checked:

• dom: checked(n: Node): bool

checked=:

• dom: checked=(n: Node; v: bool)

checkedSymAddr:

• dynlib: checkedSymAddr(lib: LibHandle; name: cstring): pointer

checkpoint:

• unittest: checkpoint(msg: string)

checkReply:

• smtp: checkReply(smtp: AsyncSmtp; reply: string): owned(Future[void])
• smtp: checkReply(smtp: Smtp; reply: string)

checkTokenMembership:

• winlean: checkTokenMembership(tokenHandle: Handle; sidToCheck: PSID; isMember: PBOOL): WINBOOL

checkValidity:

• dom: checkValidity(e: FormElement): bool
• dom: checkValidity(e: InputElement): bool

child:

• xmltree: child(n: XmlNode; name: string): XmlNode

children:

• macros: children(n: NimNode): NimNode

chmod:

• asyncftpclient: chmod(ftp: AsyncFtpClient; path: string; permissions: set[FilePermission]): owned( Future[void])

chomp:

• Module strutils

chr:

• system: chr(u: range[0 .. 255]): char

cint:

• system: cint

CiphersIntermediate:

• ssl_config: CiphersIntermediate

CiphersModern:

• ssl_config: CiphersModern

CiphersOld:

• ssl_config: CiphersOld

cite:

• htmlgen: cite(e: varargs[untyped]): untyped

C_JmpBuf:

• segfaults: C_JmpBuf

clamp:

• math: clamp[T](val: T; bounds: Slice[T]): T
• system: clamp[T](x, a, b: T): T

class:

• dom: class(n: Node): cstring

class=:

• dom: class=(n: Node; v: cstring)

classify:

• math: classify(x: float): FloatClass

ClassList:

• dom: ClassList

clean:

• asyncfutures: clean[T](future: FutureVar[T])

clear:

• atomics: clear(location: var AtomicFlag; order: MemoryOrder = moSequentiallyConsistent)
• deques: clear[T](deq: var Deque[T])
• dom: clear(s: Storage)
• heapqueue: clear[T](heap: var HeapQueue[T])
• httpcore: clear(headers: HttpHeaders)
• jsconsole: clear(console: Console)
• jsformdata: clear(self: FormData)
• jsheaders: clear(self: Headers)
• packedsets: clear[A](result: var PackedSet[A])
• sets: clear[A](s: var HashSet[A])
• sets: clear[A](s: var OrderedSet[A])
• sharedlist: clear[A](t: var SharedList[A])
• stats: clear(r: var RunningRegress)
• stats: clear(s: var RunningStat)
• strtabs: clear(s: StringTableRef)
• strtabs: clear(s: StringTableRef; mode: StringTableMode)
• tables: clear[A](t: var CountTable[A])
• tables: clear[A](t: CountTableRef[A])
• tables: clear[A, B](t: var OrderedTable[A, B])
• tables: clear[A, B](t: OrderedTableRef[A, B])
• tables: clear[A, B](t: var Table[A, B])
• tables: clear[A, B](t: TableRef[A, B])
• xmltree: clear(n: var XmlNode)

clearBit:

• bitops: clearBit[T: SomeInteger](v: var T; bit: BitsRange[T])

clearBits:

• bitops: clearBits(v: typed; bits: varargs[typed]): untyped

clearCallbacks:

• asyncfutures: clearCallbacks(future: FutureBase)

clearData:

• dom: clearData(dt: DataTransfer; format: cstring)

clearInterval:

• dom: clearInterval(i: Interval)
• dom: clearInterval(w: Window; interval: Interval)

clearMask:

• bitops: clearMask[T: SomeInteger](v: var T; slice: Slice[int])
• bitops: clearMask[T: SomeInteger](v: var T; mask: T)

clearMasked:

• bitops: clearMasked[T: SomeInteger](v: T; slice: Slice[int]): T
• bitops: clearMasked[T: SomeInteger](v, mask: T): T

clearScreen:

• linenoise: clearScreen()

clearTimeout:

• dom: clearTimeout(t: TimeOut)
• dom: clearTimeout(w: Window; timeout: TimeOut)

click:

• dom: click(e: Element)

clientData:

• xmltree: clientData(n: XmlNode): int

clientData=:

• xmltree: clientData=(n: XmlNode; data: int)

clientGetPskFunc:

• net: clientGetPskFunc(ctx: SslContext): SslClientGetPskFunc

clientGetPskFunc=:

• net: clientGetPskFunc=(ctx: SslContext; fun: SslClientGetPskFunc)

clientHeight:

• dom: clientHeight(): int

clientWidth:

• dom: clientWidth(): int

ClipboardEvent:

• dom: ClipboardEvent

clone:

• jsfetch: clone(self: Response | Request): Response

cloneNode:

• dom: cloneNode(n: Node; copyContent: bool): Node

clong:

• system: clong

clongdouble:

• system: clongdouble

c_longjmp:

• segfaults: c_longjmp(jmpb: C_JmpBuf; retval: cint)

clonglong:

• system: clonglong

close:

• asyncdispatch: close(ev: AsyncEvent)
• asyncfile: close(f: AsyncFile)
• asynchttpserver: close(server: AsyncHttpServer)
• asyncnet: close(socket: AsyncSocket)
• channels_builtin: close*[TMsg](c: var Channel[TMsg])
• db_mysql: close(db: DbConn)
• db_odbc: close(db: var DbConn)
• db_postgres: close(db: DbConn)
• db_sqlite: close(db: DbConn)
• dom: close(w: Window)
• encodings: close(c: EncodingConverter)
• httpclient: close(client: HttpClient | AsyncHttpClient)
• io: close(f: File)
• lexbase: close(L: var BaseLexer)
• memfiles: close(f: var MemFile)
• nativesockets: close(socket: SocketHandle)
• net: close(socket: Socket; flags = {SafeDisconn})
• osproc: close(p: Process)
• parsecfg: close(c: var CfgParser)
• parsecsv: close(self: var CsvParser)
• parsejson: close(my: var JsonParser)
• parsexml: close(my: var XmlParser)
• selectors: close(ev: SelectEvent)
• selectors: close[T](s: Selector[T])
• sexp: close(my: var SexpParser)
• smtp: close(smtp: AsyncSmtp): owned(Future[void])
• smtp: close(smtp: Smtp)
• streams: close(s: Stream)
• unittest: close(formatter: JUnitOutputFormatter)

closeHandle:

• winlean: closeHandle(hObject: Handle): WINBOOL

closeSocket:

• asyncdispatch: closeSocket(socket: AsyncFD)

closesocket:

• winlean: closesocket(s: SocketHandle): cint

closureScope:

• system: closureScope(body: untyped): untyped

clz32:

• jscore: clz32(m: MathLib; f: SomeInteger): int

c_malloc:

• segfaults: c_malloc(size: csize_t): pointer

cmdArgument:

• CmdLineKind.cmdArgument

cmdEnd:

• CmdLineKind.cmdEnd

CmdLineKind:

• parseopt: CmdLineKind

cmdLineRest:

• parseopt: cmdLineRest(p: OptParser): string

cmdLongOption:

• CmdLineKind.cmdLongOption

cmdShortOption:

• CmdLineKind.cmdShortOption

c_memchr:

• segfaults: c_memchr(s: pointer; c: cint; n: csize_t): pointer

c_memcmp:

• segfaults: c_memcmp(a, b: pointer; size: csize_t): cint

c_memcpy:

• segfaults: c_memcpy(a, b: pointer; size: csize_t): pointer

c_memmove:

• segfaults: c_memmove(a, b: pointer; size: csize_t): pointer

c_memset:

• segfaults: c_memset(p: pointer; value: cint; size: csize_t): pointer

cmp:

• rationals: cmp(x, y: Rational): int
• system: cmp(x, y: string): int
• system: cmp[T](x, y: T): int

cmpic:

• nimscript: cmpic(a, b: string): int

cmpIgnoreCase:

• cstrutils: cmpIgnoreCase(a, b: cstring): int
• strutils: cmpIgnoreCase(a, b: string): int

cmpIgnoreCaseImpl:

• strimpl: cmpIgnoreCaseImpl[T: string | cstring](a, b: T; firstCharCaseSensitive: static bool = false)

cmpIgnoreStyle:

• cstrutils: cmpIgnoreStyle(a, b: cstring): int
• strutils: cmpIgnoreStyle(a, b: string): int

cmpIgnoreStyleImpl:

• strimpl: cmpIgnoreStyleImpl[T: string | cstring](a, b: T; firstCharCaseSensitive: static bool = false)

cmpMem:

• system: cmpMem(a, b: pointer; size: Natural): int

cmpNimIdentifier:

• strimpl: cmpNimIdentifier[T: string | cstring](a, b: T): int

cmpPaths:

• os: cmpPaths(pathA, pathB: string): int

cmpRunesIgnoreCase:

• unicode: cmpRunesIgnoreCase(a, b: string): int

code:

• htmlgen: code(e: varargs[untyped]): untyped
• httpclient: code(response: Response | AsyncResponse): HttpCode

codePageToName:

• encodings: codePageToName(c: CodePage): string

col:

• htmlgen: col(e: varargs[untyped]): untyped
• pegs: col(nt: NonTerminal): int

colAliceBlue:

• colors: colAliceBlue

colAntiqueWhite:

• colors: colAntiqueWhite

colAqua:

• colors: colAqua

colAquamarine:

• colors: colAquamarine

colAzure:

• colors: colAzure

colBeige:

• colors: colBeige

colBisque:

• colors: colBisque

colBlack:

• colors: colBlack

colBlanchedAlmond:

• colors: colBlanchedAlmond

colBlue:

• colors: colBlue

colBlueViolet:

• colors: colBlueViolet

colBrown:

• colors: colBrown

colBurlyWood:

• colors: colBurlyWood

colCadetBlue:

• colors: colCadetBlue

colChartreuse:

• colors: colChartreuse

colChocolate:

• colors: colChocolate

colCoral:

• colors: colCoral

colCornflowerBlue:

• colors: colCornflowerBlue

colCornsilk:

• colors: colCornsilk

colCrimson:

• colors: colCrimson

colCyan:

• colors: colCyan

colDarkBlue:

• colors: colDarkBlue

colDarkCyan:

• colors: colDarkCyan

colDarkGoldenRod:

• colors: colDarkGoldenRod

colDarkGray:

• colors: colDarkGray

colDarkGreen:

• colors: colDarkGreen

colDarkKhaki:

• colors: colDarkKhaki

colDarkMagenta:

• colors: colDarkMagenta

colDarkOliveGreen:

• colors: colDarkOliveGreen

colDarkorange:

• colors: colDarkorange

colDarkOrchid:

• colors: colDarkOrchid

colDarkRed:

• colors: colDarkRed

colDarkSalmon:

• colors: colDarkSalmon

colDarkSeaGreen:

• colors: colDarkSeaGreen

colDarkSlateBlue:

• colors: colDarkSlateBlue

colDarkSlateGray:

• colors: colDarkSlateGray

colDarkTurquoise:

• colors: colDarkTurquoise

colDarkViolet:

• colors: colDarkViolet

colDeepPink:

• colors: colDeepPink

colDeepSkyBlue:

• colors: colDeepSkyBlue

colDimGray:

• colors: colDimGray

colDodgerBlue:

• colors: colDodgerBlue

colFireBrick:

• colors: colFireBrick

colFloralWhite:

• colors: colFloralWhite

colForestGreen:

• colors: colForestGreen

colFuchsia:

• colors: colFuchsia

colGainsboro:

• colors: colGainsboro

colGhostWhite:

• colors: colGhostWhite

colGold:

• colors: colGold

colGoldenRod:

• colors: colGoldenRod

colGray:

• colors: colGray

colGreen:

• colors: colGreen

colGreenYellow:

• colors: colGreenYellow

colgroup:

• htmlgen: colgroup(e: varargs[untyped]): untyped

colHoneyDew:

• colors: colHoneyDew

colHotPink:

• colors: colHotPink

colIndianRed:

• colors: colIndianRed

colIndigo:

• colors: colIndigo

colIvory:

• colors: colIvory

colKhaki:

• colors: colKhaki

colLavender:

• colors: colLavender

colLavenderBlush:

• colors: colLavenderBlush

colLawnGreen:

• colors: colLawnGreen

collect:

• sugar: collect(body: untyped): untyped
• sugar: collect(init, body: untyped): untyped

colLemonChiffon:

• colors: colLemonChiffon

colLightBlue:

• colors: colLightBlue

colLightCoral:

• colors: colLightCoral

colLightCyan:

• colors: colLightCyan

colLightGoldenRodYellow:

• colors: colLightGoldenRodYellow

colLightGreen:

• colors: colLightGreen

colLightGrey:

• colors: colLightGrey

colLightPink:

• colors: colLightPink

colLightSalmon:

• colors: colLightSalmon

colLightSeaGreen:

• colors: colLightSeaGreen

colLightSkyBlue:

• colors: colLightSkyBlue

colLightSlateGray:

• colors: colLightSlateGray

colLightSteelBlue:

• colors: colLightSteelBlue

colLightYellow:

• colors: colLightYellow

colLime:

• colors: colLime

colLimeGreen:

• colors: colLimeGreen

colLinen:

• colors: colLinen

colMagenta:

• colors: colMagenta

colMaroon:

• colors: colMaroon

colMediumAquaMarine:

• colors: colMediumAquaMarine

colMediumBlue:

• colors: colMediumBlue

colMediumOrchid:

• colors: colMediumOrchid

colMediumPurple:

• colors: colMediumPurple

colMediumSeaGreen:

• colors: colMediumSeaGreen

colMediumSlateBlue:

• colors: colMediumSlateBlue

colMediumSpringGreen:

• colors: colMediumSpringGreen

colMediumTurquoise:

• colors: colMediumTurquoise

colMediumVioletRed:

• colors: colMediumVioletRed

colMidnightBlue:

• colors: colMidnightBlue

colMintCream:

• colors: colMintCream

colMistyRose:

• colors: colMistyRose

colMoccasin:

• colors: colMoccasin

colNavajoWhite:

• colors: colNavajoWhite

colNavy:

• colors: colNavy

colOldLace:

• colors: colOldLace

colOlive:

• colors: colOlive

colOliveDrab:

• colors: colOliveDrab

Color:

• colors: Color

colOrange:

• colors: colOrange

colOrangeRed:

• colors: colOrangeRed

colOrchid:

• colors: colOrchid

colPaleGoldenRod:

• colors: colPaleGoldenRod

colPaleGreen:

• colors: colPaleGreen

colPaleTurquoise:

• colors: colPaleTurquoise

colPaleVioletRed:

• colors: colPaleVioletRed

colPapayaWhip:

• colors: colPapayaWhip

colPeachPuff:

• colors: colPeachPuff

colPeru:

• colors: colPeru

colPink:

• colors: colPink

colPlum:

• colors: colPlum

colPowderBlue:

• colors: colPowderBlue

colPurple:

• colors: colPurple

colRed:

• colors: colRed

colRosyBrown:

• colors: colRosyBrown

colRoyalBlue:

• colors: colRoyalBlue

colSaddleBrown:

• colors: colSaddleBrown

colSalmon:

• colors: colSalmon

colSandyBrown:

• colors: colSandyBrown

colSeaGreen:

• colors: colSeaGreen

colSeaShell:

• colors: colSeaShell

colSienna:

• colors: colSienna

colSilver:

• colors: colSilver

colSkyBlue:

• colors: colSkyBlue

colSlateBlue:

• colors: colSlateBlue

colSlateGray:

• colors: colSlateGray

colSnow:

• colors: colSnow

colSpringGreen:

• colors: colSpringGreen

colSteelBlue:

• colors: colSteelBlue

colTan:

• colors: colTan

colTeal:

• colors: colTeal

colThistle:

• colors: colThistle

colTomato:

• colors: colTomato

colTurquoise:

• colors: colTurquoise

colViolet:

• colors: colViolet

colWheat:

• colors: colWheat

colWhite:

• colors: colWhite

colWhiteSmoke:

• colors: colWhiteSmoke

colYellow:

• colors: colYellow

colYellowGreen:

• colors: colYellowGreen

combine:

• uri: combine(base: Uri; reference: Uri): Uri
• uri: combine(uris: varargs[Uri]): Uri

comma separated value:

• Module parsecsv

command line:

• Module os

command line argument:

• Module os

command line arguments:

• Module os

commandLineParams:

• os: commandLineParams(): seq[string]

CommentNode:

• NodeType.CommentNode

commitedLen:

• reservedmem: commitedLen(m: ReservedMem): int
• reservedmem: commitedLen[T](s: ReservedMemSeq[T]): int

commitHead:

• gitutils: commitHead

commonAttr:

• htmlgen: commonAttr

commonPrefixLen:

• critbits: commonPrefixLen[T](c: CritBitTree[T]): int

compareDocumentPosition:

• dom: compareDocumentPosition(n: Node; otherNode: Node): int

compareExchange:

• atomics: compareExchange[T](location: var Atomic[T]; expected: var T; desired: T; order: MemoryOrder = moSequentiallyConsistent): bool
• atomics: compareExchange[T](location: var Atomic[T]; expected: var T; desired: T; success, failure: MemoryOrder): bool

compareExchangeWeak:

• atomics: compareExchangeWeak[T](location: var Atomic[T]; expected: var T; desired: T; order: MemoryOrder = moSequentiallyConsistent): bool
• atomics: compareExchangeWeak[T](location: var Atomic[T]; expected: var T; desired: T; success, failure: MemoryOrder): bool

compile:

• jsre: compile(self: RegExp; pattern: cstring; flags: cstring)

CompileDate:

• system: CompileDate

compileOption:

• system: compileOption(option: string): bool
• system: compileOption(option, arg: string): bool

compiles:

• system: compiles(x: untyped): bool

CompileTime:

• system: CompileTime

complement:

• setutils: complement[T](s: set[T]): set[T]

complete:

• asyncfutures: complete[T](future: Future[T]; val: T)
• asyncfutures: complete(future: Future[void]; val = Future[void].default)
• asyncfutures: complete[T](future: FutureVar[T])
• asyncfutures: complete[T](future: FutureVar[T]; val: T)
• asyncstreams: complete[T](future: FutureStream[T])

CompletionCallback:

• linenoise: CompletionCallback

CompletionData:

• asyncdispatch: CompletionData

Completions:

• linenoise: Completions

Complex:

• complex: Complex

complex:

• complex: complex[T: SomeFloat](re: T; im: T = 0.0): Complex[T]

Complex32:

• complex: Complex32

complex32:

• complex: complex32(re: float32; im: float32 = 0.0): Complex32

Complex64:

• complex: Complex64

complex64:

• complex: complex64(re: float64; im: float64 = 0.0): Complex64

concat:

• sequtils: concat[T](seqs: varargs[seq[T]]): seq[T]

Cond:

• locks: Cond

Config:

• parsecfg: Config

confirm:

• dom: confirm(w: Window; msg: cstring): bool

conjugate:

• complex: conjugate[T](z: Complex[T]): Complex[T]

connect:

• asyncdispatch: connect(socket: AsyncFD; address: string; port: Port; domain = Domain.AF_INET): owned( Future[void])
• asyncftpclient: connect(ftp: AsyncFtpClient): owned(Future[void])
• asyncnet: connect(socket: AsyncSocket; address: string; port: Port): owned( Future[void])
• net: connect(socket: Socket; address: string; port = Port(0))
• net: connect(socket: Socket; address: string; port = Port(0); timeout: int)
• smtp: connect(smtp: AsyncSmtp; address: string; port: Port): owned(Future[void])
• smtp: connect(smtp: Smtp; address: string; port: Port)
• winlean: connect(s: SocketHandle; name: ptr SockAddr; namelen: SockLen): cint

connectUnix:

• asyncnet: connectUnix(socket: AsyncSocket; path: string): owned(Future[void])
• net: connectUnix(socket: Socket; path: string)

Console:

• jsconsole: Console

console:

• jsconsole: console

ConsoleLogger:

• logging: ConsoleLogger

ConsoleOutputFormatter:

• unittest: ConsoleOutputFormatter

contains:

• asyncdispatch: contains(disp: PDispatcher; fd: AsyncFD): bool
• critbits: contains[T](c: CritBitTree[T]; key: string): bool
• deques: contains[T](deq: Deque[T]; item: T): bool
• dom: contains(c: ClassList; class: cstring): bool
• dom: contains(n: Node): bool
• httpcore: contains(values: HttpHeaderValues; value: string): bool
• httpcore: contains(methods: set[HttpMethod]; x: string): bool
• json: contains(node: JsonNode; val: JsonNode): bool
• json: contains(node: JsonNode; key: string): bool
• jsre: contains(pattern: cstring; self: RegExp): bool
• lists: contains[T](L: SomeLinkedCollection[T]; value: T): bool
• nre: contains(pattern: CaptureBounds; i: int): bool
• nre: contains(pattern: CaptureBounds; name: string): bool
• nre: contains(pattern: Captures; i: int): bool
• nre: contains(pattern: Captures; name: string): bool
• nre: contains(str: string; pattern: Regex; start = 0; endpos = int.high): bool
• packedsets: contains[A](s: PackedSet[A]; key: A): bool
• pegs: contains(s: string; pattern: Peg; start = 0): bool
• pegs: contains(s: string; pattern: Peg; matches: var openArray[string]; start = 0): bool
• re: contains(s: string; pattern: Regex; start = 0): bool
• re: contains(s: string; pattern: Regex; matches: var openArray[string]; start = 0): bool
• selectors: contains[T](s: Selector[T]; fd: SocketHandle | int): bool
• sets: contains[A](s: HashSet[A]; key: A): bool
• sets: contains[A](s: OrderedSet[A]; key: A): bool
• strtabs: contains(t: StringTableRef; key: string): bool
• strutils: contains(s: string; chars: set[char]): bool
• strutils: contains(s, sub: string): bool
• system: contains[U, V, W](s: HSlice[U, V]; value: W): bool
• system: contains[T](a: openArray[T]; item: T): bool
• system: contains[T](x: set[T]; y: T): bool
• tables: contains[A](t: CountTable[A]; key: A): bool
• tables: contains[A](t: CountTableRef[A]; key: A): bool
• tables: contains[A, B](t: OrderedTable[A, B]; key: A): bool
• tables: contains[A, B](t: OrderedTableRef[A, B]; key: A): bool
• tables: contains[A, B](t: Table[A, B]; key: A): bool
• tables: contains[A, B](t: TableRef[A, B]; key: A): bool

containsOrIncl:

• critbits: containsOrIncl[T](c: var CritBitTree[T]; key: string; val: T): bool
• critbits: containsOrIncl(c: var CritBitTree[void]; key: string): bool
• packedsets: containsOrIncl[A](s: var PackedSet[A]; key: A): bool
• sets: containsOrIncl[A](s: var HashSet[A]; key: A): bool
• sets: containsOrIncl[A](s: var OrderedSet[A]; key: A): bool

contentLength:

• httpclient: contentLength(response: Response | AsyncResponse): int

contentType:

• httpclient: contentType(response: Response | AsyncResponse): string

continuesWith:

• strutils: continuesWith(s, substr: string; start: Natural): bool

convert:

• encodings: convert(c: EncodingConverter; s: string): string
• encodings: convert(s: string; destEncoding = "UTF-8"; srcEncoding = "CP1252"): string
• times: convert[T: SomeInteger](unitFrom, unitTo: FixedTimeUnit; quantity: T): T

convertSexp:

• sexp: convertSexp(x: untyped): untyped

ConvertThreadToFiber:

• winlean: ConvertThreadToFiber(param: pointer): pointer

ConvertThreadToFiberEx:

• winlean: ConvertThreadToFiberEx(param: pointer; flags: int32): pointer

copy:

• json: copy(p: JsonNode): JsonNode
• lists: copy[T](a: DoublyLinkedList[T]): DoublyLinkedList[T]
• lists: copy[T](a: SinglyLinkedList[T]): SinglyLinkedList[T]
• macros: copy(node: NimNode): NimNode
• sexp: copy(p: SexpNode): SexpNode

copyChildrenTo:

• macros: copyChildrenTo(src, dest: NimNode)

copyDir:

• os: copyDir(source, dest: string)

copyDirWithPermissions:

• os: copyDirWithPermissions(source, dest: string; ignorePermissionErrors = true)

copyFile:

• os: copyFile(source, dest: string; options = {cfSymlinkFollow})

copyFileToDir:

• os: copyFileToDir(source, dir: string; options = {cfSymlinkFollow})

copyFileW:

• winlean: copyFileW(lpExistingFileName, lpNewFileName: WideCString; bFailIfExists: WINBOOL): WINBOOL

copyFileWithPermissions:

• os: copyFileWithPermissions(source, dest: string; ignorePermissionErrors = true; options = {cfSymlinkFollow})

CopyFlag:

• os: CopyFlag

copyLineInfo:

• macros: copyLineInfo(arg: NimNode; info: NimNode)

copyMem:

• system: copyMem(dest, source: pointer; size: Natural)
• Module typetraits

copyNimNode:

• macros: copyNimNode(n: NimNode): NimNode

copyNimTree:

• macros: copyNimTree(n: NimNode): NimNode

copySign:

• math: copySign[T: SomeFloat](x, y: T): T

copyWithin:

• jscore: copyWithin[T](self: openArray[T]; target: int): seq[T]
• jscore: copyWithin[T](self: openArray[T]; target, start: int): seq[T]
• jscore: copyWithin[T](self: openArray[T]; target, start, ends: int): seq[T]

coreAttr:

• htmlgen: coreAttr

CoroutineRef:

• coro: CoroutineRef

correlation:

• stats: correlation(r: RunningRegress): float

cos:

• complex: cos[T](z: Complex[T]): Complex[T]
• jscore: cos(m: MathLib; a: SomeNumber): float
• math: cos(x: float32): float32
• math: cos(x: float64): float64

cosh:

• complex: cosh[T](z: Complex[T]): Complex[T]
• jscore: cosh(m: MathLib; a: SomeNumber): float
• math: cosh(x: float32): float32
• math: cosh(x: float64): float64

cot:

• complex: cot[T](z: Complex[T]): Complex[T]
• math: cot[T: float32 | float64](x: T): T

coth:

• complex: coth[T](z: Complex[T]): Complex[T]
• math: coth[T: float32 | float64](x: T): T

count:

• jsconsole: count(console: Console; label = "".cstring)
• sequtils: count[T](s: openArray[T]; x: T): int
• strutils: count(s: string; sub: char): int
• strutils: count(s: string; subs: set[char]): int
• strutils: count(s: string; sub: string; overlapping: bool = false): int

countdown:

• system: countdown[T](a, b: T; step: Positive = 1): T

countIt:

• sequtils: countIt(s, pred: untyped): int

countLeadingZeroBits:

• bitops: countLeadingZeroBits(x: SomeInteger): int

countLines:

• strutils: countLines(s: string): int

countProcessors:

• cpuinfo: countProcessors(): int
• osproc: countProcessors(): int

countReset:

• jsconsole: countReset(console: Console; label = "".cstring)

countSetBits:

• bitops: countSetBits(x: SomeInteger): int

CountTable:

• tables: CountTable

CountTableRef:

• tables: CountTableRef

countTrailingZeroBits:

• bitops: countTrailingZeroBits(x: SomeInteger): int

countup:

• system: countup[T](a, b: T; step: Positive = 1): T

cpDir:

• nimscript: cpDir(from, to: string)

cpFile:

• nimscript: cpFile(from, to: string)

cppDefine:

• nimscript: cppDefine(define: string)

c_printf:

• segfaults: c_printf(frmt: cstring): cint

CPU:

• Module threads

cpuEndian:

• system: cpuEndian

cpuRelax:

• system: cpuRelax()

cpuTime:

• times: cpuTime(): float

c_raise:

• segfaults: c_raise(sign: cint): cint

c_realloc:

• segfaults: c_realloc(p: pointer; newsize: csize_t): pointer

create:

• system: create(T: typedesc; size = 1.Positive): ptr T:type

CREATE_ALWAYS:

• winlean: CREATE_ALWAYS

createAsyncNativeSocket:

• asyncdispatch: createAsyncNativeSocket(domain: cint; sockType: cint; protocol: cint; inheritable = defined(nimInheritHandles)): AsyncFD
• asyncdispatch: createAsyncNativeSocket(domain: Domain = Domain.AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP; inheritable = defined(nimInheritHandles)): AsyncFD

createAttribute:

• dom: createAttribute(d: Document; identifier: cstring): Node

createComment:

• dom: createComment(d: Document; data: cstring): Node

createDir:

• asyncftpclient: createDir(ftp: AsyncFtpClient; dir: string; recursive = false): owned( Future[void])
• os: createDir(dir: string)

createDirectoryW:

• winlean: createDirectoryW(pathName: WideCString; security: pointer = nil): int32

createElement:

• dom: createElement(d: Document; identifier: cstring): Element

createElementNS:

• dom: createElementNS(d: Document; namespaceURI, qualifiedIdentifier: cstring): Element

createEvent:

• winlean: createEvent(lpEventAttributes: ptr SECURITY_ATTRIBUTES; bManualReset: DWORD; bInitialState: DWORD; lpName: ptr Utf16Char): Handle

CreateFiber:

• winlean: CreateFiber(stackSize: int; fn: LPFIBER_START_ROUTINE; param: pointer): pointer

CreateFiberEx:

• winlean: CreateFiberEx(stkCommit: int; stkReserve: int; flags: int32; fn: LPFIBER_START_ROUTINE; param: pointer): pointer

createFileA:

• winlean: createFileA(lpFileName: cstring; dwDesiredAccess, dwShareMode: DWORD; lpSecurityAttributes: pointer; dwCreationDisposition, dwFlagsAndAttributes: DWORD; hTemplateFile: Handle): Handle

createFileMappingW:

• winlean: createFileMappingW(hFile: Handle; lpFileMappingAttributes: pointer; flProtect, dwMaximumSizeHigh: DWORD; dwMaximumSizeLow: DWORD; lpName: pointer): Handle

createFileW:

• winlean: createFileW(lpFileName: WideCString; dwDesiredAccess, dwShareMode: DWORD; lpSecurityAttributes: pointer; dwCreationDisposition, dwFlagsAndAttributes: DWORD; hTemplateFile: Handle): Handle

createHardlink:

• os: createHardlink(src, dest: string)

createHardLinkW:

• winlean: createHardLinkW(lpFileName, lpExistingFileName: WideCString; security: pointer = nil): int32

createIoCompletionPort:

• winlean: createIoCompletionPort(FileHandle: Handle; ExistingCompletionPort: Handle; CompletionKey: ULONG_PTR; NumberOfConcurrentThreads: DWORD): Handle

createMessage:

• smtp: createMessage(mSubject, mBody: string; mTo, mCc: seq[string] = @[]): Message
• smtp: createMessage(mSubject, mBody: string; mTo, mCc: seq[string]; otherHeaders: openArray[tuple[name, value: string]]): Message

createNamedPipe:

• winlean: createNamedPipe(lpName: WideCString; dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut: int32; lpSecurityAttributes: ptr SECURITY_ATTRIBUTES): Handle

createNativeSocket:

• nativesockets: createNativeSocket(domain: cint; sockType: cint; protocol: cint; inheritable: bool = defined(nimInheritHandles)): SocketHandle
• nativesockets: createNativeSocket(domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP; inheritable: bool = defined(nimInheritHandles)): SocketHandle

CREATE_NEW:

• winlean: CREATE_NEW

CREATE_NO_WINDOW:

• winlean: CREATE_NO_WINDOW

createPipe:

• winlean: createPipe(hReadPipe, hWritePipe: var Handle; lpPipeAttributes: var SECURITY_ATTRIBUTES; nSize: int32): WINBOOL

createProcessW:

• winlean: createProcessW(lpApplicationName, lpCommandLine: WideCString; lpProcessAttributes: ptr SECURITY_ATTRIBUTES; lpThreadAttributes: ptr SECURITY_ATTRIBUTES; bInheritHandles: WINBOOL; dwCreationFlags: int32; lpEnvironment, lpCurrentDirectory: WideCString; lpStartupInfo: var STARTUPINFO; lpProcessInformation: var PROCESS_INFORMATION): WINBOOL

createShared:

• system: createShared(T: typedesc; size = 1.Positive): ptr T:type

createSharedU:

• system: createSharedU(T: typedesc; size = 1.Positive): ptr T:type

createSymbolicLinkW:

• winlean: createSymbolicLinkW(lpSymlinkFileName, lpTargetFileName: WideCString; flags: DWORD): int32

createSymlink:

• os: createSymlink(src, dest: string)

createTempDir:

• tempfiles: createTempDir(prefix, suffix: string; dir = ""): string

createTempFile:

• tempfiles: createTempFile(prefix, suffix: string; dir = ""): tuple[cfile: File, path: string]

createTextNode:

• dom: createTextNode(d: Document; identifier: cstring): Node

createThread:

• threads: createThread*[TArg](t: var Thread[TArg]; tp: proc (arg: TArg) {.thread, nimcall.}; param: TArg)
• threads: createThread*(t: var Thread[void]; tp: proc () {.thread, nimcall.})

createU:

• system: createU(T: typedesc; size = 1.Positive): ptr T:type

CREATE_UNICODE_ENVIRONMENT:

• winlean: CREATE_UNICODE_ENVIRONMENT

crit bit tree:

• Module critbits

CritBitTree:

• critbits: CritBitTree

csc:

• complex: csc[T](z: Complex[T]): Complex[T]
• math: csc[T: float32 | float64](x: T): T

csch:

• complex: csch[T](z: Complex[T]): Complex[T]
• math: csch[T: float32 | float64](x: T): T

cschar:

• system: cschar

c_setjmp:

• segfaults: c_setjmp(jmpb: C_JmpBuf): cint

cshort:

• system: cshort

c_signal:

• segfaults: c_signal(sign: cint; handler: CSighandlerT): CSighandlerT

csize:

• system: csize

csize_t:

• system: csize_t

c_sprintf:

• segfaults: c_sprintf(buf, frmt: cstring): cint

cstderr:

• segfaults: cstderr

cstdin:

• segfaults: cstdin

cstdout:

• segfaults: cstdout

c_strcmp:

• segfaults: c_strcmp(a, b: cstring): cint

cstring:

• system: cstring

cstringArray:

• system: cstringArray

cstringArrayToSeq:

• system: cstringArrayToSeq(a: cstringArray): seq[string]
• system: cstringArrayToSeq(a: cstringArray; len: Natural): seq[string]

c_strlen:

• segfaults: c_strlen(a: cstring): csize_t

CSV:

• Module parsecsv

CsvError:

• parsecsv: CsvError

CsvParser:

• parsecsv: CsvParser

CsvRow:

• parsecsv: CsvRow

cuchar:

• system: cuchar

cuint:

• system: cuint

culong:

• system: culong

culonglong:

• system: culonglong

cumsum:

• math: cumsum[T](x: var openArray[T])

cumsummed:

• math: cumsummed[T](x: openArray[T]): seq[T]

CurDir:

• os: CurDir

current working directory:

• Module os
• Module os

currentSourcePath:

• system: currentSourcePath(): string

cursorBackward:

• terminal: cursorBackward(f: File; count = 1)
• terminal: cursorBackward(count = 1)

cursorDown:

• terminal: cursorDown(f: File; count = 1)
• terminal: cursorDown(count = 1)

cursorForward:

• terminal: cursorForward(f: File; count = 1)
• terminal: cursorForward(count = 1)

cursorUp:

• terminal: cursorUp(f: File; count = 1)
• terminal: cursorUp(count = 1)

cushort:

• system: cushort

CustomRef:

• asyncdispatch: CustomRef

cut:

• Module system

CVerifyNone:

• SslCVerifyMode.CVerifyNone

CVerifyPeer:

• SslCVerifyMode.CVerifyPeer

CVerifyPeerUseEnvVars:

• SslCVerifyMode.CVerifyPeerUseEnvVars

cycle:

• sequtils: cycle[T](s: openArray[T]; n: Natural): seq[T]

data:

• htmlgen: data(e: varargs[untyped]): untyped

datalist:

• htmlgen: datalist(e: varargs[untyped]): untyped

DataTransfer:

• dom: DataTransfer

DataTransferDropEffect:

• dom: DataTransferDropEffect

DataTransferEffectAllowed:

• dom: DataTransferEffectAllowed

DataTransferItem:

• dom: DataTransferItem

DataTransferItemKind:

• dom: DataTransferItemKind

Date:

• jscore: Date

DateLib:

• jscore: DateLib

DateTime:

• jscore: DateTime
• times: DateTime

dateTime:

• times: dateTime(year: int; month: Month; monthday: MonthdayRange; hour: HourRange = 0; minute: MinuteRange = 0; second: SecondRange = 0; nanosecond: NanosecondRange = 0; zone: Timezone = local()): DateTime

DateTimeLocale:

• times: DateTimeLocale

Days:

• TimeUnit.Days

days:

• times: days(d: int): TimeInterval

dbArray:

• DbTypeKind.dbArray

dbBindParamError:

• db_sqlite: dbBindParamError(paramIdx: int; val: varargs[untyped])

dbBit:

• DbTypeKind.dbBit

dbBlob:

• DbTypeKind.dbBlob

dbBool:

• DbTypeKind.dbBool

dbBox:

• DbTypeKind.dbBox

dbCircle:

• DbTypeKind.dbCircle

DbColumn:

• db_common: DbColumn

DbColumns:

• db_common: DbColumns

dbComposite:

• DbTypeKind.dbComposite

DbConn:

• db_mysql: DbConn
• db_odbc: DbConn
• db_postgres: DbConn
• db_sqlite: DbConn

dbDate:

• DbTypeKind.dbDate

dbDatetime:

• DbTypeKind.dbDatetime

dbDecimal:

• DbTypeKind.dbDecimal

DbEffect:

• db_common: DbEffect

dbEnum:

• DbTypeKind.dbEnum

DbError:

• db_common: DbError

dbError:

• db_common: dbError(msg: string)
• db_mysql: dbError(db: DbConn)
• db_odbc: dbError(db: var DbConn)
• db_postgres: dbError(db: DbConn)
• db_sqlite: dbError(db: DbConn)

dbFixedChar:

• DbTypeKind.dbFixedChar

dbFloat:

• DbTypeKind.dbFloat

dbFormatImpl:

• dbutils: dbFormatImpl(formatstr: SqlQuery; dbQuote: proc (s: string): string; args: varargs[string]): string

dbGeometry:

• DbTypeKind.dbGeometry

dbInet:

• DbTypeKind.dbInet

dbInt:

• DbTypeKind.dbInt

dbJson:

• DbTypeKind.dbJson

dbLine:

• DbTypeKind.dbLine

dbLseg:

• DbTypeKind.dbLseg

dbMacAddress:

• DbTypeKind.dbMacAddress

dbNull:

• DbTypeKind.dbNull

dbPath:

• DbTypeKind.dbPath

dbPoint:

• DbTypeKind.dbPoint

dbPolygon:

• DbTypeKind.dbPolygon

dbQuote:

• db_mysql: dbQuote(s: string): string
• db_odbc: dbQuote(s: string): string
• db_postgres: dbQuote(s: string): string
• db_sqlite: dbQuote(s: string): string

dbSerial:

• DbTypeKind.dbSerial

dbSet:

• DbTypeKind.dbSet

dbTime:

• DbTypeKind.dbTime

dbTimeInterval:

• DbTypeKind.dbTimeInterval

dbTimestamp:

• DbTypeKind.dbTimestamp

DbType:

• db_common: DbType

DbTypeKind:

• db_common: DbTypeKind

dbUInt:

• DbTypeKind.dbUInt

dbUnknown:

• DbTypeKind.dbUnknown

dbUrl:

• DbTypeKind.dbUrl

dbUser1:

• DbTypeKind.dbUser1

dbUser2:

• DbTypeKind.dbUser2

dbUser3:

• DbTypeKind.dbUser3

dbUser4:

• DbTypeKind.dbUser4

dbUser5:

• DbTypeKind.dbUser5

dbUuid:

• DbTypeKind.dbUuid

dbVarchar:

• DbTypeKind.dbVarchar

dbXml:

• DbTypeKind.dbXml

dd:

• htmlgen: dd(e: varargs[untyped]): untyped

DeadThreadDefect:

• system: DeadThreadDefect

DeadThreadError:

• system: DeadThreadError

dealloc:

• system: dealloc(p: pointer)

deallocCStringArray:

• system: deallocCStringArray(a: cstringArray)

deallocHeap:

• system: deallocHeap(runFinalizers = true; allowGcAfterwards = true)

deallocImpl:

• system: deallocImpl(p: pointer)

deallocShared:

• system: deallocShared(p: pointer)

deallocSharedImpl:

• system: deallocSharedImpl(p: pointer)

debug:

• jsconsole: debug(console: Console)
• logging: debug(args: varargs[string, `$`])

debugEcho:

• system: debugEcho(x: varargs[typed, `$`])

debugger:

• jscore: debugger()

debugRecv:

• smtp: debugRecv(smtp: AsyncSmtp): Future[string]
• smtp: debugRecv(smtp: Smtp): string

debugSend:

• smtp: debugSend(smtp: AsyncSmtp; cmd: string): owned(Future[void])
• smtp: debugSend(smtp: Smtp; cmd: string)

dec:

• jsbigints: dec(this: var JsBigInt)
• jsbigints: dec(this: var JsBigInt; amount: JsBigInt)
• system: dec[T: Ordinal](x: var T; y = 1)

declared:

• system: declared(x: untyped): bool

declaredInScope:

• system: declaredInScope(x: untyped): bool

decode:

• base64: decode(s: string): string
• punycode: decode(encoded: string): string

decodeData:

• cgi: decodeData(allowedMethods: set[RequestMethod] = {methodNone, methodPost, methodGet}): tuple[key, value: string]
• cgi: decodeData(data: string): tuple[key, value: string]

decodePercent:

• decode_helpers: decodePercent(s: openArray[char]; i: var int): char

decodeQuery:

• uri: decodeQuery(data: string): tuple[key, value: string]

decodeURI:

• dom: decodeURI(uri: cstring): cstring

decodeURIComponent:

• dom: decodeURIComponent(uri: cstring): cstring

decodeUrl:

• uri: decodeUrl(s: string; decodePlus = true): string

decodeZigzag:

• varints: decodeZigzag(x: uint64): int64

dedent:

• strutils: dedent(s: string; count: Natural = indentation(s)): string

deduplicate:

• sequtils: deduplicate[T](s: openArray[T]; isSorted: bool = false): seq[T]

deepCopy:

• system: deepCopy[T](y: T): T
• system: deepCopy[T](x: var T; y: T)

default:

• system: default[T](_: typedesc[T]): T

defaultConfig:

• rstgen: defaultConfig(): StringTableRef

defaultConsoleFormatter:

• unittest: defaultConsoleFormatter(): ConsoleOutputFormatter

defaultFilename:

• logging: defaultFilename(): string

defaultFmtStr:

• logging: defaultFmtStr

defaultInitialSize:

• deques: defaultInitialSize
• sets: defaultInitialSize
• tables: defaultInitialSize

DefaultLocale:

• times: DefaultLocale

defaultOnProgressChanged:

• asyncftpclient: defaultOnProgressChanged(total, progress: BiggestInt; speed: float): Future[void]

Defect:

• system: Defect

defined:

• system: defined(x: untyped): bool

defUserAgent:

• httpclient: defUserAgent

degToRad:

• math: degToRad[T: float32 | float64](d: T): T

deinitCond:

• locks: deinitCond(cond: var Cond)

deinitGeneralTokenizer:

• highlite: deinitGeneralTokenizer(g: var GeneralTokenizer)

deinitLock:

• locks: deinitLock(lock: var Lock)

deinitRLock:

• rlocks: deinitRLock(lock: var RLock)

deinitSharedList:

• sharedlist: deinitSharedList[A](t: var SharedList[A])

deinitSharedTable:

• sharedtables: deinitSharedTable[A, B](t: var SharedTable[A, B])

del:

• heapqueue: del[T](heap: var HeapQueue[T]; index: Natural)
• htmlgen: del(e: varargs[untyped]): untyped
• httpcore: del(headers: HttpHeaders; key: string)
• macros: del(father: NimNode; idx = 0; n = 1)
• sharedtables: del[A, B](t: var SharedTable[A, B]; key: A)
• strtabs: del(t: StringTableRef; key: string)
• system: del[T](x: var seq[T]; i: Natural)
• tables: del[A](t: var CountTable[A]; key: A)
• tables: del[A](t: CountTableRef[A]; key: A)
• tables: del[A, B](t: var OrderedTable[A, B]; key: A)
• tables: del[A, B](t: OrderedTableRef[A, B]; key: A)
• tables: del[A, B](t: var Table[A, B]; key: A)
• tables: del[A, B](t: TableRef[A, B]; key: A)

delEnv:

• nimscript: delEnv(key: string)
• os: delEnv(key: string)

delete:

• httpclient: delete(client: AsyncHttpClient; url: Uri | string): Future[AsyncResponse]
• httpclient: delete(client: HttpClient; url: Uri | string): Response
• jsformdata: delete(self: FormData; name: cstring)
• jsheaders: delete(self: Headers; key: cstring)
• json: delete(obj: JsonNode; key: string)
• sequtils: delete[T](s: var seq[T]; first, last: Natural)
• sequtils: delete[T](s: var seq[T]; slice: Slice[int])
• strutils: delete(s: var string; first, last: int)
• strutils: delete(s: var string; slice: Slice[int])
• system: delete[T](x: var seq[T]; i: Natural)
• xmltree: delete(n: XmlNode; i: Natural)

deleteContent:

• httpclient: deleteContent(client: AsyncHttpClient; url: Uri | string): Future[string]
• httpclient: deleteContent(client: HttpClient; url: Uri | string): string

deleteData:

• dom: deleteData(n: Node; start, len: int)

DeleteFiber:

• winlean: DeleteFiber(fiber: pointer)

deleteFileA:

• winlean: deleteFileA(pathName: cstring): int32

deleteFileW:

• winlean: deleteFileW(pathName: WideCString): int32

deleteFromDocument:

• dom: deleteFromDocument(s: Selection)

delOutputFormatter:

• unittest: delOutputFormatter(formatter: OutputFormatter)

delSection:

• parsecfg: delSection(dict: var Config; section: string)

delSectionKey:

• parsecfg: delSectionKey(dict: var Config; section, key: string)

Deque:

• deques: Deque

deque:

• Module deques

Descending:

• SortOrder.Descending

description:

• nimscript: description

deserialization:

• Module marshal

destroyContext:

• net: destroyContext(ctx: SslContext)

destructor:

• Module system

DETACHED_PROCESS:

• winlean: DETACHED_PROCESS

details:

• htmlgen: details(e: varargs[untyped]): untyped

detectOs:

• distros: detectOs(d: untyped): bool

DeviceId:

• os: DeviceId

dfn:

• htmlgen: dfn(e: varargs[untyped]): untyped

dFri:

• WeekDay.dFri

dial:

• asyncdispatch: dial(address: string; port: Port; protocol: Protocol = IPPROTO_TCP): owned( Future[AsyncFD])
• asyncnet: dial(address: string; port: Port; protocol = IPPROTO_TCP; buffered = true): owned( Future[AsyncSocket])
• net: dial(address: string; port: Port; protocol = IPPROTO_TCP; buffered = true): owned( Socket)

dialog:

• htmlgen: dialog(e: varargs[untyped]): untyped

dictionary:

• Module tables

diff:

• Module diff

difference:

• packedsets: difference[A](s1, s2: PackedSet[A]): PackedSet[A]
• sets: difference[A](s1, s2: HashSet[A]): HashSet[A]

diffFiles:

• gitutils: diffFiles(path1, path2: string): tuple[output: string, same: bool]

diffInt:

• diff: diffInt(arrayA, arrayB: openArray[int]): seq[Item]

diffStrings:

• gitutils: diffStrings(a, b: string): tuple[output: string, same: bool]

diffText:

• diff: diffText(textA, textB: string): seq[Item]

digits:

• fenv: digits(T: typedesc[float32]): int
• fenv: digits(T: typedesc[float64]): int
• pegs: digits(): Peg

Digits:

• strutils: Digits

dir:

• jsconsole: dir(console: Console; obj: auto)

directory:

• Module os
• Module os

dirExists:

• nimscript: dirExists(dir: string): bool
• os: dirExists(dir: string): bool

DirSep:

• os: DirSep

dirxml:

• jsconsole: dirxml(console: Console; obj: auto)

disableCache:

• ropes: disableCache()

disabled=:

• dom: disabled=(n: Node; v: bool)

disableExternalCapture:

• dom: disableExternalCapture(w: Window)

disableParamFiltering:

• unittest: disableParamFiltering()

disableProfiling:

• nimprof: disableProfiling()

disableTrueColors:

• terminal: disableTrueColors()

disarm:

• system: disarm(x: typed)

disjoint:

• packedsets: disjoint[A](s1, s2: PackedSet[A]): bool
• sets: disjoint[A](s1, s2: HashSet[A]): bool

dispatchEvent:

• dom: dispatchEvent(et: EventTarget; ev: Event)

dispose:

• system: dispose(x: ForeignCell)

distance:

• reservedmem: distance(lhs, rhs: pointer): int

distinctBase:

• typetraits: distinctBase(T: typedesc; recursive: static bool = true): typedesc
• typetraits: distinctBase[T](a: T; recursive: static bool = true): untyped

distribute:

• sequtils: distribute[T](s: seq[T]; num: Positive; spread = true): seq[seq[T]]

Distribution:

• distros: Distribution

DivByZeroDefect:

• system: DivByZeroDefect

DivByZeroError:

• system: DivByZeroError

dl:

• htmlgen: dl(e: varargs[untyped]): untyped

DLL:

• Module os

dMon:

• WeekDay.dMon

doAssert:

• assertions: doAssert(cond: untyped; msg = "")

doAssertRaises:

• assertions: doAssertRaises(exception: typedesc; code: untyped)

doCreateThread:

• ThreadPoolAdvice.doCreateThread

Document:

• dom: Document

document:

• dom: document

DocumentFragmentNode:

• NodeType.DocumentFragmentNode

DocumentNode:

• NodeType.DocumentNode

DocumentOrShadowRoot:

• dom: DocumentOrShadowRoot

DocumentTypeNode:

• NodeType.DocumentTypeNode

Domain:

• nativesockets: Domain

DOMAIN_ALIAS_RID_ADMINS:

• winlean: DOMAIN_ALIAS_RID_ADMINS

DomApiVersion:

• dom: DomApiVersion

DomEvent:

• dom: DomEvent

DomException:

• dom: DomException

DomParser:

• dom: DomParser

doNothing:

• ThreadPoolAdvice.doNothing

doShutdownThread:

• ThreadPoolAdvice.doShutdownThread

doslikeFileSystem:

• os: doslikeFileSystem

DoublyLinkedList:

• lists: DoublyLinkedList

DoublyLinkedNode:

• lists: DoublyLinkedNode

DoublyLinkedNodeObj:

• lists: DoublyLinkedNodeObj

DoublyLinkedRing:

• lists: DoublyLinkedRing

downloadFile:

• httpclient: downloadFile(client: AsyncHttpClient; url: Uri | string; filename: string): Future[ void]
• httpclient: downloadFile(client: HttpClient; url: Uri | string; filename: string)

Drag:

• DragEventTypes.Drag

DragEnd:

• DragEventTypes.DragEnd

DragEnter:

• DragEventTypes.DragEnter

DragEvent:

• dom: DragEvent

DragEventTypes:

• dom: DragEventTypes

DragExit:

• DragEventTypes.DragExit

DragLeave:

• DragEventTypes.DragLeave

DragOver:

• DragEventTypes.DragOver

DragStart:

• DragEventTypes.DragStart

drain:

• asyncdispatch: drain(timeout = 500)

Drop:

• DragEventTypes.Drop

dSat:

• WeekDay.dSat

dSun:

• WeekDay.dSun

dt:

• htmlgen: dt(e: varargs[untyped]): untyped

dThu:

• WeekDay.dThu

dTue:

• WeekDay.dTue

dump:

• sugar: dump(x: untyped): untyped

dumpAllocstats:

• system: dumpAllocstats(code: untyped)

dumpAstGen:

• macros: dumpAstGen(s: untyped): untyped

dumpLisp:

• macros: dumpLisp(s: untyped): untyped

dumpToString:

• sugar: dumpToString(x: untyped): string

dumpTree:

• macros: dumpTree(s: untyped): untyped

dup:

• sugar: dup[T](arg: T; calls: varargs[untyped]): T

duplicateHandle:

• winlean: duplicateHandle(hSourceProcessHandle: Handle; hSourceHandle: Handle; hTargetProcessHandle: Handle; lpTargetHandle: ptr Handle; dwDesiredAccess: DWORD; bInheritHandle: WINBOOL; dwOptions: DWORD): WINBOOL

DUPLICATE_SAME_ACCESS:

• winlean: DUPLICATE_SAME_ACCESS

Duration:

• times: Duration

DurationParts:

• times: DurationParts

DurationZero:

• times: DurationZero

dWed:

• WeekDay.dWed

DWORD:

• winlean: DWORD

DynlibFormat:

• os: DynlibFormat

E:

• math: E

eat:

• parsejson: eat(p: var JsonParser; tok: TokKind)

echo:

• system: echo(x: varargs[typed, `$`])

echoForeignDeps:

• distros: echoForeignDeps()

edit distance:

• Module editdistance

editDistance:

• editdistance: editDistance(a, b: string): int

editDistanceAscii:

• editdistance: editDistanceAscii(a, b: string): int

EInvalidPeg:

• pegs: EInvalidPeg

Element:

• dom: Element

elementFromPoint:

• dom: elementFromPoint(n: DocumentOrShadowRoot; x, y: float): Element

elementName:

• parsexml: elementName(my: XmlParser): string

ElementNode:

• NodeType.ElementNode

elements:

• typeinfo: elements(x: Any): int

elementsFromPoint:

• dom: elementsFromPoint(n: DocumentOrShadowRoot; x, y: float): seq[Element]

elementType:

• typetraits: elementType(a: untyped): typedesc

em:

• htmlgen: em(e: varargs[untyped]): untyped

embed:

• htmlgen: embed(e: varargs[untyped]): untyped

EmbedElement:

• dom: EmbedElement

enableCache:

• ropes: enableCache()

enableExternalCapture:

• dom: enableExternalCapture(w: Window)

enableProfiling:

• nimprof: enableProfiling()

enableTrueColors:

• terminal: enableTrueColors()

encode:

• base64: encode[T: SomeInteger | char](s: openArray[T]; safe = false): string
• base64: encode(s: string; safe = false): string
• punycode: encode(s: string): string
• punycode: encode(prefix, s: string): string

encodeMime:

• base64: encodeMime(s: string; lineLen = 75; newLine = "\r "): string

encodeQuery:

• uri: encodeQuery(query: openArray[(string, string)]; usePlus = true; omitEq = true): string

encodeURI:

• dom: encodeURI(uri: cstring): cstring

encodeURIComponent:

• dom: encodeURIComponent(uri: cstring): cstring

encodeUrl:

• uri: encodeUrl(s: string; usePlus = true): string

encodeZigzag:

• varints: encodeZigzag(x: int64): uint64

EncodingConverter:

• encodings: EncodingConverter

EncodingError:

• encodings: EncodingError

endAnchor:

• pegs: endAnchor(): Peg

endian:

• Module endians

Endianness:

• system: Endianness

endOfFile:

• io: endOfFile(f: File): bool

EndOfFile:

• lexbase: EndOfFile

endsWith:

• cstrutils: endsWith(s, suffix: cstring): bool
• jsre: endsWith(pattern: cstring; self: RegExp): bool
• pegs: endsWith(s: string; suffix: Peg; start = 0): bool
• re: endsWith(s: string; suffix: Regex): bool
• strutils: endsWith(s: string; suffix: char): bool
• strutils: endsWith(s, suffix: string): bool

endsWithImpl:

• strimpl: endsWithImpl[T: string | cstring](s, suffix: T)

entityName:

• parsexml: entityName(my: XmlParser): string

EntityNode:

• NodeType.EntityNode

EntityRefNode:

• NodeType.EntityRefNode

entityToRune:

• htmlparser: entityToRune(entity: string): Rune

entityToUtf8:

• htmlparser: entityToUtf8(entity: string): string

entries:

• jsheaders: entries(self: Headers): seq[tuple[key, value: cstring]]

enumerate:

• enumerate: enumerate(x: ForLoopStmt): untyped

enumLen:

• typetraits: enumLen(T: typedesc[enum]): int

EnumMode:

• jsonutils: EnumMode

environment variable:

• Module os
• Module os
• Module os

environments variables:

• Module os

envPairs:

• os: envPairs(): tuple[key, value: string]

EOFError:

• system: EOFError

epochTime:

• times: epochTime(): float

epoll:

• Module asyncdispatch

epoll_create:

• epoll: epoll_create(size: cint): cint

epoll_create1:

• epoll: epoll_create1(flags: cint): cint

epoll_ctl:

• epoll: epoll_ctl(epfd: cint; op: cint; fd: cint | SocketHandle; event: ptr EpollEvent): cint

EPOLL_CTL_ADD:

• epoll: EPOLL_CTL_ADD

EPOLL_CTL_DEL:

• epoll: EPOLL_CTL_DEL

EPOLL_CTL_MOD:

• epoll: EPOLL_CTL_MOD

EpollData:

• epoll: EpollData

EPOLLERR:

• epoll: EPOLLERR

EPOLLET:

• epoll: EPOLLET

EpollEvent:

• epoll: EpollEvent

EPOLLEXCLUSIVE:

• epoll: EPOLLEXCLUSIVE

EPOLLHUP:

• epoll: EPOLLHUP

EPOLLIN:

• epoll: EPOLLIN

EPOLLMSG:

• epoll: EPOLLMSG

EPOLLONESHOT:

• epoll: EPOLLONESHOT

EPOLLOUT:

• epoll: EPOLLOUT

EPOLLPRI:

• epoll: EPOLLPRI

EPOLLRDBAND:

• epoll: EPOLLRDBAND

EPOLLRDHUP:

• epoll: EPOLLRDHUP

EPOLLRDNORM:

• epoll: EPOLLRDNORM

epoll_wait:

• epoll: epoll_wait(epfd: cint; events: ptr EpollEvent; maxevents: cint; timeout: cint): cint

EPOLLWAKEUP:

• epoll: EPOLLWAKEUP

EPOLLWRBAND:

• epoll: EPOLLWRBAND

EPOLLWRNORM:

• epoll: EPOLLWRNORM

epsilon:

• fenv: epsilon(T: typedesc[float32]): float32
• fenv: epsilon(T: typedesc[float64]): float64

eqIdent:

• macros: eqIdent(a: NimNode; b: NimNode): bool
• macros: eqIdent(a: NimNode; b: string): bool
• macros: eqIdent(a: string; b: NimNode): bool
• macros: eqIdent(a: string; b: string): bool

equalMem:

• system: equalMem(a, b: pointer; size: Natural): bool

equalsFile:

• ropes: equalsFile(r: Rope; f: File): bool
• ropes: equalsFile(r: Rope; filename: string): bool

eraseLine:

• terminal: eraseLine(f: File)
• terminal: eraseLine()

eraseScreen:

• terminal: eraseScreen(f: File)
• terminal: eraseScreen()

erf:

• math: erf(x: float32): float32
• math: erf(x: float64): float64

erfc:

• math: erfc(x: float32): float32
• math: erfc(x: float64): float64

errAttributeValueExpected:

• XmlErrorKind.errAttributeValueExpected

errBracketRiExpected:

• JsonError.errBracketRiExpected

errColonExpected:

• JsonError.errColonExpected

errCommaExpected:

• JsonError.errCommaExpected

errCurlyRiExpected:

• JsonError.errCurlyRiExpected

errEndOfCDataExpected:

• XmlErrorKind.errEndOfCDataExpected

errEndOfCommentExpected:

• XmlErrorKind.errEndOfCommentExpected

errEOC_Expected:

• JsonError.errEOC_Expected

errEofExpected:

• JsonError.errEofExpected
• SexpError.errEofExpected

errEqExpected:

• XmlErrorKind.errEqExpected

errExprExpected:

• JsonError.errExprExpected

errGtExpected:

• XmlErrorKind.errGtExpected

errInvalidToken:

• JsonError.errInvalidToken
• SexpError.errInvalidToken

errNameExpected:

• XmlErrorKind.errNameExpected

errNone:

• JsonError.errNone
• XmlErrorKind.errNone
• SexpError.errNone

Error:

• asyncjs: Error

error:

• dom: error(f: FileReader): DomException
• jsconsole: error(console: Console)
• logging: error(args: varargs[string, `$`])
• macros: error(msg: string; n: NimNode = nil)

ERROR_ACCESS_DENIED:

• winlean: ERROR_ACCESS_DENIED

ERROR_BAD_ARGUMENTS:

• winlean: ERROR_BAD_ARGUMENTS

ERROR_FILE_EXISTS:

• winlean: ERROR_FILE_EXISTS

ERROR_FILE_NOT_FOUND:

• winlean: ERROR_FILE_NOT_FOUND

errorHandle:

• osproc: errorHandle(p: Process): FileHandle

ERROR_HANDLE_EOF:

• winlean: ERROR_HANDLE_EOF

ERROR_IO_PENDING:

• winlean: ERROR_IO_PENDING

ERROR_LOCK_VIOLATION:

• winlean: ERROR_LOCK_VIOLATION

errorMessages:

• parsejson: errorMessages

errorMessageWriter:

• system: errorMessageWriter

errorMsg:

• parsejson: errorMsg(my: JsonParser): string
• parsexml: errorMsg(my: XmlParser): string
• parsexml: errorMsg(my: XmlParser; msg: string): string
• sexp: errorMsg(my: SexpParser): string

errorMsgExpected:

• parsejson: errorMsgExpected(my: JsonParser; e: string): string
• parsexml: errorMsgExpected(my: XmlParser; tag: string): string
• sexp: errorMsgExpected(my: SexpParser; e: string): string

ERROR_NETNAME_DELETED:

• winlean: ERROR_NETNAME_DELETED

ERROR_NO_MORE_FILES:

• winlean: ERROR_NO_MORE_FILES

ERROR_PATH_NOT_FOUND:

• winlean: ERROR_PATH_NOT_FOUND

errorStr:

• parsecfg: errorStr(c: CfgParser; msg: string): string

errorStream:

• osproc: errorStream(p: Process): Stream

errParensRiExpected:

• SexpError.errParensRiExpected

errQmGtExpected:

• XmlErrorKind.errQmGtExpected

errQuoteExpected:

• JsonError.errQuoteExpected
• XmlErrorKind.errQuoteExpected
• SexpError.errQuoteExpected

errSemicolonExpected:

• XmlErrorKind.errSemicolonExpected

errStringExpected:

• JsonError.errStringExpected

esc:

• rstgen: esc(target: OutputTarget; s: string; splitAfter = -1; escMode = emText): string

escape:

• dom: escape(uri: cstring): cstring
• strutils: escape(s: string; prefix = "\""; suffix = "\""): string
• xmltree: escape(s: string): string

escapeJson:

• json: escapeJson(s: string): string
• json: escapeJson(s: string; result: var string)
• sexp: escapeJson(s: string): string

escapeJsonUnquoted:

• json: escapeJsonUnquoted(s: string): string
• json: escapeJsonUnquoted(s: string; result: var string)

escapePeg:

• pegs: escapePeg(s: string): string

escapeRe:

• nre: escapeRe(str: string): string
• re: escapeRe(s: string): string

escChar:

• rstgen: escChar(target: OutputTarget; dest: var string; c: char; escMode: EscapeMode)

euclDiv:

• math: euclDiv[T: SomeInteger](x, y: T): T

euclMod:

• math: euclMod[T: SomeNumber](x, y: T): T

EV_ADD:

• kqueue: EV_ADD

EV_CLEAR:

• kqueue: EV_CLEAR

EV_DELETE:

• kqueue: EV_DELETE

EV_DISABLE:

• kqueue: EV_DISABLE

EV_DISPATCH:

• kqueue: EV_DISPATCH

EV_DROP:

• kqueue: EV_DROP

EV_ENABLE:

• kqueue: EV_ENABLE

Event:

• dom: Event
• selectors: Event

eventAttr:

• htmlgen: eventAttr

eventParser:

• pegs: eventParser(pegAst, handlers: untyped): (proc (s: string): int)

EventPhase:

• dom: EventPhase

EventTarget:

• dom: EventTarget

EV_EOF:

• kqueue: EV_EOF

EV_ERROR:

• kqueue: EV_ERROR

EV_FLAG1:

• kqueue: EV_FLAG1

EvLines:

• FtpEventType.EvLines

EV_NODATA:

• kqueue: EV_NODATA

EV_ONESHOT:

• kqueue: EV_ONESHOT

EV_RECEIPT:

• kqueue: EV_RECEIPT

EvRetr:

• FtpEventType.EvRetr

EV_SET:

• kqueue: EV_SET(event: ptr KEvent; ident: uint; filter: cshort; flags: cushort; fflags: cuint; data: int; udata: pointer)

EvStore:

• FtpEventType.EvStore

EV_SYSFLAGS:

• kqueue: EV_SYSFLAGS

EvTransferProgress:

• FtpEventType.EvTransferProgress

exception:

• jsconsole: exception(console: Console; args: varargs[untyped])

Exception:

• system: Exception

exchange:

• atomics: exchange[T](location: var Atomic[T]; desired: T; order: MemoryOrder = moSequentiallyConsistent): T

excl:

• critbits: excl[T](c: var CritBitTree[T]; key: string)
• packedsets: excl[A](s: var PackedSet[A]; key: A)
• packedsets: excl[A](s: var PackedSet[A]; other: PackedSet[A])
• sets: excl[A](s: var HashSet[A]; key: A)
• sets: excl[A](s: var HashSet[A]; other: HashSet[A])
• sets: excl[A](s: var OrderedSet[A]; key: A)
• system: excl[T](x: var set[T]; y: T)
• system: excl[T](x: var set[T]; y: set[T])

exclFilePermissions:

• os: exclFilePermissions(filename: string; permissions: set[FilePermission])

exec:

• db_mysql: exec(db: DbConn; query: SqlQuery; args: varargs[string, `$`])
• db_odbc: exec(db: var DbConn; query: SqlQuery; args: varargs[string, `$`])
• db_postgres: exec(db: DbConn; stmtName: SqlPrepared; args: varargs[string])
• db_postgres: exec(db: DbConn; query: SqlQuery; args: varargs[string, `$`])
• db_sqlite: exec(db: DbConn; query: SqlQuery; args: varargs[string, `$`])
• db_sqlite: exec(db: DbConn; stmtName: SqlPrepared; args: varargs[typed]): untyped
• jsre: exec(self: RegExp; pattern: cstring): seq[cstring]
• nimscript: exec(command: string)
• nimscript: exec(command: string; input: string; cache = "")

execAffectedRows:

• db_mysql: execAffectedRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
• db_odbc: execAffectedRows(db: var DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
• db_postgres: execAffectedRows(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): int64
• db_postgres: execAffectedRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
• db_sqlite: execAffectedRows(db: DbConn; stmtName: SqlPrepared): int64
• db_sqlite: execAffectedRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64

execCmd:

• osproc: execCmd(command: string): int

execCmdEx:

• osproc: execCmdEx(command: string; options: set[ProcessOption] = {poStdErrToStdOut, poUsePath}; env: StringTableRef = nil; workingDir = ""; input = ""): tuple[ output: string, exitCode: int]

ExecIOEffect:

• system: ExecIOEffect

execProcess:

• osproc: execProcess(command: string; workingDir: string = ""; args: openArray[string] = []; env: StringTableRef = nil; options: set[ ProcessOption] = {poStdErrToStdOut, poUsePath, poEvalCommand}): string

execProcesses:

• osproc: execProcesses(cmds: openArray[string]; options = {poStdErrToStdOut, poParentStreams}; n = countProcessors(); beforeRunEvent: proc (idx: int) = nil; afterRunEvent: proc (idx: int; p: Process) = nil): int

execShellCmd:

• os: execShellCmd(command: string): int

ExeExt:

• os: ExeExt

ExeExts:

• os: ExeExts

exists:

• logic: exists(args: varargs[untyped]): bool
• nimscript: exists(key: string): bool

existsCookie:

• cgi: existsCookie(name: string): bool

existsDir:

• nimscript: existsDir(args: varargs[untyped]): untyped
• os: existsDir(args: varargs[untyped]): untyped

existsEnv:

• nimscript: existsEnv(key: string): bool
• os: existsEnv(key: string): bool

existsFile:

• nimscript: existsFile(args: varargs[untyped]): untyped
• os: existsFile(args: varargs[untyped]): untyped

existsOrCreateDir:

• os: existsOrCreateDir(dir: string): bool

exitStatusLikeShell:

• os: exitStatusLikeShell(status: cint): cint

exp:

• complex: exp[T](z: Complex[T]): Complex[T]
• jscore: exp(m: MathLib; a: SomeNumber): float
• math: exp(x: float32): float32
• math: exp(x: float64): float64

expandFilename:

• os: expandFilename(filename: string): string

expandMacros:

• macros: expandMacros(body: typed): untyped

expandSymlink:

• os: expandSymlink(symlinkPath: string): string

expandTabs:

• strmisc: expandTabs(s: string; tabSize: int = 8): string

expandTilde:

• os: expandTilde(path: string): string

expect:

• unittest: expect(exceptions: varargs[typed]; body: untyped): untyped

expectIdent:

• macros: expectIdent(n: NimNode; name: string)

expectKind:

• macros: expectKind(n: NimNode; k: NimNodeKind)
• macros: expectKind(n: NimNode; k: set[NimNodeKind])

expectLen:

• macros: expectLen(n: NimNode; len: int)
• macros: expectLen(n: NimNode; min, max: int)

expectMinLen:

• macros: expectMinLen(n: NimNode; min: int)

expm1:

• jscore: expm1(m: MathLib; a: SomeNumber): float

extendSeq:

• typeinfo: extendSeq(x: Any)

extract:

• isolation: extract[T](src: var Isolated[T]): T

extractDocCommentsAndRunnables:

• macros: extractDocCommentsAndRunnables(n: NimNode): NimNode

extractFilename:

• os: extractFilename(path: string): string

extractRGB:

• colors: extractRGB(a: Color): tuple[r, g, b: range[0 .. 255]]

ExtSep:

• os: ExtSep

fac:

• math: fac(n: int): int

fail:

• asyncfutures: fail[T](future: Future[T]; error: ref Exception)
• asyncstreams: fail[T](future: FutureStream[T]; error: ref Exception)
• unittest: fail()

failed:

• asyncfutures: failed(future: FutureBase): bool
• asyncstreams: failed[T](future: FutureStream[T]): bool

FAILED:

• TestStatus.FAILED

failedAssertImpl:

• assertions: failedAssertImpl(msg: string)

failureOccurred:

• unittest: failureOccurred(formatter: ConsoleOutputFormatter; checkpoints: seq[string]; stackTrace: string)
• unittest: failureOccurred(formatter: JUnitOutputFormatter; checkpoints: seq[string]; stackTrace: string)
• unittest: failureOccurred(formatter: OutputFormatter; checkpoints: seq[string]; stackTrace: string)

fakeDot:

• wrapnils: fakeDot(a: Option; b): untyped

fastLog2:

• bitops: fastLog2(x: SomeInteger): int

fastRows:

• db_mysql: fastRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
• db_odbc: fastRows(db: var DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
• db_postgres: fastRows(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): Row
• db_postgres: fastRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
• db_sqlite: fastRows(db: DbConn; stmtName: SqlPrepared): Row
• db_sqlite: fastRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row

fastRuneAt:

• unicode: fastRuneAt(s: string; i: int; result: untyped; doInc = true)

fastToUTF8Copy:

• unicode: fastToUTF8Copy(c: Rune; s: var string; pos: int; doInc = true)

fatal:

• logging: fatal(args: varargs[string, `$`])

fchDefault:

• FetchCaches.fchDefault

fchForceCache:

• FetchCaches.fchForceCache

fchNoCache:

• FetchCaches.fchNoCache

fchNoStore:

• FetchCaches.fchNoStore

fchReload:

• FetchCaches.fchReload

fcInclude:

• FetchCredentials.fcInclude

fcInf:

• FloatClass.fcInf

fcNan:

• FloatClass.fcNan

fcNegInf:

• FloatClass.fcNegInf

fcNegZero:

• FloatClass.fcNegZero

fcNormal:

• FloatClass.fcNormal

fcOmit:

• FetchCredentials.fcOmit

fcSameOrigin:

• FetchCredentials.fcSameOrigin

fcSubnormal:

• FloatClass.fcSubnormal

fcZero:

• FloatClass.fcZero

FD_ACCEPT:

• winlean: FD_ACCEPT

FD_ADDRESS_LIST_CHANGE:

• winlean: FD_ADDRESS_LIST_CHANGE

FD_ALL_EVENTS:

• winlean: FD_ALL_EVENTS

FD_CLOSE:

• winlean: FD_CLOSE

FD_CONNECT:

• winlean: FD_CONNECT

FD_GROUP_QQS:

• winlean: FD_GROUP_QQS

FD_ISSET:

• winlean: FD_ISSET(socket: SocketHandle; set: var TFdSet): cint

FD_OOB:

• winlean: FD_OOB

FD_QQS:

• winlean: FD_QQS

FD_READ:

• winlean: FD_READ

FD_ROUTING_INTERFACE_CHANGE:

• winlean: FD_ROUTING_INTERFACE_CHANGE

FD_SET:

• winlean: FD_SET(socket: SocketHandle; s: var TFdSet)

FD_SETSIZE:

• winlean: FD_SETSIZE

FD_WRITE:

• winlean: FD_WRITE

FD_ZERO:

• winlean: FD_ZERO(s: var TFdSet)

FE_ALL_EXCEPT:

• fenv: FE_ALL_EXCEPT

feclearexcept:

• fenv: feclearexcept(excepts: cint): cint

FE_DFL_ENV:

• fenv: FE_DFL_ENV

FE_DIVBYZERO:

• fenv: FE_DIVBYZERO

FE_DOWNWARD:

• fenv: FE_DOWNWARD

fegetenv:

• fenv: fegetenv(envp: ptr Tfenv): cint

fegetexceptflag:

• fenv: fegetexceptflag(flagp: ptr Tfexcept; excepts: cint): cint

fegetround:

• fenv: fegetround(): cint

feholdexcept:

• fenv: feholdexcept(envp: ptr Tfenv): cint

FE_INEXACT:

• fenv: FE_INEXACT

FE_INVALID:

• fenv: FE_INVALID

fence:

• atomics: fence(order: MemoryOrder)

FE_OVERFLOW:

• fenv: FE_OVERFLOW

feraiseexcept:

• fenv: feraiseexcept(excepts: cint): cint

fesetenv:

• fenv: fesetenv(a1: ptr Tfenv): cint

fesetexceptflag:

• fenv: fesetexceptflag(flagp: ptr Tfexcept; excepts: cint): cint

fesetround:

• fenv: fesetround(roundingDirection: cint): cint

fetch:

• jsfetch: fetch(url: cstring | Request): Future[Response]
• jsfetch: fetch(url: cstring | Request; options: FetchOptions): Future[Response]

fetchAdd:

• atomics: fetchAdd[T: SomeInteger](location: var Atomic[T]; value: T; order: MemoryOrder = moSequentiallyConsistent): T

fetchAnd:

• atomics: fetchAnd[T: SomeInteger](location: var Atomic[T]; value: T; order: MemoryOrder = moSequentiallyConsistent): T

FetchCaches:

• jsfetch: FetchCaches

FetchCredentials:

• jsfetch: FetchCredentials

FetchModes:

• jsfetch: FetchModes

FetchOptions:

• jsfetch: FetchOptions

fetchOr:

• atomics: fetchOr[T: SomeInteger](location: var Atomic[T]; value: T; order: MemoryOrder = moSequentiallyConsistent): T

FetchRedirects:

• jsfetch: FetchRedirects

FetchReferrerPolicies:

• jsfetch: FetchReferrerPolicies

fetchSub:

• atomics: fetchSub[T: SomeInteger](location: var Atomic[T]; value: T; order: MemoryOrder = moSequentiallyConsistent): T

fetchXor:

• atomics: fetchXor[T: SomeInteger](location: var Atomic[T]; value: T; order: MemoryOrder = moSequentiallyConsistent): T

fetestexcept:

• fenv: fetestexcept(excepts: cint): cint

FE_TONEAREST:

• fenv: FE_TONEAREST

FE_TOWARDZERO:

• fenv: FE_TOWARDZERO

FE_UNDERFLOW:

• fenv: FE_UNDERFLOW

feupdateenv:

• fenv: feupdateenv(envp: ptr Tfenv): cint

FE_UPWARD:

• fenv: FE_UPWARD

ffDecimal:

• FloatFormatMode.ffDecimal

ffDefault:

• FloatFormatMode.ffDefault

ffScientific:

• FloatFormatMode.ffScientific

fg8Bit:

• ForegroundColor.fg8Bit

fgBlack:

• ForegroundColor.fgBlack

fgBlue:

• ForegroundColor.fgBlue

fgColor:

• TerminalCmd.fgColor

fgCyan:

• ForegroundColor.fgCyan

fgDefault:

• ForegroundColor.fgDefault

fgGreen:

• ForegroundColor.fgGreen

fgMagenta:

• ForegroundColor.fgMagenta

fgRed:

• ForegroundColor.fgRed

fgWhite:

• ForegroundColor.fgWhite

fgYellow:

• ForegroundColor.fgYellow

FIBER_FLAG_FLOAT_SWITCH:

• winlean: FIBER_FLAG_FLOAT_SWITCH

FieldDefect:

• system: FieldDefect

FieldError:

• system: FieldError

fieldPairs:

• iterators: fieldPairs[S: tuple | object; T: tuple | object](x: S; y: T): tuple[key: string, a, b: RootObj]
• iterators: fieldPairs[T: tuple | object](x: T): tuple[key: string, val: RootObj]

fields:

• iterators: fields[S: tuple | object; T: tuple | object](x: S; y: T): tuple[key: string, val: RootObj]
• iterators: fields[T: tuple | object](x: T): RootObj
• typeinfo: fields(x: Any): tuple[name: string, any: Any]

fieldset:

• htmlgen: fieldset(e: varargs[untyped]): untyped

FifthButton:

• MouseButtons.FifthButton

figcaption:

• htmlgen: figcaption(e: varargs[untyped]): untyped

figure:

• htmlgen: figure(e: varargs[untyped]): untyped

File:

• dom: File
• io: File

FILE_ATTRIBUTE_ARCHIVE:

• winlean: FILE_ATTRIBUTE_ARCHIVE

FILE_ATTRIBUTE_COMPRESSED:

• winlean: FILE_ATTRIBUTE_COMPRESSED

FILE_ATTRIBUTE_DEVICE:

• winlean: FILE_ATTRIBUTE_DEVICE

FILE_ATTRIBUTE_DIRECTORY:

• winlean: FILE_ATTRIBUTE_DIRECTORY

FILE_ATTRIBUTE_HIDDEN:

• winlean: FILE_ATTRIBUTE_HIDDEN

FILE_ATTRIBUTE_NORMAL:

• winlean: FILE_ATTRIBUTE_NORMAL

FILE_ATTRIBUTE_NOT_CONTENT_INDEXED:

• winlean: FILE_ATTRIBUTE_NOT_CONTENT_INDEXED

FILE_ATTRIBUTE_OFFLINE:

• winlean: FILE_ATTRIBUTE_OFFLINE

FILE_ATTRIBUTE_READONLY:

• winlean: FILE_ATTRIBUTE_READONLY

FILE_ATTRIBUTE_REPARSE_POINT:

• winlean: FILE_ATTRIBUTE_REPARSE_POINT

FILE_ATTRIBUTE_SPARSE_FILE:

• winlean: FILE_ATTRIBUTE_SPARSE_FILE

FILE_ATTRIBUTE_SYSTEM:

• winlean: FILE_ATTRIBUTE_SYSTEM

FILE_ATTRIBUTE_TEMPORARY:

• winlean: FILE_ATTRIBUTE_TEMPORARY

FILE_BEGIN:

• winlean: FILE_BEGIN

fileExists:

• asyncftpclient: fileExists(ftp: AsyncFtpClient; file: string): Future[bool]
• nimscript: fileExists(filename: string): bool
• os: fileExists(filename: string): bool

FILE_FLAG_BACKUP_SEMANTICS:

• winlean: FILE_FLAG_BACKUP_SEMANTICS

FILE_FLAG_DELETE_ON_CLOSE:

• winlean: FILE_FLAG_DELETE_ON_CLOSE

FILE_FLAG_FIRST_PIPE_INSTANCE:

• winlean: FILE_FLAG_FIRST_PIPE_INSTANCE

FILE_FLAG_NO_BUFFERING:

• winlean: FILE_FLAG_NO_BUFFERING

FILE_FLAG_OPEN_NO_RECALL:

• winlean: FILE_FLAG_OPEN_NO_RECALL

FILE_FLAG_OPEN_REPARSE_POINT:

• winlean: FILE_FLAG_OPEN_REPARSE_POINT

FILE_FLAG_OVERLAPPED:

• winlean: FILE_FLAG_OVERLAPPED

FILE_FLAG_POSIX_SEMANTICS:

• winlean: FILE_FLAG_POSIX_SEMANTICS

FILE_FLAG_RANDOM_ACCESS:

• winlean: FILE_FLAG_RANDOM_ACCESS

FILE_FLAG_SEQUENTIAL_SCAN:

• winlean: FILE_FLAG_SEQUENTIAL_SCAN

FILE_FLAG_WRITE_THROUGH:

• winlean: FILE_FLAG_WRITE_THROUGH

FileHandle:

• io: FileHandle

FileId:

• os: FileId

FileIndex:

• rstast: FileIndex

FileInfo:

• os: FileInfo

FileLogger:

• logging: FileLogger

FILE_MAP_READ:

• winlean: FILE_MAP_READ

FILE_MAP_WRITE:

• winlean: FILE_MAP_WRITE

FileMode:

• io: FileMode

fileNewer:

• os: fileNewer(a, b: string): bool

FilePermission:

• os: FilePermission

FILE_READ_DATA:

• winlean: FILE_READ_DATA

FileReader:

• dom: FileReader

fileReaderDone:

• dom: fileReaderDone

fileReaderEmpty:

• dom: fileReaderEmpty

fileReaderLoading:

• dom: fileReaderLoading

FileReaderState:

• dom: FileReaderState

FileSeekPos:

• system: FileSeekPos

FILE_SHARE_DELETE:

• winlean: FILE_SHARE_DELETE

FILE_SHARE_READ:

• winlean: FILE_SHARE_READ

FILE_SHARE_WRITE:

• winlean: FILE_SHARE_WRITE

FileStream:

• streams: FileStream

FileStreamObj:

• streams: FileStreamObj

FileSystemCaseSensitive:

• os: FileSystemCaseSensitive

FILETIME:

• winlean: FILETIME

FILE_WRITE_DATA:

• winlean: FILE_WRITE_DATA

fill:

• algorithm: fill[T](a: var openArray[T]; first, last: Natural; value: T)
• algorithm: fill[T](a: var openArray[T]; value: T)

filter:

• options: filter[T](self: Option[T]; callback: proc (input: T): bool): Option[T]
• sequtils: filter[T](s: openArray[T]; pred: proc (x: T): bool {.closure.}): seq[T]
• sequtils: filter[T](s: openArray[T]; pred: proc (x: T): bool {.closure.}): T

filterIt:

• sequtils: filterIt(s, pred: untyped): untyped

finalize:

• db_sqlite: finalize(sqlPrepared: SqlPrepared)
• sha1: finalize(ctx: var Sha1State): Sha1Digest

find:

• dom: find(w: Window; text: cstring; caseSensitive = false; backwards = false)
• heapqueue: find[T](heap: HeapQueue[T]; x: T): int
• lists: find[T](L: SomeLinkedCollection[T]; value: T): SomeLinkedNode[T]
• nre: find(str: string; pattern: Regex; start = 0; endpos = int.high): Option[ RegexMatch]
• pegs: find(s: string; pattern: Peg; start = 0): int
• pegs: find(s: string; pattern: Peg; matches: var openArray[string]; start = 0): int
• re: find(buf: cstring; pattern: Regex; start = 0; bufSize: int): int
• re: find(buf: cstring; pattern: Regex; matches: var openArray[string]; start = 0; bufSize: int): int
• re: find(s: string; pattern: Regex; start = 0): int
• re: find(s: string; pattern: Regex; matches: var openArray[string]; start = 0): int
• strutils: find(a: SkipTable; s, sub: string; start: Natural = 0; last = 0): int
• strutils: find(s: string; sub: char; start: Natural = 0; last = 0): int
• strutils: find(s: string; chars: set[char]; start: Natural = 0; last = 0): int
• strutils: find(s, sub: string; start: Natural = 0; last = 0): int
• system: find[T, S](a: T; item: S): int

findAll:

• nre: findAll(str: string; pattern: Regex; start = 0; endpos = int.high): seq[string]
• pegs: findAll(s: string; pattern: Peg; start = 0): seq[string]
• pegs: findAll(s: string; pattern: Peg; start = 0): string
• re: findAll(s: string; pattern: Regex; start = 0): seq[string]
• re: findAll(buf: cstring; pattern: Regex; start = 0; bufSize: int): string
• re: findAll(s: string; pattern: Regex; start = 0): string
• xmltree: findAll(n: XmlNode; tag: string; caseInsensitive = false): seq[XmlNode]
• xmltree: findAll(n: XmlNode; tag: string; result: var seq[XmlNode]; caseInsensitive = false)

findBounds:

• pegs: findBounds(s: string; pattern: Peg; matches: var openArray[string]; start = 0): tuple[ first, last: int]
• re: findBounds(buf: cstring; pattern: Regex; start = 0; bufSize: int): tuple[ first, last: int]
• re: findBounds(buf: cstring; pattern: Regex; matches: var openArray[string]; start = 0; bufSize: int): tuple[first, last: int]
• re: findBounds(buf: cstring; pattern: Regex; matches: var openArray[tuple[first, last: int]]; start = 0; bufSize: int): tuple[first, last: int]
• re: findBounds(s: string; pattern: Regex; start = 0): tuple[first, last: int]
• re: findBounds(s: string; pattern: Regex; matches: var openArray[string]; start = 0): tuple[ first, last: int]
• re: findBounds(s: string; pattern: Regex; matches: var openArray[tuple[first, last: int]]; start = 0): tuple[ first, last: int]

findChild:

• macros: findChild(n: NimNode; cond: untyped): NimNode

findClose:

• winlean: findClose(hFindFile: Handle)

findExe:

• nimscript: findExe(bin: string): string
• os: findExe(exe: string; followSymlinks: bool = true; extensions: openArray[string] = ExeExts): string

findFirstFileW:

• winlean: findFirstFileW(lpFileName: WideCString; lpFindFileData: var WIN32_FIND_DATA): Handle

findIter:

• nre: findIter(str: string; pattern: Regex; start = 0; endpos = int.high): RegexMatch

findNextFileW:

• winlean: findNextFileW(hFindFile: Handle; lpFindFileData: var WIN32_FIND_DATA): int32

finished:

• asyncfutures: finished(future: FutureBase | FutureVar): bool
• asyncstreams: finished[T](future: FutureStream[T]): bool
• system: finished[T: proc](x: T): bool

FIONBIO:

• nativesockets: FIONBIO

firstSetBit:

• bitops: firstSetBit(x: SomeInteger): int

FixedTimeUnit:

• times: FixedTimeUnit

flags:

• pegs: flags(nt: NonTerminal): set[NonTerminalFlag]

flatMap:

• options: flatMap[T, R](self: Option[T]; callback: proc (input: T): Option[R]): Option[R]

flatten:

• options: flatten[T](self: Option[Option[T]]): Option[T]

flipBit:

• bitops: flipBit[T: SomeInteger](v: var T; bit: BitsRange[T])

flipBits:

• bitops: flipBits(v: typed; bits: varargs[typed]): untyped

flipMask:

• bitops: flipMask[T: SomeInteger](v: var T; slice: Slice[int])
• bitops: flipMask[T: SomeInteger](v: var T; mask: T)

flipMasked:

• bitops: flipMasked[T: SomeInteger](v: T; slice: Slice[int]): T
• bitops: flipMasked[T: SomeInteger](v, mask: T): T

float:

• system: float

float32:

• system: float32

float64:

• system: float64

Float64Array:

• jsutils: Float64Array

FloatClass:

• math: FloatClass

FloatDivByZeroDefect:

• system: FloatDivByZeroDefect

FloatDivByZeroError:

• system: FloatDivByZeroError

FloatFormatMode:

• strutils: FloatFormatMode

FloatInexactDefect:

• system: FloatInexactDefect

FloatInexactError:

• system: FloatInexactError

FloatingPointDefect:

• system: FloatingPointDefect

FloatingPointError:

• system: FloatingPointError

FloatInvalidOpDefect:

• system: FloatInvalidOpDefect

FloatInvalidOpError:

• system: FloatInvalidOpError

FloatOverflowDefect:

• system: FloatOverflowDefect

FloatOverflowError:

• system: FloatOverflowError

FloatUnderflowDefect:

• system: FloatUnderflowDefect

FloatUnderflowError:

• system: FloatUnderflowError

floatVal:

• macros: floatVal(n: NimNode): BiggestFloat

floatVal=:

• macros: floatVal=(n: NimNode; val: BiggestFloat)

floor:

• jscore: floor(m: MathLib; f: SomeFloat): int
• math: floor(x: float32): float32
• math: floor(x: float64): float64

floorDiv:

• math: floorDiv[T: SomeInteger](x, y: T): T
• rationals: floorDiv[T: SomeInteger](x, y: Rational[T]): T

floorMod:

• math: floorMod[T: SomeNumber](x, y: T): T
• rationals: floorMod[T: SomeInteger](x, y: Rational[T]): Rational[T]

FlowVar:

• threadpool: FlowVar

FlowVarBase:

• threadpool: FlowVarBase

flush:

• memfiles: flush(f: var MemFile; attempts: Natural = 3)
• streams: flush(s: Stream)

flushFile:

• io: flushFile(f: File)

flushFileBuffers:

• winlean: flushFileBuffers(hFile: Handle): WINBOOL

flushViewOfFile:

• winlean: flushViewOfFile(lpBaseAddress: pointer; dwNumberOfBytesToFlush: DWORD): WINBOOL

fmAppend:

• FileMode.fmAppend

fmCors:

• FetchModes.fmCors

fmNoCors:

• FetchModes.fmNoCors

fmRead:

• FileMode.fmRead

fmReadWrite:

• FileMode.fmReadWrite

fmReadWriteExisting:

• FileMode.fmReadWriteExisting

fmSameOrigin:

• FetchModes.fmSameOrigin

fmt:

• strformat: fmt(pattern: static string; openChar: static char; closeChar: static char): string
• strformat: fmt(pattern: static string): untyped

fmWrite:

• FileMode.fmWrite

focus:

• dom: focus(e: Element)
• dom: focus(e: Node)
• dom: focus(w: Window)

foldl:

• sequtils: foldl(sequence, operation, first): untyped
• sequtils: foldl(sequence, operation: untyped): untyped

foldr:

• sequtils: foldr(sequence, operation: untyped): untyped

FontFaceSet:

• dom: FontFaceSet

FontFaceSetReady:

• dom: FontFaceSetReady

footer:

• htmlgen: footer(e: varargs[untyped]): untyped

for-loop macro:

• Module system

forall:

• logic: forall(args: varargs[untyped]): bool

ForegroundColor:

• terminal: ForegroundColor

ForeignCell:

• system: ForeignCell

foreignCmd:

• distros: foreignCmd(cmd: string; requiresSudo = false)

foreignDep:

• distros: foreignDep(foreignPackageName: string)

foreignDepInstallCmd:

• distros: foreignDepInstallCmd(foreignPackageName: string): (string, bool)

foreignDeps:

• distros: foreignDeps

ForLoopStmt:

• system: ForLoopStmt

form:

• htmlgen: form(e: varargs[untyped]): untyped

format:

• Module strformat
• strutils: format(formatstr: string; a: varargs[string, `$`]): string
• times: format(dt: DateTime; f: static[string]): string
• times: format(dt: DateTime; f: string; loc: DateTimeLocale = DefaultLocale): string
• times: format(dt: DateTime; f: TimeFormat; loc: DateTimeLocale = DefaultLocale): string
• times: format(time: Time; f: static[string]; zone: Timezone = local()): string
• times: format(time: Time; f: string; zone: Timezone = local()): string

formatBiggestFloat:

• strutils: formatBiggestFloat(f: BiggestFloat; format: FloatFormatMode = ffDefault; precision: range[-1 .. 32] = 16; decimalSep = '.'): string

formatEng:

• strutils: formatEng(f: BiggestFloat; precision: range[0 .. 32] = 10; trim: bool = true; siPrefix: bool = false; unit: string = ""; decimalSep = '.'; useUnitSpace = false): string

formatErrorIndexBound:

• system: formatErrorIndexBound[T](i, n: T): string
• system: formatErrorIndexBound[T](i, a, b: T): string

formatFieldDefect:

• system: formatFieldDefect(f, discVal): string

FormatFlag:

• strtabs: FormatFlag

formatFloat:

• strutils: formatFloat(f: float; format: FloatFormatMode = ffDefault; precision: range[-1 .. 32] = 16; decimalSep = '.'): string

formatMessageW:

• winlean: formatMessageW(dwFlags: int32; lpSource: pointer; dwMessageId, dwLanguageId: int32; lpBuffer: pointer; nSize: int32; arguments: pointer): int32

formatNamedVars:

• rstgen: formatNamedVars(frmt: string; varnames: openArray[string]; varvalues: openArray[string]): string

formatSize:

• strutils: formatSize(bytes: int64; decimalSep = '.'; prefix = bpIEC; includeSpace = false): string

formatStr:

• util: formatStr(howExpr, namegetter, idgetter): untyped

formatValue:

• strformat: formatValue(result: var string; value: SomeFloat; specifier: string)
• strformat: formatValue(result: var string; value: string; specifier: string)
• strformat: formatValue[T: SomeInteger](result: var string; value: T; specifier: string)
• times: formatValue(result: var string; value: DateTime; specifier: string)
• times: formatValue(result: var string; value: Time; specifier: string)

formData:

• jsfetch: formData(self: Body): Future[FormData]

FormData:

• jsformdata: FormData

FormElement:

• dom: FormElement

forward:

• dom: forward(h: History)
• dom: forward(w: Window)

forwardImpl:

• bitops_utils: forwardImpl(impl, arg)

FourthButton:

• MouseButtons.FourthButton

fpGroupExec:

• FilePermission.fpGroupExec

fpGroupRead:

• FilePermission.fpGroupRead

fpGroupWrite:

• FilePermission.fpGroupWrite

fpOthersExec:

• FilePermission.fpOthersExec

fpOthersRead:

• FilePermission.fpOthersRead

fpOthersWrite:

• FilePermission.fpOthersWrite

fpRadix:

• fenv: fpRadix(): int

fpUserExec:

• FilePermission.fpUserExec

fpUserRead:

• FilePermission.fpUserRead

fpUserWrite:

• FilePermission.fpUserWrite

Frame:

• dom: Frame

free:

• linenoise: free(s: cstring)

freeaddrinfo:

• winlean: freeaddrinfo(ai: ptr AddrInfo)

freeEnvironmentStringsW:

• winlean: freeEnvironmentStringsW(para1: WideCString): int32

freeShared:

• system: freeShared[T](p: ptr T)

freeSid:

• winlean: freeSid(pSid: PSID): PSID

frError:

• FetchRedirects.frError

frexp:

• math: frexp[T: float32 | float64](x: T): tuple[frac: T, exp: int]
• math: frexp[T: float32 | float64](x: T; exponent: var int): T

frFollow:

• FetchRedirects.frFollow

frManual:

• FetchRedirects.frManual

fromBin:

• strutils: fromBin[T: SomeInteger](s: string): T

fromHex:

• strutils: fromHex[T: SomeInteger](s: string): T

fromJson:

• jsonutils: fromJson[T](a: var T; b: JsonNode; opt = Joptions())

fromJsonHook:

• jsonutils: fromJsonHook[K: string | cstring; V](t: var (Table[K, V] | OrderedTable[K, V]); jsonNode: JsonNode)
• jsonutils: fromJsonHook[T](self: var Option[T]; jsonNode: JsonNode)
• jsonutils: fromJsonHook[A](s: var SomeSet[A]; jsonNode: JsonNode)
• jsonutils: fromJsonHook(a: var StringTableRef; b: JsonNode)

fromOct:

• strutils: fromOct[T: SomeInteger](s: string): T

fromSockAddr:

• net: fromSockAddr(sa: Sockaddr_storage | SockAddr | Sockaddr_in | Sockaddr_in6; sl: SockLen; address: var IpAddress; port: var Port)

fromUnix:

• times: fromUnix(unix: int64): Time

fromUnixFloat:

• times: fromUnixFloat(seconds: float): Time

fromWinTime:

• times: fromWinTime(win: int64): Time

fround:

• jscore: fround(m: MathLib; f: SomeFloat): float32

frpNoReferrer:

• FetchReferrerPolicies.frpNoReferrer

frpNoReferrerWhenDowngrade:

• FetchReferrerPolicies.frpNoReferrerWhenDowngrade

frpOrigin:

• FetchReferrerPolicies.frpOrigin

frpOriginWhenCrossOrigin:

• FetchReferrerPolicies.frpOriginWhenCrossOrigin

frpUnsafeUrl:

• FetchReferrerPolicies.frpUnsafeUrl

fspCur:

• FileSeekPos.fspCur

fspEnd:

• FileSeekPos.fspEnd

fspSet:

• FileSeekPos.fspSet

fsync:

• posix_utils: fsync(fd: int)

FtpEvent:

• asyncftpclient: FtpEvent

FtpEventType:

• asyncftpclient: FtpEventType

FtpJobType:

• asyncftpclient: FtpJobType

fullSet:

• setutils: fullSet[T](U: typedesc[T]): set[T]

Future:

• asyncfutures: Future
• asyncjs: Future

FutureBase:

• asyncfutures: FutureBase

FutureError:

• asyncfutures: FutureError

FutureStream:

• asyncstreams: FutureStream

FutureVar:

• asyncfutures: FutureVar

gamma:

• math: gamma(x: float32): float32
• math: gamma(x: float64): float64

gauss:

• random: gauss(mu = 0.0; sigma = 1.0): float
• random: gauss(r: var Rand; mu = 0.0; sigma = 1.0): float

GC_collectZct:

• system: GC_collectZct()

gcd:

• math: gcd[T](x: openArray[T]): T
• math: gcd(x, y: SomeInteger): SomeInteger
• math: gcd[T](x, y: T): T

GC_disable:

• system: GC_disable()

GC_disableMarkAndSweep:

• system: GC_disableMarkAndSweep()

GC_enable:

• system: GC_enable()

GC_enableMarkAndSweep:

• system: GC_enableMarkAndSweep()

GC_fullCollect:

• system: GC_fullCollect()

GC_getStatistics:

• system: GC_getStatistics(): string

gcInvariant:

• system: gcInvariant()

gcOptimizeSpace:

• GC_Strategy.gcOptimizeSpace

gcOptimizeTime:

• GC_Strategy.gcOptimizeTime

GC_ref:

• system: GC_ref[T](x: ref T)
• system: GC_ref[T](x: seq[T])
• system: GC_ref(x: string)

gcResponsiveness:

• GC_Strategy.gcResponsiveness

GC_Strategy:

• system: GC_Strategy

gcThroughput:

• GC_Strategy.gcThroughput

GC_unref:

• system: GC_unref[T](x: ref T)
• system: GC_unref[T](x: seq[T])
• system: GC_unref(x: string)

genAst:

• genasts: genAst(args: varargs[untyped]): untyped

GenAstOpt:

• genasts: GenAstOpt

genAstOpt:

• genasts: genAstOpt(options: static set[GenAstOpt]; args: varargs[untyped]): untyped

genEnumCaseStmt:

• enumutils: genEnumCaseStmt(typ: typedesc; argSym: typed; default: typed; userMin, userMax: static[int]; normalizer: static[proc (s: string): string]): untyped

GeneralTokenizer:

• highlite: GeneralTokenizer

generatedTime:

• oids: generatedTime(oid: Oid): Time

generic character types:

• Generic character types

GENERIC_ALL:

• winlean: GENERIC_ALL

genericHead:

• typetraits: genericHead(t: typedesc): typedesc

genericParams:

• typetraits: genericParams(T: typedesc): untyped

GENERIC_READ:

• winlean: GENERIC_READ

GENERIC_WRITE:

• winlean: GENERIC_WRITE

genOid:

• oids: genOid(): Oid

genSym:

• macros: genSym(kind: NimSymKind = nskLet; ident = ""): NimNode

genTempPath:

• tempfiles: genTempPath(prefix, suffix: string; dir = ""): string

get:

• httpclient: get(client: AsyncHttpClient; url: Uri | string): Future[AsyncResponse]
• httpclient: get(client: HttpClient; url: Uri | string): Response
• nimscript: get(key: string): string
• options: get[T](self: Option[T]): lent T
• options: get[T](self: Option[T]; otherwise: T): T
• options: get[T](self: var Option[T]): var T
• typetraits: get(T: typedesc[tuple]; i: static int): untyped

getAddrInfo:

• nativesockets: getAddrInfo(address: string; port: Port; domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP): ptr AddrInfo

getaddrinfo:

• winlean: getaddrinfo(nodename, servname: cstring; hints: ptr AddrInfo; res: var ptr AddrInfo): cint

getAddrString:

• nativesockets: getAddrString(sockAddr: ptr SockAddr): string
• nativesockets: getAddrString(sockAddr: ptr SockAddr; strAddress: var string)

getAlign:

• macros: getAlign(arg: NimNode): int

getAll:

• jsformdata: getAll(self: FormData; name: cstring): seq[cstring]

getAllocStats:

• system: getAllocStats(): AllocStats

getAllRows:

• db_mysql: getAllRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): seq[Row]
• db_odbc: getAllRows(db: var DbConn; query: SqlQuery; args: varargs[string, `$`]): seq[Row]
• db_postgres: getAllRows(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): seq[ Row]
• db_postgres: getAllRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): seq[Row]
• db_sqlite: getAllRows(db: DbConn; stmtName: SqlPrepared): seq[Row]
• db_sqlite: getAllRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): seq[Row]

getAppDir:

• os: getAppDir(): string

getAppFilename:

• os: getAppFilename(): string

getAsFile:

• dom: getAsFile(dti: DataTransferItem): File

getAst:

• macros: getAst(macroOrTemplate: untyped): NimNode

getAttribute:

• dom: getAttribute(n: Node; attr: cstring): cstring

getAttributeNode:

• dom: getAttributeNode(n: Node; attr: cstring): Node

getBiggestFloat:

• typeinfo: getBiggestFloat(x: Any): BiggestFloat

getBiggestInt:

• json: getBiggestInt(n: JsonNode; default: BiggestInt = 0): BiggestInt
• typeinfo: getBiggestInt(x: Any): BiggestInt

getBiggestUint:

• typeinfo: getBiggestUint(x: Any): uint64

getBool:

• json: getBool(n: JsonNode; default: bool = false): bool
• typeinfo: getBool(x: Any): bool

getBoundingClientRect:

• dom: getBoundingClientRect(e: Node): BoundingRect

getCacheDir:

• os: getCacheDir(): string
• os: getCacheDir(app: string): string

getCallSoonProc:

• asyncfutures: getCallSoonProc(): (proc (cbproc: proc ()) {.gcsafe.})

getch:

• terminal: getch(): char

getChar:

• typeinfo: getChar(x: Any): char

getClockStr:

• times: getClockStr(dt = now()): string

getColNumber:

• lexbase: getColNumber(L: BaseLexer; pos: int): int

getColumn:

• parsecfg: getColumn(c: CfgParser): int
• parsejson: getColumn(my: JsonParser): int
• parsexml: getColumn(my: XmlParser): int
• sexp: getColumn(my: SexpParser): int

getCommand:

• nimscript: getCommand(): string

getCommandLineW:

• winlean: getCommandLineW(): WideCString

getComputedStyle:

• dom: getComputedStyle(w: Window; e: Node; pe: Node = nil): Style

getConfigDir:

• os: getConfigDir(): string

getCons:

• sexp: getCons(n: SexpNode; defaults: Cons = (newSNil(), newSNil())): Cons

getContent:

• httpclient: getContent(client: AsyncHttpClient; url: Uri | string): Future[string]
• httpclient: getContent(client: HttpClient; url: Uri | string): string

getContentLength:

• cgi: getContentLength(): string

getContentType:

• cgi: getContentType(): string

getCookie:

• cgi: getCookie(name: string): string

getCreationTime:

• os: getCreationTime(file: string): times.Time

getCString:

• typeinfo: getCString(x: Any): cstring

getCurrentCompilerExe:

• os: getCurrentCompilerExe(): string

getCurrentDir:

• nimscript: getCurrentDir(): string
• os: getCurrentDir(): string

getCurrentDirectoryW:

• winlean: getCurrentDirectoryW(nBufferLength: int32; lpBuffer: WideCString): int32

getCurrentEncoding:

• encodings: getCurrentEncoding(uiApp = false): string

getCurrentException:

• system: getCurrentException(): ref Exception

getCurrentExceptionMsg:

• system: getCurrentExceptionMsg(): string

GetCurrentFiber:

• winlean: GetCurrentFiber(): pointer

getCurrentLine:

• lexbase: getCurrentLine(L: BaseLexer; marker: bool = true): string

getCurrentProcess:

• winlean: getCurrentProcess(): Handle

getCurrentProcessId:

• os: getCurrentProcessId(): int

getCustomPragmaVal:

• macros: getCustomPragmaVal(n: typed; cp: typed{nkSym}): untyped

getData:

• dom: getData(dt: DataTransfer; format: cstring): cstring
• selectors: getData[T](s: Selector[T]; fd: SocketHandle | int): var T

getDataUri:

• uri: getDataUri(data, mime: string; encoding = "utf-8"): string

getDateStr:

• times: getDateStr(dt = now()): string

getDay:

• jscore: getDay(d: DateTime): int

getDayOfWeek:

• times: getDayOfWeek(monthday: MonthdayRange; month: Month; year: int): WeekDay

getDayOfYear:

• times: getDayOfYear(monthday: MonthdayRange; month: Month; year: int): YeardayRange

getDaysInMonth:

• times: getDaysInMonth(month: Month; year: int): int

getDaysInYear:

• times: getDaysInYear(year: int): int

getDocumentRoot:

• cgi: getDocumentRoot(): string

getElementById:

• dom: getElementById(id: cstring): Element
• dom: getElementById(d: Document; id: cstring): Element

getElementsByClass:

• dom: getElementsByClass(n: Node; name: cstring): seq[Node]

getElementsByClassName:

• dom: getElementsByClassName(d: Document; name: cstring): seq[Element]
• dom: getElementsByClassName(e: Element; name: cstring): seq[Element]

getElementsByName:

• dom: getElementsByName(d: Document; name: cstring): seq[Element]

getElementsByTagName:

• dom: getElementsByTagName(d: Document; name: cstring): seq[Element]
• dom: getElementsByTagName(e: Element; name: cstring): seq[Element]

getElems:

• json: getElems(n: JsonNode; default: seq[JsonNode] = @[]): seq[JsonNode]
• sexp: getElems(n: SexpNode; default: seq[SexpNode] = @[]): seq[SexpNode]

getEnumField:

• typeinfo: getEnumField(x: Any): string
• typeinfo: getEnumField(x: Any; ordinalValue: int): string

getEnumOrdinal:

• typeinfo: getEnumOrdinal(x: Any; name: string): int

getEnv:

• nimscript: getEnv(key: string; default = ""): string
• os: getEnv(key: string; default = ""): string

getEnvironmentStringsW:

• winlean: getEnvironmentStringsW(): WideCString

getExitCodeProcess:

• winlean: getExitCodeProcess(hProcess: Handle; lpExitCode: var int32): WINBOOL

getExt:

• mimetypes: getExt(mimedb: MimeDB; mimetype: string; default = "txt"): string

getExtraData:

• net: getExtraData(ctx: SslContext; index: int): RootRef

getFd:

• asyncnet: getFd(socket: AsyncSocket): SocketHandle
• net: getFd(socket: Socket): SocketHandle
• selectors: getFd[T](s: Selector[T]): int

getFields:

• json: getFields(n: JsonNode; default = initOrderedTable(2)): OrderedTable[string, JsonNode]

getFileAttributesW:

• winlean: getFileAttributesW(lpFileName: WideCString): int32

getFileHandle:

• io: getFileHandle(f: File): FileHandle

getFileInfo:

• os: getFileInfo(file: File): FileInfo
• os: getFileInfo(handle: FileHandle): FileInfo
• os: getFileInfo(path: string; followSymlink = true): FileInfo

getFileInformationByHandle:

• winlean: getFileInformationByHandle(hFile: Handle; lpFileInformation: ptr BY_HANDLE_FILE_INFORMATION): WINBOOL

getFilename:

• parsecfg: getFilename(c: CfgParser): string
• parsejson: getFilename(my: JsonParser): string
• parsexml: getFilename(my: XmlParser): string

getFilePermissions:

• os: getFilePermissions(filename: string): set[FilePermission]

getFilePos:

• asyncfile: getFilePos(f: AsyncFile): int64
• io: getFilePos(f: File): int64

getFileSize:

• asyncfile: getFileSize(f: AsyncFile): int64
• io: getFileSize(f: File): int64
• os: getFileSize(file: string): BiggestInt
• winlean: getFileSize(hFile: Handle; lpFileSizeHigh: ptr DWORD): DWORD

getFloat:

• json: getFloat(n: JsonNode; default: float = 0.0): float
• parsejson: getFloat(my: JsonParser): float
• sexp: getFloat(my: SexpParser): float
• typeinfo: getFloat(x: Any): float

getFloat32:

• typeinfo: getFloat32(x: Any): float32

getFloat64:

• typeinfo: getFloat64(x: Any): float64

getFNum:

• sexp: getFNum(n: SexpNode; default: float = 0.0): float

getFrame:

• system: getFrame(): PFrame

getFrameState:

• system: getFrameState(): FrameState

getFreeMem:

• system: getFreeMem(): int

getFullPathNameW:

• winlean: getFullPathNameW(lpFileName: WideCString; nBufferLength: int32; lpBuffer: WideCString; lpFilePart: var WideCString): int32

getFullYear:

• jscore: getFullYear(d: DateTime): int

getGatewayInterface:

• cgi: getGatewayInterface(): string

getGcFrame:

• system: getGcFrame(): GcFrame

getGlobalDispatcher:

• asyncdispatch: getGlobalDispatcher(): PDispatcher

getHandleInformation:

• winlean: getHandleInformation(hObject: Handle; lpdwFlags: ptr DWORD): WINBOOL

getHandlers:

• logging: getHandlers(): seq[Logger]

getHomeDir:

• os: getHomeDir(): string

getHostByAddr:

• nativesockets: getHostByAddr(ip: string): Hostent

gethostbyaddr:

• winlean: gethostbyaddr(ip: ptr InAddr; len: cuint; theType: cint): ptr Hostent

getHostByName:

• nativesockets: getHostByName(name: string): Hostent

gethostbyname:

• winlean: gethostbyname(name: cstring): ptr Hostent

getHostname:

• nativesockets: getHostname(): string

gethostname:

• winlean: gethostname(hostname: cstring; len: cint): cint

getHours:

• jscore: getHours(d: DateTime): int

getHttpAccept:

• cgi: getHttpAccept(): string

getHttpAcceptCharset:

• cgi: getHttpAcceptCharset(): string

getHttpAcceptEncoding:

• cgi: getHttpAcceptEncoding(): string

getHttpAcceptLanguage:

• cgi: getHttpAcceptLanguage(): string

getHttpConnection:

• cgi: getHttpConnection(): string

getHttpCookie:

• cgi: getHttpCookie(): string

getHttpHost:

• cgi: getHttpHost(): string

getHttpReferer:

• cgi: getHttpReferer(): string

getHttpUserAgent:

• cgi: getHttpUserAgent(): string

getImpl:

• macros: getImpl(symbol: NimNode): NimNode
• macros: getImpl(s: NimSym): NimNode

getImplTransformed:

• macros: getImplTransformed(symbol: NimNode): NimNode

getInt:

• json: getInt(n: JsonNode; default: int = 0): int
• parsejson: getInt(my: JsonParser): BiggestInt
• sexp: getInt(my: SexpParser): BiggestInt
• typeinfo: getInt(x: Any): int

getInt16:

• typeinfo: getInt16(x: Any): int16

getInt32:

• typeinfo: getInt32(x: Any): int32

getInt64:

• typeinfo: getInt64(x: Any): int64

getInt8:

• typeinfo: getInt8(x: Any): int8

getIoHandler:

• asyncdispatch: getIoHandler(disp: PDispatcher): Handle

getItem:

• dom: getItem(s: Storage; key: cstring): cstring

getLastAccessTime:

• os: getLastAccessTime(file: string): times.Time

getLastError:

• winlean: getLastError(): int32

getLastModificationTime:

• os: getLastModificationTime(file: string): times.Time

getLine:

• parsecfg: getLine(c: CfgParser): int
• parsejson: getLine(my: JsonParser): int
• parsexml: getLine(my: XmlParser): int
• sexp: getLine(my: SexpParser): int

getLocalAddr:

• asyncnet: getLocalAddr(socket: AsyncSocket): (string, Port)
• nativesockets: getLocalAddr(socket: SocketHandle; domain: Domain): (string, Port)
• net: getLocalAddr(socket: Socket): (string, Port)

getLogFilter:

• logging: getLogFilter(): Level

getMaxMem:

• system: getMaxMem(): int

getMD5:

• md5: getMD5(s: string): string

getMilliseconds:

• jscore: getMilliseconds(d: DateTime): int

getMimetype:

• mimetypes: getMimetype(mimedb: MimeDB; ext: string; default = "text/plain"): string

getMinutes:

• jscore: getMinutes(d: DateTime): int

getModifierState:

• dom: getModifierState(ev: KeyboardEvent; keyArg: cstring): bool
• dom: getModifierState(ev: MouseEvent; keyArg: cstring): bool

getModuleFileNameW:

• winlean: getModuleFileNameW(handle: Handle; buf: WideCString; size: int32): int32

getMonoTime:

• monotimes: getMonoTime(): MonoTime

getMonth:

• jscore: getMonth(d: DateTime): int

getnameinfo:

• winlean: getnameinfo(a1: ptr SockAddr; a2: SockLen; a3: cstring; a4: SockLen; a5: cstring; a6: SockLen; a7: cint): cint

getNextToken:

• highlite: getNextToken(g: var GeneralTokenizer; lang: SourceLanguage)

getNum:

• mersenne: getNum(m: var MersenneTwister): uint32
• sexp: getNum(n: SexpNode; default: BiggestInt = 0): BiggestInt

getOccupiedMem:

• system: getOccupiedMem(): int

getOffset:

• macros: getOffset(arg: NimNode): int

getopt:

• parseopt: getopt(p: var OptParser): tuple[kind: CmdLineKind, key, val: string]
• parseopt: getopt(cmdline: seq[string] = @[]; shortNoVal: set[char] = {}; longNoVal: seq[string] = @[]): tuple[kind: CmdLineKind, key, val: string]

getOrDefault:

• httpcore: getOrDefault(headers: HttpHeaders; key: string; default = @[""].HttpHeaderValues): HttpHeaderValues
• json: getOrDefault(node: JsonNode; key: string): JsonNode
• strtabs: getOrDefault(t: StringTableRef; key: string; default: string = ""): string
• tables: getOrDefault[A](t: CountTable[A]; key: A; default: int = 0): int
• tables: getOrDefault[A](t: CountTableRef[A]; key: A; default: int): int
• tables: getOrDefault[A, B](t: OrderedTable[A, B]; key: A): B
• tables: getOrDefault[A, B](t: OrderedTable[A, B]; key: A; default: B): B
• tables: getOrDefault[A, B](t: OrderedTableRef[A, B]; key: A): B
• tables: getOrDefault[A, B](t: OrderedTableRef[A, B]; key: A; default: B): B
• tables: getOrDefault[A, B](t: Table[A, B]; key: A): B
• tables: getOrDefault[A, B](t: Table[A, B]; key: A; default: B): B
• tables: getOrDefault[A, B](t: TableRef[A, B]; key: A): B
• tables: getOrDefault[A, B](t: TableRef[A, B]; key: A; default: B): B

get_osfhandle:

• winlean: get_osfhandle(fd: FileHandle): Handle

getOsFileHandle:

• io: getOsFileHandle(f: File): FileHandle

getOverlappedResult:

• winlean: getOverlappedResult(hFile: Handle; lpOverlapped: POVERLAPPED; lpNumberOfBytesTransferred: var DWORD; bWait: WINBOOL): WINBOOL

getPathInfo:

• cgi: getPathInfo(): string

getPathTranslated:

• cgi: getPathTranslated(): string

getPeerAddr:

• asyncnet: getPeerAddr(socket: AsyncSocket): (string, Port)
• nativesockets: getPeerAddr(socket: SocketHandle; domain: Domain): (string, Port)
• net: getPeerAddr(socket: Socket): (string, Port)

getPeerCertificates:

• asyncnet: getPeerCertificates(socket: AsyncSocket): seq[Certificate]
• net: getPeerCertificates(socket: Socket): seq[Certificate]
• net: getPeerCertificates(sslHandle: SslPtr): seq[Certificate]

getpeername:

• Module asyncnet
• Module nativesockets
• Module net
• winlean: getpeername(s: SocketHandle; name: ptr SockAddr; namelen: ptr SockLen): cint

getPFrame:

• stackframes: getPFrame(): PFrame

getPointer:

• typeinfo: getPointer(x: Any): pointer

getPort:

• asynchttpserver: getPort(self: AsyncHttpServer): Port

getPosition:

• streams: getPosition(s: Stream): int

getPrimaryIPAddr:

• net: getPrimaryIPAddr(dest = parseIpAddress("8.8.8.8")): IpAddress

getProcessTimes:

• winlean: getProcessTimes(hProcess: Handle; lpCreationTime, lpExitTime, lpKernelTime, lpUserTime: var FILETIME): WINBOOL

getProgramResult:

• exitprocs: getProgramResult(): int

getProjectPath:

• macros: getProjectPath(): string

getPropertyPriority:

• dom: getPropertyPriority(s: Style; property: cstring): cstring

getPropertyValue:

• dom: getPropertyValue(s: Style; property: cstring): cstring

getProtoByName:

• nativesockets: getProtoByName(name: string): int

getprotobyname:

• winlean: getprotobyname(name: cstring): ptr Protoent

getprotobynumber:

• winlean: getprotobynumber(proto: cint): ptr Protoent

getProtoName:

• jsutils: getProtoName[T](a: T): cstring

getPskIdentity:

• net: getPskIdentity(socket: Socket): string

getQueryString:

• cgi: getQueryString(): string

getQueuedCompletionStatus:

• winlean: getQueuedCompletionStatus(CompletionPort: Handle; lpNumberOfBytesTransferred: PDWORD; lpCompletionKey: PULONG_PTR; lpOverlapped: ptr POVERLAPPED; dwMilliseconds: DWORD): WINBOOL

getRaisesList:

• effecttraits: getRaisesList(fn: NimNode): NimNode

getRangeAt:

• dom: getRangeAt(s: Selection; index: int): Range

getRawData:

• rtarrays: getRawData[T](x: var RtArray[T]): ptr UncheckedArray[T]

getRemoteAddr:

• cgi: getRemoteAddr(): string

getRemoteHost:

• cgi: getRemoteHost(): string

getRemoteIdent:

• cgi: getRemoteIdent(): string

getRemotePort:

• cgi: getRemotePort(): string

getRemoteUser:

• cgi: getRemoteUser(): string

getRequestMethod:

• cgi: getRequestMethod(): string

getRequestURI:

• cgi: getRequestURI(): string

getRootNode:

• dom: getRootNode(n: Node; options: RootNodeOptions): Node

getRow:

• db_mysql: getRow(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
• db_odbc: getRow(db: var DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
• db_postgres: getRow(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): Row
• db_postgres: getRow(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
• db_sqlite: getRow(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row

getScriptFilename:

• cgi: getScriptFilename(): string

getScriptName:

• cgi: getScriptName(): string

getSeconds:

• jscore: getSeconds(d: DateTime): int

getSectionValue:

• parsecfg: getSectionValue(dict: Config; section, key: string; defaultVal = ""): string

getSelection:

• dom: getSelection(d: Document): Selection
• dom: getSelection(n: DocumentOrShadowRoot): Selection

getServByName:

• nativesockets: getServByName(name, proto: string): Servent

getservbyname:

• winlean: getservbyname(name, proto: cstring): ptr Servent

getServByPort:

• nativesockets: getServByPort(port: Port; proto: string): Servent

getservbyport:

• winlean: getservbyport(port: cint; proto: cstring): ptr Servent

getServerAddr:

• cgi: getServerAddr(): string

getServerAdmin:

• cgi: getServerAdmin(): string

getServerName:

• cgi: getServerName(): string

getServerPort:

• cgi: getServerPort(): string

getServerProtocol:

• cgi: getServerProtocol(): string

getServerSignature:

• cgi: getServerSignature(): string

getServerSoftware:

• cgi: getServerSoftware(): string

getSize:

• macros: getSize(arg: NimNode): int

getSockDomain:

• nativesockets: getSockDomain(socket: SocketHandle): Domain

getSocket:

• httpclient: getSocket(client: AsyncHttpClient): AsyncSocket
• httpclient: getSocket(client: HttpClient): Socket

getSocketError:

• net: getSocketError(socket: Socket): OSErrorCode

getsockname:

• Module asyncnet

getSockName:

• nativesockets: getSockName(socket: SocketHandle): Port

getsockname:

• Module nativesockets
• Module net
• winlean: getsockname(s: SocketHandle; name: ptr SockAddr; namelen: ptr SockLen): cint

getSockOpt:

• asyncnet: getSockOpt(socket: AsyncSocket; opt: SOBool; level = SOL_SOCKET): bool
• net: getSockOpt(socket: Socket; opt: SOBool; level = SOL_SOCKET): bool

getsockopt:

• winlean: getsockopt(s: SocketHandle; level, optname: cint; optval: pointer; optlen: ptr SockLen): cint

getSockOptInt:

• nativesockets: getSockOptInt(socket: SocketHandle; level, optname: int): int

getSourceLanguage:

• highlite: getSourceLanguage(name: string): SourceLanguage

getStackTrace:

• system: getStackTrace(): string
• system: getStackTrace(e: ref Exception): string

getStackTraceEntries:

• system: getStackTraceEntries(): seq[StackTraceEntry]
• system: getStackTraceEntries(e: ref Exception): lent seq[StackTraceEntry]

getStdHandle:

• winlean: getStdHandle(nStdHandle: int32): Handle

getStr:

• json: getStr(n: JsonNode; default: string = ""): string
• sexp: getStr(n: SexpNode; default: string = ""): string

getString:

• typeinfo: getString(x: Any): string

getSymbol:

• sexp: getSymbol(n: SexpNode; default: string = ""): string

getSystemTimeAsFileTime:

• winlean: getSystemTimeAsFileTime(lpSystemTimeAsFileTime: var FILETIME)

getSystemTimePreciseAsFileTime:

• winlean: getSystemTimePreciseAsFileTime(lpSystemTimeAsFileTime: var FILETIME)

getSystemTimes:

• winlean: getSystemTimes(lpIdleTime, lpKernelTime, lpUserTime: var FILETIME): WINBOOL

getTagsList:

• effecttraits: getTagsList(fn: NimNode): NimNode

getTempDir:

• os: getTempDir(): string

getThreadId:

• threads: getThreadId*(): int

getTime:

• jscore: getTime(d: DateTime): int
• times: getTime(): Time

getTimezoneOffset:

• jscore: getTimezoneOffset(d: DateTime): int

getTok:

• parsejson: getTok(my: var JsonParser): TokKind

getTotalMem:

• system: getTotalMem(): int

getType:

• macros: getType(n: NimNode): NimNode
• macros: getType(n: typedesc): NimNode

getTypeImpl:

• macros: getTypeImpl(n: NimNode): NimNode
• macros: getTypeImpl(n: typedesc): NimNode

getTypeInfo:

• system: getTypeInfo[T](x: T): pointer

getTypeInst:

• macros: getTypeInst(n: NimNode): NimNode
• macros: getTypeInst(n: typedesc): NimNode

getUInt:

• typeinfo: getUInt(x: Any): uint

getUInt16:

• typeinfo: getUInt16(x: Any): uint16

getUInt32:

• typeinfo: getUInt32(x: Any): uint32

getUInt64:

• typeinfo: getUInt64(x: Any): uint64

getUInt8:

• typeinfo: getUInt8(x: Any): uint8

getUnicodeValue:

• registry: getUnicodeValue(path, key: string; handle: HKEY): string

getUTCDate:

• jscore: getUTCDate(d: DateTime): int

getUTCDay:

• jscore: getUTCDay(d: DateTime): int

getUTCFullYear:

• jscore: getUTCFullYear(d: DateTime): int

getUTCHours:

• jscore: getUTCHours(d: DateTime): int

getUTCMilliseconds:

• jscore: getUTCMilliseconds(d: DateTime): int

getUTCMinutes:

• jscore: getUTCMinutes(d: DateTime): int

getUTCMonth:

• jscore: getUTCMonth(d: DateTime): int

getUTCSeconds:

• jscore: getUTCSeconds(d: DateTime): int

getValue:

• db_mysql: getValue(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): string
• db_odbc: getValue(db: var DbConn; query: SqlQuery; args: varargs[string, `$`]): string
• db_postgres: getValue(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): string
• db_postgres: getValue(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): string
• db_sqlite: getValue(db: DbConn; stmtName: SqlPrepared): string
• db_sqlite: getValue(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): string

getVersion:

• winlean: getVersion(): DWORD

getVersionExA:

• winlean: getVersionExA(lpVersionInfo: ptr OSVERSIONINFO): WINBOOL

getVersionExW:

• winlean: getVersionExW(lpVersionInfo: ptr OSVERSIONINFO): WINBOOL

getYear:

• jscore: getYear(d: DateTime): int

glob:

• Module os
• Module os
• Module os

globalRaiseHook:

• system: globalRaiseHook

go:

• dom: go(h: History; pagesToJump: int)

gorge:

• system: gorge(command: string; input = ""; cache = ""): string

gorgeEx:

• system: gorgeEx(command: string; input = ""; cache = ""): tuple[output: string, exitCode: int]

graphemeLen:

• unicode: graphemeLen(s: string; i: Natural): Natural

group:

• jsconsole: group(console: Console; label = "".cstring)

groupCollapsed:

• jsconsole: groupCollapsed(console: Console; label = "".cstring)

groupEnd:

• jsconsole: groupEnd(console: Console)

gtAssembler:

• TokenClass.gtAssembler

gtBinNumber:

• TokenClass.gtBinNumber

gtCharLit:

• TokenClass.gtCharLit

gtCommand:

• TokenClass.gtCommand

gtComment:

• TokenClass.gtComment

gtDecNumber:

• TokenClass.gtDecNumber

gtDirective:

• TokenClass.gtDirective

gtEof:

• TokenClass.gtEof

gtEscapeSequence:

• TokenClass.gtEscapeSequence

gtFloatNumber:

• TokenClass.gtFloatNumber

gtHexNumber:

• TokenClass.gtHexNumber

gtHyperlink:

• TokenClass.gtHyperlink

gtIdentifier:

• TokenClass.gtIdentifier

gtKey:

• TokenClass.gtKey

gtKeyword:

• TokenClass.gtKeyword

gtLabel:

• TokenClass.gtLabel

gtLongComment:

• TokenClass.gtLongComment

gtLongStringLit:

• TokenClass.gtLongStringLit

gtNone:

• TokenClass.gtNone

gtOctNumber:

• TokenClass.gtOctNumber

gtOperator:

• TokenClass.gtOperator

gtOption:

• TokenClass.gtOption

gtOther:

• TokenClass.gtOther

gtPreprocessor:

• TokenClass.gtPreprocessor

gtProgram:

• TokenClass.gtProgram

gtProgramOutput:

• TokenClass.gtProgramOutput

gtPrompt:

• TokenClass.gtPrompt

gtPunctuation:

• TokenClass.gtPunctuation

gtRawData:

• TokenClass.gtRawData

gtReference:

• TokenClass.gtReference

gtRegularExpression:

• TokenClass.gtRegularExpression

gtRule:

• TokenClass.gtRule

gtStringLit:

• TokenClass.gtStringLit

gtTagEnd:

• TokenClass.gtTagEnd

gtTagStart:

• TokenClass.gtTagStart

gtValue:

• TokenClass.gtValue

gtWhitespace:

• TokenClass.gtWhitespace

GUID:

• winlean: GUID

h1:

• htmlgen: h1(e: varargs[untyped]): untyped

h2:

• htmlgen: h2(e: varargs[untyped]): untyped

h3:

• htmlgen: h3(e: varargs[untyped]): untyped

h4:

• htmlgen: h4(e: varargs[untyped]): untyped

h5:

• htmlgen: h5(e: varargs[untyped]): untyped

h6:

• htmlgen: h6(e: varargs[untyped]): untyped

Hamming weight:

• Module bitops

handle:

• threads: handle*[TArg](t: Thread[TArg]): SysThread

Handle:

• winlean: Handle

handleCR:

• lexbase: handleCR(L: var BaseLexer; pos: int): int

handleEvent:

• dom: handleEvent(d: Document; event: Event)
• dom: handleEvent(e: Element; event: Event)
• dom: handleEvent(w: Window; e: Event)

HANDLE_FLAG_INHERIT:

• winlean: HANDLE_FLAG_INHERIT

handleHexChar:

• decode_helpers: handleHexChar(c: char): int
• decode_helpers: handleHexChar(c: char; x: var int): bool

handleLF:

• lexbase: handleLF(L: var BaseLexer; pos: int): int

handleRefillChar:

• lexbase: handleRefillChar(L: var BaseLexer; pos: int): int

handshakeAsClient:

• SslHandshakeType.handshakeAsClient

handshakeAsServer:

• SslHandshakeType.handshakeAsServer

hasAnyModuleChanged:

• hotcodereloading: hasAnyModuleChanged(): bool

hasArgOfName:

• macros: hasArgOfName(params: NimNode; name: string): bool

hasAttribute:

• dom: hasAttribute(n: Node; attr: cstring): bool

hasBigUint64Array:

• jsutils: hasBigUint64Array(): bool

hasChildNodes:

• dom: hasChildNodes(n: Node): bool

hasClosure:

• typetraits: hasClosure(fn: NimNode): bool

hasCustomPragma:

• macros: hasCustomPragma(n: typed; cp: typed{nkSym}): untyped

hasData:

• osproc: hasData(p: Process): bool

hasDataBuffered:

• asyncnet: hasDataBuffered(s: AsyncSocket): bool
• net: hasDataBuffered(s: Socket): bool

Hash:

• hashes: Hash

hash:

• hashes: hash(x: cstring): Hash
• hashes: hash(x: float): Hash
• hashes: hash[A](x: openArray[A]): Hash
• hashes: hash[A](aBuf: openArray[A]; sPos, ePos: int): Hash
• hashes: hash(x: pointer): Hash
• hashes: hash[T](x: ptr [T]): Hash
• hashes: hash[T](x: ref [T]): Hash
• hashes: hash[A](x: set[A]): Hash
• hashes: hash(x: string): Hash
• hashes: hash(sBuf: string; sPos, ePos: int): Hash
• hashes: hash[T: Ordinal | enum](x: T): Hash
• hashes: hash[T: tuple | object | proc](x: T): Hash
• json: hash(n: JsonNode): Hash
• json: hash(n: OrderedTable[string, JsonNode]): Hash
• oids: hash(oid: Oid): Hash
• rationals: hash[T](x: Rational[T]): Hash
• sets: hash[A](s: HashSet[A]): Hash
• sets: hash[A](s: OrderedSet[A]): Hash
• sexp: hash(n: SexpNode): Hash

hash set:

• Module sets

hash table:

• Module tables

hashData:

• hashes: hashData(data: pointer; size: int): Hash

hashIdentity:

• hashes: hashIdentity[T: Ordinal | enum](x: T): Hash

hashIgnoreCase:

• hashes: hashIgnoreCase(x: string): Hash
• hashes: hashIgnoreCase(sBuf: string; sPos, ePos: int): Hash

hashIgnoreStyle:

• hashes: hashIgnoreStyle(x: string): Hash
• hashes: hashIgnoreStyle(sBuf: string; sPos, ePos: int): Hash

HashSet:

• sets: HashSet

hashWangYi1:

• hashes: hashWangYi1(x: int64 | uint64 | Hash): Hash

hasItem:

• dom: hasItem(s: Storage; key: cstring): bool

hasJsBigInt:

• jsutils: hasJsBigInt(): bool

hasKey:

• critbits: hasKey[T](c: CritBitTree[T]; key: string): bool
• httpcore: hasKey(headers: HttpHeaders; key: string): bool
• jsformdata: hasKey(self: FormData; name: cstring): bool
• jsheaders: hasKey(self: Headers; key: cstring): bool
• json: hasKey(node: JsonNode; key: string): bool
• strtabs: hasKey(t: StringTableRef; key: string): bool
• tables: hasKey[A](t: CountTable[A]; key: A): bool
• tables: hasKey[A](t: CountTableRef[A]; key: A): bool
• tables: hasKey[A, B](t: OrderedTable[A, B]; key: A): bool
• tables: hasKey[A, B](t: OrderedTableRef[A, B]; key: A): bool
• tables: hasKey[A, B](t: Table[A, B]; key: A): bool
• tables: hasKey[A, B](t: TableRef[A, B]; key: A): bool

hasKeyOrPut:

• sharedtables: hasKeyOrPut[A, B](t: var SharedTable[A, B]; key: A; val: B): bool
• tables: hasKeyOrPut[A, B](t: var OrderedTable[A, B]; key: A; val: B): bool
• tables: hasKeyOrPut[A, B](t: var OrderedTableRef[A, B]; key: A; val: B): bool
• tables: hasKeyOrPut[A, B](t: var Table[A, B]; key: A; val: B): bool
• tables: hasKeyOrPut[A, B](t: var TableRef[A, B]; key: A; val: B): bool

hasModuleChanged:

• hotcodereloading: hasModuleChanged(module: typed): bool

hasNext:

• pathnorm: hasNext(it: PathIter; x: string): bool

hasNoSideEffects:

• effecttraits: hasNoSideEffects(fn: NimNode): bool

hasNxt:

• strscans: hasNxt(input: string; idx: int): bool

hasOverlappedIoCompleted:

• winlean: hasOverlappedIoCompleted(lpOverlapped): bool

hasOwnProperty:

• jsffi: hasOwnProperty(x: JsObject; prop: cstring): bool

hasPendingOperations:

• asyncdispatch: hasPendingOperations(): bool

hcrAddEventHandler:

• nimhcr: hcrAddEventHandler(isBefore: bool; cb: proc ())

hcrAddModule:

• nimhcr: hcrAddModule(module: cstring)

hcrGeneration:

• nimhcr: hcrGeneration(): int

hcrGetGlobal:

• nimhcr: hcrGetGlobal(module: cstring; name: cstring): pointer

hcrGetProc:

• nimhcr: hcrGetProc(module: cstring; name: cstring): pointer

hcrHasModuleChanged:

• nimhcr: hcrHasModuleChanged(moduleHash: string): bool

hcrInit:

• nimhcr: hcrInit(moduleList: ptr pointer; main, sys: cstring; datInit: HcrModuleInitializer; handle: pointer; gpa: HcrProcGetter)

hcrMarkGlobals:

• nimhcr: hcrMarkGlobals()

HcrModuleInitializer:

• nimhcr: HcrModuleInitializer

hcrPerformCodeReload:

• nimhcr: hcrPerformCodeReload()

HcrProcGetter:

• nimhcr: HcrProcGetter

hcrRegisterGlobal:

• nimhcr: hcrRegisterGlobal(module: cstring; name: cstring; size: Natural; gcMarker: HcrGcMarkerProc; outPtr: ptr pointer): bool

hcrRegisterProc:

• nimhcr: hcrRegisterProc(module: cstring; name: cstring; fn: pointer): pointer

hcrReloadNeeded:

• nimhcr: hcrReloadNeeded(): bool

HDC:

• winlean: HDC

head:

• htmlgen: head(e: varargs[untyped]): untyped
• httpclient: head(client: AsyncHttpClient; url: Uri | string): Future[AsyncResponse]
• httpclient: head(client: HttpClient; url: Uri | string): Response

header:

• htmlgen: header(e: varargs[untyped]): untyped

headerLimit:

• httpcore: headerLimit

Headers:

• jsheaders: Headers

HeapQueue:

• heapqueue: HeapQueue

helo:

• smtp: helo(smtp: AsyncSmtp): owned(Future[void])
• smtp: helo(smtp: Smtp)

hexbyte:

• oids: hexbyte(hex: char): int

HexDigits:

• strutils: HexDigits

HGLRC:

• winlean: HGLRC

hideCursor:

• terminal: hideCursor(f: File)
• terminal: hideCursor()

high:

• jsbigints: high(_: typedesc[JsBigInt]): JsBigInt
• monotimes: high(typ: typedesc[MonoTime]): MonoTime
• system: high[I, T](x: array[I, T]): I
• system: high(x: cstring): int
• system: high[T](x: openArray[T]): int
• system: high(x: string): int
• system: high[T: Ordinal | enum | range](x: T): T
• system: high[I, T](x: typedesc[array[I, T]]): I
• system: high(T: typedesc[SomeFloat]): T:type
• system: high[T: Ordinal | enum | range](x: typedesc[T]): T
• times: high(typ: typedesc[Duration]): Duration
• times: high(typ: typedesc[Time]): Time

HIGH_PRIORITY_CLASS:

• winlean: HIGH_PRIORITY_CLASS

hint:

• macros: hint(msg: string; n: NimNode = nil)
• nimscript: hint(name: string; val: bool)

History:

• dom: History

historyAdd:

• linenoise: historyAdd(line: cstring): cint

historyLoad:

• linenoise: historyLoad(filename: cstring): cint

historySave:

• linenoise: historySave(filename: cstring): cint

historySetMaxLen:

• linenoise: historySetMaxLen(len: cint): cint

HKEY:

• registry: HKEY

HKEY_CURRENT_USER:

• registry: HKEY_CURRENT_USER

HKEY_LOCAL_MACHINE:

• registry: HKEY_LOCAL_MACHINE

HoleyEnum:

• typetraits: HoleyEnum

home:

• dom: home(w: Window)

hostCPU:

• system: hostCPU

Hostent:

• nativesockets: Hostent
• winlean: Hostent

hostOS:

• system: hostOS

hour:

• times: hour(dt: DateTime): HourRange

hour=:

• times: hour=(dt: var DateTime; value: HourRange)

HourRange:

• times: HourRange

Hours:

• TimeUnit.Hours

hours:

• times: hours(h: int): TimeInterval

hr:

• htmlgen: hr(): untyped

HSlice:

• system: HSlice

html:

• htmlgen: html(e: varargs[untyped]): untyped

HTML:

• Module htmlgen
• Module parsexml

HTMLSlotElement:

• dom: HTMLSlotElement

HtmlTag:

• htmlparser: HtmlTag

htmlTag:

• htmlparser: htmlTag(s: string): HtmlTag
• htmlparser: htmlTag(n: XmlNode): HtmlTag

htonl:

• nativesockets: htonl(x: uint32): untyped

htons:

• nativesockets: htons(x: uint16): untyped

Http100:

• httpcore: Http100

Http101:

• httpcore: Http101

Http102:

• httpcore: Http102

Http103:

• httpcore: Http103

Http200:

• httpcore: Http200

Http201:

• httpcore: Http201

Http202:

• httpcore: Http202

Http203:

• httpcore: Http203

Http204:

• httpcore: Http204

Http205:

• httpcore: Http205

Http206:

• httpcore: Http206

Http207:

• httpcore: Http207

Http208:

• httpcore: Http208

Http226:

• httpcore: Http226

Http300:

• httpcore: Http300

Http301:

• httpcore: Http301

Http302:

• httpcore: Http302

Http303:

• httpcore: Http303

Http304:

• httpcore: Http304

Http305:

• httpcore: Http305

Http307:

• httpcore: Http307

Http308:

• httpcore: Http308

Http400:

• httpcore: Http400

Http401:

• httpcore: Http401

Http402:

• httpcore: Http402

Http403:

• httpcore: Http403

Http404:

• httpcore: Http404

Http405:

• httpcore: Http405

Http406:

• httpcore: Http406

Http407:

• httpcore: Http407

Http408:

• httpcore: Http408

Http409:

• httpcore: Http409

Http410:

• httpcore: Http410

Http411:

• httpcore: Http411

Http412:

• httpcore: Http412

Http413:

• httpcore: Http413

Http414:

• httpcore: Http414

Http415:

• httpcore: Http415

Http416:

• httpcore: Http416

Http417:

• httpcore: Http417

Http418:

• httpcore: Http418

Http421:

• httpcore: Http421

Http422:

• httpcore: Http422

Http423:

• httpcore: Http423

Http424:

• httpcore: Http424

Http425:

• httpcore: Http425

Http426:

• httpcore: Http426

Http428:

• httpcore: Http428

Http429:

• httpcore: Http429

Http431:

• httpcore: Http431

Http451:

• httpcore: Http451

Http500:

• httpcore: Http500

Http501:

• httpcore: Http501

Http502:

• httpcore: Http502

Http503:

• httpcore: Http503

Http504:

• httpcore: Http504

Http505:

• httpcore: Http505

Http506:

• httpcore: Http506

Http507:

• httpcore: Http507

Http508:

• httpcore: Http508

Http510:

• httpcore: Http510

Http511:

• httpcore: Http511

HttpClient:

• httpclient: HttpClient

HttpClientBase:

• httpclient: HttpClientBase

HttpCode:

• httpcore: HttpCode

HttpConnect:

• HttpMethod.HttpConnect

HttpDelete:

• HttpMethod.HttpDelete

HttpGet:

• HttpMethod.HttpGet

HttpHead:

• HttpMethod.HttpHead

HttpHeaders:

• httpcore: HttpHeaders

HttpHeaderValues:

• httpcore: HttpHeaderValues

HttpMethod:

• httpcore: HttpMethod

httpNewLine:

• httpcore: httpNewLine

HttpOptions:

• HttpMethod.HttpOptions

HttpPatch:

• HttpMethod.HttpPatch

HttpPost:

• HttpMethod.HttpPost

HttpPut:

• HttpMethod.HttpPut

HttpRequestError:

• httpclient: HttpRequestError

HttpTrace:

• HttpMethod.HttpTrace

HttpVer10:

• HttpVersion.HttpVer10

HttpVer11:

• HttpVersion.HttpVer11

HttpVersion:

• httpcore: HttpVersion

hypot:

• jscore: hypot(m: MathLib; args: varargs[distinct SomeNumber]): float
• math: hypot(x, y: float32): float32
• math: hypot(x, y: float64): float64

i:

• htmlgen: i(e: varargs[untyped]): untyped

iconv:

• Module encodings

id:

• dom: id(n: Node): cstring

id=:

• dom: id=(n: Node; x: cstring)

ident:

• macros: ident(n: NimNode): NimIdent
• macros: ident(name: string): NimNode
• pegs: ident(): Peg

ident=:

• macros: ident=(n: NimNode; val: NimIdent)

identChars:

• pegs: identChars(): Peg

IdentChars:

• strutils: IdentChars

identifiedTouch:

• dom: identifiedTouch(list: TouchList): Touch

identStartChars:

• pegs: identStartChars(): Peg

IdentStartChars:

• strutils: IdentStartChars

IDLE_PRIORITY_CLASS:

• winlean: IDLE_PRIORITY_CLASS

iframe:

• htmlgen: iframe(e: varargs[untyped]): untyped

ignoreMsg:

• parsecfg: ignoreMsg(c: CfgParser; e: CfgEvent): string

ikDollar:

• InterpolatedKind.ikDollar

ikExpr:

• InterpolatedKind.ikExpr

ikStr:

• InterpolatedKind.ikStr

ikVar:

• InterpolatedKind.ikVar

im:

• complex: im(arg: float32): Complex32
• complex: im(arg: float64): Complex64
• complex: im(arg: typedesc[float32]): Complex32
• complex: im(arg: typedesc[float64]): Complex64

ImageElement:

• dom: ImageElement

img:

• htmlgen: img(e: varargs[untyped]): untyped

imul:

• jscore: imul(m: MathLib; a, b: int32): int32

in-place:

• Module sugar

In6_addr:

• winlean: In6_addr

IN_ACCESS:

• inotify: IN_ACCESS

InAddr:

• winlean: InAddr

INADDR_ANY:

• winlean: INADDR_ANY

INADDR_BROADCAST:

• winlean: INADDR_BROADCAST

INADDR_LOOPBACK:

• winlean: INADDR_LOOPBACK

INADDR_NONE:

• winlean: INADDR_NONE

IN_ALL_EVENTS:

• inotify: IN_ALL_EVENTS

IN_ATTRIB:

• inotify: IN_ATTRIB

inc:

• critbits: inc(c: var CritBitTree[int]; key: string; val: int = 1)
• jsbigints: inc(this: var JsBigInt)
• jsbigints: inc(this: var JsBigInt; amount: JsBigInt)
• macrocache: inc(c: CacheCounter; by = 1)
• system: inc[T: Ordinal](x: var T; y = 1)
• tables: inc[A](t: var CountTable[A]; key: A; val = 1)
• tables: inc[A](t: CountTableRef[A]; key: A; val = 1)

incl:

• critbits: incl[T](c: var CritBitTree[T]; key: string; val: T)
• critbits: incl(c: var CritBitTree[void]; key: string)
• macrocache: incl(s: CacheSeq; value: NimNode)
• packedsets: incl[A](s: var PackedSet[A]; key: A)
• packedsets: incl[A](s: var PackedSet[A]; other: PackedSet[A])
• sets: incl[A](s: var HashSet[A]; key: A)
• sets: incl[A](s: var HashSet[A]; other: HashSet[A])
• sets: incl[A](s: var HashSet[A]; other: OrderedSet[A])
• sets: incl[A](s: var OrderedSet[A]; key: A)
• system: incl[T](x: var set[T]; y: T)
• system: incl[T](x: var set[T]; y: set[T])

inclFilePermissions:

• os: inclFilePermissions(filename: string; permissions: set[FilePermission])

IN_CLOSE:

• inotify: IN_CLOSE

IN_CLOSE_NOWRITE:

• inotify: IN_CLOSE_NOWRITE

IN_CLOSE_WRITE:

• inotify: IN_CLOSE_WRITE

inclSetElement:

• typeinfo: inclSetElement(x: Any; elem: int)

IN_CREATE:

• inotify: IN_CREATE

inDays:

• times: inDays(dur: Duration): int64

IN_DELETE:

• inotify: IN_DELETE

IN_DELETE_SELF:

• inotify: IN_DELETE_SELF

indent:

• strutils: indent(s: string; count: Natural; padding: string = " "): string

indentation:

• strutils: indentation(s: string): Natural

index:

• pegs: index(p: Peg): range[-20 .. 20 - 1]

indexBy:

• tables: indexBy[A, B, C](collection: A; index: proc (x: B): C): Table[C, B]

IndexDefect:

• system: IndexDefect

IndexError:

• system: IndexError

IndexExt:

• rstgen: IndexExt

IN_DONT_FOLLOW:

• inotify: IN_DONT_FOLLOW

inet_addr:

• winlean: inet_addr(cp: cstring): uint32

inet_ntoa:

• winlean: inet_ntoa(i: InAddr): cstring

inet_ntop:

• winlean: inet_ntop(family: cint; paddr: pointer; pStringBuffer: cstring; stringBufSize: int32): cstring

IN_EXCL_UNLINK:

• inotify: IN_EXCL_UNLINK

Inf:

• system: Inf

INFINITE:

• winlean: INFINITE

infix:

• macros: infix(a: NimNode; op: string; b: NimNode): NimNode

info:

• jsconsole: info(console: Console)
• logging: info(args: varargs[string, `$`])

inHours:

• times: inHours(dur: Duration): int64

IN_IGNORED:

• inotify: IN_IGNORED

IN_ISDIR:

• inotify: IN_ISDIR

init:

• reservedmem: init(T: type ReservedMem; maxLen: Natural; initLen: Natural = 0; initCommitLen = initLen; memStart = pointer(nil); accessFlags = memReadWrite; maxCommittedAndUnusedPages = 3): ReservedMem
• reservedmem: init(SeqType: type ReservedMemSeq; maxLen: Natural; initLen: Natural = 0; initCommitLen: Natural = 0; memStart = pointer(nil); accessFlags = memReadWrite; maxCommittedAndUnusedPages = 3): SeqType:type
• sets: init[A](s: var HashSet[A]; initialSize = defaultInitialSize)
• sets: init[A](s: var OrderedSet[A]; initialSize = defaultInitialSize)
• sharedlist: init[A](t: var SharedList[A])
• sharedtables: init[A, B](t: var SharedTable[A, B]; initialSize = 32)

initCond:

• locks: initCond(cond: var Cond)

initCountTable:

• tables: initCountTable[A](initialSize = defaultInitialSize): CountTable[A]

initDateTime:

• times: initDateTime(monthday: MonthdayRange; month: Month; year: int; hour: HourRange; minute: MinuteRange; second: SecondRange; nanosecond: NanosecondRange; zone: Timezone = local()): DateTime
• times: initDateTime(monthday: MonthdayRange; month: Month; year: int; hour: HourRange; minute: MinuteRange; second: SecondRange; zone: Timezone = local()): DateTime

initDecodeTable:

• base64: initDecodeTable(): array[256, char]

initDeque:

• deques: initDeque[T](initialSize: int = defaultInitialSize): Deque[T]

initDoublyLinkedList:

• lists: initDoublyLinkedList[T](): DoublyLinkedList[T]

initDoublyLinkedRing:

• lists: initDoublyLinkedRing[T](): DoublyLinkedRing[T]

initDuration:

• times: initDuration(nanoseconds, microseconds, milliseconds, seconds, minutes, hours, days, weeks: int64 = 0): Duration

initGeneralTokenizer:

• highlite: initGeneralTokenizer(g: var GeneralTokenizer; buf: cstring)
• highlite: initGeneralTokenizer(g: var GeneralTokenizer; buf: string)

initHashSet:

• sets: initHashSet[A](initialSize = defaultInitialSize): HashSet[A]

initHeapQueue:

• heapqueue: initHeapQueue[T](): HeapQueue[T]

initIntSet:

• intsets: initIntSet(): IntSet

initLock:

• locks: initLock(lock: var Lock)

initOptParser:

• parseopt: initOptParser(cmdline: seq[string]; shortNoVal: set[char] = {}; longNoVal: seq[string] = @[]; allowWhitespaceAfterColon = true): OptParser
• parseopt: initOptParser(cmdline = ""; shortNoVal: set[char] = {}; longNoVal: seq[string] = @[]; allowWhitespaceAfterColon = true): OptParser

initOrderedSet:

• sets: initOrderedSet[A](initialSize = defaultInitialSize): OrderedSet[A]

initOrderedTable:

• tables: initOrderedTable[A, B](initialSize = defaultInitialSize): OrderedTable[A, B]

initPackedSet:

• packedsets: initPackedSet[A](): PackedSet[A]

initRand:

• random: initRand(): Rand
• random: initRand(seed: int64): Rand
• random: initRand(seed: int64): Rand

initRational:

• rationals: initRational[T: SomeInteger](num, den: T): Rational[T]

initRLock:

• rlocks: initRLock(lock: var RLock)

initRstGenerator:

• rstgen: initRstGenerator(g: var RstGenerator; target: OutputTarget; config: StringTableRef; filename: string; findFile: FindFileHandler = nil; msgHandler: MsgHandler = nil; filenames = default(RstFileTable))

initRtArray:

• rtarrays: initRtArray[T](len: Natural): RtArray[T]

initSet:

• sets: initSet[A](initialSize = defaultInitialSize): HashSet[A]

initSinglyLinkedList:

• lists: initSinglyLinkedList[T](): SinglyLinkedList[T]

initSinglyLinkedRing:

• lists: initSinglyLinkedRing[T](): SinglyLinkedRing[T]

initSkipTable:

• strutils: initSkipTable(a: var SkipTable; sub: string)

initTable:

• tables: initTable[A, B](initialSize = defaultInitialSize): Table[A, B]

initTime:

• times: initTime(unix: int64; nanosecond: NanosecondRange): Time

initTimeFormat:

• times: initTimeFormat(format: string): TimeFormat

initTimeInterval:

• times: initTimeInterval(nanoseconds, microseconds, milliseconds, seconds, minutes, hours, days, weeks, months, years: int = 0): TimeInterval

initToJsonOptions:

• jsonutils: initToJsonOptions(): ToJsonOptions

initUri:

• uri: initUri(isIpv6 = false): Uri

InlineTags:

• htmlparser: InlineTags

IN_MASK_ADD:

• inotify: IN_MASK_ADD

inMicroseconds:

• times: inMicroseconds(dur: Duration): int64

inMilliseconds:

• times: inMilliseconds(dur: Duration): int64

inMinutes:

• times: inMinutes(dur: Duration): int64

IN_MODIFY:

• inotify: IN_MODIFY

IN_MOVE:

• inotify: IN_MOVE

IN_MOVED_FROM:

• inotify: IN_MOVED_FROM

IN_MOVED_TO:

• inotify: IN_MOVED_TO

IN_MOVE_SELF:

• inotify: IN_MOVE_SELF

inNanoseconds:

• times: inNanoseconds(dur: Duration): int64

innerText:

• xmltree: innerText(n: XmlNode): string

IN_ONESHOT:

• inotify: IN_ONESHOT

IN_ONLYDIR:

• inotify: IN_ONLYDIR

IN_OPEN:

• inotify: IN_OPEN

inotify_add_watch:

• inotify: inotify_add_watch(fd: cint; name: cstring; mask: uint32): cint

InotifyEvent:

• inotify: InotifyEvent

inotify_events:

• inotify: inotify_events(evs: pointer; n: int): ptr InotifyEvent

inotify_init:

• inotify: inotify_init(): FileHandle

inotify_init1:

• inotify: inotify_init1(flags: cint): FileHandle

inotify_rm_watch:

• inotify: inotify_rm_watch(fd: cint; wd: cint): cint

input:

• htmlgen: input(e: varargs[untyped]): untyped

InputElement:

• dom: InputElement

inputHandle:

• osproc: inputHandle(p: Process): FileHandle

inputStream:

• osproc: inputStream(p: Process): Stream

IN_Q_OVERFLOW:

• inotify: IN_Q_OVERFLOW

ins:

• htmlgen: ins(e: varargs[untyped]): untyped

inSeconds:

• times: inSeconds(dur: Duration): int64

insert:

• db_mysql: insert(db: DbConn; query: SqlQuery; pkName: string; args: varargs[string, `$`]): int64
• db_odbc: insert(db: var DbConn; query: SqlQuery; pkName: string; args: varargs[string, `$`]): int64
• db_postgres: insert(db: DbConn; query: SqlQuery; pkName: string; args: varargs[string, `$`]): int64
• db_sqlite: insert(db: DbConn; query: SqlQuery; pkName: string; args: varargs[string, `$`]): int64
• macros: insert(a: NimNode; pos: int; b: NimNode)
• sequtils: insert[T](dest: var seq[T]; src: openArray[T]; pos = 0)
• system: insert[T](x: var seq[T]; item: sink T; i = 0.Natural)
• system: insert(x: var string; item: string; i = 0.Natural)
• xmltree: insert(father, son: XmlNode; index: int)

insertBefore:

• dom: insertBefore(n, newNode, before: Node)

insertData:

• dom: insertData(n: Node; position: int; data: cstring)

insertId:

• db_mysql: insertId(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
• db_odbc: insertId(db: var DbConn; query: SqlQuery; args: varargs[string, `$`]): int64

insertID:

• db_postgres: insertID(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
• db_sqlite: insertID(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64

insertNode:

• dom: insertNode(range: Range; node: Node)

insertSep:

• strutils: insertSep(s: string; sep = '_'; digits = 3): string

installDirs:

• nimscript: installDirs

installExt:

• nimscript: installExt

installFiles:

• nimscript: installFiles

instantiationInfo:

• system: instantiationInfo(index = -1; fullPaths = false): tuple[filename: string, line: int, column: int]

InstantRow:

• db_mysql: InstantRow
• db_odbc: InstantRow
• db_postgres: InstantRow
• db_sqlite: InstantRow

instantRows:

• db_mysql: instantRows(db: DbConn; columns: var DbColumns; query: SqlQuery; args: varargs[string, `$`]): InstantRow
• db_mysql: instantRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): InstantRow
• db_odbc: instantRows(db: var DbConn; query: SqlQuery; args: varargs[string, `$`]): InstantRow
• db_postgres: instantRows(db: DbConn; columns: var DbColumns; query: SqlQuery; args: varargs[string, `$`]): InstantRow
• db_postgres: instantRows(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): InstantRow
• db_postgres: instantRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): InstantRow
• db_sqlite: instantRows(db: DbConn; columns: var DbColumns; query: SqlQuery; args: varargs[string, `$`]): InstantRow
• db_sqlite: instantRows(db: DbConn; stmtName: SqlPrepared): InstantRow
• db_sqlite: instantRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): InstantRow

int:

• system: int

int16:

• system: int16

int32:

• system: int32

int64:

• system: int64

int8:

• system: int8

intensity:

• colors: intensity(a: Color; f: float): Color

intercept:

• stats: intercept(r: RunningRegress): float

internalErrorFlag:

• macros: internalErrorFlag(): string

internalNew:

• system: internalNew[T](a: var ref T)

interpolatedFragments:

• parseutils: interpolatedFragments(s: string): tuple[kind: InterpolatedKind, value: string]

InterpolatedKind:

• parseutils: InterpolatedKind

interpolation:

• Module strformat

intersection:

• packedsets: intersection[A](s1, s2: PackedSet[A]): PackedSet[A]
• sets: intersection[A](s1, s2: HashSet[A]): HashSet[A]

Interval:

• dom: Interval

INT_MAX:

• Module system

INT_MIN:

• Module system

IntSet:

• intsets: IntSet

intToStr:

• strutils: intToStr(x: int; minchars: Positive = 1): string

intVal:

• macros: intVal(n: NimNode): BiggestInt

intVal=:

• macros: intVal=(n: NimNode; val: BiggestInt)

IN_UNMOUNT:

• inotify: IN_UNMOUNT

inv:

• complex: inv[T](z: Complex[T]): Complex[T]

invalidFilenameChars:

• os: invalidFilenameChars

invalidFilenames:

• os: invalidFilenames

INVALID_FILE_SIZE:

• winlean: INVALID_FILE_SIZE

INVALID_HANDLE_VALUE:

• winlean: INVALID_HANDLE_VALUE

INVALID_SET_FILE_POINTER:

• winlean: INVALID_SET_FILE_POINTER

INVALID_SOCKET:

• winlean: INVALID_SOCKET

InvalidUnicodeError:

• nre: InvalidUnicodeError

inViewport:

• dom: inViewport(el: Node): bool

invoke:

• tasks: invoke(task: Task)

invokeNew:

• typeinfo: invokeNew(x: Any)

invokeNewSeq:

• typeinfo: invokeNewSeq(x: Any; len: int)

inWeeks:

• times: inWeeks(dur: Duration): int64

inZone:

• times: inZone(dt: DateTime; zone: Timezone): DateTime
• times: inZone(time: Time; zone: Timezone): DateTime

IOC_IN:

• nativesockets: IOC_IN
• winlean: IOC_IN

IOC_INOUT:

• winlean: IOC_INOUT

IOC_OUT:

• winlean: IOC_OUT

IOCPARM_MASK:

• nativesockets: IOCPARM_MASK

ioctlsocket:

• nativesockets: ioctlsocket(s: SocketHandle; cmd: clong; argptr: ptr clong): cint

IOC_WS2:

• winlean: IOC_WS2

IOEffect:

• system: IOEffect

IOError:

• system: IOError

IOSelectorsException:

• selectors: IOSelectorsException

ioselSupportedPlatform:

• selectors: ioselSupportedPlatform

IpAddress:

• net: IpAddress

IpAddressFamily:

• net: IpAddressFamily

IPPROTO_ICMP:

• Protocol.IPPROTO_ICMP

IPPROTO_ICMPV6:

• Protocol.IPPROTO_ICMPV6

IPPROTO_IP:

• Protocol.IPPROTO_IP

IPPROTO_IPV6:

• Protocol.IPPROTO_IPV6

IPPROTO_RAW:

• Protocol.IPPROTO_RAW

IPPROTO_TCP:

• Protocol.IPPROTO_TCP

IPPROTO_UDP:

• Protocol.IPPROTO_UDP

IPv4_any:

• net: IPv4_any(): IpAddress

IPv4_broadcast:

• net: IPv4_broadcast(): IpAddress

IPv4_loopback:

• net: IPv4_loopback(): IpAddress

IPv6_any:

• net: IPv6_any(): IpAddress

IPv6_loopback:

• net: IPv6_loopback(): IpAddress

is1xx:

• httpcore: is1xx(code: HttpCode): bool

is2xx:

• httpcore: is2xx(code: HttpCode): bool

is3xx:

• httpcore: is3xx(code: HttpCode): bool

is4xx:

• httpcore: is4xx(code: HttpCode): bool

is5xx:

• httpcore: is5xx(code: HttpCode): bool

isAbsolute:

• os: isAbsolute(path: string): bool
• uri: isAbsolute(uri: Uri): bool

isAdmin:

• os: isAdmin(): bool

isAlpha:

• unicode: isAlpha(c: Rune): bool
• unicode: isAlpha(s: string): bool

isAlphaAscii:

• strutils: isAlphaAscii(c: char): bool

isAlphaNumeric:

• strutils: isAlphaNumeric(c: char): bool

isatty:

• terminal: isatty(f: File): bool

isClosed:

• asyncnet: isClosed(socket: AsyncSocket): bool

isColor:

• colors: isColor(name: string): bool

isCombining:

• unicode: isCombining(c: Rune): bool

isDefaultNamespace:

• dom: isDefaultNamespace(n: Node): bool

isDigit:

• strutils: isDigit(c: char): bool

isDisconnectionError:

• net: isDisconnectionError(flags: set[SocketFlag]; lastError: OSErrorCode): bool

isDst:

• times: isDst(dt: DateTime): bool

isDst=:

• times: isDst=(dt: var DateTime; value: bool)

isEmpty:

• selectors: isEmpty[T](s: Selector[T]): bool

isEmptyOrWhitespace:

• strutils: isEmptyOrWhitespace(s: string): bool

isEqualNode:

• dom: isEqualNode(n: Node): bool

isExported:

• macros: isExported(n: NimNode): bool

isFinite:

• dom: isFinite(x: BiggestFloat): bool

isFutureLoggingEnabled:

• asyncfutures: isFutureLoggingEnabled

isGcSafe:

• effecttraits: isGcSafe(fn: NimNode): bool

isGitRepo:

• gitutils: isGitRepo(dir: string): bool

isHidden:

• os: isHidden(path: string): bool

isInitialized:

• times: isInitialized(dt: DateTime): bool

isInstantiationOf:

• macros: isInstantiationOf(instanceProcSym, genProcSym: NimNode): bool

isInteger:

• jsutils: isInteger[T](x: T): bool

isIpAddress:

• net: isIpAddress(addressStr: string): bool

isLeapDay:

• times: isLeapDay(dt: DateTime): bool

isLeapYear:

• times: isLeapYear(year: int): bool

isLower:

• unicode: isLower(c: Rune): bool

isLowerAscii:

• strutils: isLowerAscii(c: char): bool

isMainModule:

• system: isMainModule

isNamedTuple:

• typetraits: isNamedTuple(T: typedesc): bool

isNaN:

• dom: isNaN(x: BiggestFloat): bool
• math: isNaN(x: SomeFloat): bool

isNil:

• packedsets: isNil[A](x: PackedSet[A]): bool
• system: isNil(x: cstring): bool
• system: isNil(x: pointer): bool
• system: isNil[T](x: ptr T): bool
• system: isNil[T](x: ref T): bool
• system: isNil[T](x: seq[T]): bool
• system: isNil(x: string): bool
• system: isNil[T: proc](x: T): bool
• typeinfo: isNil(x: Any): bool

isNone:

• options: isNone[T](self: Option[T]): bool

isNotForeign:

• system: isNotForeign(x: ForeignCell): bool

isNull:

• jsffi: isNull[T](x: T): bool

isolate:

• isolation: isolate[T](value: sink T): Isolated[T]

Isolated:

• isolation: Isolated

isPowerOfTwo:

• math: isPowerOfTwo(x: int): bool

isReady:

• threadpool: isReady(fv: FlowVarBase): bool

isRefSkipDistinct:

• json: isRefSkipDistinct(arg: typed): untyped

isRelativeTo:

• os: isRelativeTo(path: string; base: string): bool

isRootDir:

• os: isRootDir(path: string): bool

isSafeInteger:

• jsutils: isSafeInteger[T](x: T): bool

isSameNode:

• dom: isSameNode(n: Node): bool

isSome:

• options: isSome[T](self: Option[T]): bool

isSorted:

• algorithm: isSorted[T](a: openArray[T]; order = SortOrder.Ascending): bool
• algorithm: isSorted[T](a: openArray[T]; cmp: proc (x, y: T): int {.closure.}; order = SortOrder.Ascending): bool

isSpace:

• unicode: isSpace(s: string): bool

isSpaceAscii:

• strutils: isSpaceAscii(c: char): bool

isSsl:

• asyncnet: isSsl(socket: AsyncSocket): bool
• net: isSsl(socket: Socket): bool

isSuccess:

• winlean: isSuccess(a: WINBOOL): bool

isTitle:

• unicode: isTitle(c: Rune): bool

isTrueColorSupported:

• terminal: isTrueColorSupported(): bool

isUndefined:

• jsffi: isUndefined[T](x: T): bool

isUpper:

• unicode: isUpper(c: Rune): bool

isUpperAscii:

• strutils: isUpperAscii(c: char): bool

isValid:

• sets: isValid[A](s: HashSet[A]): bool

isValidFilename:

• os: isValidFilename(filename: string; maxLen = 259.Positive): bool

isValidSha1Hash:

• sha1: isValidSha1Hash(s: string): bool

isWhiteSpace:

• unicode: isWhiteSpace(c: Rune): bool

Item:

• diff: Item

item:

• dom: item(list: TouchList; i: int): Touch

items:

• critbits: items[T](c: CritBitTree[T]): string
• deques: items[T](deq: Deque[T]): lent T
• enumutils: items[T: HoleyEnum](E: typedesc[T]): T
• iterators: items[IX, T](a: array[IX, T]): T
• iterators: items(a: cstring): char
• iterators: items[T: not char](a: openArray[T]): lent2 T
• iterators: items[T: char](a: openArray[T]): T
• iterators: items[T](a: seq[T]): lent2 T
• iterators: items[T](a: set[T]): T
• iterators: items[T: Ordinal](s: Slice[T]): T
• iterators: items(a: string): char
• iterators: items[T: enum and Ordinal](E: typedesc[T]): T
• jsffi: items[K, V](assoc: JsAssoc[K, V]): V
• jsffi: items(obj: JsObject): JsObject
• json: items(node: JsonNode): JsonNode
• lists: items[T](L: SomeLinkedList[T]): T
• lists: items[T](L: SomeLinkedRing[T]): T
• macrocache: items(s: CacheSeq): NimNode
• macros: items(n: NimNode): NimNode
• nre: items(pattern: CaptureBounds; default = none(HSlice[int, int])): Option[ HSlice[int, int]]
• nre: items(pattern: Captures; default: Option[string] = none(string)): Option[string]
• packedsets: items[A](s: PackedSet[A]): A
• pegs: items(p: Peg): Peg
• ropes: items(r: Rope): char
• sequtils: items[T](xs: iterator (): T): T
• sets: items[A](s: HashSet[A]): A
• sets: items[A](s: OrderedSet[A]): A
• sexp: items(node: SexpNode): SexpNode
• sharedlist: items[A](x: var SharedList[A]): A
• xmltree: items(n: XmlNode): XmlNode

itemsWithPrefix:

• critbits: itemsWithPrefix[T](c: CritBitTree[T]; prefix: string): string

iterable:

• system: iterable

iterAndMutate:

• sharedlist: iterAndMutate[A](x: var SharedList[A]; action: proc (x: A): bool)

iterToProc:

• system: iterToProc(iter: typed; envType: typedesc; procName: untyped)

JArray:

• JsonNodeKind.JArray

javaEnabled:

• dom: javaEnabled(h: Navigator): bool

JBool:

• JsonNodeKind.JBool

JFloat:

• JsonNodeKind.JFloat

JInt:

• JsonNodeKind.JInt

JNull:

• JsonNodeKind.JNull

JObject:

• JsonNodeKind.JObject

join:

• strutils: join(a: openArray[string]; sep: string = ""): string
• strutils: join[T: not string](a: openArray[T]; sep: string = ""): string

joinPath:

• os: joinPath(head, tail: string): string
• os: joinPath(parts: varargs[string]): string

joinThread:

• threads: joinThread*[TArg](t: Thread[TArg])

joinThreads:

• threads: joinThreads*[TArg](t: varargs[Thread[TArg]])

joptEnumOrd:

• EnumMode.joptEnumOrd

joptEnumString:

• EnumMode.joptEnumString

joptEnumSymbol:

• EnumMode.joptEnumSymbol

Joptions:

• jsonutils: Joptions

joptJsonNodeAsCopy:

• JsonNodeMode.joptJsonNodeAsCopy

joptJsonNodeAsObject:

• JsonNodeMode.joptJsonNodeAsObject

joptJsonNodeAsRef:

• JsonNodeMode.joptJsonNodeAsRef

JRetr:

• FtpJobType.JRetr

JRetrText:

• FtpJobType.JRetrText

js:

• jsffi: js

jsArguments:

• jsffi: jsArguments

jsAssert:

• jsconsole: jsAssert(console: Console; assertion)

JsAssoc:

• jsffi: JsAssoc

JsBigInt:

• jsbigints: JsBigInt

jsConstructorName:

• jsutils: jsConstructorName[T](a: T): cstring

jsDelete:

• jsffi: jsDelete(x: auto): JsObject

jsDirname:

• jsffi: jsDirname

JsError:

• jsffi: JsError

JsEvalError:

• jsffi: JsEvalError

jsFilename:

• jsffi: jsFilename

jsFromAst:

• jsffi: jsFromAst(n: untyped): untyped

JsKey:

• jsffi: JsKey

jsNew:

• jsffi: jsNew(x: auto): JsObject

jsNull:

• jsffi: jsNull

JsObject:

• jsffi: JsObject

JSON:

• jscore: JSON

json:

• jsfetch: json(self: Response): Future[JsObject]

JSON:

• Module json
• Module marshal

jsonArrayEnd:

• JsonEventKind.jsonArrayEnd

jsonArrayStart:

• JsonEventKind.jsonArrayStart

jsonEof:

• JsonEventKind.jsonEof

jsonError:

• JsonEventKind.jsonError

JsonError:

• parsejson: JsonError

JsonEventKind:

• parsejson: JsonEventKind

jsonFalse:

• JsonEventKind.jsonFalse

jsonFloat:

• JsonEventKind.jsonFloat

jsonInt:

• JsonEventKind.jsonInt

JsonKindError:

• parsejson: JsonKindError

JsonLib:

• jscore: JsonLib

JsonNode:

• json: JsonNode

JsonNodeKind:

• json: JsonNodeKind

JsonNodeMode:

• jsonutils: JsonNodeMode

JsonNodeObj:

• json: JsonNodeObj

jsonNull:

• JsonEventKind.jsonNull

jsonObjectEnd:

• JsonEventKind.jsonObjectEnd

jsonObjectStart:

• JsonEventKind.jsonObjectStart

JsonParser:

• parsejson: JsonParser

JsonParsingError:

• parsejson: JsonParsingError

jsonString:

• JsonEventKind.jsonString

jsonTo:

• jsonutils: jsonTo(b: JsonNode; T: typedesc; opt = Joptions()): T:type

jsonTrue:

• JsonEventKind.jsonTrue

JsRangeError:

• jsffi: JsRangeError

JsReferenceError:

• jsffi: JsReferenceError

JsRoot:

• system: JsRoot

JsSyntaxError:

• jsffi: JsSyntaxError

JStore:

• FtpJobType.JStore

JString:

• JsonNodeKind.JString

JsTypeError:

• jsffi: JsTypeError

jsTypeOf:

• jsffi: jsTypeOf(x: JsObject): cstring
• jsutils: jsTypeOf[T](x: T): cstring

jsUndefined:

• jsffi: jsUndefined

JsURIError:

• jsffi: JsURIError

JUnitOutputFormatter:

• unittest: JUnitOutputFormatter

kbd:

• htmlgen: kbd(e: varargs[untyped]): untyped

kDirtyTemplate:

• GenAstOpt.kDirtyTemplate

keepIf:

• sequtils: keepIf[T](s: var seq[T]; pred: proc (x: T): bool {.closure.})

keepItIf:

• sequtils: keepItIf(varSeq: seq; pred: untyped)

KEvent:

• kqueue: KEvent

kevent:

• kqueue: kevent(kqFD: cint; changelist: ptr KEvent; nchanges: cint; eventlist: ptr KEvent; nevents: cint; timeout: ptr Timespec): cint

KeyboardEvent:

• dom: KeyboardEvent

KeyboardEventKey:

• dom: KeyboardEventKey

KeyError:

• system: KeyError

KEY_EVENT_RECORD:

• winlean: KEY_EVENT_RECORD

keygen:

• htmlgen: keygen(e: varargs[untyped]): untyped

keys:

• critbits: keys[T](c: CritBitTree[T]): string
• jsffi: keys[K: JsKey; V](assoc: JsAssoc[K, V]): K
• jsffi: keys(obj: JsObject): cstring
• jsformdata: keys(self: FormData): seq[cstring]
• jsheaders: keys(self: Headers): seq[cstring]
• json: keys(node: JsonNode): string
• strtabs: keys(t: StringTableRef): string
• tables: keys[A](t: CountTable[A]): lent A
• tables: keys[A](t: CountTableRef[A]): A
• tables: keys[A, B](t: OrderedTable[A, B]): lent A
• tables: keys[A, B](t: OrderedTableRef[A, B]): lent A
• tables: keys[A, B](t: Table[A, B]): lent A
• tables: keys[A, B](t: TableRef[A, B]): lent A

keysWithPrefix:

• critbits: keysWithPrefix[T](c: CritBitTree[T]; prefix: string): string

kill:

• osproc: kill(p: Process)

kind:

• macros: kind(n: NimNode): NimNodeKind
• parsejson: kind(my: JsonParser): JsonEventKind
• parsexml: kind(my: XmlParser): XmlEventKind
• pegs: kind(p: Peg): PegKind
• sexp: kind(my: SexpParser): SexpEventKind
• typeinfo: kind(x: Any): AnyKind
• xmltree: kind(n: XmlNode): XmlNodeKind

kNoNewLit:

• GenAstOpt.kNoNewLit

kqueue:

• Module asyncdispatch
• kqueue: kqueue(): cint

kurtosis:

• stats: kurtosis[T](x: openArray[T]): float
• stats: kurtosis(s: RunningStat): float

kurtosisS:

• stats: kurtosisS[T](x: openArray[T]): float
• stats: kurtosisS(s: RunningStat): float

label:

• htmlgen: label(e: varargs[untyped]): untyped

LacksDevPackages:

• distros: LacksDevPackages

langC:

• SourceLanguage.langC

langCmd:

• SourceLanguage.langCmd

langConsole:

• SourceLanguage.langConsole

langCpp:

• SourceLanguage.langCpp

langCsharp:

• SourceLanguage.langCsharp

langJava:

• SourceLanguage.langJava

langNim:

• SourceLanguage.langNim

langNone:

• SourceLanguage.langNone

langPython:

• SourceLanguage.langPython

langYaml:

• SourceLanguage.langYaml

largest:

• tables: largest[A](t: CountTable[A]): tuple[key: A, val: int]
• tables: largest[A](t: CountTableRef[A]): tuple[key: A, val: int]

last:

• macros: last(node: NimNode): NimNode

lastModified:

• httpclient: lastModified(response: Response | AsyncResponse): DateTime

lastPathPart:

• os: lastPathPart(path: string): string

lastRune:

• unicode: lastRune(s: string; last: int): (Rune, int)

lastSon:

• rstast: lastSon(n: PRstNode): PRstNode

lcm:

• math: lcm[T](x: openArray[T]): T
• math: lcm[T](x, y: T): T

leaves:

• ropes: leaves(r: Rope): string

legend:

• htmlgen: legend(e: varargs[untyped]): untyped

len:

• asyncstreams: len[T](future: FutureStream[T]): int
• critbits: len[T](c: CritBitTree[T]): int
• db_mysql: len(row: InstantRow): int
• db_odbc: len(row: InstantRow): int
• db_postgres: len(row: InstantRow): int
• db_sqlite: len(row: InstantRow): int32
• deques: len[T](deq: Deque[T]): int
• dom: len(x: Node): int
• heapqueue: len[T](heap: HeapQueue[T]): int
• httpcore: len(headers: HttpHeaders): int
• jsformdata: len(self: FormData): int
• jsheaders: len(self: Headers): int
• json: len(n: JsonNode): int
• macrocache: len(s: CacheSeq): int
• macrocache: len(t: CacheTable): int
• macros: len(n: NimNode): int
• packedsets: len[A](s: PackedSet[A]): int
• parsesql: len(n: SqlNode): int
• reservedmem: len(m: ReservedMem): int
• reservedmem: len[T](s: ReservedMemSeq[T]): int
• ropes: len(a: Rope): int
• rstast: len(n: PRstNode): int
• sets: len[A](s: HashSet[A]): int
• sets: len[A](s: OrderedSet[A]): int
• sexp: len(n: SexpNode): int
• sharedtables: len[A, B](t: var SharedTable[A, B]): int
• strtabs: len(t: StringTableRef): int
• system: len(x: (type array) | array): int
• system: len(x: cstring): int
• system: len[U: Ordinal; V: Ordinal](x: HSlice[U, V]): int
• system: len[T](x: seq[T]): int
• system: len[T](x: set[T]): int
• system: len(x: string): int
• system: len[TOpenArray: openArray | varargs](x: TOpenArray): int
• tables: len[A](t: CountTable[A]): int
• tables: len[A](t: CountTableRef[A]): int
• tables: len[A, B](t: OrderedTable[A, B]): int
• tables: len[A, B](t: OrderedTableRef[A, B]): int
• tables: len[A, B](t: Table[A, B]): int
• tables: len[A, B](t: TableRef[A, B]): int
• typeinfo: len(x: Any): int
• widestrs: len(w: WideCString): int
• xmltree: len(n: XmlNode): int

lent:

• system: lent

letters:

• pegs: letters(): Peg

Letters:

• strutils: Letters

Level:

• logging: Level

LevelNames:

• logging: LevelNames

Levenshtein:

• Module editdistance
• Module editdistance

lgamma:

• math: lgamma(x: float32): float32
• math: lgamma(x: float64): float64

li:

• htmlgen: li(e: varargs[untyped]): untyped

libCandidates:

• dynlib: libCandidates(s: string; dest: var seq[string])

LibHandle:

• dynlib: LibHandle

LibraryError:

• system: LibraryError

license:

• nimscript: license

likely:

• system: likely(val: bool): bool

limit:

• Module system

line:

• pegs: line(nt: NonTerminal): int

LineInfo:

• macros: LineInfo

lineInfo:

• macros: lineInfo(arg: NimNode): string

lineInfoObj:

• macros: lineInfoObj(n: NimNode): LineInfo

lines:

• io: lines(f: File): string
• io: lines(filename: string): string
• memfiles: lines(mfile: MemFile; delim = ' '; eat = '\r'): string
• memfiles: lines(mfile: MemFile; buf: var string; delim = ' '; eat = '\r'): string
• osproc: lines(p: Process): string
• streams: lines(s: Stream): string

link:

• htmlgen: link(e: varargs[untyped]): untyped

LinkElement:

• dom: LinkElement

lispRepr:

• macros: lispRepr(n: NimNode; indented = false): string

list:

• asyncftpclient: list(ftp: AsyncFtpClient; dir = ""): Future[string]

listDirs:

• asyncftpclient: listDirs(ftp: AsyncFtpClient; dir = ""): Future[seq[string]]
• nimscript: listDirs(dir: string): seq[string]

listen:

• asynchttpserver: listen(server: AsyncHttpServer; port: Port; address = ""; domain = AF_INET)
• asyncnet: listen(socket: AsyncSocket; backlog = SOMAXCONN)
• nativesockets: listen(socket: SocketHandle; backlog = SOMAXCONN): cint
• net: listen(socket: Socket; backlog = SOMAXCONN)
• winlean: listen(s: SocketHandle; backlog: cint): cint

listFiles:

• nimscript: listFiles(dir: string): seq[string]

littleEndian:

• Endianness.littleEndian

littleEndian16:

• endians: littleEndian16(outp, inp: pointer)

littleEndian32:

• endians: littleEndian32(outp, inp: pointer)

littleEndian64:

• endians: littleEndian64(outp, inp: pointer)

ln:

• complex: ln[T](z: Complex[T]): Complex[T]
• math: ln(x: float32): float32
• math: ln(x: float64): float64

load:

• atomics: load[T](location: var Atomic[T]; order: MemoryOrder = moSequentiallyConsistent): T
• marshal: load[T](s: Stream; data: var T)

loadConfig:

• parsecfg: loadConfig(stream: Stream; filename: string = "[stream]"): Config
• parsecfg: loadConfig(filename: string): Config

loadHtml:

• htmlparser: loadHtml(path: string): XmlNode
• htmlparser: loadHtml(path: string; errors: var seq[string]): XmlNode

loadLib:

• dynlib: loadLib(): LibHandle
• dynlib: loadLib(path: string; globalSymbols = false): LibHandle

loadLibPattern:

• dynlib: loadLibPattern(pattern: string; globalSymbols = false): LibHandle

loadUnidecodeTable:

• unidecode: loadUnidecodeTable(datafile = "unidecode.dat")

loadXml:

• xmlparser: loadXml(path: string; errors: var seq[string]; options: set[XmlParseOption] = {reportComments}): XmlNode
• xmlparser: loadXml(path: string; options: set[XmlParseOption] = {reportComments}): XmlNode

local:

• times: local(): Timezone
• times: local(dt: DateTime): DateTime
• times: local(t: Time): DateTime

localFree:

• winlean: localFree(p: pointer)

localRaiseHook:

• system: localRaiseHook

locals:

• system: locals(): RootObj

Location:

• dom: Location

LocationBar:

• dom: LocationBar

Lock:

• locks: Lock

log:

• jsconsole: log(console: Console)
• jscore: log(m: MathLib; a: SomeNumber): float
• logging: log(logger: ConsoleLogger; level: Level; args: varargs[string, `$`])
• logging: log(logger: FileLogger; level: Level; args: varargs[string, `$`])
• logging: log(logger: Logger; level: Level; args: varargs[string, `$`])
• logging: log(logger: RollingFileLogger; level: Level; args: varargs[string, `$`])
• logging: log(level: Level; args: varargs[string, `$`])
• math: log[T: SomeFloat](x, base: T): T

log10:

• complex: log10[T](z: Complex[T]): Complex[T]
• jscore: log10(m: MathLib; a: SomeNumber): float
• math: log10(x: float32): float32
• math: log10(x: float64): float64

log1p:

• jscore: log1p(m: MathLib; a: SomeNumber): float

log2:

• complex: log2[T](z: Complex[T]): Complex[T]
• jscore: log2(m: MathLib; a: SomeNumber): float
• math: log2(x: float32): float32
• math: log2(x: float64): float64

Logger:

• logging: Logger

LONG:

• winlean: LONG

lookupNamespaceURI:

• dom: lookupNamespaceURI(n: Node): cstring

lookupPrefix:

• dom: lookupPrefix(n: Node): cstring

low:

• jsbigints: low(_: typedesc[JsBigInt]): JsBigInt
• monotimes: low(typ: typedesc[MonoTime]): MonoTime
• system: low[I, T](x: array[I, T]): I
• system: low(x: cstring): int
• system: low[T](x: openArray[T]): int
• system: low(x: string): int
• system: low[T: Ordinal | enum | range](x: T): T
• system: low[I, T](x: typedesc[array[I, T]]): I
• system: low(T: typedesc[SomeFloat]): T:type
• system: low[T: Ordinal | enum | range](x: typedesc[T]): T
• times: low(typ: typedesc[Duration]): Duration
• times: low(typ: typedesc[Time]): Time

lowerBound:

• algorithm: lowerBound[T, K](a: openArray[T]; key: K; cmp: proc (x: T; k: K): int {.closure.}): int
• algorithm: lowerBound[T](a: openArray[T]; key: T): int

LPFIBER_START_ROUTINE:

• winlean: LPFIBER_START_ROUTINE

LPFILETIME:

• winlean: LPFILETIME

LPINT:

• winlean: LPINT

lvlAll:

• Level.lvlAll

lvlDebug:

• Level.lvlDebug

lvlError:

• Level.lvlError

lvlFatal:

• Level.lvlFatal

lvlInfo:

• Level.lvlInfo

lvlNone:

• Level.lvlNone

lvlNotice:

• Level.lvlNotice

lvlWarn:

• Level.lvlWarn

maction:

• htmlgen: maction(e: varargs[untyped]): untyped

main:

• htmlgen: main(e: varargs[untyped]): untyped

mantissaDigits:

• fenv: mantissaDigits(T: typedesc[float32]): int
• fenv: mantissaDigits(T: typedesc[float64]): int

map:

• htmlgen: map(e: varargs[untyped]): untyped
• options: map[T](self: Option[T]; callback: proc (input: T))
• options: map[T, R](self: Option[T]; callback: proc (input: T): R): Option[R]
• sequtils: map[T, S](s: openArray[T]; op: proc (x: T): S {.closure.}): seq[S]
• sets: map[A, B](data: HashSet[A]; op: proc (x: A): B {.closure.}): HashSet[B]

mapIt:

• sequtils: mapIt(s: typed; op: untyped): untyped

mapLiterals:

• sequtils: mapLiterals(constructor, op: untyped; nested = true): untyped

mapMem:

• memfiles: mapMem(m: var MemFile; mode: FileMode = fmRead; mappedSize = -1; offset = 0; mapFlags = cint(-1)): pointer

mApr:

• Month.mApr

mapViewOfFileEx:

• winlean: mapViewOfFileEx(hFileMappingObject: Handle; dwDesiredAccess: DWORD; dwFileOffsetHigh, dwFileOffsetLow: DWORD; dwNumberOfBytesToMap: WinSizeT; lpBaseAddress: pointer): pointer

mark:

• htmlgen: mark(e: varargs[untyped]): untyped

marquee:

• htmlgen: marquee(e: varargs[untyped]): untyped

mask:

• bitops: mask[T: SomeInteger](v: var T; slice: Slice[int])
• bitops: mask[T: SomeInteger](v: var T; mask: T)

masked:

• bitops: masked[T: SomeInteger](v: T; slice: Slice[int]): T
• bitops: masked[T: SomeInteger](v, mask: T): T

match:

• jsre: match(pattern: cstring; self: RegExp): seq[cstring]
• nre: match(pattern: RegexMatch): string
• nre: match(str: string; pattern: Regex; start = 0; endpos = int.high): Option[ RegexMatch]
• pegs: match(s: string; pattern: Peg; start = 0): bool
• pegs: match(s: string; pattern: Peg; matches: var openArray[string]; start = 0): bool
• re: match(buf: cstring; pattern: Regex; matches: var openArray[string]; start = 0; bufSize: int): bool
• re: match(s: string; pattern: Regex; start = 0): bool
• re: match(s: string; pattern: Regex; matches: var openArray[string]; start = 0): bool

matchBounds:

• nre: matchBounds(pattern: RegexMatch): HSlice[int, int]

matchLen:

• pegs: matchLen(s: string; pattern: Peg; start = 0): int
• pegs: matchLen(s: string; pattern: Peg; matches: var openArray[string]; start = 0): int
• re: matchLen(buf: cstring; pattern: Regex; start = 0; bufSize: int): int
• re: matchLen(buf: cstring; pattern: Regex; matches: var openArray[string]; start = 0; bufSize: int): int
• re: matchLen(s: string; pattern: Regex; start = 0): int
• re: matchLen(s: string; pattern: Regex; matches: var openArray[string]; start = 0): int

math:

• htmlgen: math(e: varargs[untyped]): untyped

Math:

• jscore: Math

MathLib:

• jscore: MathLib

mAug:

• Month.mAug

max:

• jscore: max(m: MathLib; a, b: SomeNumber): SomeNumber
• system: max(x, y: float32): float32
• system: max(x, y: float64): float64
• system: max(x, y: int): int
• system: max(x, y: int16): int16
• system: max(x, y: int32): int32
• system: max(x, y: int64): int64
• system: max(x, y: int8): int8
• system: max[T](x: openArray[T]): T
• system: max[T: not SomeFloat](x, y: T): T

max10Exponent:

• fenv: max10Exponent(T: typedesc[float32]): int
• fenv: max10Exponent(T: typedesc[float64]): int

maxDescriptors:

• asyncdispatch: maxDescriptors(): int

MaxDistinguishedThread:

• threadpool: MaxDistinguishedThread

maxExponent:

• fenv: maxExponent(T: typedesc[float32]): int
• fenv: maxExponent(T: typedesc[float64]): int

MaxFloat32Precision:

• math: MaxFloat32Precision

MaxFloat64Precision:

• math: MaxFloat64Precision

MaxFloatPrecision:

• math: MaxFloatPrecision

maximumPositiveValue:

• fenv: maximumPositiveValue(T: typedesc[float32]): float32
• fenv: maximumPositiveValue(T: typedesc[float64]): float64

MAXIMUM_WAIT_OBJECTS:

• winlean: MAXIMUM_WAIT_OBJECTS

maxIndex:

• sequtils: maxIndex[T](s: openArray[T]): int

MAX_INT:

• Module system

maxLen:

• reservedmem: maxLen(m: ReservedMem): int
• reservedmem: maxLen[T](s: ReservedMemSeq[T]): int

MaxLineLength:

• net: MaxLineLength

MAX_PATH:

• winlean: MAX_PATH

MaxReBufSize:

• re: MaxReBufSize

maxSafeInteger:

• jsutils: maxSafeInteger

MaxSubpatterns:

• pegs: MaxSubpatterns
• re: MaxSubpatterns

MaxThreadPoolSize:

• threadpool: MaxThreadPoolSize

maxVarIntLen:

• varints: maxVarIntLen

MD5Context:

• md5: MD5Context

MD5Digest:

• md5: MD5Digest

md5Final:

• md5: md5Final(c: var MD5Context; digest: var MD5Digest)

md5Init:

• md5: md5Init(c: var MD5Context)

md5Update:

• md5: md5Update(c: var MD5Context; input: cstring; len: int)

mDec:

• Month.mDec

mean:

• stats: mean[T](x: openArray[T]): float
• stats: mean(s: RunningStat): float

MemAccessFlags:

• reservedmem: MemAccessFlags

memExec:

• reservedmem: memExec

memExecRead:

• reservedmem: memExecRead

memExecReadWrite:

• reservedmem: memExecReadWrite

MemFile:

• memfiles: MemFile

MemMapFileStream:

• memfiles: MemMapFileStream

MemMapFileStreamObj:

• memfiles: MemMapFileStreamObj

memory mapped files:

• Module memfiles

memoryLock:

• posix_utils: memoryLock(a1: pointer; a2: int)

memoryLockAll:

• posix_utils: memoryLockAll(flags: int)

MemoryOrder:

• atomics: MemoryOrder

memoryUnlock:

• posix_utils: memoryUnlock(a1: pointer; a2: int)

memoryUnlockAll:

• posix_utils: memoryUnlockAll()

memRead:

• reservedmem: memRead

memReadWrite:

• reservedmem: memReadWrite

MemSlice:

• memfiles: MemSlice

memSlices:

• memfiles: memSlices(mfile: MemFile; delim = ' '; eat = '\r'): MemSlice

menclose:

• htmlgen: menclose(e: varargs[untyped]): untyped

MenuBar:

• dom: MenuBar

merge:

• algorithm: merge[T](result: var seq[T]; x, y: openArray[T])
• algorithm: merge[T](result: var seq[T]; x, y: openArray[T]; cmp: proc (x, y: T): int {.closure.})
• tables: merge[A](s: var CountTable[A]; t: CountTable[A])
• tables: merge[A](s, t: CountTableRef[A])

mergeIndexes:

• rstgen: mergeIndexes(dir: string): string

merror:

• htmlgen: merror(e: varargs[untyped]): untyped

MersenneTwister:

• mersenne: MersenneTwister

message:

• dom: message(ex: DomException): cstring

Message:

• smtp: Message

meta:

• htmlgen: meta(e: varargs[untyped]): untyped

metaAuthor:

• MetaEnum.metaAuthor

MetaEnum:

• rstgen: MetaEnum

metaNone:

• MetaEnum.metaNone

metaSubtitle:

• MetaEnum.metaSubtitle

metaTitle:

• MetaEnum.metaTitle

metaVersion:

• MetaEnum.metaVersion

meter:

• htmlgen: meter(e: varargs[untyped]): untyped

method:

• Module system

methodGet:

• RequestMethod.methodGet

methodNone:

• RequestMethod.methodNone

methodPost:

• RequestMethod.methodPost

mFeb:

• Month.mFeb

mfenced:

• htmlgen: mfenced(e: varargs[untyped]): untyped

mfrac:

• htmlgen: mfrac(e: varargs[untyped]): untyped

mget:

• asyncfutures: mget[T](future: FutureVar[T]): var T
• sharedtables: mget[A, B](t: var SharedTable[A, B]; key: A): var B

mgetOrPut:

• sharedtables: mgetOrPut[A, B](t: var SharedTable[A, B]; key: A; val: B): var B
• tables: mgetOrPut[A, B](t: var OrderedTable[A, B]; key: A; val: B): var B
• tables: mgetOrPut[A, B](t: OrderedTableRef[A, B]; key: A; val: B): var B
• tables: mgetOrPut[A, B](t: var Table[A, B]; key: A; val: B): var B
• tables: mgetOrPut[A, B](t: TableRef[A, B]; key: A; val: B): var B

mglyph:

• htmlgen: mglyph(e: varargs[untyped]): untyped

mi:

• htmlgen: mi(e: varargs[untyped]): untyped

Microseconds:

• TimeUnit.Microseconds

microseconds:

• times: microseconds(micros: int): TimeInterval

Milliseconds:

• TimeUnit.Milliseconds

milliseconds:

• times: milliseconds(ms: int): TimeInterval

MimeDB:

• mimetypes: MimeDB

mimes:

• mimetypes: mimes

MimeType:

• dom: MimeType

min:

• jscore: min[T: SomeNumber | JsRoot](m: MathLib; a, b: T): T
• system: min(x, y: float32): float32
• system: min(x, y: float64): float64
• system: min(x, y: int): int
• system: min(x, y: int16): int16
• system: min(x, y: int32): int32
• system: min(x, y: int64): int64
• system: min(x, y: int8): int8
• system: min[T](x: openArray[T]): T
• system: min[T: not SomeFloat](x, y: T): T

min10Exponent:

• fenv: min10Exponent(T: typedesc[float32]): int
• fenv: min10Exponent(T: typedesc[float64]): int

minExponent:

• fenv: minExponent(T: typedesc[float32]): int
• fenv: minExponent(T: typedesc[float64]): int

MinFloatNormal:

• math: MinFloatNormal

minimumPositiveValue:

• fenv: minimumPositiveValue(T: typedesc[float32]): float32
• fenv: minimumPositiveValue(T: typedesc[float64]): float64

minIndex:

• sequtils: minIndex[T](s: openArray[T]): int

MIN_INT:

• Module system

minute:

• times: minute(dt: DateTime): MinuteRange

minute=:

• times: minute=(dt: var DateTime; value: MinuteRange)

MinuteRange:

• times: MinuteRange

Minutes:

• TimeUnit.Minutes

minutes:

• times: minutes(m: int): TimeInterval

missingOrExcl:

• critbits: missingOrExcl[T](c: var CritBitTree[T]; key: string): bool
• packedsets: missingOrExcl[A](s: var PackedSet[A]; key: A): bool
• sets: missingOrExcl[A](s: var HashSet[A]; key: A): bool
• sets: missingOrExcl[A](s: var OrderedSet[A]; key: A): bool

mitems:

• deques: mitems[T](deq: var Deque[T]): var T
• iterators: mitems[IX, T](a: var array[IX, T]): var T
• iterators: mitems(a: var cstring): var char
• iterators: mitems[T](a: var openArray[T]): var T
• iterators: mitems[T](a: var seq[T]): var T
• iterators: mitems(a: var string): var char
• json: mitems(node: var JsonNode): var JsonNode
• lists: mitems[T](L: var SomeLinkedList[T]): var T
• lists: mitems[T](L: var SomeLinkedRing[T]): var T
• sexp: mitems(node: var SexpNode): var SexpNode
• xmltree: mitems(n: var XmlNode): var XmlNode

mix:

• colors: mix(a, b: Color; fn: untyped): untyped

mJan:

• Month.mJan

mJul:

• Month.mJul

mJun:

• Month.mJun

mkDir:

• nimscript: mkDir(dir: string)

mkdtemp:

• posix_utils: mkdtemp(prefix: string): string

mkstemp:

• posix_utils: mkstemp(prefix: string; suffix = ""): (string, File)

mlabeledtr:

• htmlgen: mlabeledtr(e: varargs[untyped]): untyped

mmap:

• Module memfiles

mMar:

• Month.mMar

mMay:

• Month.mMay

mmultiscripts:

• htmlgen: mmultiscripts(e: varargs[untyped]): untyped

mn:

• htmlgen: mn(e: varargs[untyped]): untyped

mNov:

• Month.mNov

mo:

• htmlgen: mo(e: varargs[untyped]): untyped

mOct:

• Month.mOct

mode:

• nimscript: mode
• strtabs: mode(t: StringTableRef): StringTableMode

modeCaseInsensitive:

• StringTableMode.modeCaseInsensitive

modeCaseSensitive:

• StringTableMode.modeCaseSensitive

modeStyleInsensitive:

• StringTableMode.modeStyleInsensitive

MonoTime:

• monotimes: MonoTime

Month:

• times: Month

month:

• times: month(dt: DateTime): Month

monthday:

• times: monthday(dt: DateTime): MonthdayRange

MonthdayRange:

• times: MonthdayRange

monthdayZero=:

• times: monthdayZero=(dt: var DateTime; value: int)

Months:

• TimeUnit.Months

months:

• times: months(m: int): TimeInterval

monthZero=:

• times: monthZero=(dt: var DateTime; value: int)

MouseButtons:

• dom: MouseButtons

MouseEvent:

• dom: MouseEvent

move:

• system: move[T](x: var T): T

moveBy:

• dom: moveBy(w: Window; x, y: int)

moveDir:

• os: moveDir(source, dest: string)

moveFile:

• os: moveFile(source, dest: string)

MOVEFILE_COPY_ALLOWED:

• winlean: MOVEFILE_COPY_ALLOWED

MOVEFILE_CREATE_HARDLINK:

• winlean: MOVEFILE_CREATE_HARDLINK

MOVEFILE_DELAY_UNTIL_REBOOT:

• winlean: MOVEFILE_DELAY_UNTIL_REBOOT

moveFileExW:

• winlean: moveFileExW(lpExistingFileName, lpNewFileName: WideCString; flags: DWORD): WINBOOL

MOVEFILE_FAIL_IF_NOT_TRACKABLE:

• winlean: MOVEFILE_FAIL_IF_NOT_TRACKABLE

MOVEFILE_REPLACE_EXISTING:

• winlean: MOVEFILE_REPLACE_EXISTING

moveFileW:

• winlean: moveFileW(lpExistingFileName, lpNewFileName: WideCString): WINBOOL

MOVEFILE_WRITE_THROUGH:

• winlean: MOVEFILE_WRITE_THROUGH

moveMem:

• system: moveMem(dest, source: pointer; size: Natural)

mover:

• htmlgen: mover(e: varargs[untyped]): untyped

moveTo:

• dom: moveTo(w: Window; x, y: int)

mpadded:

• htmlgen: mpadded(e: varargs[untyped]): untyped

mpairs:

• critbits: mpairs[T](c: var CritBitTree[T]): tuple[key: string, val: var T]
• iterators: mpairs[IX, T](a: var array[IX, T]): tuple[key: IX, val: var T]
• iterators: mpairs(a: var cstring): tuple[key: int, val: var char]
• iterators: mpairs[T](a: var openArray[T]): tuple[key: int, val: var T]
• iterators: mpairs[T](a: var seq[T]): tuple[key: int, val: var T]
• iterators: mpairs(a: var string): tuple[key: int, val: var char]
• json: mpairs(node: var JsonNode): tuple[key: string, val: var JsonNode]
• tables: mpairs[A](t: var CountTable[A]): (A, var int)
• tables: mpairs[A](t: CountTableRef[A]): (A, var int)
• tables: mpairs[A, B](t: var OrderedTable[A, B]): (A, var B)
• tables: mpairs[A, B](t: OrderedTableRef[A, B]): (A, var B)
• tables: mpairs[A, B](t: var Table[A, B]): (A, var B)
• tables: mpairs[A, B](t: TableRef[A, B]): (A, var B)

mpairsWithPrefix:

• critbits: mpairsWithPrefix[T](c: var CritBitTree[T]; prefix: string): tuple[key: string, val: var T]

mphantom:

• htmlgen: mphantom(e: varargs[untyped]): untyped

mroot:

• htmlgen: mroot(e: varargs[untyped]): untyped

mrow:

• htmlgen: mrow(e: varargs[untyped]): untyped

ms:

• htmlgen: ms(e: varargs[untyped]): untyped

mSep:

• Month.mSep

MSG_PEEK:

• winlean: MSG_PEEK

mspace:

• htmlgen: mspace(e: varargs[untyped]): untyped

msqrt:

• htmlgen: msqrt(e: varargs[untyped]): untyped

mstyle:

• htmlgen: mstyle(e: varargs[untyped]): untyped

msub:

• htmlgen: msub(e: varargs[untyped]): untyped

msubsup:

• htmlgen: msubsup(e: varargs[untyped]): untyped

msup:

• htmlgen: msup(e: varargs[untyped]): untyped

mtable:

• htmlgen: mtable(e: varargs[untyped]): untyped

mtd:

• htmlgen: mtd(e: varargs[untyped]): untyped

mtext:

• htmlgen: mtext(e: varargs[untyped]): untyped

MultipartData:

• httpclient: MultipartData

MultipartEntries:

• httpclient: MultipartEntries

MultipleValueSetting:

• compilesettings: MultipleValueSetting

multiReplace:

• re: multiReplace(s: string; subs: openArray[tuple[pattern: Regex, repl: string]]): string
• strutils: multiReplace(s: string; replacements: varargs[(string, string)]): string

multisync:

• asyncdispatch: multisync(prc: untyped): untyped
• asyncmacro: multisync(prc: untyped): untyped

munder:

• htmlgen: munder(e: varargs[untyped]): untyped

munderover:

• htmlgen: munderover(e: varargs[untyped]): untyped

mvalues:

• critbits: mvalues[T](c: var CritBitTree[T]): var T
• tables: mvalues[A](t: var CountTable[A]): var int
• tables: mvalues[A](t: CountTableRef[A]): var int
• tables: mvalues[A, B](t: var OrderedTable[A, B]): var B
• tables: mvalues[A, B](t: OrderedTableRef[A, B]): var B
• tables: mvalues[A, B](t: var Table[A, B]): var B
• tables: mvalues[A, B](t: TableRef[A, B]): var B

mvaluesWithPrefix:

• critbits: mvaluesWithPrefix[T](c: var CritBitTree[T]; prefix: string): var T

mvDir:

• nimscript: mvDir(from, to: string)

mvFile:

• nimscript: mvFile(from, to: string)

mySQL:

• Module db_mysql

name:

• dom: name(ex: DomException): cstring
• macros: name(someProc: NimNode): NimNode
• pegs: name(nt: NonTerminal): string
• times: name(zone: Timezone): string
• typetraits: name(t: typedesc): string

name=:

• macros: name=(someProc: NimNode; val: NimNode)

nameToCodePage:

• encodings: nameToCodePage(name: string): CodePage

NaN:

• system: NaN

nanosecond:

• times: nanosecond(dt: DateTime): NanosecondRange
• times: nanosecond(time: Time): NanosecondRange

nanosecond=:

• times: nanosecond=(dt: var DateTime; value: NanosecondRange)

NanosecondRange:

• times: NanosecondRange

Nanoseconds:

• TimeUnit.Nanoseconds

nanoseconds:

• times: nanoseconds(nanos: int): TimeInterval

nativeToUnixPath:

• globs: nativeToUnixPath(path: string): string

natural:

• pegs: natural(): Peg

Natural:

• system: Natural

nav:

• htmlgen: nav(e: varargs[untyped]): untyped

Navigator:

• dom: Navigator

navigator:

• dom: navigator

NegInf:

• system: NegInf

nestList:

• macros: nestList(op: NimNode; pack: NimNode): NimNode
• macros: nestList(op: NimNode; pack: NimNode; init: NimNode): NimNode

new:

• system: new[T](a: var ref T)
• system: new[T](a: var ref T; finalizer: proc (x: ref T) {.nimcall.})
• system: new(t: typedesc): auto

newArrayBuffer:

• jsutils: newArrayBuffer(n: int): ArrayBuffer

newAssignment:

• macros: newAssignment(lhs, rhs: NimNode): NimNode

newAsyncEvent:

• asyncdispatch: newAsyncEvent(): AsyncEvent

newAsyncFile:

• asyncfile: newAsyncFile(fd: AsyncFD): AsyncFile

newAsyncFtpClient:

• asyncftpclient: newAsyncFtpClient(address: string; port = Port(21); user, pass = ""; progressInterval: int = 1000): AsyncFtpClient

newAsyncHttpClient:

• httpclient: newAsyncHttpClient(userAgent = defUserAgent; maxRedirects = 5; sslContext = getDefaultSSL(); proxy: Proxy = nil; headers = newHttpHeaders()): AsyncHttpClient

newAsyncHttpServer:

• asynchttpserver: newAsyncHttpServer(reuseAddr = true; reusePort = false; maxBody = 8388608): AsyncHttpServer

newAsyncSmtp:

• smtp: newAsyncSmtp(useSsl = false; debug = false; sslContext: SslContext = nil): AsyncSmtp

newAsyncSocket:

• asyncnet: newAsyncSocket(fd: AsyncFD; domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP; buffered = true; inheritable = defined(nimInheritHandles)): owned(AsyncSocket)
• asyncnet: newAsyncSocket(domain, sockType, protocol: cint; buffered = true; inheritable = defined(nimInheritHandles)): owned(AsyncSocket)
• asyncnet: newAsyncSocket(domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP; buffered = true; inheritable = defined(nimInheritHandles)): owned(AsyncSocket)

newBigUint64Array:

• jsutils: newBigUint64Array(buffer: ArrayBuffer): BigUint64Array

newBlockStmt:

• macros: newBlockStmt(body: NimNode): NimNode
• macros: newBlockStmt(label, body: NimNode): NimNode

newCall:

• macros: newCall(theProc: NimIdent; args: varargs[NimNode]): NimNode
• macros: newCall(theProc: NimNode; args: varargs[NimNode]): NimNode
• macros: newCall(theProc: string; args: varargs[NimNode]): NimNode

newCData:

• xmltree: newCData(cdata: sink string): XmlNode

newColonExpr:

• macros: newColonExpr(a, b: NimNode): NimNode

newComment:

• xmltree: newComment(comment: sink string): XmlNode

newCommentStmtNode:

• macros: newCommentStmtNode(s: string): NimNode

newConfig:

• parsecfg: newConfig(): Config

newConsoleLogger:

• logging: newConsoleLogger(levelThreshold = lvlAll; fmtStr = defaultFmtStr; useStderr = false): ConsoleLogger

newConsoleOutputFormatter:

• unittest: newConsoleOutputFormatter(outputLevel: OutputLevel = outputLevelDefault; colorOutput = true): ConsoleOutputFormatter

newConstStmt:

• macros: newConstStmt(name, value: NimNode): NimNode

newContext:

• net: newContext(protVersion = protSSLv23; verifyMode = CVerifyPeer; certFile = ""; keyFile = ""; cipherList = CiphersIntermediate; caDir = ""; caFile = ""): SslContext

newCountTable:

• tables: newCountTable[A](initialSize = defaultInitialSize): CountTableRef[A]
• tables: newCountTable[A](keys: openArray[A]): CountTableRef[A]

newCustom:

• asyncdispatch: newCustom(): CustomRef

newDate:

• jscore: newDate(): DateTime
• jscore: newDate(year, month, day, hours, minutes, seconds, milliseconds: int): DateTime
• jscore: newDate(date: int | int64 | string): DateTime

newDispatcher:

• asyncdispatch: newDispatcher(): owned PDispatcher

newDomException:

• dom: newDomException(): DomException

newDomParser:

• dom: newDomParser(): DomParser

newDotExpr:

• macros: newDotExpr(a, b: NimNode): NimNode

newDoublyLinkedNode:

• lists: newDoublyLinkedNode[T](value: T): DoublyLinkedNode[T]

newElement:

• xmltree: newElement(tag: sink string): XmlNode

newEmptyNode:

• macros: newEmptyNode(): NimNode

newEntity:

• xmltree: newEntity(entity: string): XmlNode

newEnum:

• macros: newEnum(name: NimNode; fields: openArray[NimNode]; public, pure: bool): NimNode

newEvent:

• dom: newEvent(name: cstring): Event

newException:

• system: newException(exceptn: typedesc; message: string; parentException: ref Exception = nil): untyped

newfetchOptions:

• jsfetch: newfetchOptions(metod: HttpMethod; body: cstring; mode: FetchModes; credentials: FetchCredentials; cache: FetchCaches; referrerPolicy: FetchReferrerPolicies; keepalive: bool; redirect = frFollow; referrer = "client".cstring; integrity = "".cstring): FetchOptions

newFileLogger:

• logging: newFileLogger(file: File; levelThreshold = lvlAll; fmtStr = defaultFmtStr): FileLogger
• logging: newFileLogger(filename = defaultFilename(); mode: FileMode = fmAppend; levelThreshold = lvlAll; fmtStr = defaultFmtStr; bufSize: int = -1): FileLogger

newFileReader:

• dom: newFileReader(): FileReader

newFileStream:

• streams: newFileStream(f: File): owned FileStream
• streams: newFileStream(filename: string; mode: FileMode = fmRead; bufSize: int = -1): owned FileStream

newFloat64Array:

• jsutils: newFloat64Array(buffer: ArrayBuffer): Float64Array

newFloatLitNode:

• macros: newFloatLitNode(f: BiggestFloat): NimNode

newFormData:

• jsformdata: newFormData(): FormData

newFuture:

• asyncfutures: newFuture[T](fromProc: string = "unspecified"): owned(Future[T])

newFutureStream:

• asyncstreams: newFutureStream[T](fromProc = "unspecified"): FutureStream[T]

newFutureVar:

• asyncfutures: newFutureVar[T](fromProc = "unspecified"): owned(FutureVar[T])

newHeaders:

• jsheaders: newHeaders(): Headers

newHttpClient:

• httpclient: newHttpClient(userAgent = defUserAgent; maxRedirects = 5; sslContext = getDefaultSSL(); proxy: Proxy = nil; timeout = -1; headers = newHttpHeaders()): HttpClient

newHttpHeaders:

• httpcore: newHttpHeaders(titleCase = false): HttpHeaders
• httpcore: newHttpHeaders(keyValuePairs: openArray[tuple[key: string, val: string]]; titleCase = false): HttpHeaders

newIdentDefs:

• macros: newIdentDefs(name, kind: NimNode; default = newEmptyNode()): NimNode

newIdentNode:

• macros: newIdentNode(i: NimIdent): NimNode
• macros: newIdentNode(i: string): NimNode

newIfStmt:

• macros: newIfStmt(branches: varargs[tuple[cond, body: NimNode]]): NimNode

newIntLitNode:

• macros: newIntLitNode(i: BiggestInt): NimNode

newJArray:

• json: newJArray(): JsonNode

newJBool:

• json: newJBool(b: bool): JsonNode

newJFloat:

• json: newJFloat(n: float): JsonNode

newJInt:

• json: newJInt(n: BiggestInt): JsonNode

newJNull:

• json: newJNull(): JsonNode

newJObject:

• json: newJObject(): JsonNode

newJsAssoc:

• jsffi: newJsAssoc[K: JsKey; V](): JsAssoc[K, V]

newJsObject:

• jsffi: newJsObject(): JsObject

newJString:

• json: newJString(s: string): JsonNode

newJUnitOutputFormatter:

• unittest: newJUnitOutputFormatter(stream: Stream): JUnitOutputFormatter

newLetStmt:

• macros: newLetStmt(name, value: NimNode): NimNode

newLine:

• pegs: newLine(): Peg

newline:

• Module pegs

NewLines:

• lexbase: NewLines

Newlines:

• strutils: Newlines

newLit:

• macros: newLit(arg: enum): NimNode
• macros: newLit[N, T](arg: array[N, T]): NimNode
• macros: newLit(b: bool): NimNode
• macros: newLit(c: char): NimNode
• macros: newLit(f: float32): NimNode
• macros: newLit(f: float64): NimNode
• macros: newLit(i: int): NimNode
• macros: newLit(i: int16): NimNode
• macros: newLit(i: int32): NimNode
• macros: newLit(i: int64): NimNode
• macros: newLit(i: int8): NimNode
• macros: newLit(arg: ref object): NimNode
• macros: newLit[T](arg: seq[T]): NimNode
• macros: newLit[T](s: set[T]): NimNode
• macros: newLit(s: string): NimNode
• macros: newLit[T: tuple](arg: T): NimNode
• macros: newLit(i: uint): NimNode
• macros: newLit(i: uint16): NimNode
• macros: newLit(i: uint32): NimNode
• macros: newLit(i: uint64): NimNode
• macros: newLit(i: uint8): NimNode
• macros: newLit(arg: object): NimNode

newMemMapFileStream:

• memfiles: newMemMapFileStream(filename: string; mode: FileMode = fmRead; fileSize: int = -1): MemMapFileStream

newMersenneTwister:

• mersenne: newMersenneTwister(seed: uint32): MersenneTwister

newMimetypes:

• mimetypes: newMimetypes(): MimeDB

newMultipartData:

• httpclient: newMultipartData(): MultipartData
• httpclient: newMultipartData(xs: MultipartEntries): MultipartData

newNilLit:

• macros: newNilLit(): NimNode

newNimNode:

• macros: newNimNode(kind: NimNodeKind; lineInfoFrom: NimNode = nil): NimNode

newNode:

• parsesql: newNode(k: SqlNodeKind): SqlNode
• parsesql: newNode(k: SqlNodeKind; sons: seq[SqlNode]): SqlNode
• parsesql: newNode(k: SqlNodeKind; s: string): SqlNode

newNonTerminal:

• pegs: newNonTerminal(name: string; line, column: int): NonTerminal

newOrderedTable:

• tables: newOrderedTable[A, B](initialSize = defaultInitialSize): OrderedTableRef[A, B]
• tables: newOrderedTable[A, B](pairs: openArray[(A, B)]): OrderedTableRef[A, B]

newOSError:

• os: newOSError(errorCode: OSErrorCode; additionalInfo = ""): owned(ref OSError)

newPar:

• macros: newPar(exprs: varargs[NimNode]): NimNode

newPipeOutStream:

• streamwrapper: newPipeOutStream[T](s: sink (ref T)): owned PipeOutStream[T]

newProc:

• macros: newProc(name = newEmptyNode(); params: openArray[NimNode] = [newEmptyNode()]; body: NimNode = newStmtList(); procType = nnkProcDef; pragmas: NimNode = newEmptyNode()): NimNode

newPromise:

• asyncjs: newPromise[T](handler: proc (resolve: proc (response: T))): Future[T]
• asyncjs: newPromise(handler: proc (resolve: proc ())): Future[void]

newProxy:

• httpclient: newProxy(url: string; auth = ""): Proxy
• httpclient: newProxy(url: Uri; auth = ""): Proxy

newReadSocketStream:

• socketstreams: newReadSocketStream(s: Socket): owned ReadSocketStream

newRegExp:

• jsre: newRegExp(pattern: cstring): RegExp
• jsre: newRegExp(pattern: cstring; flags: cstring): RegExp

newRequest:

• jsfetch: newRequest(url: cstring): Request

newResponse:

• jsfetch: newResponse(body: cstring | FormData): Response

newRollingFileLogger:

• logging: newRollingFileLogger(filename = defaultFilename(); mode: FileMode = fmReadWrite; levelThreshold = lvlAll; fmtStr = defaultFmtStr; maxLines: Positive = 1000; bufSize: int = -1): RollingFileLogger

newRstLeaf:

• rstast: newRstLeaf(s: string): PRstNode

newRstNode:

• rstast: newRstNode(kind: RstNodeKind; sons: seq[PRstNode] = @[]; anchor = ""): PRstNode
• rstast: newRstNode(kind: RstNodeKind; s: string): PRstNode
• rstast: newRstNode(kind: RstNodeKind; info: TLineInfo; sons: seq[PRstNode] = @[]): PRstNode

newSCons:

• sexp: newSCons(car, cdr: SexpNode): SexpNode

newSelectEvent:

• selectors: newSelectEvent(): SelectEvent

newSelector:

• selectors: newSelector[T](): Selector[T]

newSeq:

• system: newSeq[T](len = 0.Natural): seq[T]
• system: newSeq[T](s: var seq[T]; len: Natural)

newSeqOfCap:

• system: newSeqOfCap[T](cap: Natural): seq[T]

newSeqUninitialized:

• system: newSeqUninitialized[T: SomeNumber](len: Natural): seq[T]

newSeqWith:

• sequtils: newSeqWith(len: int; init: untyped): untyped

newSFloat:

• sexp: newSFloat(n: float): SexpNode

newSha1State:

• sha1: newSha1State(): Sha1State

newSinglyLinkedNode:

• lists: newSinglyLinkedNode[T](value: T): SinglyLinkedNode[T]

newSInt:

• sexp: newSInt(n: BiggestInt): SexpNode

newSList:

• sexp: newSList(): SexpNode

newSmtp:

• smtp: newSmtp(useSsl = false; debug = false; sslContext: SslContext = nil): Smtp

newSNil:

• sexp: newSNil(): SexpNode

newSocket:

• net: newSocket(domain, sockType, protocol: cint; buffered = true; inheritable = defined(nimInheritHandles)): owned(Socket)
• net: newSocket(domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP; buffered = true; inheritable = defined(nimInheritHandles)): owned(Socket)
• net: newSocket(fd: SocketHandle; domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP; buffered = true): owned(Socket)

newSString:

• sexp: newSString(s: string): SexpNode

newSSymbol:

• sexp: newSSymbol(s: string): SexpNode

newStmtList:

• macros: newStmtList(stmts: varargs[NimNode]): NimNode

newString:

• system: newString(len: Natural): string

newStringOfCap:

• system: newStringOfCap(cap: Natural): string

newStringStream:

• streams: newStringStream(s: sink string = ""): owned StringStream

newStringTable:

• strtabs: newStringTable(mode: StringTableMode): owned(StringTableRef)
• strtabs: newStringTable(keyValuePairs: varargs[string]; mode: StringTableMode): owned( StringTableRef)
• strtabs: newStringTable(keyValuePairs: varargs[tuple[key, val: string]]; mode: StringTableMode = modeCaseSensitive): owned(StringTableRef)

newStrLitNode:

• macros: newStrLitNode(s: string): NimNode

newTable:

• tables: newTable[A, B](initialSize = defaultInitialSize): TableRef[A, B]
• tables: newTable[A, B](pairs: openArray[(A, B)]): TableRef[A, B]

newTableFrom:

• tables: newTableFrom[A, B, C](collection: A; index: proc (x: B): C): TableRef[C, B]

newText:

• xmltree: newText(text: sink string): XmlNode

newTimezone:

• times: newTimezone(name: string; zonedTimeFromTimeImpl: proc (time: Time): ZonedTime {. tags: [], raises: [], gcsafe, locks: 0.}; zonedTimeFromAdjTimeImpl: proc ( adjTime: Time): ZonedTime {.tags: [], raises: [], gcsafe, locks: 0.}): owned Timezone

newTree:

• macros: newTree(kind: NimNodeKind; children: varargs[NimNode]): NimNode

newUint32Array:

• jsutils: newUint32Array(buffer: ArrayBuffer): Uint32Array

newUint8Array:

• jsutils: newUint8Array(n: int): Uint8Array

newVarStmt:

• macros: newVarStmt(name, value: NimNode): NimNode

newVerbatimText:

• xmltree: newVerbatimText(text: sink string): XmlNode

newWideCString:

• widestrs: newWideCString(s: cstring): WideCStringObj
• widestrs: newWideCString(source: cstring; L: int): WideCStringObj
• widestrs: newWideCString(size: int): WideCStringObj
• widestrs: newWideCString(s: string): WideCStringObj

newWriteSocketStream:

• socketstreams: newWriteSocketStream(s: Socket): owned WriteSocketStream

newXmlTree:

• xmltree: newXmlTree(tag: sink string; children: openArray[XmlNode]; attributes: XmlAttributes = nil): XmlNode

next:

• parsecfg: next(c: var CfgParser): CfgEvent
• parsejson: next(my: var JsonParser)
• parseopt: next(p: var OptParser)
• parsexml: next(my: var XmlParser)
• pathnorm: next(it: var PathIter; x: string): (int, int)
• random: next(r: var Rand): uint64

nextPermutation:

• algorithm: nextPermutation[T](x: var openArray[T]): bool

nextPowerOfTwo:

• math: nextPowerOfTwo(x: int): int

nextSplitPoint:

• rstgen: nextSplitPoint(s: string; start: int): int

NilAccessDefect:

• system: NilAccessDefect

NilAccessError:

• system: NilAccessError

NimAsyncContinueSuffix:

• asyncfutures: NimAsyncContinueSuffix

nimcacheDir:

• nimscript: nimcacheDir(): string

nimGC_setStackBottom:

• system: nimGC_setStackBottom(theStackBottom: pointer)

NimIdent:

• macros: NimIdent

nimIdentNormalize:

• strutils: nimIdentNormalize(s: string): string

NimMajor:

• system: NimMajor

nimMaxDescriptorsFallback:

• asynchttpserver: nimMaxDescriptorsFallback

NimMinor:

• system: NimMinor

NimNode:

• system: NimNode

NimNodeKind:

• macros: NimNodeKind

NimNodeKinds:

• macros: NimNodeKinds

NimPatch:

• system: NimPatch

NimSym:

• macros: NimSym

NimSymKind:

• macros: NimSymKind

NimTypeKind:

• macros: NimTypeKind

NimVersion:

• system: NimVersion

nimvm:

• system: nimvm

nkAsgn:

• SqlNodeKind.nkAsgn

nkBitStringLit:

• SqlNodeKind.nkBitStringLit

nkCall:

• SqlNodeKind.nkCall

nkCheck:

• SqlNodeKind.nkCheck

nkColumnDef:

• SqlNodeKind.nkColumnDef

nkColumnList:

• SqlNodeKind.nkColumnList

nkColumnReference:

• SqlNodeKind.nkColumnReference

nkConstraint:

• SqlNodeKind.nkConstraint

nkCreateIndex:

• SqlNodeKind.nkCreateIndex

nkCreateIndexIfNotExists:

• SqlNodeKind.nkCreateIndexIfNotExists

nkCreateTable:

• SqlNodeKind.nkCreateTable

nkCreateTableIfNotExists:

• SqlNodeKind.nkCreateTableIfNotExists

nkCreateType:

• SqlNodeKind.nkCreateType

nkCreateTypeIfNotExists:

• SqlNodeKind.nkCreateTypeIfNotExists

nkDefault:

• SqlNodeKind.nkDefault

nkDelete:

• SqlNodeKind.nkDelete

nkDesc:

• SqlNodeKind.nkDesc

nkDot:

• SqlNodeKind.nkDot

nkDotDot:

• SqlNodeKind.nkDotDot

nkEnumDef:

• SqlNodeKind.nkEnumDef

nkExcept:

• SqlNodeKind.nkExcept

nkForeignKey:

• SqlNodeKind.nkForeignKey

nkFrom:

• SqlNodeKind.nkFrom

nkFromItemPair:

• SqlNodeKind.nkFromItemPair

nkGroup:

• SqlNodeKind.nkGroup

nkHaving:

• SqlNodeKind.nkHaving

nkHexStringLit:

• SqlNodeKind.nkHexStringLit

nkIdent:

• SqlNodeKind.nkIdent

nkIdentity:

• SqlNodeKind.nkIdentity

nkInfix:

• SqlNodeKind.nkInfix

nkInsert:

• SqlNodeKind.nkInsert

nkIntegerLit:

• SqlNodeKind.nkIntegerLit

nkIntersect:

• SqlNodeKind.nkIntersect

nkJoin:

• SqlNodeKind.nkJoin

nkLimit:

• SqlNodeKind.nkLimit

nkNone:

• SqlNodeKind.nkNone

nkNotNull:

• SqlNodeKind.nkNotNull

nkNull:

• SqlNodeKind.nkNull

nkNumericLit:

• SqlNodeKind.nkNumericLit

nkOrder:

• SqlNodeKind.nkOrder

nkPrefix:

• SqlNodeKind.nkPrefix

nkPrGroup:

• SqlNodeKind.nkPrGroup

nkPrimaryKey:

• SqlNodeKind.nkPrimaryKey

nkQuotedIdent:

• SqlNodeKind.nkQuotedIdent

nkReferences:

• SqlNodeKind.nkReferences

nkSelect:

• SqlNodeKind.nkSelect

nkSelectColumns:

• SqlNodeKind.nkSelectColumns

nkSelectDistinct:

• SqlNodeKind.nkSelectDistinct

nkSelectPair:

• SqlNodeKind.nkSelectPair

nkStmtList:

• SqlNodeKind.nkStmtList

nkStringLit:

• SqlNodeKind.nkStringLit

nkUnion:

• SqlNodeKind.nkUnion

nkUnique:

• SqlNodeKind.nkUnique

nkUpdate:

• SqlNodeKind.nkUpdate

nkValueList:

• SqlNodeKind.nkValueList

nkWhere:

• SqlNodeKind.nkWhere

nnkAccQuoted:

• NimNodeKind.nnkAccQuoted

nnkAddr:

• NimNodeKind.nnkAddr

nnkArgList:

• NimNodeKind.nnkArgList

nnkAsgn:

• NimNodeKind.nnkAsgn

nnkAsmStmt:

• NimNodeKind.nnkAsmStmt

nnkBind:

• NimNodeKind.nnkBind

nnkBindStmt:

• NimNodeKind.nnkBindStmt

nnkBlockExpr:

• NimNodeKind.nnkBlockExpr

nnkBlockStmt:

• NimNodeKind.nnkBlockStmt

nnkBlockType:

• NimNodeKind.nnkBlockType

nnkBracket:

• NimNodeKind.nnkBracket

nnkBracketExpr:

• NimNodeKind.nnkBracketExpr

nnkBreakState:

• NimNodeKind.nnkBreakState

nnkBreakStmt:

• NimNodeKind.nnkBreakStmt

nnkCall:

• NimNodeKind.nnkCall

nnkCallKinds:

• macros: nnkCallKinds

nnkCallStrLit:

• NimNodeKind.nnkCallStrLit

nnkCaseStmt:

• NimNodeKind.nnkCaseStmt

nnkCast:

• NimNodeKind.nnkCast

nnkCharLit:

• NimNodeKind.nnkCharLit

nnkChckRange:

• NimNodeKind.nnkChckRange

nnkChckRange64:

• NimNodeKind.nnkChckRange64

nnkChckRangeF:

• NimNodeKind.nnkChckRangeF

nnkCheckedFieldExpr:

• NimNodeKind.nnkCheckedFieldExpr

nnkClosedSymChoice:

• NimNodeKind.nnkClosedSymChoice

nnkClosure:

• NimNodeKind.nnkClosure

nnkComesFrom:

• NimNodeKind.nnkComesFrom

nnkCommand:

• NimNodeKind.nnkCommand

nnkCommentStmt:

• NimNodeKind.nnkCommentStmt

nnkConstDef:

• NimNodeKind.nnkConstDef

nnkConstSection:

• NimNodeKind.nnkConstSection

nnkConstTy:

• NimNodeKind.nnkConstTy

nnkContinueStmt:

• NimNodeKind.nnkContinueStmt

nnkConv:

• NimNodeKind.nnkConv

nnkConverterDef:

• NimNodeKind.nnkConverterDef

nnkCStringToString:

• NimNodeKind.nnkCStringToString

nnkCurly:

• NimNodeKind.nnkCurly

nnkCurlyExpr:

• NimNodeKind.nnkCurlyExpr

nnkDefer:

• NimNodeKind.nnkDefer

nnkDerefExpr:

• NimNodeKind.nnkDerefExpr

nnkDiscardStmt:

• NimNodeKind.nnkDiscardStmt

nnkDistinctTy:

• NimNodeKind.nnkDistinctTy

nnkDo:

• NimNodeKind.nnkDo

nnkDotCall:

• NimNodeKind.nnkDotCall

nnkDotExpr:

• NimNodeKind.nnkDotExpr

nnkElifBranch:

• NimNodeKind.nnkElifBranch

nnkElifExpr:

• NimNodeKind.nnkElifExpr

nnkElse:

• NimNodeKind.nnkElse

nnkElseExpr:

• NimNodeKind.nnkElseExpr

nnkEmpty:

• NimNodeKind.nnkEmpty

nnkEnumFieldDef:

• NimNodeKind.nnkEnumFieldDef

nnkEnumTy:

• NimNodeKind.nnkEnumTy

nnkError:

• NimNodeKind.nnkError

nnkExceptBranch:

• NimNodeKind.nnkExceptBranch

nnkExportExceptStmt:

• NimNodeKind.nnkExportExceptStmt

nnkExportStmt:

• NimNodeKind.nnkExportStmt

nnkExprColonExpr:

• NimNodeKind.nnkExprColonExpr

nnkExprEqExpr:

• NimNodeKind.nnkExprEqExpr

nnkFastAsgn:

• NimNodeKind.nnkFastAsgn

nnkFinally:

• NimNodeKind.nnkFinally

nnkFloat128Lit:

• NimNodeKind.nnkFloat128Lit

nnkFloat32Lit:

• NimNodeKind.nnkFloat32Lit

nnkFloat64Lit:

• NimNodeKind.nnkFloat64Lit

nnkFloatLit:

• NimNodeKind.nnkFloatLit

nnkFormalParams:

• NimNodeKind.nnkFormalParams

nnkForStmt:

• NimNodeKind.nnkForStmt

nnkFromStmt:

• NimNodeKind.nnkFromStmt

nnkFuncDef:

• NimNodeKind.nnkFuncDef

nnkGenericParams:

• NimNodeKind.nnkGenericParams

nnkGotoState:

• NimNodeKind.nnkGotoState

nnkHiddenAddr:

• NimNodeKind.nnkHiddenAddr

nnkHiddenCallConv:

• NimNodeKind.nnkHiddenCallConv

nnkHiddenDeref:

• NimNodeKind.nnkHiddenDeref

nnkHiddenStdConv:

• NimNodeKind.nnkHiddenStdConv

nnkHiddenSubConv:

• NimNodeKind.nnkHiddenSubConv

nnkHiddenTryStmt:

• NimNodeKind.nnkHiddenTryStmt

nnkIdent:

• NimNodeKind.nnkIdent

nnkIdentDefs:

• NimNodeKind.nnkIdentDefs

nnkIfExpr:

• NimNodeKind.nnkIfExpr

nnkIfStmt:

• NimNodeKind.nnkIfStmt

nnkImportAs:

• NimNodeKind.nnkImportAs

nnkImportExceptStmt:

• NimNodeKind.nnkImportExceptStmt

nnkImportStmt:

• NimNodeKind.nnkImportStmt

nnkIncludeStmt:

• NimNodeKind.nnkIncludeStmt

nnkInfix:

• NimNodeKind.nnkInfix

nnkInt16Lit:

• NimNodeKind.nnkInt16Lit

nnkInt32Lit:

• NimNodeKind.nnkInt32Lit

nnkInt64Lit:

• NimNodeKind.nnkInt64Lit

nnkInt8Lit:

• NimNodeKind.nnkInt8Lit

nnkIntLit:

• NimNodeKind.nnkIntLit

nnkIteratorDef:

• NimNodeKind.nnkIteratorDef

nnkIteratorTy:

• NimNodeKind.nnkIteratorTy

nnkLambda:

• NimNodeKind.nnkLambda

nnkLetSection:

• NimNodeKind.nnkLetSection

nnkLiterals:

• macros: nnkLiterals

nnkMacroDef:

• NimNodeKind.nnkMacroDef

nnkMethodDef:

• NimNodeKind.nnkMethodDef

nnkMixinStmt:

• NimNodeKind.nnkMixinStmt

nnkMutableTy:

• NimNodeKind.nnkMutableTy

nnkNilLit:

• NimNodeKind.nnkNilLit

nnkNone:

• NimNodeKind.nnkNone

nnkObjConstr:

• NimNodeKind.nnkObjConstr

nnkObjDownConv:

• NimNodeKind.nnkObjDownConv

nnkObjectTy:

• NimNodeKind.nnkObjectTy

nnkObjUpConv:

• NimNodeKind.nnkObjUpConv

nnkOfBranch:

• NimNodeKind.nnkOfBranch

nnkOfInherit:

• NimNodeKind.nnkOfInherit

nnkOpenSymChoice:

• NimNodeKind.nnkOpenSymChoice

nnkPar:

• NimNodeKind.nnkPar

nnkParForStmt:

• NimNodeKind.nnkParForStmt

nnkPattern:

• NimNodeKind.nnkPattern

nnkPostfix:

• NimNodeKind.nnkPostfix

nnkPragma:

• NimNodeKind.nnkPragma

nnkPragmaBlock:

• NimNodeKind.nnkPragmaBlock

nnkPragmaExpr:

• NimNodeKind.nnkPragmaExpr

nnkPrefix:

• NimNodeKind.nnkPrefix

nnkProcDef:

• NimNodeKind.nnkProcDef

nnkProcTy:

• NimNodeKind.nnkProcTy

nnkPtrTy:

• NimNodeKind.nnkPtrTy

nnkRaiseStmt:

• NimNodeKind.nnkRaiseStmt

nnkRange:

• NimNodeKind.nnkRange

nnkRecCase:

• NimNodeKind.nnkRecCase

nnkRecList:

• NimNodeKind.nnkRecList

nnkRecWhen:

• NimNodeKind.nnkRecWhen

nnkRefTy:

• NimNodeKind.nnkRefTy

nnkReturnStmt:

• NimNodeKind.nnkReturnStmt

nnkRStrLit:

• NimNodeKind.nnkRStrLit

nnkSharedTy:

• NimNodeKind.nnkSharedTy

nnkState:

• NimNodeKind.nnkState

nnkStaticExpr:

• NimNodeKind.nnkStaticExpr

nnkStaticStmt:

• NimNodeKind.nnkStaticStmt

nnkStaticTy:

• NimNodeKind.nnkStaticTy

nnkStmtList:

• NimNodeKind.nnkStmtList

nnkStmtListExpr:

• NimNodeKind.nnkStmtListExpr

nnkStmtListType:

• NimNodeKind.nnkStmtListType

nnkStringToCString:

• NimNodeKind.nnkStringToCString

nnkStrLit:

• NimNodeKind.nnkStrLit

nnkSym:

• NimNodeKind.nnkSym

nnkTableConstr:

• NimNodeKind.nnkTableConstr

nnkTemplateDef:

• NimNodeKind.nnkTemplateDef

nnkTripleStrLit:

• NimNodeKind.nnkTripleStrLit

nnkTryStmt:

• NimNodeKind.nnkTryStmt

nnkTupleClassTy:

• NimNodeKind.nnkTupleClassTy

nnkTupleConstr:

• NimNodeKind.nnkTupleConstr

nnkTupleTy:

• NimNodeKind.nnkTupleTy

nnkType:

• NimNodeKind.nnkType

nnkTypeClassTy:

• NimNodeKind.nnkTypeClassTy

nnkTypeDef:

• NimNodeKind.nnkTypeDef

nnkTypeOfExpr:

• NimNodeKind.nnkTypeOfExpr

nnkTypeSection:

• NimNodeKind.nnkTypeSection

nnkUInt16Lit:

• NimNodeKind.nnkUInt16Lit

nnkUInt32Lit:

• NimNodeKind.nnkUInt32Lit

nnkUInt64Lit:

• NimNodeKind.nnkUInt64Lit

nnkUInt8Lit:

• NimNodeKind.nnkUInt8Lit

nnkUIntLit:

• NimNodeKind.nnkUIntLit

nnkUsingStmt:

• NimNodeKind.nnkUsingStmt

nnkVarSection:

• NimNodeKind.nnkVarSection

nnkVarTuple:

• NimNodeKind.nnkVarTuple

nnkVarTy:

• NimNodeKind.nnkVarTy

nnkWhenStmt:

• NimNodeKind.nnkWhenStmt

nnkWhileStmt:

• NimNodeKind.nnkWhileStmt

nnkWith:

• NimNodeKind.nnkWith

nnkWithout:

• NimNodeKind.nnkWithout

nnkYieldStmt:

• NimNodeKind.nnkYieldStmt

NoButton:

• MouseButtons.NoButton

Node:

• dom: Node

nodeID:

• macros: nodeID(n: NimNode): int

nodes:

• lists: nodes[T](L: SomeLinkedList[T]): SomeLinkedNode[T]
• lists: nodes[T](L: SomeLinkedRing[T]): SomeLinkedNode[T]

NodeType:

• dom: NodeType

NO_ERROR:

• winlean: NO_ERROR

None:

• EventPhase.None

none:

• options: none[T](): Option[T]
• options: none(T: typedesc): Option[T]

NonTerminal:

• pegs: NonTerminal

nonterminal:

• pegs: nonterminal(n: NonTerminal): Peg

NonTerminalFlag:

• pegs: NonTerminalFlag

normalize:

• dom: normalize(n: Node)
• strutils: normalize(s: string): string

normalizedPath:

• os: normalizedPath(path: string): string

normalizeExe:

• os: normalizeExe(file: var string)

normalizePath:

• os: normalizePath(path: var string)
• pathnorm: normalizePath(path: string; dirSep = DirSep): string

normalizePathEnd:

• os: normalizePathEnd(path: var string; trailingSep = false)
• os: normalizePathEnd(path: string; trailingSep = false): string

NORMAL_PRIORITY_CLASS:

• winlean: NORMAL_PRIORITY_CLASS

noscript:

• htmlgen: noscript(e: varargs[untyped]): untyped

NotationNode:

• NodeType.NotationNode

NOTE_ATTRIB:

• kqueue: NOTE_ATTRIB

NOTE_CHILD:

• kqueue: NOTE_CHILD

NOTE_DELETE:

• kqueue: NOTE_DELETE

NOTE_EXEC:

• kqueue: NOTE_EXEC

NOTE_EXIT:

• kqueue: NOTE_EXIT

NOTE_EXTEND:

• kqueue: NOTE_EXTEND

NOTE_FORK:

• kqueue: NOTE_FORK

NOTE_LINK:

• kqueue: NOTE_LINK

NOTE_LOWAT:

• kqueue: NOTE_LOWAT

NOTE_MSECONDS:

• kqueue: NOTE_MSECONDS

NOTE_PCTRLMASK:

• kqueue: NOTE_PCTRLMASK

NOTE_PDATAMASK:

• kqueue: NOTE_PDATAMASK

NOTE_RENAME:

• kqueue: NOTE_RENAME

NOTE_REVOKE:

• kqueue: NOTE_REVOKE

NOTE_TRACK:

• kqueue: NOTE_TRACK

NOTE_TRACKERR:

• kqueue: NOTE_TRACKERR

NOTE_WRITE:

• kqueue: NOTE_WRITE

notice:

• logging: notice(args: varargs[string, `$`])

now:

• dom: now(p: Performance): float
• jscore: now(d: DateLib): int
• times: now(): DateTime

nskConditional:

• NimSymKind.nskConditional

nskConst:

• NimSymKind.nskConst

nskConverter:

• NimSymKind.nskConverter

nskDynLib:

• NimSymKind.nskDynLib

nskEnumField:

• NimSymKind.nskEnumField

nskField:

• NimSymKind.nskField

nskForVar:

• NimSymKind.nskForVar

nskFunc:

• NimSymKind.nskFunc

nskGenericParam:

• NimSymKind.nskGenericParam

nskIterator:

• NimSymKind.nskIterator

nskLabel:

• NimSymKind.nskLabel

nskLet:

• NimSymKind.nskLet

nskMacro:

• NimSymKind.nskMacro

nskMethod:

• NimSymKind.nskMethod

nskModule:

• NimSymKind.nskModule

nskParam:

• NimSymKind.nskParam

nskProc:

• NimSymKind.nskProc

nskResult:

• NimSymKind.nskResult

nskStub:

• NimSymKind.nskStub

nskTemp:

• NimSymKind.nskTemp

nskTemplate:

• NimSymKind.nskTemplate

nskType:

• NimSymKind.nskType

nskUnknown:

• NimSymKind.nskUnknown

nskVar:

• NimSymKind.nskVar

nt:

• pegs: nt(p: Peg): NonTerminal

ntDeclared:

• NonTerminalFlag.ntDeclared

ntohl:

• nativesockets: ntohl(x: uint32): uint32

ntohs:

• nativesockets: ntohs(x: uint16): uint16

ntUsed:

• NonTerminalFlag.ntUsed

ntyAlias:

• NimTypeKind.ntyAlias

ntyAnd:

• NimTypeKind.ntyAnd

ntyAnything:

• NimTypeKind.ntyAnything

ntyArray:

• NimTypeKind.ntyArray

ntyBool:

• NimTypeKind.ntyBool

ntyBuiltinTypeClass:

• NimTypeKind.ntyBuiltinTypeClass

ntyChar:

• NimTypeKind.ntyChar

ntyCompositeTypeClass:

• NimTypeKind.ntyCompositeTypeClass

ntyCString:

• NimTypeKind.ntyCString

ntyDistinct:

• NimTypeKind.ntyDistinct

ntyEmpty:

• NimTypeKind.ntyEmpty

ntyEnum:

• NimTypeKind.ntyEnum

ntyError:

• NimTypeKind.ntyError

ntyExpr:

• NimTypeKind.ntyExpr

ntyFloat:

• NimTypeKind.ntyFloat

ntyFloat128:

• NimTypeKind.ntyFloat128

ntyFloat32:

• NimTypeKind.ntyFloat32

ntyFloat64:

• NimTypeKind.ntyFloat64

ntyForward:

• NimTypeKind.ntyForward

ntyFromExpr:

• NimTypeKind.ntyFromExpr

ntyGenericBody:

• NimTypeKind.ntyGenericBody

ntyGenericInst:

• NimTypeKind.ntyGenericInst

ntyGenericInvocation:

• NimTypeKind.ntyGenericInvocation

ntyGenericParam:

• NimTypeKind.ntyGenericParam

ntyInferred:

• NimTypeKind.ntyInferred

ntyInt:

• NimTypeKind.ntyInt

ntyInt16:

• NimTypeKind.ntyInt16

ntyInt32:

• NimTypeKind.ntyInt32

ntyInt64:

• NimTypeKind.ntyInt64

ntyInt8:

• NimTypeKind.ntyInt8

ntyNil:

• NimTypeKind.ntyNil

ntyNone:

• NimTypeKind.ntyNone

ntyNot:

• NimTypeKind.ntyNot

ntyObject:

• NimTypeKind.ntyObject

ntyOpenArray:

• NimTypeKind.ntyOpenArray

ntyOptDeprecated:

• NimTypeKind.ntyOptDeprecated

ntyOr:

• NimTypeKind.ntyOr

ntyOrdinal:

• NimTypeKind.ntyOrdinal

ntyPointer:

• NimTypeKind.ntyPointer

ntyProc:

• NimTypeKind.ntyProc

ntyPtr:

• NimTypeKind.ntyPtr

ntyRange:

• NimTypeKind.ntyRange

ntyRef:

• NimTypeKind.ntyRef

ntySequence:

• NimTypeKind.ntySequence

ntySet:

• NimTypeKind.ntySet

ntyStatic:

• NimTypeKind.ntyStatic

ntyStmt:

• NimTypeKind.ntyStmt

ntyString:

• NimTypeKind.ntyString

ntyTuple:

• NimTypeKind.ntyTuple

ntyTypeDesc:

• NimTypeKind.ntyTypeDesc

ntyUInt:

• NimTypeKind.ntyUInt

ntyUInt16:

• NimTypeKind.ntyUInt16

ntyUInt32:

• NimTypeKind.ntyUInt32

ntyUInt64:

• NimTypeKind.ntyUInt64

ntyUInt8:

• NimTypeKind.ntyUInt8

ntyUncheckedArray:

• NimTypeKind.ntyUncheckedArray

ntyUnused0:

• NimTypeKind.ntyUnused0

ntyUnused1:

• NimTypeKind.ntyUnused1

ntyUnused2:

• NimTypeKind.ntyUnused2

ntyUserTypeClass:

• NimTypeKind.ntyUserTypeClass

ntyUserTypeClassInst:

• NimTypeKind.ntyUserTypeClassInst

ntyVar:

• NimTypeKind.ntyVar

ntyVarargs:

• NimTypeKind.ntyVarargs

ntyVoid:

• NimTypeKind.ntyVoid

nxt:

• strscans: nxt(input: string; idx, step: int = 1)

ObjectAssignmentDefect:

• system: ObjectAssignmentDefect

ObjectAssignmentError:

• system: ObjectAssignmentError

ObjectConversionDefect:

• system: ObjectConversionDefect

ObjectConversionError:

• system: ObjectConversionError

off:

• system: off

offsetHeight:

• dom: offsetHeight(e: Node): int

offsetLeft:

• dom: offsetLeft(e: Node): int

offsetOf:

• system: offsetOf[T](value: T; member: untyped): int
• system: offsetOf[T](t: typedesc[T]; member: untyped): int

offsetTop:

• dom: offsetTop(e: Node): int

offsetWidth:

• dom: offsetWidth(e: Node): int

Oid:

• oids: Oid

oidToString:

• oids: oidToString(oid: Oid; str: cstring)

OK:

• TestStatus.OK

ol:

• htmlgen: ol(e: varargs[untyped]): untyped

old:

• logic: old[T](x: T): T

on:

• system: on

once:

• system: once(body: untyped): untyped

onFailedAssert:

• assertions: onFailedAssert(msg, code: untyped): untyped

OnReject:

• asyncjs: OnReject

onThreadDestruction:

• threads: onThreadDestruction*(handler: proc () {.closure, gcsafe, raises: [].})

onUnhandledException:

• system: onUnhandledException

open:

• channels_builtin: open*[TMsg](c: var Channel[TMsg]; maxItems: int = 0)
• db_mysql: open(connection, user, password, database: string): DbConn
• db_odbc: open(connection, user, password, database: string): DbConn
• db_postgres: open(connection, user, password, database: string): DbConn
• db_sqlite: open(connection, user, password, database: string): DbConn
• dom: open(d: Document)
• dom: open(w: Window; uri, windowname: cstring; properties: cstring = nil): Window
• encodings: open(destEncoding = "UTF-8"; srcEncoding = "CP1252"): EncodingConverter
• io: open(f: var File; filehandle: FileHandle; mode: FileMode = fmRead): bool
• io: open(f: var File; filename: string; mode: FileMode = fmRead; bufSize: int = -1): bool
• io: open(filename: string; mode: FileMode = fmRead; bufSize: int = -1): File
• lexbase: open(L: var BaseLexer; input: Stream; bufLen: int = 8192; refillChars: set[char] = NewLines)
• memfiles: open(filename: string; mode: FileMode = fmRead; mappedSize = -1; offset = 0; newFileSize = -1; allowRemap = false; mapFlags = cint(-1)): MemFile
• parsecfg: open(c: var CfgParser; input: Stream; filename: string; lineOffset = 0)
• parsecsv: open(self: var CsvParser; input: Stream; filename: string; separator = ','; quote = '\"'; escape = '\x00'; skipInitialSpace = false)
• parsecsv: open(self: var CsvParser; filename: string; separator = ','; quote = '\"'; escape = '\x00'; skipInitialSpace = false)
• parsejson: open(my: var JsonParser; input: Stream; filename: string; rawStringLiterals = false)
• parsexml: open(my: var XmlParser; input: Stream; filename: string; options: set[XmlParseOption] = {})
• sexp: open(my: var SexpParser; input: Stream)

OPEN_ALWAYS:

• winlean: OPEN_ALWAYS

openArray:

• system: openArray

openAsync:

• asyncfile: openAsync(filename: string; mode = fmRead): AsyncFile

openDefaultBrowser:

• browsers: openDefaultBrowser()
• browsers: openDefaultBrowser(url: string)

OPEN_EXISTING:

• winlean: OPEN_EXISTING

openFileStream:

• streams: openFileStream(filename: string; mode: FileMode = fmRead; bufSize: int = -1): owned FileStream

OpenMP:

• Module system
• Module system

openProcess:

• winlean: openProcess(dwDesiredAccess: DWORD; bInheritHandle: WINBOOL; dwProcessId: DWORD): Handle

OptAcceptConn:

• SOBool.OptAcceptConn

OptBroadcast:

• SOBool.OptBroadcast

OptDebug:

• SOBool.OptDebug

OptDontRoute:

• SOBool.OptDontRoute

optgroup:

• htmlgen: optgroup(e: varargs[untyped]): untyped

option:

• htmlgen: option(e: varargs[untyped]): untyped

Option:

• options: Option

option:

• options: option[T](val: sink T): Option[T]

OptionElement:

• dom: OptionElement

OptKeepAlive:

• SOBool.OptKeepAlive

OptNoDelay:

• SOBool.OptNoDelay

OptOOBInline:

• SOBool.OptOOBInline

OptParser:

• parseopt: OptParser

OptReuseAddr:

• SOBool.OptReuseAddr

OptReusePort:

• SOBool.OptReusePort

ord:

• system: ord[T: Ordinal | enum](x: T): int

OrderedSet:

• sets: OrderedSet

OrderedTable:

• tables: OrderedTable

OrderedTableRef:

• tables: OrderedTableRef

Ordinal:

• system: Ordinal

OrdinalEnum:

• typetraits: OrdinalEnum

OSError:

• system: OSError

OSErrorCode:

• os: OSErrorCode

osErrorMsg:

• os: osErrorMsg(errorCode: OSErrorCode): string

osInvalidSocket:

• nativesockets: osInvalidSocket

osLastError:

• os: osLastError(): OSErrorCode

osOpenCmd:

• browsers: osOpenCmd

osReleaseFile:

• posix_utils: osReleaseFile(): Config

OSVERSIONINFO:

• winlean: OSVERSIONINFO

out of memory:

• Module system

outHtml:

• OutputTarget.outHtml

outLatex:

• OutputTarget.outLatex

OutOfMemDefect:

• system: OutOfMemDefect

OutOfMemError:

• system: OutOfMemError

outOfMemHook:

• system: outOfMemHook

output:

• htmlgen: output(e: varargs[untyped]): untyped

OutputFormatter:

• unittest: OutputFormatter

outputHandle:

• osproc: outputHandle(p: Process): FileHandle

OutputLevel:

• unittest: OutputLevel

outputStream:

• osproc: outputStream(p: Process): Stream

OutputTarget:

• rstgen: OutputTarget

OverflowDefect:

• system: OverflowDefect

OverflowError:

• system: OverflowError

OVERLAPPED:

• winlean: OVERLAPPED

owned:

• system: owned

owner:

• macros: owner(sym: NimNode): NimNode

p:

• htmlgen: p(e: varargs[untyped]): untyped

packageName:

• nimscript: packageName

PackedSet:

• packedsets: PackedSet

PAGE_EXECUTE:

• winlean: PAGE_EXECUTE

PAGE_EXECUTE_READ:

• winlean: PAGE_EXECUTE_READ

PAGE_EXECUTE_READWRITE:

• winlean: PAGE_EXECUTE_READWRITE

PAGE_NOACCESS:

• winlean: PAGE_NOACCESS

PAGE_READONLY:

• winlean: PAGE_READONLY

PAGE_READWRITE:

• winlean: PAGE_READWRITE

pairs:

• critbits: pairs[T](c: CritBitTree[T]): tuple[key: string, val: T]
• deques: pairs[T](deq: Deque[T]): tuple[key: int, val: T]
• httpcore: pairs(headers: HttpHeaders): tuple[key, value: string]
• iterators: pairs[IX, T](a: array[IX, T]): tuple[key: IX, val: T]
• iterators: pairs(a: cstring): tuple[key: int, val: char]
• iterators: pairs[T](a: openArray[T]): tuple[key: int, val: T]
• iterators: pairs[T](a: seq[T]): tuple[key: int, val: T]
• iterators: pairs(a: string): tuple[key: int, val: char]
• jsffi: pairs[K: JsKey; V](assoc: JsAssoc[K, V]): (K, V)
• jsffi: pairs(obj: JsObject): (cstring, JsObject)
• jsformdata: pairs(self: FormData): seq[tuple[key, val: cstring]]
• json: pairs(node: JsonNode): tuple[key: string, val: JsonNode]
• macrocache: pairs(t: CacheTable): (string, NimNode)
• macros: pairs(n: NimNode): (int, NimNode)
• pegs: pairs(p: Peg): (int, Peg)
• sets: pairs[A](s: OrderedSet[A]): tuple[a: int, b: A]
• strtabs: pairs(t: StringTableRef): tuple[key, value: string]
• tables: pairs[A](t: CountTable[A]): (A, int)
• tables: pairs[A](t: CountTableRef[A]): (A, int)
• tables: pairs[A, B](t: OrderedTable[A, B]): (A, B)
• tables: pairs[A, B](t: OrderedTableRef[A, B]): (A, B)
• tables: pairs[A, B](t: Table[A, B]): (A, B)
• tables: pairs[A, B](t: TableRef[A, B]): (A, B)

pairsWithPrefix:

• critbits: pairsWithPrefix[T](c: CritBitTree[T]; prefix: string): tuple[key: string, val: T]

parallel:

• threadpool: parallel(body: untyped)

parallelReplace:

• pegs: parallelReplace(s: string; subs: varargs[tuple[pattern: Peg, repl: string]]): string

param:

• htmlgen: param(e: varargs[untyped]): untyped

paramCount:

• nimscript: paramCount(): int
• os: paramCount(): int

params:

• macros: params(someProc: NimNode): NimNode

params=:

• macros: params=(someProc: NimNode; params: NimNode)

paramStr:

• nimscript: paramStr(i: int): string
• os: paramStr(i: int): string

ParDir:

• os: ParDir

parentDir:

• os: parentDir(path: string): string

parentDirs:

• os: parentDirs(path: string; fromRoot = false; inclusive = true): string

parityBits:

• bitops: parityBits(x: SomeInteger): int

parse:

• jscore: parse(d: DateLib; s: cstring): int
• jscore: parse(l: JsonLib; s: cstring): JsRoot
• times: parse(input: string; f: static[string]; zone: Timezone = local(); loc: DateTimeLocale = DefaultLocale): DateTime
• times: parse(input, f: string; tz: Timezone = local(); loc: DateTimeLocale = DefaultLocale): DateTime
• times: parse(input: string; f: TimeFormat; zone: Timezone = local(); loc: DateTimeLocale = DefaultLocale): DateTime

parseBiggestFloat:

• parseutils: parseBiggestFloat(s: string; number: var BiggestFloat; start = 0): int

parseBiggestInt:

• parseutils: parseBiggestInt(s: string; number: var BiggestInt; start = 0): int
• strutils: parseBiggestInt(s: string): BiggestInt

parseBiggestUInt:

• parseutils: parseBiggestUInt(s: string; number: var BiggestUInt; start = 0): int
• strutils: parseBiggestUInt(s: string): BiggestUInt

parseBin:

• parseutils: parseBin[T: SomeInteger](s: string; number: var T; start = 0; maxLen = 0): int

parseBinInt:

• strutils: parseBinInt(s: string): int

parseBool:

• strutils: parseBool(s: string): bool

parseChar:

• parseutils: parseChar(s: string; c: var char; start = 0): int

parseCmdLine:

• os: parseCmdLine(c: string): seq[string]

parseColor:

• colors: parseColor(name: string): Color

parseCookies:

• cookies: parseCookies(s: string): StringTableRef

parseEnum:

• strutils: parseEnum[T: enum](s: string): T
• strutils: parseEnum[T: enum](s: string; default: T): T

parseEscapedUTF16:

• parsejson: parseEscapedUTF16(buf: cstring; pos: var int): int

parseExpr:

• macros: parseExpr(s: string): NimNode

parseFile:

• json: parseFile(filename: string): JsonNode

parseFloat:

• parseutils: parseFloat(s: string; number: var float; start = 0): int
• strutils: parseFloat(s: string): float

parseFromString:

• dom: parseFromString(this: DomParser; str: cstring; mimeType: cstring): Document

parseHeader:

• httpcore: parseHeader(line: string): tuple[key: string, value: seq[string]]

parseHex:

• parseutils: parseHex[T: SomeInteger](s: string; number: var T; start = 0; maxLen = 0): int

parseHexInt:

• strutils: parseHexInt(s: string): int

parseHexStr:

• strutils: parseHexStr(s: string): string

parseHtml:

• htmlparser: parseHtml(s: Stream): XmlNode
• htmlparser: parseHtml(s: Stream; filename: string; errors: var seq[string]): XmlNode
• htmlparser: parseHtml(html: string): XmlNode

parseIdent:

• parseutils: parseIdent(s: string; start = 0): string
• parseutils: parseIdent(s: string; ident: var string; start = 0): int

parseInt:

• parseutils: parseInt(s: string; number: var int; start = 0): int
• Module parseutils
• strutils: parseInt(s: string): int

parseIpAddress:

• net: parseIpAddress(addressStr: string): IpAddress

parseJson:

• json: parseJson(s: Stream; filename: string = ""; rawIntegers = false; rawFloats = false): JsonNode
• json: parseJson(buffer: string; rawIntegers = false; rawFloats = false): JsonNode

parseJsonFragments:

• json: parseJsonFragments(s: Stream; filename: string = ""; rawIntegers = false; rawFloats = false): JsonNode

parseOct:

• parseutils: parseOct[T: SomeInteger](s: string; number: var T; start = 0; maxLen = 0): int

parseOctInt:

• strutils: parseOctInt(s: string): int

parseOid:

• oids: parseOid(str: cstring): Oid

parsePeg:

• pegs: parsePeg(pattern: string; filename = "pattern"; line = 1; col = 0): Peg

parseSaturatedNatural:

• parseutils: parseSaturatedNatural(s: string; b: var int; start = 0): int

parseSecureHash:

• sha1: parseSecureHash(hash: string): SecureHash

parseSexp:

• sexp: parseSexp(s: Stream): SexpNode
• sexp: parseSexp(buffer: string): SexpNode

parseSQL:

• parsesql: parseSQL(input: Stream; filename: string): SqlNode
• parsesql: parseSQL(input: string; filename = ""): SqlNode

parseStandardFormatSpecifier:

• strformat: parseStandardFormatSpecifier(s: string; start = 0; ignoreUnknownSuffix = false): StandardFormatSpecifier

parseStmt:

• macros: parseStmt(s: string): NimNode

parseTableCells:

• asciitables: parseTableCells(s: string; delim = ' '): Cell

parseTime:

• times: parseTime(input: string; f: static[string]; zone: Timezone): Time
• times: parseTime(input, f: string; zone: Timezone): Time

parseUInt:

• parseutils: parseUInt(s: string; number: var uint; start = 0): int
• strutils: parseUInt(s: string): uint

parseUntil:

• parseutils: parseUntil(s: string; token: var string; until: char; start = 0): int
• parseutils: parseUntil(s: string; token: var string; until: set[char]; start = 0): int
• parseutils: parseUntil(s: string; token: var string; until: string; start = 0): int

parseUri:

• uri: parseUri(uri: string): Uri
• uri: parseUri(uri: string; result: var Uri)

parseWhile:

• parseutils: parseWhile(s: string; token: var string; validChars: set[char]; start = 0): int

parseXml:

• xmlparser: parseXml(s: Stream; options: set[XmlParseOption] = {reportComments}): XmlNode
• xmlparser: parseXml(s: Stream; filename: string; errors: var seq[string]; options: set[XmlParseOption] = {reportComments}): XmlNode
• xmlparser: parseXml(str: string; options: set[XmlParseOption] = {reportComments}): XmlNode

partition:

• strmisc: partition(s: string; sep: string; right: bool = false): (string, string, string)

patch:

• httpclient: patch(client: AsyncHttpClient; url: Uri | string; body = ""; multipart: MultipartData = nil): Future[AsyncResponse]
• httpclient: patch(client: HttpClient; url: Uri | string; body = ""; multipart: MultipartData = nil): Response

patchContent:

• httpclient: patchContent(client: AsyncHttpClient; url: Uri | string; body = ""; multipart: MultipartData = nil): Future[string]
• httpclient: patchContent(client: HttpClient; url: Uri | string; body = ""; multipart: MultipartData = nil): string

patchFile:

• nimscript: patchFile(package, filename, replacement: string)

PathComponent:

• os: PathComponent

PathEntry:

• globs: PathEntry

PathIter:

• pathnorm: PathIter

PathSep:

• os: PathSep

patricia trie:

• Module critbits

PBOOL:

• winlean: PBOOL

pcDir:

• PathComponent.pcDir

pcFile:

• PathComponent.pcFile

pcLinkToDir:

• PathComponent.pcLinkToDir

pcLinkToFile:

• PathComponent.pcLinkToFile

PDispatcher:

• asyncdispatch: PDispatcher

PDWORD:

• winlean: PDWORD

peek:

• channels_builtin: peek*[TMsg](c: var Channel[TMsg]): int
• streams: peek[T](s: Stream; result: var T)

peekableErrorStream:

• osproc: peekableErrorStream(p: Process): Stream

peekableOutputStream:

• osproc: peekableOutputStream(p: Process): Stream

peekBool:

• streams: peekBool(s: Stream): bool

peekChar:

• streams: peekChar(s: Stream): char

peekData:

• streams: peekData(s: Stream; buffer: pointer; bufLen: int): int

peekExitCode:

• osproc: peekExitCode(p: Process): int

peekFirst:

• deques: peekFirst[T](deq: Deque[T]): lent T
• deques: peekFirst[T](deq: var Deque[T]): var T

peekFloat32:

• streams: peekFloat32(s: Stream): float32

peekFloat64:

• streams: peekFloat64(s: Stream): float64

peekInt16:

• streams: peekInt16(s: Stream): int16

peekInt32:

• streams: peekInt32(s: Stream): int32

peekInt64:

• streams: peekInt64(s: Stream): int64

peekInt8:

• streams: peekInt8(s: Stream): int8

peekLast:

• deques: peekLast[T](deq: Deque[T]): lent T
• deques: peekLast[T](deq: var Deque[T]): var T

peekLine:

• streams: peekLine(s: Stream): string
• streams: peekLine(s: Stream; line: var string): bool

peekNamedPipe:

• winlean: peekNamedPipe(hNamedPipe: Handle; lpBuffer: pointer = nil; nBufferSize: int32 = 0; lpBytesRead: ptr int32 = nil; lpTotalBytesAvail: ptr int32 = nil; lpBytesLeftThisMessage: ptr int32 = nil): bool

peekStr:

• streams: peekStr(s: Stream; length: int): string
• streams: peekStr(s: Stream; length: int; str: var string)

peekUint16:

• streams: peekUint16(s: Stream): uint16

peekUint32:

• streams: peekUint32(s: Stream): uint32

peekUint64:

• streams: peekUint64(s: Stream): uint64

peekUint8:

• streams: peekUint8(s: Stream): uint8

Peg:

• pegs: Peg

peg:

• pegs: peg(pattern: string): Peg

PegKind:

• pegs: PegKind

Performance:

• dom: Performance

PerformanceMemory:

• dom: PerformanceMemory

PerformanceTiming:

• dom: PerformanceTiming

performCodeReload:

• hotcodereloading: performCodeReload()

PersonalBar:

• dom: PersonalBar

PFloat32:

• system: PFloat32

PFloat64:

• system: PFloat64

PFrame:

• system: PFrame

phase:

• complex: phase[T](z: Complex[T]): T

PI:

• math: PI

picture:

• htmlgen: picture(e: varargs[untyped]): untyped

piName:

• parsexml: piName(my: XmlParser): string

pinnedSpawn:

• threadpool: pinnedSpawn(id: ThreadId; call: sink typed)

PInt32:

• system: PInt32

PInt64:

• system: PInt64

pinToCpu:

• threads: pinToCpu*[Arg](t: var Thread[Arg]; cpu: Natural)

PIPE_ACCESS_DUPLEX:

• winlean: PIPE_ACCESS_DUPLEX

PIPE_ACCESS_INBOUND:

• winlean: PIPE_ACCESS_INBOUND

PIPE_ACCESS_OUTBOUND:

• winlean: PIPE_ACCESS_OUTBOUND

PIPE_NOWAIT:

• winlean: PIPE_NOWAIT

PipeOutStream:

• streamwrapper: PipeOutStream

piRest:

• parsexml: piRest(my: XmlParser): string

pkAndPredicate:

• PegKind.pkAndPredicate

pkAny:

• PegKind.pkAny

pkAnyRune:

• PegKind.pkAnyRune

pkBackRef:

• PegKind.pkBackRef

pkBackRefIgnoreCase:

• PegKind.pkBackRefIgnoreCase

pkBackRefIgnoreStyle:

• PegKind.pkBackRefIgnoreStyle

pkCapture:

• PegKind.pkCapture

pkCapturedSearch:

• PegKind.pkCapturedSearch

pkChar:

• PegKind.pkChar

pkCharChoice:

• PegKind.pkCharChoice

pkEmpty:

• PegKind.pkEmpty

pkGreedyAny:

• PegKind.pkGreedyAny

pkGreedyRep:

• PegKind.pkGreedyRep

pkGreedyRepChar:

• PegKind.pkGreedyRepChar

pkGreedyRepSet:

• PegKind.pkGreedyRepSet

pkLetter:

• PegKind.pkLetter

pkList:

• PegKind.pkList

pkLower:

• PegKind.pkLower

pkNewLine:

• PegKind.pkNewLine

pkNonTerminal:

• PegKind.pkNonTerminal

pkNotPredicate:

• PegKind.pkNotPredicate

pkOption:

• PegKind.pkOption

pkOrderedChoice:

• PegKind.pkOrderedChoice

pkRule:

• PegKind.pkRule

pkSearch:

• PegKind.pkSearch

pkSequence:

• PegKind.pkSequence

pkStartAnchor:

• PegKind.pkStartAnchor

pkTerminal:

• PegKind.pkTerminal

pkTerminalIgnoreCase:

• PegKind.pkTerminalIgnoreCase

pkTerminalIgnoreStyle:

• PegKind.pkTerminalIgnoreStyle

pkTitle:

• PegKind.pkTitle

pkUpper:

• PegKind.pkUpper

pkWhitespace:

• PegKind.pkWhitespace

play:

• dom: play(e: EmbedElement)

Plugin:

• dom: Plugin

poDaemon:

• ProcessOption.poDaemon

poDemon:

• osproc: poDemon

poEchoCmd:

• ProcessOption.poEchoCmd

poEvalCommand:

• ProcessOption.poEvalCommand

pointer:

• system: pointer

poInteractive:

• ProcessOption.poInteractive

pointerBase:

• typetraits: pointerBase[T](_: typedesc[ptr T | ref T]): typedesc

polar:

• complex: polar[T](z: Complex[T]): tuple[r, phi: T]

poll:

• asyncdispatch: poll(timeout = 500)

pop:

• heapqueue: pop[T](heap: var HeapQueue[T]): T
• reservedmem: pop[T](s: var ReservedMemSeq[T]): T
• sets: pop[A](s: var HashSet[A]): A
• system: pop[T](s: var seq[T]): T
• tables: pop[A](t: var CountTable[A]; key: A; val: var int): bool
• tables: pop[A](t: CountTableRef[A]; key: A; val: var int): bool
• tables: pop[A, B](t: var OrderedTable[A, B]; key: A; val: var B): bool
• tables: pop[A, B](t: OrderedTableRef[A, B]; key: A; val: var B): bool
• tables: pop[A, B](t: var Table[A, B]; key: A; val: var B): bool
• tables: pop[A, B](t: TableRef[A, B]; key: A; val: var B): bool

poParentStreams:

• ProcessOption.poParentStreams

popcount:

• bitops: popcount(x: SomeInteger): int

popFirst:

• deques: popFirst[T](deq: var Deque[T]): T

popGcFrame:

• system: popGcFrame()

popLast:

• deques: popLast[T](deq: var Deque[T]): T

Port:

• nativesockets: Port

portal:

• htmlgen: portal(e: varargs[untyped]): untyped

Positive:

• system: Positive

post:

• httpclient: post(client: AsyncHttpClient; url: Uri | string; body = ""; multipart: MultipartData = nil): Future[AsyncResponse]
• httpclient: post(client: HttpClient; url: Uri | string; body = ""; multipart: MultipartData = nil): Response

postContent:

• httpclient: postContent(client: AsyncHttpClient; url: Uri | string; body = ""; multipart: MultipartData = nil): Future[string]
• httpclient: postContent(client: HttpClient; url: Uri | string; body = ""; multipart: MultipartData = nil): string

poStdErrToStdOut:

• ProcessOption.poStdErrToStdOut

postfix:

• macros: postfix(node: NimNode; op: string): NimNode

PostgreSQL:

• Module db_postgres

postQueuedCompletionStatus:

• winlean: postQueuedCompletionStatus(CompletionPort: Handle; dwNumberOfBytesTransferred: DWORD; dwCompletionKey: ULONG_PTR; lpOverlapped: pointer): bool

poUsePath:

• ProcessOption.poUsePath

POVERLAPPED:

• winlean: POVERLAPPED

POVERLAPPED_COMPLETION_ROUTINE:

• winlean: POVERLAPPED_COMPLETION_ROUTINE

pow:

• complex: pow[T](x, y: Complex[T]): Complex[T]
• complex: pow[T](x: Complex[T]; y: T): Complex[T]
• jscore: pow(m: MathLib; a, b: distinct SomeNumber): float
• math: pow(x, y: float32): float32
• math: pow(x, y: float64): float64

pragma:

• macros: pragma(someProc: NimNode): NimNode

pragma=:

• macros: pragma=(someProc: NimNode; val: NimNode)

pre:

• htmlgen: pre(e: varargs[untyped]): untyped

pred:

• system: pred[T: Ordinal](x: T; y = 1): T

preferSpawn:

• threadpool: preferSpawn(): bool

prefix:

• macros: prefix(node: NimNode; op: string): NimNode

prepare:

• db_postgres: prepare(db: DbConn; stmtName: string; query: SqlQuery; nParams: int): SqlPrepared
• db_sqlite: prepare(db: DbConn; q: string): SqlPrepared

prepareMutation:

• system: prepareMutation(s: var string)

prepend:

• chains: prepend(header, node)
• lists: prepend[T](L: var DoublyLinkedList[T]; n: DoublyLinkedNode[T])
• lists: prepend[T](L: var DoublyLinkedList[T]; value: T)
• lists: prepend[T](L: var DoublyLinkedRing[T]; n: DoublyLinkedNode[T])
• lists: prepend[T](L: var DoublyLinkedRing[T]; value: T)
• lists: prepend[T](L: var SinglyLinkedList[T]; n: SinglyLinkedNode[T])
• lists: prepend[T](L: var SinglyLinkedList[T]; value: T)
• lists: prepend[T](L: var SinglyLinkedRing[T]; n: SinglyLinkedNode[T])
• lists: prepend[T](L: var SinglyLinkedRing[T]; value: T)
• lists: prepend[T: SomeLinkedList](a: var T; b: T)

prependMoved:

• lists: prependMoved[T: SomeLinkedList](a, b: var T)

pretty:

• json: pretty(node: JsonNode; indent = 2): string
• sexp: pretty(node: SexpNode; indent = 2): string

prettyLink:

• rstgen: prettyLink(file: string): string

preventDefault:

• dom: preventDefault(ev: Event)

prevPermutation:

• algorithm: prevPermutation[T](x: var openArray[T]): bool

PrimaryButton:

• MouseButtons.PrimaryButton

print:

• dom: print(w: Window)

PRINT_ALL:

• OutputLevel.PRINT_ALL

PRINT_FAILURES:

• OutputLevel.PRINT_FAILURES

printKeyCodes:

• linenoise: printKeyCodes()

PRINT_NONE:

• OutputLevel.PRINT_NONE

privateAccess:

• importutils: privateAccess(t: typedesc)

procCall:

• system: procCall(x: untyped)

Process:

• osproc: Process

PROCESS_CREATE_PROCESS:

• winlean: PROCESS_CREATE_PROCESS

PROCESS_CREATE_THREAD:

• winlean: PROCESS_CREATE_THREAD

PROCESS_DUP_HANDLE:

• winlean: PROCESS_DUP_HANDLE

processedRows:

• parsecsv: processedRows(self: var CsvParser): int

processID:

• osproc: processID(p: Process): int

PROCESS_INFORMATION:

• winlean: PROCESS_INFORMATION

ProcessingInstructionNode:

• NodeType.ProcessingInstructionNode

ProcessOption:

• osproc: ProcessOption

PROCESS_QUERY_INFORMATION:

• winlean: PROCESS_QUERY_INFORMATION

PROCESS_QUERY_LIMITED_INFORMATION:

• winlean: PROCESS_QUERY_LIMITED_INFORMATION

PROCESS_SET_INFORMATION:

• winlean: PROCESS_SET_INFORMATION

PROCESS_SET_LIMITED_INFORMATION:

• winlean: PROCESS_SET_LIMITED_INFORMATION

PROCESS_SET_QUOTA:

• winlean: PROCESS_SET_QUOTA

PROCESS_SET_SESSIONID:

• winlean: PROCESS_SET_SESSIONID

PROCESS_SUSPEND_RESUME:

• winlean: PROCESS_SUSPEND_RESUME

PROCESS_TERMINATE:

• winlean: PROCESS_TERMINATE

PROCESS_VM_OPERATION:

• winlean: PROCESS_VM_OPERATION

PROCESS_VM_READ:

• winlean: PROCESS_VM_READ

PROCESS_VM_WRITE:

• winlean: PROCESS_VM_WRITE

procName:

• stackframes: procName(): string

prod:

• math: prod[T](x: openArray[T]): T

product:

• algorithm: product[T](x: openArray[seq[T]]): seq[seq[T]]

programResult:

• system: programResult

progress:

• htmlgen: progress(e: varargs[untyped]): untyped

ProgressChangedProc:

• asyncftpclient: ProgressChangedProc
• httpclient: ProgressChangedProc

projectDir:

• nimscript: projectDir(): string

projectName:

• nimscript: projectName(): string

projectPath:

• nimscript: projectPath(): string

PromiseJs:

• asyncjs: PromiseJs

prompt:

• dom: prompt(w: Window; text, default: cstring): cstring

protect:

• system: protect(x: pointer): ForeignCell

Protocol:

• nativesockets: Protocol

ProtocolError:

• httpclient: ProtocolError

Protoent:

• winlean: Protoent

protSSLv2:

• SslProtVersion.protSSLv2

protSSLv23:

• SslProtVersion.protSSLv23

protSSLv3:

• SslProtVersion.protSSLv3

protTLSv1:

• SslProtVersion.protTLSv1

Proxy:

• httpclient: Proxy

PRstNode:

• rstast: PRstNode

PSID:

• winlean: PSID

pskIdentityHint=:

• net: pskIdentityHint=(ctx: SslContext; hint: string)

PULONG:

• winlean: PULONG

PULONG_PTR:

• winlean: PULONG_PTR

PunyError:

• punycode: PunyError

push:

• heapqueue: push[T](heap: var HeapQueue[T]; item: sink T)
• stats: push(r: var RunningRegress; x, y: float)
• stats: push(r: var RunningRegress; x, y: int)
• stats: push(r: var RunningRegress; x, y: openArray[float | int])
• stats: push(s: var RunningStat; x: float)
• stats: push(s: var RunningStat; x: int)
• stats: push(s: var RunningStat; x: openArray[float | int])

pushGcFrame:

• system: pushGcFrame(s: GcFrame)

pushpop:

• heapqueue: pushpop[T](heap: var HeapQueue[T]; item: sink T): T

pushState:

• dom: pushState[T](h: History; stateObject: T; title, url: cstring)

put:

• httpclient: put(client: AsyncHttpClient; url: Uri | string; body = ""; multipart: MultipartData = nil): Future[AsyncResponse]
• httpclient: put(client: HttpClient; url: Uri | string; body = ""; multipart: MultipartData = nil): Response
• jsformdata: put(self: FormData; name, value, filename: cstring)
• nimscript: put(key, value: string)

putContent:

• httpclient: putContent(client: AsyncHttpClient; url: Uri | string; body = ""; multipart: MultipartData = nil): Future[string]
• httpclient: putContent(client: HttpClient; url: Uri | string; body = ""; multipart: MultipartData = nil): string

putEnv:

• nimscript: putEnv(key, val: string)
• os: putEnv(key, val: string)

pwd:

• asyncftpclient: pwd(ftp: AsyncFtpClient): Future[string]

PWOHandleArray:

• winlean: PWOHandleArray

q:

• htmlgen: q(e: varargs[untyped]): untyped

querySelector:

• dom: querySelector(d: Document; selectors: cstring): Element
• dom: querySelector(n: Node; selectors: cstring): Element

querySelectorAll:

• dom: querySelectorAll(d: Document; selectors: cstring): seq[Element]
• dom: querySelectorAll(n: Node; selectors: cstring): seq[Element]

querySetting:

• compilesettings: querySetting(setting: SingleValueSetting): string

querySettingSeq:

• compilesettings: querySettingSeq(setting: MultipleValueSetting): seq[string]

quit:

• system: quit(errorcode: int = QuitSuccess)
• system: quit(errormsg: string; errorcode = QuitFailure)

QuitFailure:

• system: QuitFailure

QuitSuccess:

• system: QuitSuccess

quote:

• macros: quote(bl: typed; op = "``"): NimNode

quoteShell:

• os: quoteShell(s: string): string

quoteShellCommand:

• os: quoteShellCommand(args: openArray[string]): string

quoteShellPosix:

• os: quoteShellPosix(s: string): string

quoteShellWindows:

• os: quoteShellWindows(s: string): string

radix tree:

• Module critbits

radToDeg:

• math: radToDeg[T: float32 | float64](d: T): T

raiseAssert:

• assertions: raiseAssert(msg: string)

raiseInvalidLibrary:

• dynlib: raiseInvalidLibrary(name: cstring)

raiseOSError:

• os: raiseOSError(errorCode: OSErrorCode; additionalInfo = "")

raiseParseErr:

• parsejson: raiseParseErr(p: JsonParser; msg: string)
• sexp: raiseParseErr(p: SexpParser; msg: string)

raiseSSLError:

• net: raiseSSLError(s = "")

Rand:

• random: Rand

rand:

• random: rand(max: float): float
• random: rand[T: Ordinal or SomeFloat](x: HSlice[T, T]): T
• random: rand(max: int): int
• random: rand[T: Ordinal or SomeFloat](r: var Rand; x: HSlice[T, T]): T
• random: rand(r: var Rand; max: Natural): int
• random: rand(r: var Rand; max: range[0.0 .. high(float)]): float
• random: rand[T: SomeInteger](t: typedesc[T]): T

random:

• jscore: random(m: MathLib): float

randomize:

• random: randomize()
• random: randomize(seed: int64)

randState:

• random: randState(): untyped

Range:

• dom: Range

range:

• system: range

rangeCheck:

• system: rangeCheck(cond)

RangeDefect:

• system: RangeDefect

RangeError:

• system: RangeError

Rational:

• rationals: Rational

rawData:

• parsexml: rawData(my: var XmlParser): lent string

rawData2:

• parsexml: rawData2(my: var XmlParser): lent string

rawEnv:

• system: rawEnv[T: proc](x: T): pointer

rawMatch:

• pegs: rawMatch(s: string; p: Peg; start: int; c: var Captures): int

rawProc:

• system: rawProc[T: proc](x: T): pointer

rawTag:

• xmltree: rawTag(n: XmlNode): string

rawText:

• xmltree: rawText(n: XmlNode): string

rawWrite:

• segfaults: rawWrite(f: CFilePtr; s: cstring)

rawWriteString:

• segfaults: rawWriteString(f: CFilePtr; s: cstring; length: int)

rb:

• htmlgen: rb(e: varargs[untyped]): untyped

rdFileSize:

• winlean: rdFileSize(f: WIN32_FIND_DATA): int64

rdFileTime:

• winlean: rdFileTime(f: FILETIME): int64

re:

• nre: re(pattern: string): Regex
• re: re(s: string; flags = {reStudy}): Regex

read:

• asyncfile: read(f: AsyncFile; size: int): Future[string]
• asyncfutures: read[T](future: Future[T] | FutureVar[T]): T
• asyncstreams: read[T](future: FutureStream[T]): owned(Future[(bool, T)])
• streams: read[T](s: Stream; result: var T)

readAll:

• asyncdispatch: readAll(future: FutureStream[string]): owned(Future[string])
• asyncfile: readAll(f: AsyncFile): Future[string]
• io: readAll(file: File): string
• streams: readAll(s: Stream): string

readAllFromStdin:

• nimscript: readAllFromStdin(): string

readAsBinaryString:

• dom: readAsBinaryString(f: FileReader; b: Blob)

readAsDataURL:

• dom: readAsDataURL(f: FileReader; b: Blob)

readAsText:

• dom: readAsText(f: FileReader; b: Blob | File; encoding = cstring"UTF-8")

readBool:

• streams: readBool(s: Stream): bool

readBuffer:

• asyncfile: readBuffer(f: AsyncFile; buf: pointer; size: int): Future[int]
• io: readBuffer(f: File; buffer: pointer; len: Natural): int

readBytes:

• io: readBytes(f: File; a: var openArray[int8 | uint8]; start, len: Natural): int

readChar:

• io: readChar(f: File): char
• streams: readChar(s: Stream): char

readChars:

• io: readChars(f: File; a: var openArray[char]): int
• io: readChars(f: File; a: var openArray[char]; start, len: Natural): int

readConsoleInput:

• winlean: readConsoleInput(hConsoleInput: Handle; lpBuffer: pointer; nLength: cint; lpNumberOfEventsRead: ptr cint): cint

readData:

• cgi: readData(allowedMethods: set[RequestMethod] = {methodNone, methodPost, methodGet}): StringTableRef
• cgi: readData(data: string): StringTableRef
• streams: readData(s: Stream; buffer: pointer; bufLen: int): int

readDataStr:

• streams: readDataStr(s: Stream; buffer: var string; slice: Slice[int]): int

ReadDbEffect:

• db_common: ReadDbEffect

ReadDirEffect:

• os: ReadDirEffect

ReadDisconnected:

• ReadLineResult.ReadDisconnected

ReadEnvEffect:

• os: ReadEnvEffect

readError:

• asyncfutures: readError[T](future: Future[T]): ref Exception

readFile:

• io: readFile(filename: string): string
• winlean: readFile(hFile: Handle; buffer: pointer; nNumberOfBytesToRead: int32; lpNumberOfBytesRead: ptr int32; lpOverlapped: pointer): WINBOOL

readFloat32:

• streams: readFloat32(s: Stream): float32

readFloat64:

• streams: readFloat64(s: Stream): float64

ReadFullLine:

• ReadLineResult.ReadFullLine

readHeaderRow:

• parsecsv: readHeaderRow(self: var CsvParser)

readInt16:

• streams: readInt16(s: Stream): int16

readInt32:

• streams: readInt32(s: Stream): int32

readInt64:

• streams: readInt64(s: Stream): int64

readInt8:

• streams: readInt8(s: Stream): int8

ReadIOEffect:

• system: ReadIOEffect

readLine:

• asyncfile: readLine(f: AsyncFile): Future[string]
• io: readLine(f: File): string
• io: readLine(f: File; line: var string): bool
• linenoise: readLine(prompt: cstring): cstring
• net: readLine(socket: Socket; line: var string; timeout = -1; flags = {SafeDisconn}; maxLength = MaxLineLength)
• streams: readLine(s: Stream): string
• streams: readLine(s: Stream; line: var string): bool

readLineFromStdin:

• nimscript: readLineFromStdin(): string
• rdstdin: readLineFromStdin(prompt: string): string
• rdstdin: readLineFromStdin(prompt: string; line: var string): bool

ReadLineResult:

• net: ReadLineResult

readLines:

• io: readLines(filename: string; n: Natural): seq[string]
• io: readLines(filename: string): seq[string]
• osproc: readLines(p: Process): (seq[string], int)

ReadNone:

• ReadLineResult.ReadNone

ReadPartialLine:

• ReadLineResult.ReadPartialLine

readPasswordFromStdin:

• terminal: readPasswordFromStdin(prompt = "password: "): string
• terminal: readPasswordFromStdin(prompt: string; password: var string): bool

readRow:

• parsecsv: readRow(self: var CsvParser; columns = 0): bool

ReadSocketStream:

• socketstreams: ReadSocketStream

ReadSocketStreamObj:

• socketstreams: ReadSocketStreamObj

readStr:

• streams: readStr(s: Stream; length: int): string
• streams: readStr(s: Stream; length: int; str: var string)

readToStream:

• asyncfile: readToStream(f: AsyncFile; fs: FutureStream[string]): owned(Future[void])

readUint16:

• streams: readUint16(s: Stream): uint16

readUint32:

• streams: readUint32(s: Stream): uint32

readUint64:

• streams: readUint64(s: Stream): uint64

readUint8:

• streams: readUint8(s: Stream): uint8

readVu64:

• varints: readVu64(z: openArray[byte]; pResult: var uint64): int

ready:

• channels_builtin: ready*[TMsg](c: var Channel[TMsg]): bool

ReadyKey:

• selectors: ReadyKey

readyState:

• dom: readyState(f: FileReader): FileReaderState

realloc:

• system: realloc(p: pointer; newSize: Natural): pointer

realloc0:

• system: realloc0(p: pointer; oldSize, newSize: Natural): pointer

realloc0Impl:

• system: realloc0Impl(p: pointer; oldSize, newSize: Natural): pointer

reallocImpl:

• system: reallocImpl(p: pointer; newSize: Natural): pointer

reallocShared:

• system: reallocShared(p: pointer; newSize: Natural): pointer

reallocShared0:

• system: reallocShared0(p: pointer; oldSize, newSize: Natural): pointer

reallocShared0Impl:

• system: reallocShared0Impl(p: pointer; oldSize, newSize: Natural): pointer

reallocSharedImpl:

• system: reallocSharedImpl(p: pointer; newSize: Natural): pointer

REALTIME_PRIORITY_CLASS:

• winlean: REALTIME_PRIORITY_CLASS

reciprocal:

• rationals: reciprocal[T](x: Rational[T]): Rational[T]

rect:

• complex: rect[T](r, phi: T): Complex[T]

recv:

• asyncdispatch: recv(socket: AsyncFD; size: int; flags = {SafeDisconn}): owned(Future[string])
• asyncnet: recv(socket: AsyncSocket; size: int; flags = {SafeDisconn}): owned( Future[string])
• channels_builtin: recv*[TMsg](c: var Channel[TMsg]): TMsg
• net: recv(socket: Socket; size: int; timeout = -1; flags = {SafeDisconn}): string
• net: recv(socket: Socket; data: pointer; size: int): int
• net: recv(socket: Socket; data: pointer; size: int; timeout: int): int
• net: recv(socket: Socket; data: var string; size: int; timeout = -1; flags = {SafeDisconn}): int
• winlean: recv(s: SocketHandle; buf: pointer; len, flags: cint): cint

recvFrom:

• asyncnet: recvFrom(socket: AsyncSocket; data: FutureVar[string]; size: int; address: FutureVar[string]; port: FutureVar[Port]; flags = {SafeDisconn}): owned(Future[int])
• asyncnet: recvFrom(socket: AsyncSocket; size: int; flags = {SafeDisconn}): owned( Future[tuple[data: string, address: string, port: Port]])
• net: recvFrom(socket: Socket; data: var string; length: int; address: var string; port: var Port; flags = 0'i32): int

recvfrom:

• winlean: recvfrom(s: SocketHandle; buf: cstring; len, flags: cint; fromm: ptr SockAddr; fromlen: ptr SockLen): cint

recvFromInto:

• asyncdispatch: recvFromInto(socket: AsyncFD; data: pointer; size: int; saddr: ptr SockAddr; saddrLen: ptr SockLen; flags = {SafeDisconn}): owned(Future[int])

recvInto:

• asyncdispatch: recvInto(socket: AsyncFD; buf: pointer; size: int; flags = {SafeDisconn}): owned( Future[int])
• asyncnet: recvInto(socket: AsyncSocket; buf: pointer; size: int; flags = {SafeDisconn}): owned( Future[int])

recvLine:

• asyncnet: recvLine(socket: AsyncSocket; flags = {SafeDisconn}; maxLength = MaxLineLength): owned( Future[string])
• net: recvLine(socket: Socket; timeout = -1; flags = {SafeDisconn}; maxLength = MaxLineLength): string

recvLineInto:

• asyncnet: recvLineInto(socket: AsyncSocket; resString: FutureVar[string]; flags = {SafeDisconn}; maxLength = MaxLineLength): owned( Future[void])

reDotAll:

• RegexFlag.reDotAll

reduce:

• rationals: reduce[T: SomeInteger](x: var Rational[T])

reExtended:

• RegexFlag.reExtended

Regex:

• nre: Regex
• re: Regex

RegexError:

• nre: RegexError
• re: RegexError

RegexFlag:

• re: RegexFlag

RegexInternalError:

• nre: RegexInternalError

RegexMatch:

• nre: RegexMatch

RegExp:

• jsre: RegExp

register:

• asyncdispatch: register(fd: AsyncFD)
• mimetypes: register(mimedb: var MimeDB; ext: string; mimetype: string)

registerEvent:

• selectors: registerEvent[T](s: Selector[T]; ev: SelectEvent; data: T)

registerHandle:

• selectors: registerHandle[T](s: Selector[T]; fd: int | SocketHandle; events: set[Event]; data: T)

registerProcess:

• selectors: registerProcess[T](s: Selector[T]; pid: int; data: T): int

registerProtocolHandler:

• dom: registerProtocolHandler(self: Navigator; scheme, url, title: cstring)

registerSignal:

• selectors: registerSignal[T](s: Selector[T]; signal: int; data: T): int

registerTimer:

• selectors: registerTimer[T](s: Selector[T]; timeout: int; oneshot: bool; data: T): int

registerVnode:

• selectors: registerVnode[T](s: Selector[T]; fd: cint; events: set[Event]; data: T)

registerWaitForSingleObject:

• winlean: registerWaitForSingleObject(phNewWaitObject: ptr Handle; hObject: Handle; Callback: WAITORTIMERCALLBACK; Context: pointer; dwMilliseconds: ULONG; dwFlags: ULONG): bool

reIgnoreCase:

• RegexFlag.reIgnoreCase

relativePath:

• os: relativePath(path, base: string; sep = DirSep): string

release:

• locks: release(lock: var Lock)
• rlocks: release(lock: var RLock)

reload:

• dom: reload(loc: Location)

remainingArgs:

• parseopt: remainingArgs(p: OptParser): seq[string]

remove:

• dom: remove(c: ClassList; class: cstring)
• dom: remove(child: Node)
• lists: remove[T](L: var DoublyLinkedList[T]; n: DoublyLinkedNode[T])
• lists: remove[T](L: var DoublyLinkedRing[T]; n: DoublyLinkedNode[T])
• lists: remove[T](L: var SinglyLinkedList[T]; n: SinglyLinkedNode[T]): bool

removeAllRanges:

• dom: removeAllRanges(s: Selection)

removeAttribute:

• dom: removeAttribute(n: Node; attr: cstring)

removeAttributeNode:

• dom: removeAttributeNode(n, attr: Node)

removeChild:

• dom: removeChild(n, child: Node)

removeDir:

• asyncftpclient: removeDir(ftp: AsyncFtpClient; dir: string): owned(Future[void])
• os: removeDir(dir: string; checkDir = false)

removeDirectoryW:

• winlean: removeDirectoryW(lpPathName: WideCString): int32

removeEventListener:

• dom: removeEventListener(et: EventTarget; ev: cstring; cb: proc (ev: Event))

removeFile:

• asyncftpclient: removeFile(ftp: AsyncFtpClient; filename: string): owned(Future[void])
• os: removeFile(file: string)

removeItem:

• dom: removeItem(s: Storage; key: cstring)

removePrefix:

• strutils: removePrefix(s: var string; c: char)
• strutils: removePrefix(s: var string; chars: set[char] = Newlines)
• strutils: removePrefix(s: var string; prefix: string)

removeProperty:

• dom: removeProperty(s: Style; property: cstring)

removeSuffix:

• strutils: removeSuffix(s: var string; c: char)
• strutils: removeSuffix(s: var string; chars: set[char] = Newlines)
• strutils: removeSuffix(s: var string; suffix: string)

reMultiLine:

• RegexFlag.reMultiLine

rename:

• asyncftpclient: rename(ftp: AsyncFtpClient; nameFrom: string; nameTo: string): owned( Future[void])

rename files:

• Module os

renderCodeLang:

• rstgen: renderCodeLang(result: var string; lang: SourceLanguage; code: string; target: OutputTarget)

renderIndexTerm:

• rstgen: renderIndexTerm(d: PDoc; n: PRstNode; result: var string)

renderNimCode:

• rstgen: renderNimCode(result: var string; code: string; target: OutputTarget)

renderRstToJson:

• rstast: renderRstToJson(node: PRstNode): string

renderRstToOut:

• rstgen: renderRstToOut(d: var RstGenerator; n: PRstNode; result: var string)

renderRstToRst:

• rstast: renderRstToRst(n: PRstNode; result: var string)

renderRstToText:

• rstast: renderRstToText(node: PRstNode): string

renderSQL:

• parsesql: renderSQL(n: SqlNode; upperCase = false): string

renderTocEntries:

• rstgen: renderTocEntries(d: var RstGenerator; j: var int; lvl: int; result: var string)

reopen:

• io: reopen(f: File; filename: string; mode: FileMode = fmRead): bool

repeat:

• sequtils: repeat[T](x: T; n: Natural): seq[T]
• strutils: repeat(c: char; count: Natural): string
• strutils: repeat(s: string; n: Natural): string
• unicode: repeat(c: Rune; count: Natural): string

replace:

• dom: replace(loc: Location; s: cstring)
• heapqueue: replace[T](heap: var HeapQueue[T]; item: sink T): T
• jsre: replace(pattern: cstring; self: RegExp; replacement: cstring): cstring
• nre: replace(str: string; pattern: Regex; subproc: proc (match: RegexMatch): string): string
• nre: replace(str: string; pattern: Regex; subproc: proc (match: string): string): string
• nre: replace(str: string; pattern: Regex; sub: string): string
• pegs: replace(s: string; sub: Peg; cb: proc (match: int; cnt: int; caps: openArray[string]): string): string
• pegs: replace(s: string; sub: Peg; by = ""): string
• re: replace(s: string; sub: Regex; by = ""): string
• strutils: replace(s: string; sub, by: char): string
• strutils: replace(s, sub: string; by = ""): string

replaceChild:

• dom: replaceChild(n, newNode, oldNode: Node)

replaceData:

• dom: replaceData(n: Node; start, len: int; text: cstring)

replacef:

• pegs: replacef(s: string; sub: Peg; by: string): string
• re: replacef(s: string; sub: Regex; by: string): string

replaceWord:

• strutils: replaceWord(s, sub: string; by = ""): string

ReplyError:

• asyncftpclient: ReplyError
• smtp: ReplyError

reportComments:

• XmlParseOption.reportComments

reportValidity:

• dom: reportValidity(e: FormElement): bool

reportWhitespace:

• XmlParseOption.reportWhitespace

repr:

• system: repr[T](x: T): string

reprDiscriminant:

• system: reprDiscriminant(e: int; typ: PNimType): string

Request:

• asynchttpserver: Request

request:

• httpclient: request(client: AsyncHttpClient; url: Uri | string; httpMethod: HttpMethod | string = HttpGet; body = ""; headers: HttpHeaders = nil; multipart: MultipartData = nil): Future[ AsyncResponse]
• httpclient: request(client: HttpClient; url: Uri | string; httpMethod: HttpMethod | string = HttpGet; body = ""; headers: HttpHeaders = nil; multipart: MultipartData = nil): Response

Request:

• jsfetch: Request

requestAnimationFrame:

• dom: requestAnimationFrame(w: Window; function: proc (time: float)): int

RequestMethod:

• cgi: RequestMethod

require:

• jsffi: require(module: cstring): JsObject
• unittest: require(conditions: untyped)

requires:

• nimscript: requires(deps: varargs[string])

requiresData:

• nimscript: requiresData

ReraiseDefect:

• system: ReraiseDefect

ReraiseError:

• system: ReraiseError

ReservedMem:

• reservedmem: ReservedMem

ReservedMemSeq:

• reservedmem: ReservedMemSeq

reset:

• dom: reset(f: FormElement)
• system: reset[T](obj: var T)

resetAttributes:

• terminal: resetAttributes()
• terminal: resetAttributes(f: File)

resetOutputFormatters:

• unittest: resetOutputFormatters()

resetStream:

• socketstreams: resetStream(s: ReadSocketStream)
• socketstreams: resetStream(s: WriteSocketStream)

resetStyle:

• TerminalCmd.resetStyle

resize:

• memfiles: resize(f: var MemFile; newFileSize: int)
• system: resize[T](p: ptr T; newSize: Natural): ptr T

resizeBy:

• dom: resizeBy(w: Window; x, y: int)

resizeShared:

• system: resizeShared[T](p: ptr T; newSize: Natural): ptr T

resizeTo:

• dom: resizeTo(w: Window; x, y: int)

resource:

• Module system

ResourceExhaustedError:

• system: ResourceExhaustedError

respond:

• asynchttpserver: respond(req: Request; code: HttpCode; content: string; headers: HttpHeaders = nil): Future[void]

Response:

• httpclient: Response
• jsfetch: Response

reStructuredText:

• Module rstast
• Module rstgen

reStudy:

• RegexFlag.reStudy

resultAsString:

• dom: resultAsString(f: FileReader): cstring

resume:

• osproc: resume(p: Process)

resumeThread:

• winlean: resumeThread(hThread: Handle): int32

retrFile:

• asyncftpclient: retrFile(ftp: AsyncFtpClient; file, dest: string; onProgressChanged: ProgressChangedProc = defaultOnProgressChanged): owned( Future[void])

retrText:

• asyncftpclient: retrText(ftp: AsyncFtpClient; file: string): Future[string]

retryCall:

• gitutils: retryCall(maxRetry = 3; backoffDuration = 1.0; call: untyped): bool

reverse:

• algorithm: reverse[T](a: var openArray[T])
• algorithm: reverse[T](a: var openArray[T]; first, last: Natural)

reverseBits:

• bitops: reverseBits[T: SomeUnsignedInt](x: T): T

reversed:

• algorithm: reversed[T](a: openArray[T]): seq[T]
• algorithm: reversed[T](a: openArray[T]; first: Natural; last: int): seq[T]
• unicode: reversed(s: string): string

rex:

• re: rex(s: string; flags = {reStudy, reExtended}): Regex

rfind:

• strutils: rfind(s: string; sub: char; start: Natural = 0; last = -1): int
• strutils: rfind(s: string; chars: set[char]; start: Natural = 0; last = -1): int
• strutils: rfind(s, sub: string; start: Natural = 0; last = -1): int

rgb:

• colors: rgb(r, g, b: range[0 .. 255]): Color

rightSize:

• sets: rightSize(count: Natural): int
• sharedtables: rightSize(count: Natural): int
• tables: rightSize(count: Natural): int

RLock:

• rlocks: RLock

rmDir:

• nimscript: rmDir(dir: string; checkDir = false)

rmFile:

• nimscript: rmFile(file: string)

rnAdmonition:

• RstNodeKind.rnAdmonition

rnBlockQuote:

• RstNodeKind.rnBlockQuote

rnBulletItem:

• RstNodeKind.rnBulletItem

rnBulletList:

• RstNodeKind.rnBulletList

rnCitation:

• RstNodeKind.rnCitation

rnCodeBlock:

• RstNodeKind.rnCodeBlock

rnCodeFragment:

• RstNodeKind.rnCodeFragment

rnContainer:

• RstNodeKind.rnContainer

rnContents:

• RstNodeKind.rnContents

rnDefaultRole:

• RstNodeKind.rnDefaultRole

rnDefBody:

• RstNodeKind.rnDefBody

rnDefItem:

• RstNodeKind.rnDefItem

rnDefList:

• RstNodeKind.rnDefList

rnDefName:

• RstNodeKind.rnDefName

rnDescription:

• RstNodeKind.rnDescription

rnDirArg:

• RstNodeKind.rnDirArg

rnDirective:

• RstNodeKind.rnDirective

rnEmphasis:

• RstNodeKind.rnEmphasis

rnEnumItem:

• RstNodeKind.rnEnumItem

rnEnumList:

• RstNodeKind.rnEnumList

rnField:

• RstNodeKind.rnField

rnFieldBody:

• RstNodeKind.rnFieldBody

rnFieldList:

• RstNodeKind.rnFieldList

rnFieldName:

• RstNodeKind.rnFieldName

rnFigure:

• RstNodeKind.rnFigure

rnFootnote:

• RstNodeKind.rnFootnote

rnFootnoteGroup:

• RstNodeKind.rnFootnoteGroup

rnFootnoteRef:

• RstNodeKind.rnFootnoteRef

rnGridTable:

• RstNodeKind.rnGridTable

rnHeadline:

• RstNodeKind.rnHeadline

rnHyperlink:

• RstNodeKind.rnHyperlink

rnIdx:

• RstNodeKind.rnIdx

rnImage:

• RstNodeKind.rnImage

rnIndex:

• RstNodeKind.rnIndex

rnInlineCode:

• RstNodeKind.rnInlineCode

rnInlineLiteral:

• RstNodeKind.rnInlineLiteral

rnInlineTarget:

• RstNodeKind.rnInlineTarget

rnInner:

• RstNodeKind.rnInner

rnInternalRef:

• RstNodeKind.rnInternalRef

rnInterpretedText:

• RstNodeKind.rnInterpretedText

rnLeaf:

• RstNodeKind.rnLeaf

rnLineBlock:

• RstNodeKind.rnLineBlock

rnLineBlockItem:

• RstNodeKind.rnLineBlockItem

rnLiteralBlock:

• RstNodeKind.rnLiteralBlock

rnMarkdownHeadline:

• RstNodeKind.rnMarkdownHeadline

rnMarkdownTable:

• RstNodeKind.rnMarkdownTable

rnOption:

• RstNodeKind.rnOption

rnOptionArgument:

• RstNodeKind.rnOptionArgument

rnOptionGroup:

• RstNodeKind.rnOptionGroup

rnOptionList:

• RstNodeKind.rnOptionList

rnOptionListItem:

• RstNodeKind.rnOptionListItem

rnOptionString:

• RstNodeKind.rnOptionString

rnOverline:

• RstNodeKind.rnOverline

rnParagraph:

• RstNodeKind.rnParagraph

rnQuotedLiteralBlock:

• RstNodeKind.rnQuotedLiteralBlock

rnRaw:

• RstNodeKind.rnRaw

rnRawHtml:

• RstNodeKind.rnRawHtml

rnRawLatex:

• RstNodeKind.rnRawLatex

rnRef:

• RstNodeKind.rnRef

rnSmiley:

• RstNodeKind.rnSmiley

rnStandaloneHyperlink:

• RstNodeKind.rnStandaloneHyperlink

rnStrongEmphasis:

• RstNodeKind.rnStrongEmphasis

rnSub:

• RstNodeKind.rnSub

rnSubstitutionDef:

• RstNodeKind.rnSubstitutionDef

rnSubstitutionReferences:

• RstNodeKind.rnSubstitutionReferences

rnSup:

• RstNodeKind.rnSup

rnTable:

• RstNodeKind.rnTable

rnTableDataCell:

• RstNodeKind.rnTableDataCell

rnTableHeaderCell:

• RstNodeKind.rnTableHeaderCell

rnTableRow:

• RstNodeKind.rnTableRow

rnTitle:

• RstNodeKind.rnTitle

rnTransition:

• RstNodeKind.rnTransition

rnTripleEmphasis:

• RstNodeKind.rnTripleEmphasis

rnUnknownRole:

• RstNodeKind.rnUnknownRole

RollingFileLogger:

• logging: RollingFileLogger

roof:

• Module system

RootEffect:

• system: RootEffect

RootNodeOptions:

• dom: RootNodeOptions

RootObj:

• system: RootObj

RootRef:

• system: RootRef

Rope:

• ropes: Rope

rope:

• ropes: rope(f: BiggestFloat): Rope
• ropes: rope(i: BiggestInt): Rope
• ropes: rope(s: string = ""): Rope
• Module ropes

rotatedLeft:

• algorithm: rotatedLeft[T](arg: openArray[T]; slice: HSlice[int, int]; dist: int): seq[T]
• algorithm: rotatedLeft[T](arg: openArray[T]; dist: int): seq[T]

rotateLeft:

• algorithm: rotateLeft[T](arg: var openArray[T]; slice: HSlice[int, int]; dist: int): int
• algorithm: rotateLeft[T](arg: var openArray[T]; dist: int): int

rotateLeftBits:

• bitops: rotateLeftBits[T: SomeUnsignedInt](value: T; shift: range[0 .. (sizeof(T) * 8)]): T

rotateRightBits:

• bitops: rotateRightBits[T: SomeUnsignedInt](value: T; shift: range[0 .. (sizeof(T) * 8)]): T

round:

• jscore: round(m: MathLib; f: SomeFloat): int
• math: round(x: float32): float32
• math: round(x: float64): float64
• math: round[T: float32 | float64](x: T; places: int): T

routeEvent:

• dom: routeEvent(d: Document; event: Event)
• dom: routeEvent(w: Window; event: Event)

RoutineNodes:

• macros: RoutineNodes

Row:

• db_mysql: Row
• db_odbc: Row
• db_postgres: Row
• db_sqlite: Row

rowEntry:

• parsecsv: rowEntry(self: var CsvParser; entry: string): var string

rows:

• db_mysql: rows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
• db_odbc: rows(db: var DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
• db_postgres: rows(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): Row
• db_postgres: rows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
• db_sqlite: rows(db: DbConn; stmtName: SqlPrepared): Row
• db_sqlite: rows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row

rp:

• htmlgen: rp(e: varargs[untyped]): untyped

rpartition:

• strmisc: rpartition(s: string; sep: string): (string, string, string)

rsplit:

• strutils: rsplit(s: string; sep: char; maxsplit: int = -1): seq[string]
• strutils: rsplit(s: string; seps: set[char] = Whitespace; maxsplit: int = -1): seq[string]
• strutils: rsplit(s: string; sep: string; maxsplit: int = -1): seq[string]
• strutils: rsplit(s: string; sep: char; maxsplit: int = -1): string
• strutils: rsplit(s: string; seps: set[char] = Whitespace; maxsplit: int = -1): string
• strutils: rsplit(s: string; sep: string; maxsplit: int = -1; keepSeparators: bool = false): string

RstGenerator:

• rstgen: RstGenerator

RstNode:

• rstast: RstNode

RstNodeKind:

• rstast: RstNodeKind

RstNodeSeq:

• rstast: RstNodeSeq

rstToHtml:

• rstgen: rstToHtml(s: string; options: RstParseOptions; config: StringTableRef; msgHandler: MsgHandler = rst.defaultMsgHandler): string

rstToLatex:

• rstgen: rstToLatex(rstSource: string; options: RstParseOptions): string

rt:

• htmlgen: rt(e: varargs[untyped]): untyped

RtArray:

• rtarrays: RtArray

rtc:

• htmlgen: rtc(e: varargs[untyped]): untyped

RTTI:

• Module typeinfo

ruby:

• htmlgen: ruby(e: varargs[untyped]): untyped

rule:

• pegs: rule(nt: NonTerminal): Peg

run:

• coro: run()

Rune:

• unicode: Rune

runeAt:

• unicode: runeAt(s: string; i: Natural): Rune

runeAtPos:

• unicode: runeAtPos(s: string; pos: int): Rune

runeLen:

• unicode: runeLen(s: string): int

runeLenAt:

• unicode: runeLenAt(s: string; i: Natural): int

runeOffset:

• unicode: runeOffset(s: string; pos: Natural; start: Natural = 0): int

runeReverseOffset:

• unicode: runeReverseOffset(s: string; rev: Positive): (int, int)

runes:

• unicode: runes(s: string): Rune

runeStrAtPos:

• unicode: runeStrAtPos(s: string; pos: Natural): string

runeSubStr:

• unicode: runeSubStr(s: string; pos: int; len: int = int.high): string

runeToEntity:

• htmlparser: runeToEntity(rune: Rune): string

runForever:

• asyncdispatch: runForever()

runnable example:

• Module system

runnableExamples:

• system: runnableExamples(rdoccmd = ""; body: untyped)

running:

• osproc: running(p: Process): bool
• threads: running*[TArg](t: Thread[TArg]): bool

RunningRegress:

• stats: RunningRegress

RunningStat:

• stats: RunningStat

runtime type information:

• Module typeinfo

s:

• htmlgen: s(e: varargs[untyped]): untyped

sameFile:

• os: sameFile(path1, path2: string): bool

sameFileContent:

• os: sameFileContent(path1, path2: string): bool

SameSite:

• cookies: SameSite

sameType:

• macros: sameType(a, b: NimNode): bool

samp:

• htmlgen: samp(e: varargs[untyped]): untyped

sample:

• random: sample[T](a: openArray[T]): lent T
• random: sample[T, U](a: openArray[T]; cdf: openArray[U]): T
• random: sample[T](r: var Rand; a: openArray[T]): T
• random: sample[T, U](r: var Rand; a: openArray[T]; cdf: openArray[U]): T
• random: sample[T](r: var Rand; s: set[T]): T
• random: sample[T](s: set[T]): T

scanf:

• strscans: scanf(input: string; pattern: static[string]; results: varargs[typed]): bool
• Module strscans

scanp:

• strscans: scanp(input, idx: typed; pattern: varargs[untyped]): bool

scanSSLCertificates:

• ssl_certs: scanSSLCertificates(useEnvVars = false): string

scanTuple:

• strscans: scanTuple(input: untyped; pattern: static[string]; matcherTypes: varargs[untyped]): untyped

SCons:

• SexpNodeKind.SCons

screen:

• dom: screen

script:

• htmlgen: script(e: varargs[untyped]): untyped

ScriptExt:

• os: ScriptExt

ScriptMode:

• nimscript: ScriptMode

ScrollBars:

• dom: ScrollBars

scrollBy:

• dom: scrollBy(w: Window; x, y: int)

scrollHeight:

• dom: scrollHeight(e: Node): int

scrollIntoView:

• dom: scrollIntoView(n: Node)
• dom: scrollIntoView(n: Node; options: ScrollIntoViewOptions)

ScrollIntoViewOptions:

• dom: ScrollIntoViewOptions

scrollLeft:

• dom: scrollLeft(e: Node): int

scrollTo:

• dom: scrollTo(w: Window; x, y: int)

scrollTop:

• dom: scrollTop(e: Node): int

scrollTop=:

• dom: scrollTop=(e: Node; value: int)

scrollWidth:

• dom: scrollWidth(e: Node): int

searchExtPos:

• os: searchExtPos(path: string): int

sec:

• complex: sec[T](z: Complex[T]): Complex[T]
• math: sec[T: float32 | float64](x: T): T

sech:

• complex: sech[T](z: Complex[T]): Complex[T]
• math: sech[T: float32 | float64](x: T): T

second:

• times: second(dt: DateTime): SecondRange

second=:

• times: second=(dt: var DateTime; value: SecondRange)

SecondaryButton:

• MouseButtons.SecondaryButton

SecondRange:

• times: SecondRange

Seconds:

• TimeUnit.Seconds

seconds:

• times: seconds(s: int): TimeInterval

section:

• htmlgen: section(e: varargs[untyped]): untyped

sections:

• parsecfg: sections(dict: Config): lent string

SecureHash:

• sha1: SecureHash

secureHash:

• sha1: secureHash(str: openArray[char]): SecureHash

secureHashFile:

• sha1: secureHashFile(filename: string): SecureHash

SECURITY_ATTRIBUTES:

• winlean: SECURITY_ATTRIBUTES

SECURITY_BUILTIN_DOMAIN_RID:

• winlean: SECURITY_BUILTIN_DOMAIN_RID

SECURITY_NT_AUTHORITY:

• winlean: SECURITY_NT_AUTHORITY

select:

• dom: select(e: Element)
• htmlgen: select(e: varargs[untyped]): untyped
• selectors: select[T](s: Selector[T]; timeout: int): seq[ReadyKey]
• winlean: select(nfds: cint; readfds, writefds, exceptfds: ptr TFdSet; timeout: ptr Timeval): cint

SelectEvent:

• selectors: SelectEvent

selectInto:

• selectors: selectInto[T](s: Selector[T]; timeout: int; results: var openArray[ReadyKey]): int

Selection:

• dom: Selection

Selector:

• selectors: Selector

selectRead:

• nativesockets: selectRead(readfds: var seq[SocketHandle]; timeout = 500): int

selectWrite:

• nativesockets: selectWrite(writefds: var seq[SocketHandle]; timeout = 500): int

selfExe:

• nimscript: selfExe(): string

selfExec:

• nimscript: selfExec(command: string)

semantics:

• htmlgen: semantics(e: varargs[untyped]): untyped

send:

• asyncdispatch: send(socket: AsyncFD; buf: pointer; size: int; flags = {SafeDisconn}): owned( Future[void])
• asyncdispatch: send(socket: AsyncFD; data: string; flags = {SafeDisconn}): owned(Future[void])
• asyncftpclient: send(ftp: AsyncFtpClient; m: string): Future[string]
• asyncnet: send(socket: AsyncSocket; buf: pointer; size: int; flags = {SafeDisconn}): owned( Future[void])
• asyncnet: send(socket: AsyncSocket; data: string; flags = {SafeDisconn}): owned( Future[void])
• channels_builtin: send*[TMsg](c: var Channel[TMsg]; msg: sink TMsg)
• net: send(socket: Socket; data: pointer; size: int): int
• net: send(socket: Socket; data: string; flags = {SafeDisconn})
• winlean: send(s: SocketHandle; buf: pointer; len, flags: cint): cint

sendBeacon:

• dom: sendBeacon(self: Navigator; url, data: cstring): bool

sendHeaders:

• asynchttpserver: sendHeaders(req: Request; headers: HttpHeaders): Future[void]

sendMail:

• smtp: sendMail(smtp: AsyncSmtp; fromAddr: string; toAddrs: seq[string]; msg: string): owned( Future[void])
• smtp: sendMail(smtp: Smtp; fromAddr: string; toAddrs: seq[string]; msg: string)

sendSignal:

• posix_utils: sendSignal(pid: Pid; signal: int)

sendTo:

• asyncdispatch: sendTo(socket: AsyncFD; data: pointer; size: int; saddr: ptr SockAddr; saddrLen: SockLen; flags = {SafeDisconn}): owned(Future[void])
• asyncnet: sendTo(socket: AsyncSocket; address: string; port: Port; data: string; flags = {SafeDisconn}): owned(Future[void])
• net: sendTo(socket: Socket; address: string; port: Port; data: pointer; size: int; af: Domain = AF_INET; flags = 0'i32)
• net: sendTo(socket: Socket; address: string; port: Port; data: string)

sendto:

• winlean: sendto(s: SocketHandle; buf: pointer; len, flags: cint; to: ptr SockAddr; tolen: SockLen): cint

seq:

• Module sequtils
• system: seq

sequence:

• pegs: sequence(a: varargs[Peg]): Peg

serialization:

• Module marshal

serve:

• asynchttpserver: serve(server: AsyncHttpServer; port: Port; callback: proc (request: Request): Future[void] {.closure, gcsafe.}; address = ""; assumedDescriptorsPerRequest = -1; domain = AF_INET): owned( Future[void])

Servent:

• nativesockets: Servent
• winlean: Servent

serverGetPskFunc:

• net: serverGetPskFunc(ctx: SslContext): SslServerGetPskFunc

serverGetPskFunc=:

• net: serverGetPskFunc=(ctx: SslContext; fun: SslServerGetPskFunc)

sessionIdContext=:

• net: sessionIdContext=(ctx: SslContext; sidCtx: string)

set:

• system: set

setAttr:

• dom: setAttr(n: Node; key, val: cstring)

setAttribute:

• dom: setAttribute(n: Node; name, value: cstring)

setAttributeNode:

• dom: setAttributeNode(n: Node; attr: Node)

setBackgroundColor:

• terminal: setBackgroundColor(f: File; bg: BackgroundColor; bright = false)
• terminal: setBackgroundColor(f: File; color: Color)
• terminal: setBackgroundColor(bg: BackgroundColor; bright = false)
• terminal: setBackgroundColor(color: Color)

setBiggestFloat:

• typeinfo: setBiggestFloat(x: Any; y: BiggestFloat)

setBiggestInt:

• typeinfo: setBiggestInt(x: Any; y: BiggestInt)

setBiggestUint:

• typeinfo: setBiggestUint(x: Any; y: uint64)

setBit:

• bitops: setBit[T: SomeInteger](v: var T; bit: BitsRange[T])

setBits:

• bitops: setBits(v: typed; bits: varargs[typed]): untyped

setBlocking:

• nativesockets: setBlocking(s: SocketHandle; blocking: bool)

setCallSoonProc:

• asyncfutures: setCallSoonProc(p: (proc (cbproc: proc ()) {.gcsafe.}))

setCommand:

• nimscript: setCommand(cmd: string; project = "")

setCompletionCallback:

• linenoise: setCompletionCallback(a2: CompletionCallback)

setControlCHook:

• system: setControlCHook(hook: proc () {.noconv.})

setCookie:

• cgi: setCookie(name, value: string)
• cookies: setCookie(key, value: string; expires: DateTime | Time; domain = ""; path = ""; noName = false; secure = false; httpOnly = false; maxAge = none(int); sameSite = SameSite.Default): string
• cookies: setCookie(key, value: string; domain = ""; path = ""; expires = ""; noName = false; secure = false; httpOnly = false; maxAge = none(int); sameSite = SameSite.Default): string

setCurrentDir:

• os: setCurrentDir(newDir: string)

setCurrentDirectoryW:

• winlean: setCurrentDirectoryW(lpPathName: WideCString): int32

setCurrentException:

• system: setCurrentException(exc: ref Exception)

setCursorPos:

• terminal: setCursorPos(f: File; x, y: int)
• terminal: setCursorPos(x, y: int)

setCursorXPos:

• terminal: setCursorXPos(f: File; x: int)
• terminal: setCursorXPos(x: int)

setCursorYPos:

• terminal: setCursorYPos(f: File; y: int)
• terminal: setCursorYPos(x: int)

setCustomValidity:

• dom: setCustomValidity(e: InputElement; error: cstring)

setData:

• dom: setData(dt: DataTransfer; format: cstring; data: cstring)
• selectors: setData[T](s: Selector[T]; fd: SocketHandle | int; data: var T): bool

setDragImage:

• dom: setDragImage(dt: DataTransfer; img: Element; xOffset: int64; yOffset: int64)

setEncoding:

• db_mysql: setEncoding(connection: DbConn; encoding: string): bool
• db_odbc: setEncoding(connection: DbConn; encoding: string): bool
• db_postgres: setEncoding(connection: DbConn; encoding: string): bool
• db_sqlite: setEncoding(connection: DbConn; encoding: string): bool

setEndOfFile:

• winlean: setEndOfFile(hFile: Handle): WINBOOL

setEnvImpl:

• win_setenv: setEnvImpl(name: string; value: string; overwrite: cint): cint

setEnvironmentVariableA:

• win_setenv: setEnvironmentVariableA(lpName, lpValue: cstring): int32

setEnvironmentVariableW:

• winlean: setEnvironmentVariableW(lpName, lpValue: WideCString): int32

setEvent:

• winlean: setEvent(hEvent: Handle): cint

setExtraData:

• net: setExtraData(ctx: SslContext; index: int; data: RootRef)

setFileAttributesW:

• winlean: setFileAttributesW(lpFileName: WideCString; dwFileAttributes: int32): WINBOOL

setFilePermissions:

• os: setFilePermissions(filename: string; permissions: set[FilePermission]; followSymlinks = true)

setFilePointer:

• winlean: setFilePointer(hFile: Handle; lDistanceToMove: LONG; lpDistanceToMoveHigh: ptr LONG; dwMoveMethod: DWORD): DWORD

setFilePos:

• asyncfile: setFilePos(f: AsyncFile; pos: int64)
• io: setFilePos(f: File; pos: int64; relativeTo: FileSeekPos = fspSet)

setFileSize:

• asyncfile: setFileSize(f: AsyncFile; length: int64)

setFileTime:

• winlean: setFileTime(hFile: Handle; lpCreationTime: LPFILETIME; lpLastAccessTime: LPFILETIME; lpLastWriteTime: LPFILETIME): WINBOOL

setForegroundColor:

• terminal: setForegroundColor(f: File; color: Color)
• terminal: setForegroundColor(f: File; fg: ForegroundColor; bright = false)
• terminal: setForegroundColor(color: Color)
• terminal: setForegroundColor(fg: ForegroundColor; bright = false)

setFrame:

• system: setFrame(s: PFrame)

setFrameMsg:

• stackframes: setFrameMsg(msg: string; prefix = " ")

setFrameState:

• system: setFrameState(state: FrameState)

setFullYear:

• jscore: setFullYear(d: DateTime; year: int)

setGcFrame:

• system: setGcFrame(s: GcFrame)

setGlobalDispatcher:

• asyncdispatch: setGlobalDispatcher(disp: sink PDispatcher)

setHandleInformation:

• winlean: setHandleInformation(hObject: Handle; dwMask: DWORD; dwFlags: DWORD): WINBOOL

setIndexTerm:

• rstgen: setIndexTerm(d: var RstGenerator; htmlFile, id, term: string; linkTitle, linkDesc = "")

setInheritable:

• asyncdispatch: setInheritable(fd: AsyncFD; inheritable: bool): bool
• io: setInheritable(f: FileHandle; inheritable: bool): bool
• nativesockets: setInheritable(s: SocketHandle; inheritable: bool): bool

setInterval:

• dom: setInterval(action: proc (); ms: int): Interval
• dom: setInterval(w: Window; code: cstring; pause: int): Interval
• dom: setInterval(w: Window; function: proc (); pause: int): Interval

setItem:

• dom: setItem(s: Storage; key, value: cstring)

setLastError:

• winlean: setLastError(error: int32)

setLastModificationTime:

• os: setLastModificationTime(file: string; t: times.Time)

setLen:

• reservedmem: setLen(m: var ReservedMem; newLen: int)
• reservedmem: setLen[T](s: var ReservedMemSeq[T]; newLen: int)
• system: setLen[T](s: var seq[T]; newlen: Natural)
• system: setLen(s: var string; newlen: Natural)

setLogFilter:

• logging: setLogFilter(lvl: Level)

setMask:

• bitops: setMask[T: SomeInteger](v: var T; slice: Slice[int])
• bitops: setMask[T: SomeInteger](v: var T; mask: T)

setMasked:

• bitops: setMasked[T: SomeInteger](v: T; slice: Slice[int]): T
• bitops: setMasked[T: SomeInteger](v, mask: T): T

setMaxPoolSize:

• threadpool: setMaxPoolSize(size: range[1 .. MaxThreadPoolSize])

setMinPoolSize:

• threadpool: setMinPoolSize(size: range[1 .. MaxThreadPoolSize])

setMultiLine:

• linenoise: setMultiLine(ml: cint)

setObjectRuntimeType:

• typeinfo: setObjectRuntimeType(x: Any)

setPointer:

• typeinfo: setPointer(x: Any; y: pointer)

setPosition:

• streams: setPosition(s: Stream; pos: int)

setProgramResult:

• exitprocs: setProgramResult(a: int)

setProperty:

• dom: setProperty(s: Style; property, value: cstring; priority = "")

setRangeText:

• dom: setRangeText(e: InputElement; replacement: cstring; startindex: int = 0; endindex: int = 0; selectionMode: cstring = "preserve")

setSamplingFrequency:

• nimprof: setSamplingFrequency(intervalInUs: int)

setSectionKey:

• parsecfg: setSectionKey(dict: var Config; section, key, value: string)

setSelectionRange:

• dom: setSelectionRange(e: InputElement; selectionStart: int; selectionEnd: int; selectionDirection: cstring = "none")

setSlice:

• strbasics: setSlice(s: var string; slice: Slice[int])

setSockOpt:

• asyncnet: setSockOpt(socket: AsyncSocket; opt: SOBool; value: bool; level = SOL_SOCKET)
• net: setSockOpt(socket: Socket; opt: SOBool; value: bool; level = SOL_SOCKET)

setsockopt:

• winlean: setsockopt(s: SocketHandle; level, optname: cint; optval: pointer; optlen: SockLen): cint

setSockOptInt:

• nativesockets: setSockOptInt(socket: SocketHandle; level, optname, optval: int)

setStackTraceStdout:

• cgi: setStackTraceStdout()

setStdHandle:

• winlean: setStdHandle(nStdHandle: int32; hHandle: Handle): WINBOOL

setStdIoUnbuffered:

• io: setStdIoUnbuffered()

setString:

• typeinfo: setString(x: Any; y: string)

setStyle:

• terminal: setStyle(f: File; style: set[Style])
• terminal: setStyle(style: set[Style])

setTestData:

• cgi: setTestData(keysvalues: varargs[string])

setTimeout:

• dom: setTimeout(action: proc (); ms: int): TimeOut
• dom: setTimeout(w: Window; code: cstring; pause: int): TimeOut
• dom: setTimeout(w: Window; function: proc (); pause: int): Interval

setUnicodeValue:

• registry: setUnicodeValue(path, key, val: string; handle: HKEY)

setupForeignThreadGc:

• system: setupForeignThreadGc()

sexp:

• sexp: sexp(n: BiggestInt): SexpNode
• sexp: sexp(b: bool): SexpNode
• sexp: sexp(n: float): SexpNode
• sexp: sexp(elements: openArray[SexpNode]): SexpNode
• sexp: sexp(s: SexpNode): SexpNode
• sexp: sexp(s: string): SexpNode

sexpDot:

• SexpEventKind.sexpDot

sexpEof:

• SexpEventKind.sexpEof

sexpError:

• SexpEventKind.sexpError

SexpError:

• sexp: SexpError

SexpEventKind:

• sexp: SexpEventKind

sexpFloat:

• SexpEventKind.sexpFloat

sexpInt:

• SexpEventKind.sexpInt

sexpListEnd:

• SexpEventKind.sexpListEnd

sexpListStart:

• SexpEventKind.sexpListStart

sexpNil:

• SexpEventKind.sexpNil

SexpNode:

• sexp: SexpNode

SexpNodeKind:

• sexp: SexpNodeKind

SexpNodeObj:

• sexp: SexpNodeObj

SexpParser:

• sexp: SexpParser

SexpParsingError:

• sexp: SexpParsingError

sexpString:

• SexpEventKind.sexpString

sexpSymbol:

• SexpEventKind.sexpSymbol

SFloat:

• SexpNodeKind.SFloat

sgn:

• math: sgn[T: SomeNumber](x: T): int

Sha1Digest:

• sha1: Sha1Digest

Sha1State:

• sha1: Sha1State

ShadowRoot:

• dom: ShadowRoot

ShadowRootInit:

• dom: ShadowRootInit

shallow:

• system: shallow[T](s: var seq[T])
• system: shallow(s: var string)
• Module system
• Module system

shallow copy:

• Module system

shallowCopy:

• system: shallowCopy[T](x: var T; y: T)

shared object:

• Module os

SharedList:

• sharedlist: SharedList

SharedTable:

• sharedtables: SharedTable

shell command:

• Module os

shellExecuteW:

• winlean: shellExecuteW(hwnd: Handle; lpOperation, lpFile, lpParameters, lpDirectory: WideCString; nShowCmd: int32): Handle

shift:

• reservedmem: shift(p: pointer; distance: int): pointer

shouldAcceptRequest:

• asynchttpserver: shouldAcceptRequest(server: AsyncHttpServer; assumedDescriptorsPerRequest = 5): bool

showCursor:

• terminal: showCursor(f: File)
• terminal: showCursor()

shrink:

• deques: shrink[T](deq: var Deque[T]; fromFirst = 0; fromLast = 0)

shuffle:

• random: shuffle[T](x: var openArray[T])
• random: shuffle[T](r: var Rand; x: var openArray[T])

shutdown:

• winlean: shutdown(s: SocketHandle; how: cint): cint

SID:

• winlean: SID

SID_IDENTIFIER_AUTHORITY:

• winlean: SID_IDENTIFIER_AUTHORITY

SIGABRT:

• segfaults: SIGABRT

SIG_DFL:

• segfaults: SIG_DFL

SIGFPE:

• segfaults: SIGFPE

SIGILL:

• segfaults: SIGILL

SIGINT:

• segfaults: SIGINT

sign:

• jscore: sign(m: MathLib; f: SomeNumber): int

signal:

• locks: signal(cond: var Cond)

signalFence:

• atomics: signalFence(order: MemoryOrder)

signatureHash:

• macros: signatureHash(n: NimNode): string

signbit:

• math: signbit(x: SomeFloat): bool

SIGSEGV:

• segfaults: SIGSEGV

simple assertions:

• Simple assertions

sin:

• complex: sin[T](z: Complex[T]): Complex[T]
• jscore: sin(m: MathLib; a: SomeNumber): float
• math: sin(x: float32): float32
• math: sin(x: float64): float64

since:

• since: since(version: (int, int); body: untyped)
• since: since(version: (int, int, int); body: untyped)

SingleTags:

• htmlparser: SingleTags

SingleValueSetting:

• compilesettings: SingleValueSetting

SinglyLinkedList:

• lists: SinglyLinkedList

SinglyLinkedNode:

• lists: SinglyLinkedNode

SinglyLinkedNodeObj:

• lists: SinglyLinkedNodeObj

SinglyLinkedRing:

• lists: SinglyLinkedRing

sinh:

• complex: sinh[T](z: Complex[T]): Complex[T]
• jscore: sinh(m: MathLib; a: SomeNumber): float
• math: sinh(x: float32): float32
• math: sinh(x: float64): float64

sink:

• system: sink
• Module system

SInt:

• SexpNodeKind.SInt

SIO_GET_EXTENSION_FUNCTION_POINTER:

• winlean: SIO_GET_EXTENSION_FUNCTION_POINTER

size:

• typeinfo: size(x: Any): int
• unicode: size(r: Rune): int

sizeof:

• system: sizeof[T](x: T): int
• system: sizeof(x: typedesc): int

skewness:

• stats: skewness[T](x: openArray[T]): float
• stats: skewness(s: RunningStat): float

skewnessS:

• stats: skewnessS[T](x: openArray[T]): float
• stats: skewnessS(s: RunningStat): float

skip:

• net: skip(socket: Socket; size: int; timeout = -1)
• parseutils: skip(s, token: string; start = 0): int
• unittest: skip()

skipDirs:

• nimscript: skipDirs

skipExt:

• nimscript: skipExt

skipFiles:

• nimscript: skipFiles

skipIgnoreCase:

• parseutils: skipIgnoreCase(s, token: string; start = 0): int

SKIPPED:

• TestStatus.SKIPPED

skipRandomNumbers:

• random: skipRandomNumbers(s: var Rand)

skipRange:

• typeinfo: skipRange(x: Any): Any

SkipTable:

• strutils: SkipTable

skipUntil:

• parseutils: skipUntil(s: string; until: char; start = 0): int
• parseutils: skipUntil(s: string; until: set[char]; start = 0): int

skipWhile:

• parseutils: skipWhile(s: string; toSkip: set[char]; start = 0): int

skipWhitespace:

• parseutils: skipWhitespace(s: string; start = 0): int

sleep:

• os: sleep(milsecs: int)
• winlean: sleep(dwMilliseconds: int32)

sleepAsync:

• asyncdispatch: sleepAsync(ms: int | float): owned(Future[void])

slice:

• dom: slice(e: Blob; startindex: int = 0; endindex: int = e.size; contentType: cstring = "")

Slice:

• system: Slice

slice:

• Module system
• Module system

SList:

• SexpNodeKind.SList

slope:

• stats: slope(r: RunningRegress): float

slot:

• htmlgen: slot(e: varargs[untyped]): untyped

SlotOptions:

• dom: SlotOptions

slurp:

• system: slurp(filename: string): string

small:

• htmlgen: small(e: varargs[untyped]): untyped

smallest:

• tables: smallest[A](t: CountTable[A]): tuple[key: A, val: int]
• tables: smallest[A](t: CountTableRef[A]): tuple[key: A, val: int]

Smtp:

• smtp: Smtp

SNil:

• SexpNodeKind.SNil

SO_ACCEPTCONN:

• winlean: SO_ACCEPTCONN

SOBool:

• net: SOBool

SO_BROADCAST:

• winlean: SO_BROADCAST

SockAddr:

• winlean: SockAddr

Sockaddr_in:

• winlean: Sockaddr_in

Sockaddr_in6:

• winlean: Sockaddr_in6

Sockaddr_storage:

• winlean: Sockaddr_storage

SOCK_DGRAM:

• SockType.SOCK_DGRAM

Socket:

• net: Socket

socket:

• winlean: socket(af, typ, protocol: cint): SocketHandle

socketError:

• net: socketError(socket: Socket; err: int = -1; async = false; lastError = -1.OSErrorCode; flags: set[SocketFlag] = {})

SocketFlag:

• net: SocketFlag

SocketHandle:

• winlean: SocketHandle

SocketImpl:

• net: SocketImpl

SockLen:

• winlean: SockLen

SOCK_RAW:

• SockType.SOCK_RAW

SOCK_SEQPACKET:

• SockType.SOCK_SEQPACKET

SOCK_STREAM:

• SockType.SOCK_STREAM

SockType:

• nativesockets: SockType

SO_DEBUG:

• winlean: SO_DEBUG

SO_DONTLINGER:

• winlean: SO_DONTLINGER

SO_DONTROUTE:

• winlean: SO_DONTROUTE

SO_ERROR:

• winlean: SO_ERROR

SO_EXCLUSIVEADDRUSE:

• winlean: SO_EXCLUSIVEADDRUSE

SO_KEEPALIVE:

• winlean: SO_KEEPALIVE

SO_LINGER:

• winlean: SO_LINGER

SOL_SOCKET:

• winlean: SOL_SOCKET

SOMAXCONN:

• winlean: SOMAXCONN

some:

• options: some[T](val: sink T): Option[T]

SomeFloat:

• system: SomeFloat

SomeInteger:

• system: SomeInteger

SomeLinkedCollection:

• lists: SomeLinkedCollection

SomeLinkedList:

• lists: SomeLinkedList

SomeLinkedNode:

• lists: SomeLinkedNode

SomeLinkedRing:

• lists: SomeLinkedRing

SomeNumber:

• system: SomeNumber

SomeOrdinal:

• system: SomeOrdinal

SomeSet:

• sets: SomeSet

SomeSignedInt:

• system: SomeSignedInt

SomeUnsignedInt:

• system: SomeUnsignedInt

SO_OOBINLINE:

• winlean: SO_OOBINLINE

SO_REUSEADDR:

• winlean: SO_REUSEADDR

SO_REUSEPORT:

• winlean: SO_REUSEPORT

sort:

• algorithm: sort[T](a: var openArray[T]; order = SortOrder.Ascending)
• algorithm: sort[T](a: var openArray[T]; cmp: proc (x, y: T): int {.closure.}; order = SortOrder.Ascending)
• tables: sort[A](t: var CountTable[A]; order = SortOrder.Descending)
• tables: sort[A](t: CountTableRef[A]; order = SortOrder.Descending)
• tables: sort[A, B](t: var OrderedTable[A, B]; cmp: proc (x, y: (A, B)): int; order = SortOrder.Ascending)
• tables: sort[A, B](t: OrderedTableRef[A, B]; cmp: proc (x, y: (A, B)): int; order = SortOrder.Ascending)

sorted:

• algorithm: sorted[T](a: openArray[T]; order = SortOrder.Ascending): seq[T]
• algorithm: sorted[T](a: openArray[T]; cmp: proc (x, y: T): int {.closure.}; order = SortOrder.Ascending): seq[T]

sortedByIt:

• algorithm: sortedByIt(seq1, op: untyped): untyped

SortOrder:

• algorithm: SortOrder

SO_UPDATE_ACCEPT_CONTEXT:

• winlean: SO_UPDATE_ACCEPT_CONTEXT

source:

• htmlgen: source(e: varargs[untyped]): untyped

SourceLanguage:

• highlite: SourceLanguage

sourceLanguageToAlpha:

• highlite: sourceLanguageToAlpha

sourceLanguageToStr:

• highlite: sourceLanguageToStr

SO_USELOOPBACK:

• winlean: SO_USELOOPBACK

spaces:

• strutils: spaces(n: Natural): string

span:

• htmlgen: span(e: varargs[untyped]): untyped

sparse bit set:

• Module packedsets

spawn:

• threadpool: spawn(call: sink typed)

spawnX:

• threadpool: spawnX(call)

splice:

• Module system
• Module system

split:

• jsre: split(pattern: cstring; self: RegExp): seq[cstring]
• nre: split(str: string; pattern: Regex; maxSplit = -1; start = 0): seq[string]
• pegs: split(s: string; sep: Peg): seq[string]
• pegs: split(s: string; sep: Peg): string
• re: split(s: string; sep: Regex; maxsplit = -1): seq[string]
• re: split(s: string; sep: Regex; maxsplit = -1): string
• strutils: split(s: string; sep: char; maxsplit: int = -1): seq[string]
• strutils: split(s: string; seps: set[char] = Whitespace; maxsplit: int = -1): seq[string]
• strutils: split(s: string; sep: string; maxsplit: int = -1): seq[string]
• strutils: split(s: string; sep: char; maxsplit: int = -1): string
• strutils: split(s: string; seps: set[char] = Whitespace; maxsplit: int = -1): string
• strutils: split(s: string; sep: string; maxsplit: int = -1): string
• unicode: split(s: string; seps: openArray[Rune] = unicodeSpaces; maxsplit: int = -1): seq[ string]
• unicode: split(s: string; sep: Rune; maxsplit: int = -1): seq[string]
• unicode: split(s: string; seps: openArray[Rune] = unicodeSpaces; maxsplit: int = -1): string
• unicode: split(s: string; sep: Rune; maxsplit: int = -1): string

splitDecimal:

• math: splitDecimal[T: float32 | float64](x: T): tuple[intpart: T, floatpart: T]

splitFile:

• os: splitFile(path: string): tuple[dir, name, ext: string]

splitLines:

• strutils: splitLines(s: string; keepEol = false): seq[string]
• strutils: splitLines(s: string; keepEol = false): string

splitPath:

• os: splitPath(path: string): tuple[head, tail: string]

splitWhitespace:

• strutils: splitWhitespace(s: string; maxsplit: int = -1): seq[string]
• strutils: splitWhitespace(s: string; maxsplit: int = -1): string
• unicode: splitWhitespace(s: string): seq[string]
• unicode: splitWhitespace(s: string): string

sql:

• db_common: sql(query: string): SqlQuery

SQLite:

• Module db_sqlite

SqlLexer:

• parsesql: SqlLexer

SqlNode:

• parsesql: SqlNode

SqlNodeKind:

• parsesql: SqlNodeKind

SqlNodeObj:

• parsesql: SqlNodeObj

SqlParseError:

• parsesql: SqlParseError

SqlParser:

• parsesql: SqlParser

SqlPrepared:

• db_postgres: SqlPrepared
• db_sqlite: SqlPrepared

SqlQuery:

• db_common: SqlQuery

sqrt:

• complex: sqrt[T](z: Complex[T]): Complex[T]
• jscore: sqrt(m: MathLib; f: SomeFloat): SomeFloat
• math: sqrt(x: float32): float32
• math: sqrt(x: float64): float64

srcDir:

• nimscript: srcDir

SslAcceptResult:

• net: SslAcceptResult

SslClientGetPskFunc:

• net: SslClientGetPskFunc

SslContext:

• net: SslContext

SslCVerifyMode:

• net: SslCVerifyMode

SslError:

• net: SslError

sslHandle:

• asyncnet: sslHandle(self: AsyncSocket): SslPtr
• net: sslHandle(self: Socket): SslPtr

SslHandshakeType:

• net: SslHandshakeType

SslProtVersion:

• net: SslProtVersion

SslServerGetPskFunc:

• net: SslServerGetPskFunc

SString:

• SexpNodeKind.SString

SSymbol:

• SexpNodeKind.SSymbol

StackOverflowDefect:

• system: StackOverflowDefect

StackOverflowError:

• system: StackOverflowError

stackTraceAvailable:

• system: stackTraceAvailable(): bool

StackTraceEntry:

• system: StackTraceEntry

standardDeviation:

• stats: standardDeviation[T](x: openArray[T]): float
• stats: standardDeviation(s: RunningStat): float

standardDeviationS:

• stats: standardDeviationS[T](x: openArray[T]): float
• stats: standardDeviationS(s: RunningStat): float

StandardFormatSpecifier:

• strformat: StandardFormatSpecifier

start:

• coro: start(c: proc (); stacksize: int = defaultStackSize): CoroutineRef

startAnchor:

• pegs: startAnchor(): Peg

STARTF_USESHOWWINDOW:

• winlean: STARTF_USESHOWWINDOW

STARTF_USESTDHANDLES:

• winlean: STARTF_USESTDHANDLES

startProcess:

• osproc: startProcess(command: string; workingDir: string = ""; args: openArray[string] = []; env: StringTableRef = nil; options: set[ProcessOption] = {poStdErrToStdOut}): owned(Process)

startsWith:

• cstrutils: startsWith(s, prefix: cstring): bool
• jsre: startsWith(pattern: cstring; self: RegExp): bool
• pegs: startsWith(s: string; prefix: Peg; start = 0): bool
• re: startsWith(s: string; prefix: Regex): bool
• strutils: startsWith(s: string; prefix: char): bool
• strutils: startsWith(s, prefix: string): bool

startsWithImpl:

• strimpl: startsWithImpl[T: string | cstring](s, prefix: T)

startTls:

• smtp: startTls(smtp: AsyncSmtp; sslContext: SslContext = nil): owned(Future[void])
• smtp: startTls(smtp: Smtp; sslContext: SslContext = nil)

STARTUPINFO:

• winlean: STARTUPINFO

stat:

• posix_utils: stat(path: string): Stat

staticExec:

• system: staticExec(command: string; input = ""; cache = ""): string

StaticParam:

• typetraits: StaticParam

staticRead:

• system: staticRead(filename: string): string

StatusBar:

• dom: StatusBar

STATUS_PENDING:

• winlean: STATUS_PENDING

stderr:

• io: stderr

STD_ERROR_HANDLE:

• winlean: STD_ERROR_HANDLE

stdin:

• io: stdin
• Module rdstdin

STD_INPUT_HANDLE:

• winlean: STD_INPUT_HANDLE

stdmsg:

• io: stdmsg(): File

stdout:

• io: stdout

STD_OUTPUT_HANDLE:

• winlean: STD_OUTPUT_HANDLE

STILL_ACTIVE:

• winlean: STILL_ACTIVE

stop:

• dom: stop(e: EmbedElement)
• dom: stop(w: Window)

stopImmediatePropagation:

• dom: stopImmediatePropagation(ev: Event)

stopPropagation:

• dom: stopPropagation(ev: Event)

Storage:

• dom: Storage

StorageEvent:

• dom: StorageEvent

store:

• asyncftpclient: store(ftp: AsyncFtpClient; file, dest: string; onProgressChanged: ProgressChangedProc = defaultOnProgressChanged): owned( Future[void])
• atomics: store[T](location: var Atomic[T]; desired: T; order: MemoryOrder = moSequentiallyConsistent)
• marshal: store[T](s: Stream; data: T)

str:

• parsejson: str(my: JsonParser): string
• sexp: str(my: SexpParser): string

Stream:

• streams: Stream

StreamObj:

• streams: StreamObj

string:

• system: string

string interpolation:

• Module strutils

stringify:

• jscore: stringify(l: JsonLib; s: JsRoot): cstring

StringStream:

• streams: StringStream

StringStreamObj:

• streams: StringStreamObj

StringTableMode:

• strtabs: StringTableMode

StringTableObj:

• strtabs: StringTableObj

StringTableRef:

• strtabs: StringTableRef

strip:

• strbasics: strip(a: var string; leading = true; trailing = true; chars: set[char] = whitespaces)
• strutils: strip(s: string; leading = true; trailing = true; chars: set[char] = Whitespace): string
• unicode: strip(s: string; leading = true; trailing = true; runes: openArray[Rune] = unicodeSpaces): string

stripGenericParams:

• typetraits: stripGenericParams(t: typedesc): typedesc

stripLineEnd:

• strutils: stripLineEnd(s: var string)

strong:

• htmlgen: strong(e: varargs[untyped]): untyped

strVal:

• macros: strVal(n: NimNode): string

strVal=:

• macros: strVal=(n: NimNode; val: string)

StudyError:

• nre: StudyError

Style:

• dom: Style

style:

• htmlgen: style(e: varargs[untyped]): untyped

Style:

• terminal: Style

styleBlink:

• Style.styleBlink

styleBlinkRapid:

• Style.styleBlinkRapid

styleBright:

• Style.styleBright

styledEcho:

• terminal: styledEcho(args: varargs[untyped])

styleDim:

• Style.styleDim

styledWrite:

• terminal: styledWrite(f: File; m: varargs[typed]): untyped

styledWriteLine:

• terminal: styledWriteLine(f: File; args: varargs[untyped])

styleHidden:

• Style.styleHidden

styleItalic:

• Style.styleItalic

styleReverse:

• Style.styleReverse

styleStrikethrough:

• Style.styleStrikethrough

styleUnderscore:

• Style.styleUnderscore

sub:

• htmlgen: sub(e: varargs[untyped]): untyped

submit:

• dom: submit(f: FormElement)

substituteLog:

• logging: substituteLog(frmt: string; level: Level; args: varargs[string, `$`]): string

substitution:

• Module strutils

substr:

• system: substr(s: string; first = 0): string
• system: substr(s: string; first, last: int): string

succ:

• system: succ[T: Ordinal](x: T; y = 1): T

success:

• strscans: success(x: int): bool

suite:

• unittest: suite(name, body)

suiteEnded:

• unittest: suiteEnded(formatter: ConsoleOutputFormatter)
• unittest: suiteEnded(formatter: JUnitOutputFormatter)
• unittest: suiteEnded(formatter: OutputFormatter)

suiteStarted:

• unittest: suiteStarted(formatter: ConsoleOutputFormatter; suiteName: string)
• unittest: suiteStarted(formatter: JUnitOutputFormatter; suiteName: string)
• unittest: suiteStarted(formatter: OutputFormatter; suiteName: string)

sum:

• math: sum[T](x: openArray[T]): T

sumKbn:

• sums: sumKbn[T](x: openArray[T]): T

summary:

• htmlgen: summary(e: varargs[untyped]): untyped

sumPairs:

• sums: sumPairs[T](x: openArray[T]): T

sup:

• htmlgen: sup(e: varargs[untyped]): untyped

super:

• Module system

supportsCopyMem:

• typetraits: supportsCopyMem(t: typedesc): bool

suspend:

• coro: suspend(sleepTime: float = 0)
• osproc: suspend(p: Process)

suspendThread:

• winlean: suspendThread(hThread: Handle): int32

swap:

• system: swap[T](a, b: var T)

swapCase:

• unicode: swapCase(s: string): string

swapEndian16:

• endians: swapEndian16(outp, inp: pointer)

swapEndian32:

• endians: swapEndian32(outp, inp: pointer)

swapEndian64:

• endians: swapEndian64(outp, inp: pointer)

switch:

• nimscript: switch(key: string; val = "")

SwitchToFiber:

• winlean: SwitchToFiber(fiber: pointer)

SW_SHOWNORMAL:

• winlean: SW_SHOWNORMAL

symAddr:

• dynlib: symAddr(lib: LibHandle; name: cstring): pointer

symBodyHash:

• macros: symBodyHash(s: NimNode): string

symbol:

• macros: symbol(n: NimNode): NimSym

symbol=:

• macros: symbol=(n: NimNode; val: NimSym)

symbolName:

• enumutils: symbolName[T: enum](a: T): string

symbolRank:

• enumutils: symbolRank[T: enum](a: T): int

symKind:

• macros: symKind(symbol: NimNode): NimSymKind

symlinkExists:

• os: symlinkExists(link: string): bool

symmetricDifference:

• packedsets: symmetricDifference[A](s1, s2: PackedSet[A]): PackedSet[A]
• sets: symmetricDifference[A](s1, s2: HashSet[A]): HashSet[A]

sync:

• threadpool: sync()

SYNCHRONIZE:

• winlean: SYNCHRONIZE

SyntaxError:

• nre: SyntaxError

system:

• Module osproc

table:

• htmlgen: table(e: varargs[untyped]): untyped
• jsconsole: table(console: Console)

Table:

• tables: Table

TableRef:

• tables: TableRef

tag:

• xmltree: tag(n: XmlNode): lent string

tag=:

• xmltree: tag=(n: XmlNode; tag: sink string)

tagA:

• HtmlTag.tagA

tagAbbr:

• HtmlTag.tagAbbr

tagAcronym:

• HtmlTag.tagAcronym

tagAddress:

• HtmlTag.tagAddress

tagApplet:

• HtmlTag.tagApplet

tagArea:

• HtmlTag.tagArea

tagArticle:

• HtmlTag.tagArticle

tagAside:

• HtmlTag.tagAside

tagAudio:

• HtmlTag.tagAudio

tagB:

• HtmlTag.tagB

tagBase:

• HtmlTag.tagBase

tagBasefont:

• HtmlTag.tagBasefont

tagBdi:

• HtmlTag.tagBdi

tagBdo:

• HtmlTag.tagBdo

tagBig:

• HtmlTag.tagBig

tagBlockquote:

• HtmlTag.tagBlockquote

tagBody:

• HtmlTag.tagBody

tagBr:

• HtmlTag.tagBr

tagButton:

• HtmlTag.tagButton

tagCanvas:

• HtmlTag.tagCanvas

tagCaption:

• HtmlTag.tagCaption

tagCenter:

• HtmlTag.tagCenter

tagCite:

• HtmlTag.tagCite

tagCode:

• HtmlTag.tagCode

tagCol:

• HtmlTag.tagCol

tagColgroup:

• HtmlTag.tagColgroup

tagCommand:

• HtmlTag.tagCommand

tagDatalist:

• HtmlTag.tagDatalist

tagDd:

• HtmlTag.tagDd

tagDel:

• HtmlTag.tagDel

tagDetails:

• HtmlTag.tagDetails

tagDfn:

• HtmlTag.tagDfn

tagDialog:

• HtmlTag.tagDialog

tagDir:

• HtmlTag.tagDir

tagDiv:

• HtmlTag.tagDiv

tagDl:

• HtmlTag.tagDl

tagDt:

• HtmlTag.tagDt

tagEm:

• HtmlTag.tagEm

tagEmbed:

• HtmlTag.tagEmbed

tagFieldset:

• HtmlTag.tagFieldset

tagFigcaption:

• HtmlTag.tagFigcaption

tagFigure:

• HtmlTag.tagFigure

tagFont:

• HtmlTag.tagFont

tagFooter:

• HtmlTag.tagFooter

tagForm:

• HtmlTag.tagForm

tagFrame:

• HtmlTag.tagFrame

tagFrameset:

• HtmlTag.tagFrameset

tagH1:

• HtmlTag.tagH1

tagH2:

• HtmlTag.tagH2

tagH3:

• HtmlTag.tagH3

tagH4:

• HtmlTag.tagH4

tagH5:

• HtmlTag.tagH5

tagH6:

• HtmlTag.tagH6

tagHead:

• HtmlTag.tagHead

tagHeader:

• HtmlTag.tagHeader

tagHgroup:

• HtmlTag.tagHgroup

tagHr:

• HtmlTag.tagHr

tagHtml:

• HtmlTag.tagHtml

tagI:

• HtmlTag.tagI

tagIframe:

• HtmlTag.tagIframe

tagImg:

• HtmlTag.tagImg

tagInput:

• HtmlTag.tagInput

tagIns:

• HtmlTag.tagIns

tagIsindex:

• HtmlTag.tagIsindex

tagKbd:

• HtmlTag.tagKbd

tagKeygen:

• HtmlTag.tagKeygen

tagLabel:

• HtmlTag.tagLabel

tagLegend:

• HtmlTag.tagLegend

tagLi:

• HtmlTag.tagLi

tagLink:

• HtmlTag.tagLink

tagMap:

• HtmlTag.tagMap

tagMark:

• HtmlTag.tagMark

tagMenu:

• HtmlTag.tagMenu

tagMeta:

• HtmlTag.tagMeta

tagMeter:

• HtmlTag.tagMeter

tagNav:

• HtmlTag.tagNav

tagNobr:

• HtmlTag.tagNobr

tagNoframes:

• HtmlTag.tagNoframes

tagNoscript:

• HtmlTag.tagNoscript

tagObject:

• HtmlTag.tagObject

tagOl:

• HtmlTag.tagOl

tagOptgroup:

• HtmlTag.tagOptgroup

tagOption:

• HtmlTag.tagOption

tagOutput:

• HtmlTag.tagOutput

tagP:

• HtmlTag.tagP

tagParam:

• HtmlTag.tagParam

tagPre:

• HtmlTag.tagPre

tagProgress:

• HtmlTag.tagProgress

tagQ:

• HtmlTag.tagQ

tagRp:

• HtmlTag.tagRp

tagRt:

• HtmlTag.tagRt

tagRuby:

• HtmlTag.tagRuby

tagS:

• HtmlTag.tagS

tagSamp:

• HtmlTag.tagSamp

tagScript:

• HtmlTag.tagScript

tagSection:

• HtmlTag.tagSection

tagSelect:

• HtmlTag.tagSelect

tagSmall:

• HtmlTag.tagSmall

tagSource:

• HtmlTag.tagSource

tagSpan:

• HtmlTag.tagSpan

tagStrike:

• HtmlTag.tagStrike

tagStrong:

• HtmlTag.tagStrong

tagStyle:

• HtmlTag.tagStyle

tagSub:

• HtmlTag.tagSub

tagSummary:

• HtmlTag.tagSummary

tagSup:

• HtmlTag.tagSup

tagTable:

• HtmlTag.tagTable

tagTbody:

• HtmlTag.tagTbody

tagTd:

• HtmlTag.tagTd

tagTextarea:

• HtmlTag.tagTextarea

tagTfoot:

• HtmlTag.tagTfoot

tagTh:

• HtmlTag.tagTh

tagThead:

• HtmlTag.tagThead

tagTime:

• HtmlTag.tagTime

tagTitle:

• HtmlTag.tagTitle

tagToStr:

• htmlparser: tagToStr

tagTr:

• HtmlTag.tagTr

tagTrack:

• HtmlTag.tagTrack

tagTt:

• HtmlTag.tagTt

tagU:

• HtmlTag.tagU

tagUl:

• HtmlTag.tagUl

tagUnknown:

• HtmlTag.tagUnknown

tagVar:

• HtmlTag.tagVar

tagVideo:

• HtmlTag.tagVideo

tagWbr:

• HtmlTag.tagWbr

tailDir:

• os: tailDir(path: string): string

TaintedString:

• system: TaintedString

take:

• tables: take[A, B](t: var Table[A, B]; key: A; val: var B): bool
• tables: take[A, B](t: TableRef[A, B]; key: A; val: var B): bool

tan:

• complex: tan[T](z: Complex[T]): Complex[T]
• jscore: tan(m: MathLib; a: SomeNumber): float
• math: tan(x: float32): float32
• math: tan(x: float64): float64

tanh:

• complex: tanh[T](z: Complex[T]): Complex[T]
• jscore: tanh(m: MathLib; a: SomeNumber): float
• math: tanh(x: float32): float32
• math: tanh(x: float64): float64

task:

• nimscript: task(name: untyped; description: string; body: untyped): untyped

Task:

• tasks: Task

TAU:

• math: TAU

tbody:

• htmlgen: tbody(e: varargs[untyped]): untyped

TCP_NODELAY:

• winlean: TCP_NODELAY

td:

• htmlgen: td(e: varargs[untyped]): untyped

tearDownForeignThreadGc:

• system: tearDownForeignThreadGc()

term:

• pegs: term(t: char): Peg
• pegs: term(p: Peg): string
• pegs: term(t: string): Peg

termIgnoreCase:

• pegs: termIgnoreCase(t: string): Peg

termIgnoreStyle:

• pegs: termIgnoreStyle(t: string): Peg

TerminalCmd:

• terminal: TerminalCmd

terminalHeight:

• terminal: terminalHeight(): int

terminalHeightIoctl:

• terminal: terminalHeightIoctl(handles: openArray[Handle]): int

terminalSize:

• terminal: terminalSize(): tuple[w, h: int]

terminalWidth:

• terminal: terminalWidth(): int

terminalWidthIoctl:

• terminal: terminalWidthIoctl(handles: openArray[Handle]): int

terminate:

• osproc: terminate(p: Process)

terminateProcess:

• winlean: terminateProcess(hProcess: Handle; uExitCode: int): WINBOOL

test:

• jsre: test(self: RegExp; pattern: cstring): bool
• unittest: test(name, body)

testAndSet:

• atomics: testAndSet(location: var AtomicFlag; order: MemoryOrder = moSequentiallyConsistent): bool

testBit:

• bitops: testBit[T: SomeInteger](v: T; bit: BitsRange[T]): bool

testEnded:

• unittest: testEnded(formatter: ConsoleOutputFormatter; testResult: TestResult)
• unittest: testEnded(formatter: JUnitOutputFormatter; testResult: TestResult)
• unittest: testEnded(formatter: OutputFormatter; testResult: TestResult)

TestResult:

• unittest: TestResult

testStarted:

• unittest: testStarted(formatter: ConsoleOutputFormatter; testName: string)
• unittest: testStarted(formatter: JUnitOutputFormatter; testName: string)
• unittest: testStarted(formatter: OutputFormatter; testName: string)

TestStatus:

• unittest: TestStatus

text:

• jsfetch: text(self: Response): Future[cstring]
• xmltree: text(n: XmlNode): lent string

text=:

• xmltree: text=(n: XmlNode; text: sink string)

textarea:

• htmlgen: textarea(e: varargs[untyped]): untyped

TextAreaElement:

• dom: TextAreaElement

TextNode:

• NodeType.TextNode

TFdSet:

• winlean: TFdSet

Tfenv:

• fenv: Tfenv

Tfexcept:

• fenv: Tfexcept

tfoot:

• htmlgen: tfoot(e: varargs[untyped]): untyped

TFrame:

• system: TFrame

th:

• htmlgen: th(e: varargs[untyped]): untyped

thead:

• htmlgen: thead(e: varargs[untyped]): untyped

then:

• asyncjs: then[T](future: Future[T]; onSuccess: proc; onReject: OnReject = nil): auto

thisDir:

• nimscript: thisDir(): string

Thread:

• threads: Thread

ThreadId:

• threadpool: ThreadId

ThreadPoolAdvice:

• cpuload: ThreadPoolAdvice

ThreadPoolState:

• cpuload: ThreadPoolState

ticks:

• monotimes: ticks(t: MonoTime): int64

time:

• htmlgen: time(e: varargs[untyped]): untyped
• jsconsole: time(console: Console; label = "".cstring)

Time:

• times: Time
• time_t: Time

TimeEffect:

• system: TimeEffect

timeEnd:

• jsconsole: timeEnd(console: Console; label = "".cstring)

TimeFormat:

• times: TimeFormat

TimeFormatParseError:

• times: TimeFormatParseError

TimeInterval:

• times: TimeInterval

TimeIntervalParts:

• times: TimeIntervalParts

timeLog:

• jsconsole: timeLog(console: Console; label = "".cstring)

TimeOut:

• dom: TimeOut

TimeoutError:

• net: TimeoutError

TimeParseError:

• times: TimeParseError

timeStamp:

• jsconsole: timeStamp(console: Console; label: cstring)

TimeUnit:

• times: TimeUnit

Timeval:

• winlean: Timeval

Timezone:

• times: Timezone

timezone:

• times: timezone(dt: DateTime): Timezone

timezone=:

• times: timezone=(dt: var DateTime; value: Timezone)

title:

• htmlgen: title(e: varargs[untyped]): untyped
• unicode: title(s: string): string

tkBracketLe:

• TokKind.tkBracketLe

tkBracketRi:

• TokKind.tkBracketRi

tkColon:

• TokKind.tkColon

tkComma:

• TokKind.tkComma

tkCurlyLe:

• TokKind.tkCurlyLe

tkCurlyRi:

• TokKind.tkCurlyRi

tkEof:

• TokKind.tkEof

tkError:

• TokKind.tkError

tkFalse:

• TokKind.tkFalse

tkFloat:

• TokKind.tkFloat

tkInt:

• TokKind.tkInt

tkNull:

• TokKind.tkNull

tkString:

• TokKind.tkString

tkTrue:

• TokKind.tkTrue

TLineInfo:

• rstast: TLineInfo

TNimSymKinds:

• macros: TNimSymKinds

TNimTypeKinds:

• macros: TNimTypeKinds

to:

• jsffi: to(x: JsObject; T: typedesc): T:type
• json: to[T](node: JsonNode; t: typedesc[T]): T
• marshal: to[T](data: string): T

toAny:

• typeinfo: toAny[T](x: var T): Any

toBiggestFloat:

• system: toBiggestFloat(i: BiggestInt): BiggestFloat

toBiggestInt:

• system: toBiggestInt(f: BiggestFloat): BiggestInt

toBin:

• strutils: toBin(x: BiggestInt; len: Positive): string

toCInt:

• net: toCInt(opt: SOBool): cint

toCountTable:

• tables: toCountTable[A](keys: openArray[A]): CountTable[A]

toCritBitTree:

• critbits: toCritBitTree[T](pairs: openArray[(string, T)]): CritBitTree[T]
• critbits: toCritBitTree(items: openArray[string]): CritBitTree[void]

toCstring:

• jsbigints: toCstring(this: JsBigInt): cstring
• jsbigints: toCstring(this: JsBigInt; radix: 2 .. 36): cstring
• jsfetch: toCstring(self: Request | Response | Body | FetchOptions): cstring
• jsformdata: toCstring(self: FormData): cstring
• jsheaders: toCstring(self: Headers): cstring
• jsre: toCstring(self: RegExp): cstring

toDeque:

• deques: toDeque[T](x: openArray[T]): Deque[T]

toDll:

• nimscript: toDll(filename: string): string

toDoublyLinkedList:

• lists: toDoublyLinkedList[T](elems: openArray[T]): DoublyLinkedList[T]

toExe:

• nimscript: toExe(filename: string): string

toFILETIME:

• winlean: toFILETIME(t: int64): FILETIME

toFloat:

• rationals: toFloat[T](x: Rational[T]): float
• system: toFloat(i: int): float

toggle:

• dom: toggle(c: ClassList; class: cstring)

toHashSet:

• sets: toHashSet[A](keys: openArray[A]): HashSet[A]

toHeapQueue:

• heapqueue: toHeapQueue[T](x: openArray[T]): HeapQueue[T]

toHex:

• strutils: toHex(s: string): string
• strutils: toHex[T: SomeInteger](x: T): string
• strutils: toHex[T: SomeInteger](x: T; len: Positive): string

toInt:

• nativesockets: toInt(domain: Domain): cint
• nativesockets: toInt(p: Protocol): cint
• nativesockets: toInt(typ: SockType): cint
• rationals: toInt[T](x: Rational[T]): int
• system: toInt(f: float): int

toIntSet:

• intsets: toIntSet(x: openArray[int]): IntSet

toJs:

• jsffi: toJs[T](val: T): JsObject
• jsffi: toJs(s: string): JsObject

toJsKey:

• jsffi: toJsKey(text: cstring; t: type cstring): cstring
• jsffi: toJsKey[T: SomeInteger](text: cstring; t: type T): T
• jsffi: toJsKey[T: enum](text: cstring; t: type T): T
• jsffi: toJsKey[T: SomeFloat](text: cstring; t: type T): T

toJson:

• jsonutils: toJson[T](a: T; opt = initToJsonOptions()): JsonNode

toJsonHook:

• jsonutils: toJsonHook[K: string | cstring; V](t: (Table[K, V] | OrderedTable[K, V])): JsonNode
• jsonutils: toJsonHook[T](self: Option[T]): JsonNode
• jsonutils: toJsonHook[A](s: SomeSet[A]): JsonNode
• jsonutils: toJsonHook(a: StringTableRef): JsonNode

ToJsonOptions:

• jsonutils: ToJsonOptions

TokenClass:

• highlite: TokenClass

tokenClassToStr:

• highlite: tokenClassToStr

tokenize:

• highlite: tokenize(text: string; lang: SourceLanguage): seq[(string, TokenClass)]
• strutils: tokenize(s: string; seps: set[char] = Whitespace): tuple[token: string, isSep: bool]

TokKind:

• parsejson: TokKind

toKnownDomain:

• nativesockets: toKnownDomain(family: cint): Option[Domain]

toLocation:

• miscdollars: toLocation(result: var string; file: string | cstring; line: int; col: int)

toLower:

• unicode: toLower(c: Rune): Rune
• unicode: toLower(s: string): string

toLowerAscii:

• strimpl: toLowerAscii(c: char): char
• strutils: toLowerAscii(c: char): char
• strutils: toLowerAscii(s: string): string

toMask:

• bitops: toMask[T: SomeInteger](slice: Slice[int]): T

toMD5:

• md5: toMD5(s: string): MD5Digest

toNimIdent:

• macros: toNimIdent(s: string): NimIdent

toNumber:

• jsbigints: toNumber(this: JsBigInt): BiggestInt

toOct:

• strutils: toOct(x: BiggestInt; len: Positive): string

toOctal:

• strutils: toOctal(c: char): string

ToolBar:

• dom: ToolBar

toOpenArray:

• system: toOpenArray[I, T](x: array[I, T]; first, last: I): openArray[T]
• system: toOpenArray(x: cstring; first, last: int): openArray[char]
• system: toOpenArray[T](x: openArray[T]; first, last: int): openArray[T]
• system: toOpenArray[T](x: ptr UncheckedArray[T]; first, last: int): openArray[T]
• system: toOpenArray[T](x: seq[T]; first, last: int): openArray[T]
• system: toOpenArray(x: string; first, last: int): openArray[char]

toOpenArrayByte:

• system: toOpenArrayByte(x: cstring; first, last: int): openArray[byte]
• system: toOpenArrayByte(x: openArray[char]; first, last: int): openArray[byte]
• system: toOpenArrayByte(x: seq[char]; first, last: int): openArray[byte]
• system: toOpenArrayByte(x: string; first, last: int): openArray[byte]

toOrderedSet:

• sets: toOrderedSet[A](keys: openArray[A]): OrderedSet[A]

toOrderedTable:

• tables: toOrderedTable[A, B](pairs: openArray[(A, B)]): OrderedTable[A, B]

toOSFlags:

• net: toOSFlags(socketFlags: set[SocketFlag]): cint

toPackedSet:

• packedsets: toPackedSet[A](x: openArray[A]): PackedSet[A]

toParts:

• times: toParts(dur: Duration): DurationParts
• times: toParts(ti: TimeInterval): TimeIntervalParts

toRational:

• rationals: toRational(x: float; n: int = high(int) shr 32): Rational[int]
• rationals: toRational[T: SomeInteger](x: T): Rational[T]

toRunes:

• unicode: toRunes(s: string): seq[Rune]

toSeq:

• nre: toSeq(pattern: CaptureBounds; default = none(HSlice[int, int])): seq[ Option[HSlice[int, int]]]
• nre: toSeq(pattern: Captures; default: Option[string] = none(string)): seq[ Option[string]]
• sequtils: toSeq(iter: untyped): untyped

toSet:

• sets: toSet[A](keys: openArray[A]): HashSet[A]
• setutils: toSet(iter: untyped): untyped

toSinglyLinkedList:

• lists: toSinglyLinkedList[T](elems: openArray[T]): SinglyLinkedList[T]

toSockAddr:

• net: toSockAddr(address: IpAddress; port: Port; sa: var Sockaddr_storage; sl: var SockLen)

toSockType:

• nativesockets: toSockType(protocol: Protocol): SockType

toString:

• Module dollars
• dom: toString(s: Selection): cstring
• httpcore: toString(values: HttpHeaderValues): string
• jscore: toString(d: DateTime): cstring
• jsre: toString(self: RegExp): cstring

toStrLit:

• macros: toStrLit(n: NimNode): NimNode

toTable:

• nre: toTable(pattern: CaptureBounds): Table[string, HSlice[int, int]]
• nre: toTable(pattern: Captures): Table[string, string]
• tables: toTable[A, B](pairs: openArray[(A, B)]): Table[A, B]

toTask:

• tasks: toTask(e: typed{nkCall | nkInfix | nkPrefix | nkPostfix | nkCommand | nkCallStrLit}): Task

toTime:

• times: toTime(dt: DateTime): Time

toTitle:

• unicode: toTitle(c: Rune): Rune

toU16:

• system: toU16(x: int): int16

toU32:

• system: toU32(x: int64): int32

toU8:

• system: toU8(x: int): int8

Touch:

• dom: Touch

TouchEvent:

• dom: TouchEvent

TouchList:

• dom: TouchList

toUgly:

• json: toUgly(result: var string; node: JsonNode)

toUnix:

• times: toUnix(t: Time): int64

toUnixFloat:

• times: toUnixFloat(t: Time): float

toUnsigned:

• bitops_utils: toUnsigned(x: int): uint
• bitops_utils: toUnsigned(x: int16): uint16
• bitops_utils: toUnsigned(x: int32): uint32
• bitops_utils: toUnsigned(x: int64): uint64
• bitops_utils: toUnsigned(x: int8): uint8

toUpper:

• unicode: toUpper(c: Rune): Rune
• unicode: toUpper(s: string): string

toUpperAscii:

• strutils: toUpperAscii(c: char): char
• strutils: toUpperAscii(s: string): string

toUTF8:

• unicode: toUTF8(c: Rune): string

toWinTime:

• times: toWinTime(t: Time): int64

toXmlAttributes:

• xmltree: toXmlAttributes(keyValuePairs: varargs[tuple[key, val: string]]): XmlAttributes

tr:

• htmlgen: tr(e: varargs[untyped]): untyped

trace:

• jsconsole: trace(console: Console)
• Module system

track:

• htmlgen: track(e: varargs[untyped]): untyped

trailingZeros2Digits:

• digitsutils: trailingZeros2Digits(digits: uint32): int32

transformFile:

• pegs: transformFile(infile, outfile: string; subs: varargs[tuple[pattern: Peg, repl: string]])
• re: transformFile(infile, outfile: string; subs: openArray[tuple[pattern: Regex, repl: string]])

translate:

• unicode: translate(s: string; replacements: proc (key: string): string): string

treeRepr:

• macros: treeRepr(n: NimNode): string
• parsesql: treeRepr(s: SqlNode): string
• rstast: treeRepr(node: PRstNode; indent = 0): string

trigger:

• asyncdispatch: trigger(ev: AsyncEvent)
• selectors: trigger(ev: SelectEvent)

trimZeros:

• strutils: trimZeros(x: var string; decimalSep = '.')

trunc:

• jscore: trunc(m: MathLib; f: SomeFloat): int
• math: trunc(x: float32): float32
• math: trunc(x: float64): float64

tryAcquire:

• locks: tryAcquire(lock: var Lock): bool
• rlocks: tryAcquire(lock: var RLock): bool

tryExec:

• db_mysql: tryExec(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): bool
• db_odbc: tryExec(db: var DbConn; query: SqlQuery; args: varargs[string, `$`]): bool
• db_postgres: tryExec(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): bool
• db_postgres: tryExec(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): bool
• db_sqlite: tryExec(db: DbConn; stmtName: SqlPrepared): bool
• db_sqlite: tryExec(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): bool

tryInsert:

• db_mysql: tryInsert(db: DbConn; query: SqlQuery; pkName: string; args: varargs[string, `$`]): int64
• db_odbc: tryInsert(db: var DbConn; query: SqlQuery; pkName: string; args: varargs[string, `$`]): int64
• db_postgres: tryInsert(db: DbConn; query: SqlQuery; pkName: string; args: varargs[string, `$`]): int64
• db_sqlite: tryInsert(db: DbConn; query: SqlQuery; pkName: string; args: varargs[string, `$`]): int64

tryInsertId:

• db_mysql: tryInsertId(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
• db_odbc: tryInsertId(db: var DbConn; query: SqlQuery; args: varargs[string, `$`]): int64

tryInsertID:

• db_postgres: tryInsertID(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
• db_sqlite: tryInsertID(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64

tryRecv:

• channels_builtin: tryRecv*[TMsg](c: var Channel[TMsg]): tuple[dataAvailable: bool, msg: TMsg]

tryRemoveFile:

• os: tryRemoveFile(file: string): bool

trySend:

• channels_builtin: trySend*[TMsg](c: var Channel[TMsg]; msg: sink TMsg): bool
• net: trySend(socket: Socket; data: string): bool

tt:

• htmlgen: tt(e: varargs[untyped]): untyped

tupleLen:

• typetraits: tupleLen(T: typedesc[tuple]): int
• typetraits: tupleLen(t: tuple): int

TWSABuf:

• winlean: TWSABuf

type:

• Module macros
• Module macros
• Module macros

typed:

• system: typed

typedesc:

• system: typedesc

typeKind:

• macros: typeKind(n: NimNode): NimTypeKind

typeof:

• system: typeof(x: untyped; mode = typeOfIter): typedesc

typeOfIter:

• TypeOfMode.typeOfIter

TypeOfMode:

• system: TypeOfMode

typeOfProc:

• TypeOfMode.typeOfProc

u:

• htmlgen: u(e: varargs[untyped]): untyped

UIEvent:

• dom: UIEvent

uint:

• system: uint

uint16:

• system: uint16

uint32:

• system: uint32

Uint32Array:

• jsutils: Uint32Array

uint64:

• system: uint64

uint8:

• system: uint8

Uint8Array:

• jsutils: Uint8Array

ul:

• htmlgen: ul(e: varargs[untyped]): untyped

ULONG:

• winlean: ULONG

ULONG_PTR:

• winlean: ULONG_PTR

Uname:

• posix_utils: Uname

uname:

• posix_utils: uname(): Uname

UncheckedArray:

• system: UncheckedArray

underscoredCalls:

• underscored_calls: underscoredCalls(result, calls, arg0: NimNode)

unescape:

• dom: unescape(uri: cstring): cstring
• strutils: unescape(s: string; prefix = "\""; suffix = "\""): string

unhandledExceptionHook:

• system: unhandledExceptionHook

unicodeLetter:

• pegs: unicodeLetter(): Peg

unicodeLower:

• pegs: unicodeLower(): Peg

unicodeTitle:

• pegs: unicodeTitle(): Peg

unicodeUpper:

• pegs: unicodeUpper(): Peg

unicodeWhitespace:

• pegs: unicodeWhitespace(): Peg

unidecode:

• unidecode: unidecode(s: string): string

unindent:

• strutils: unindent(s: string; count: Natural = int.high; padding: string = " "): string

union:

• packedsets: union[A](s1, s2: PackedSet[A]): PackedSet[A]
• sets: union[A](s1, s2: HashSet[A]): HashSet[A]

unixToNativePath:

• os: unixToNativePath(path: string; drive = ""): string

unlikely:

• system: unlikely(val: bool): bool

unlink:

• chains: unlink(header, node)

unloadLib:

• dynlib: unloadLib(lib: LibHandle)

unmapMem:

• memfiles: unmapMem(f: var MemFile; p: pointer; size: int)

unmapViewOfFile:

• winlean: unmapViewOfFile(lpBaseAddress: pointer): WINBOOL

Unmarshals:

• Module json

unown:

• system: unown(x: typed): untyped

UnpackDefect:

• options: UnpackDefect

UnpackError:

• options: UnpackError

unpackInfix:

• macros: unpackInfix(node: NimNode): tuple[left: NimNode, op: string, right: NimNode]

unpackPostfix:

• macros: unpackPostfix(node: NimNode): tuple[node: NimNode, op: string]

unpackPrefix:

• macros: unpackPrefix(node: NimNode): tuple[node: NimNode, op: string]

unpackVarargs:

• macros: unpackVarargs(callee: untyped; args: varargs[untyped]): untyped

unregister:

• asyncdispatch: unregister(ev: AsyncEvent)
• asyncdispatch: unregister(fd: AsyncFD)
• selectors: unregister[T](s: Selector[T]; fd: int | SocketHandle | cint)
• selectors: unregister[T](s: Selector[T]; ev: SelectEvent)

unregisterWait:

• winlean: unregisterWait(WaitHandle: Handle): DWORD

unsafeAddr:

• system: unsafeAddr[T](x: T): ptr T

unsafeColumnAt:

• db_mysql: unsafeColumnAt(row: InstantRow; index: int): cstring
• db_odbc: unsafeColumnAt(row: InstantRow; index: int): cstring
• db_postgres: unsafeColumnAt(row: InstantRow; index: int): cstring
• db_sqlite: unsafeColumnAt(row: InstantRow; index: int32): cstring

unsafeGet:

• options: unsafeGet[T](self: Option[T]): lent T

unsafeIsolate:

• isolation: unsafeIsolate[T](value: sink T): Isolated[T]

unsafeNew:

• system: unsafeNew[T](a: var ref T; size: Natural)

unsafeNewFetchOptions:

• jsfetch: unsafeNewFetchOptions(metod, body, mode, credentials, cache, referrerPolicy: cstring; keepalive: bool; redirect = "follow".cstring; referrer = "client".cstring; integrity = "".cstring): FetchOptions

unsafeRead:

• threadpool: unsafeRead[T](fv: FlowVar[ref T]): ptr T

unsetControlCHook:

• system: unsetControlCHook()

untyped:

• system: untyped

unzip:

• sequtils: unzip[S, T](s: openArray[(S, T)]): (seq[S], seq[T])

update:

• sha1: update(ctx: var Sha1State; data: openArray[char])

updateHandle:

• selectors: updateHandle[T](s: Selector[T]; fd: int | SocketHandle; events: set[Event])

upperBound:

• algorithm: upperBound[T, K](a: openArray[T]; key: K; cmp: proc (x: T; k: K): int {.closure.}): int
• algorithm: upperBound[T](a: openArray[T]; key: T): int

urandom:

• sysrand: urandom(size: Natural): seq[byte]
• sysrand: urandom(dest: var openArray[byte]): bool

Uri:

• uri: Uri

UriParseError:

• uri: UriParseError

uriParseError:

• uri: uriParseError(msg: string)

Url:

• uri: Url

useEmpty:

• FormatFlag.useEmpty

useEnvironment:

• FormatFlag.useEnvironment

useKey:

• FormatFlag.useKey

useRealtimeGC:

• Soft real-time support

useWinUnicode:

• winlean: useWinUnicode

UTC:

• jscore: UTC(d: DateLib): int

utc:

• times: utc(): Timezone
• times: utc(dt: DateTime): DateTime
• times: utc(t: Time): DateTime

utcOffset:

• times: utcOffset(dt: DateTime): int

utcOffset=:

• times: utcOffset=(dt: var DateTime; value: int)

Utf16Char:

• widestrs: Utf16Char

utf8:

• unicode: utf8(s: string): string

utoa2Digits:

• digitsutils: utoa2Digits(buf: var openArray[char]; pos: int; digits: uint32)

validateData:

• cgi: validateData(data: StringTableRef; validKeys: varargs[string])

validateUtf8:

• unicode: validateUtf8(s: string): int

validIdentifier:

• strutils: validIdentifier(s: string): bool

ValidityState:

• dom: ValidityState

value:

• dom: value(n: Node): cstring
• macrocache: value(c: CacheCounter): int

value=:

• dom: value=(n: Node; v: cstring)

ValueError:

• system: ValueError

values:

• critbits: values[T](c: CritBitTree[T]): T
• jsformdata: values(self: FormData): seq[cstring]
• jsheaders: values(self: Headers): seq[cstring]
• strtabs: values(t: StringTableRef): string
• tables: values[A](t: CountTable[A]): int
• tables: values[A](t: CountTableRef[A]): int
• tables: values[A, B](t: OrderedTable[A, B]): lent B
• tables: values[A, B](t: OrderedTableRef[A, B]): lent B
• tables: values[A, B](t: Table[A, B]): lent B
• tables: values[A, B](t: TableRef[A, B]): lent B

valuesWithPrefix:

• critbits: valuesWithPrefix[T](c: CritBitTree[T]; prefix: string): T

varargs:

• system: varargs

varargsLen:

• system: varargsLen(x: varargs[untyped]): int

variance:

• stats: variance[T](x: openArray[T]): float
• stats: variance(s: RunningStat): float

varianceS:

• stats: varianceS[T](x: openArray[T]): float
• stats: varianceS(s: RunningStat): float

verboseFmtStr:

• logging: verboseFmtStr

version:

• nimscript: version

vibrate:

• dom: vibrate(self: Navigator; pattern: cint): bool
• dom: vibrate(self: Navigator; pattern: openArray[cint]): bool

video:

• htmlgen: video(e: varargs[untyped]): untyped

vmTrace:

• vmutils: vmTrace(on: bool)

void:

• system: void

volatileLoad:

• volatile: volatileLoad[T](src: ptr T): T

volatileStore:

• volatile: volatileStore[T](dest: ptr T; val: T)

wait:

• coro: wait(c: CoroutineRef; interval = 0.01)
• locks: wait(cond: var Cond; lock: var Lock)

WAIT_FAILED:

• winlean: WAIT_FAILED

waitFor:

• asyncdispatch: waitFor[T](fut: Future[T]): T

waitForExit:

• osproc: waitForExit(p: Process; timeout: int = -1): int

waitForMultipleObjects:

• winlean: waitForMultipleObjects(nCount: DWORD; lpHandles: PWOHandleArray; bWaitAll: WINBOOL; dwMilliseconds: DWORD): DWORD

waitForSingleObject:

• winlean: waitForSingleObject(hHandle: Handle; dwMilliseconds: int32): int32

WAIT_OBJECT_0:

• winlean: WAIT_OBJECT_0

WAITORTIMERCALLBACK:

• winlean: WAITORTIMERCALLBACK

WAIT_TIMEOUT:

• winlean: WAIT_TIMEOUT

walkDir:

• os: walkDir(dir: string; relative = false; checkDir = false): tuple[ kind: PathComponent, path: string]

walkDirRec:

• os: walkDirRec(dir: string; yieldFilter = {pcFile}; followFilter = {pcDir}; relative = false; checkDir = false): string

walkDirRecFilter:

• globs: walkDirRecFilter(dir: string; follow: proc (entry: PathEntry): bool = nil; relative = false; checkDir = true): PathEntry

walkDirs:

• os: walkDirs(pattern: string): string

walkFiles:

• os: walkFiles(pattern: string): string

walkPattern:

• os: walkPattern(pattern: string): string

warn:

• jsconsole: warn(console: Console)
• logging: warn(args: varargs[string, `$`])

warning:

• macros: warning(msg: string; n: NimNode = nil)
• nimscript: warning(name: string; val: bool)

warningStr:

• parsecfg: warningStr(c: CfgParser; msg: string): string

wasMoved:

• system: wasMoved[T](obj: var T)

wbr:

• htmlgen: wbr(e: varargs[untyped]): untyped

WeekDay:

• times: WeekDay

weekday:

• times: weekday(dt: DateTime): WeekDay

weekday=:

• times: weekday=(dt: var DateTime; value: WeekDay)

Weeks:

• TimeUnit.Weeks

weeks:

• times: weeks(w: int): TimeInterval

whitespace:

• pegs: whitespace(): Peg

Whitespace:

• strutils: Whitespace

WideCString:

• widestrs: WideCString

WideCStringObj:

• widestrs: WideCStringObj

WIN32_FIND_DATA:

• winlean: WIN32_FIND_DATA

WINBOOL:

• winlean: WINBOOL

WinChar:

• winlean: WinChar

Window:

• dom: Window

window:

• dom: window

WinSizeT:

• winlean: WinSizeT

with:

• with: with(arg: typed; calls: varargs[untyped]): untyped

withData:

• selectors: withData[T](s: Selector[T]; fd: SocketHandle | int; value, body: untyped)
• selectors: withData[T](s: Selector[T]; fd: SocketHandle | int; value, body1, body2: untyped)

withDir:

• nimscript: withDir(dir: string; body: untyped): untyped

withKey:

• sharedtables: withKey[A, B](t: var SharedTable[A, B]; key: A; mapper: proc (key: A; val: var B; pairExists: var bool))

withLock:

• locks: withLock(a: Lock; body: untyped)

withRLock:

• rlocks: withRLock(lock: RLock; code: untyped)

withTimeout:

• asyncdispatch: withTimeout[T](fut: Future[T]; timeout: int): owned(Future[bool])

withValue:

• sharedtables: withValue[A, B](t: var SharedTable[A, B]; key: A; value, body: untyped)
• sharedtables: withValue[A, B](t: var SharedTable[A, B]; key: A; value, body1, body2: untyped)
• tables: withValue[A, B](t: var Table[A, B]; key: A; value, body: untyped)
• tables: withValue[A, B](t: var Table[A, B]; key: A; value, body1, body2: untyped)

WOHandleArray:

• winlean: WOHandleArray

wrapConnectedSocket:

• asyncnet: wrapConnectedSocket(ctx: SslContext; socket: AsyncSocket; handshake: SslHandshakeType; hostname: string = "")
• net: wrapConnectedSocket(ctx: SslContext; socket: Socket; handshake: SslHandshakeType; hostname: string = "")

wrapSocket:

• asyncnet: wrapSocket(ctx: SslContext; socket: AsyncSocket)
• net: wrapSocket(ctx: SslContext; socket: Socket)

wrapToInt:

• jsbigints: wrapToInt(this: JsBigInt; bits: Natural): JsBigInt

wrapToUint:

• jsbigints: wrapToUint(this: JsBigInt; bits: Natural): JsBigInt

wrapWords:

• wordwrap: wrapWords(s: string; maxLineWidth = 80; splitLongWords = true; seps: set[char] = Whitespace; newLine = " "): string

write:

• asyncfile: write(f: AsyncFile; data: string): Future[void]
• asyncstreams: write[T](future: FutureStream[T]; value: T): Future[void]
• dom: write(d: Document; text: cstring)
• io: write(f: File; r: BiggestFloat)
• io: write(f: File; i: BiggestInt)
• io: write(f: File; b: bool)
• io: write(f: File; c: char)
• io: write(f: File; c: cstring)
• io: write(f: File; r: float32)
• io: write(f: File; i: int)
• io: write(f: File; s: string)
• io: write(f: File; a: varargs[string, `$`])
• ropes: write(f: File; r: Rope)
• ropes: write(s: Stream; r: Rope)
• streams: write(s: Stream; x: string)
• streams: write[T](s: Stream; x: T)
• streams: write(s: Stream; args: varargs[string, `$`])

writeBuffer:

• asyncfile: writeBuffer(f: AsyncFile; buf: pointer; size: int): Future[void]
• io: writeBuffer(f: File; buffer: pointer; len: Natural): int

writeBytes:

• io: writeBytes(f: File; a: openArray[int8 | uint8]; start, len: Natural): int

writeChars:

• io: writeChars(f: File; a: openArray[char]; start, len: Natural): int

writeConfig:

• parsecfg: writeConfig(dict: Config; stream: Stream)
• parsecfg: writeConfig(dict: Config; filename: string)

writeContentType:

• cgi: writeContentType()

writeData:

• streams: writeData(s: Stream; buffer: pointer; bufLen: int)

WriteDbEffect:

• db_common: WriteDbEffect

WriteDirEffect:

• os: WriteDirEffect

WriteEnvEffect:

• os: WriteEnvEffect

writeErrorMessage:

• cgi: writeErrorMessage(data: string)

writeFile:

• io: writeFile(filename: string; content: openArray[byte])
• io: writeFile(filename, content: string)
• winlean: writeFile(hFile: Handle; buffer: pointer; nNumberOfBytesToWrite: int32; lpNumberOfBytesWritten: ptr int32; lpOverlapped: pointer): WINBOOL

writeFromStream:

• asyncfile: writeFromStream(f: AsyncFile; fs: FutureStream[string]): owned(Future[void])

writeIndexFile:

• rstgen: writeIndexFile(g: var RstGenerator; outfile: string)

WriteIOEffect:

• system: WriteIOEffect

writeLine:

• io: writeLine[Ty](f: File; x: varargs[Ty, `$`])
• streams: writeLine(s: Stream; args: varargs[string, `$`])

writeln:

• dom: writeln(d: Document; text: cstring)

WriteSocketStream:

• socketstreams: WriteSocketStream

WriteSocketStreamObj:

• socketstreams: WriteSocketStreamObj

writeStackTrace:

• system: writeStackTrace()

writeStyled:

• terminal: writeStyled(txt: string; style: set[Style] = {styleBright})

writeVu64:

• varints: writeVu64(z: var openArray[byte]; x: uint64): int

wsaCloseEvent:

• winlean: wsaCloseEvent(hEvent: Handle): bool

wsaCreateEvent:

• winlean: wsaCreateEvent(): Handle

WSAData:

• winlean: WSAData

WSADESCRIPTION_LEN:

• winlean: WSADESCRIPTION_LEN

WSAEADDRINUSE:

• winlean: WSAEADDRINUSE

WSAECONNABORTED:

• winlean: WSAECONNABORTED

WSAECONNRESET:

• winlean: WSAECONNRESET

WSAEDISCON:

• winlean: WSAEDISCON

WSAEINPROGRESS:

• winlean: WSAEINPROGRESS

WSAEINTR:

• winlean: WSAEINTR

WSAENETRESET:

• winlean: WSAENETRESET

WSAENOTSOCK:

• winlean: WSAENOTSOCK

WSAESHUTDOWN:

• winlean: WSAESHUTDOWN

WSAETIMEDOUT:

• winlean: WSAETIMEDOUT

wsaEventSelect:

• winlean: wsaEventSelect(s: SocketHandle; hEventObject: Handle; lNetworkEvents: clong): cint

WSAEWOULDBLOCK:

• winlean: WSAEWOULDBLOCK

wsaGetLastError:

• winlean: wsaGetLastError(): cint

WSAID_ACCEPTEX:

• winlean: WSAID_ACCEPTEX

WSAID_CONNECTEX:

• winlean: WSAID_CONNECTEX

WSAID_GETACCEPTEXSOCKADDRS:

• winlean: WSAID_GETACCEPTEXSOCKADDRS

WSAIoctl:

• winlean: WSAIoctl(s: SocketHandle; dwIoControlCode: DWORD; lpvInBuffer: pointer; cbInBuffer: DWORD; lpvOutBuffer: pointer; cbOutBuffer: DWORD; lpcbBytesReturned: PDWORD; lpOverlapped: POVERLAPPED; lpCompletionRoutine: POVERLAPPED_COMPLETION_ROUTINE): cint

WSAIORW:

• winlean: WSAIORW(x, y): untyped

WSANOTINITIALISED:

• winlean: WSANOTINITIALISED

WSAPROC_ACCEPTEX:

• winlean: WSAPROC_ACCEPTEX

WSAPROC_CONNECTEX:

• winlean: WSAPROC_CONNECTEX

WSAPROC_GETACCEPTEXSOCKADDRS:

• winlean: WSAPROC_GETACCEPTEXSOCKADDRS

WSARecv:

• winlean: WSARecv(s: SocketHandle; buf: ptr TWSABuf; bufCount: DWORD; bytesReceived, flags: PDWORD; lpOverlapped: POVERLAPPED; completionProc: POVERLAPPED_COMPLETION_ROUTINE): cint

WSARecvFrom:

• winlean: WSARecvFrom(s: SocketHandle; buf: ptr TWSABuf; bufCount: DWORD; bytesReceived: PDWORD; flags: PDWORD; name: ptr SockAddr; namelen: ptr cint; lpOverlapped: POVERLAPPED; completionProc: POVERLAPPED_COMPLETION_ROUTINE): cint

wsaResetEvent:

• winlean: wsaResetEvent(hEvent: Handle): bool

WSASend:

• winlean: WSASend(s: SocketHandle; buf: ptr TWSABuf; bufCount: DWORD; bytesSent: PDWORD; flags: DWORD; lpOverlapped: POVERLAPPED; completionProc: POVERLAPPED_COMPLETION_ROUTINE): cint

WSASendTo:

• winlean: WSASendTo(s: SocketHandle; buf: ptr TWSABuf; bufCount: DWORD; bytesSent: PDWORD; flags: DWORD; name: ptr SockAddr; namelen: cint; lpOverlapped: POVERLAPPED; completionProc: POVERLAPPED_COMPLETION_ROUTINE): cint

wsaStartup:

• winlean: wsaStartup(wVersionRequired: int16; WSData: ptr WSAData): cint

WSASYS_STATUS_LEN:

• winlean: WSASYS_STATUS_LEN

WT_EXECUTEDEFAULT:

• winlean: WT_EXECUTEDEFAULT

WT_EXECUTEINIOTHREAD:

• winlean: WT_EXECUTEINIOTHREAD

WT_EXECUTEINPERSISTENTIOTHREAD:

• winlean: WT_EXECUTEINPERSISTENTIOTHREAD

WT_EXECUTEINPERSISTENTTHREAD:

• winlean: WT_EXECUTEINPERSISTENTTHREAD

WT_EXECUTEINTIMERTHREAD:

• winlean: WT_EXECUTEINTIMERTHREAD

WT_EXECUTEINUITHREAD:

• winlean: WT_EXECUTEINUITHREAD

WT_EXECUTEINWAITTHREAD:

• winlean: WT_EXECUTEINWAITTHREAD

WT_EXECUTELONGFUNCTION:

• winlean: WT_EXECUTELONGFUNCTION

WT_EXECUTEONLYONCE:

• winlean: WT_EXECUTEONLYONCE

WT_TRANSFER_IMPERSONATION:

• winlean: WT_TRANSFER_IMPERSONATION

XML:

• Module htmlgen
• Module parsexml

xmlAttribute:

• XmlEventKind.xmlAttribute

XmlAttributes:

• xmltree: XmlAttributes

xmlCData:

• XmlEventKind.xmlCData

xmlCharData:

• XmlEventKind.xmlCharData

xmlCheckedTag:

• htmlgen: xmlCheckedTag(argsList: NimNode; tag: string; optAttr = ""; reqAttr = ""; isLeaf = false): NimNode

xmlComment:

• XmlEventKind.xmlComment

xmlElementClose:

• XmlEventKind.xmlElementClose

xmlElementEnd:

• XmlEventKind.xmlElementEnd

xmlElementOpen:

• XmlEventKind.xmlElementOpen

xmlElementStart:

• XmlEventKind.xmlElementStart

xmlEncode:

• cgi: xmlEncode(s: string): string

xmlEntity:

• XmlEventKind.xmlEntity

xmlEof:

• XmlEventKind.xmlEof

xmlError:

• XmlEventKind.xmlError

XmlError:

• xmlparser: XmlError

XmlErrorKind:

• parsexml: XmlErrorKind

XmlEventKind:

• parsexml: XmlEventKind

xmlHeader:

• xmltree: xmlHeader

XmlNode:

• xmltree: XmlNode

XmlNodeKind:

• xmltree: XmlNodeKind

XmlParseOption:

• parsexml: XmlParseOption

XmlParser:

• parsexml: XmlParser

xmlPI:

• XmlEventKind.xmlPI

xmlSpecial:

• XmlEventKind.xmlSpecial

xmlWhitespace:

• XmlEventKind.xmlWhitespace

xnCData:

• XmlNodeKind.xnCData

xnComment:

• XmlNodeKind.xnComment

xnElement:

• XmlNodeKind.xnElement

xnEntity:

• XmlNodeKind.xnEntity

xnText:

• XmlNodeKind.xnText

xnVerbatimText:

• XmlNodeKind.xnVerbatimText

year:

• times: year(dt: DateTime): int

year=:

• times: year=(dt: var DateTime; value: int)

yearday:

• times: yearday(dt: DateTime): YeardayRange

yearday=:

• times: yearday=(dt: var DateTime; value: YeardayRange)

YeardayRange:

• times: YeardayRange

Years:

• TimeUnit.Years

years:

• times: years(y: int): TimeInterval

ze:

• system: ze(x: int16): int
• system: ze(x: int8): int

ze64:

• system: ze64(x: int): int64
• system: ze64(x: int16): int64
• system: ze64(x: int32): int64
• system: ze64(x: int8): int64

zeroMem:

• system: zeroMem(p: pointer; size: Natural)

zip:

• sequtils: zip[S, T](s1: openArray[S]; s2: openArray[T]): seq[(S, T)]

ZonedTime:

• times: ZonedTime

zonedTimeFromAdjTime:

• times: zonedTimeFromAdjTime(zone: Timezone; adjTime: Time): ZonedTime

zonedTimeFromTime:

• times: zonedTimeFromTime(zone: Timezone; time: Time): ZonedTime