Index

Documents: API naming design, Code owners, 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, Source Code Filters, Tools available with Nim.

Modules: algorithm, assertions, asyncdispatch, asyncfile, asyncftpclient, asyncfutures, asynchttpserver, asyncjs, asyncmacro, asyncnet, asyncstreams, atomics, base64, bitops, browsers, cgi, chains, channels, colors, compilesettings, complex, cookies, coro, cpuinfo, cpuload, critbits, cstrutils, db_common, db_mysql, db_odbc, db_postgres, db_sqlite, decls, deques, diff, distros, dollars, dom, dynlib, editdistance, encodings, endians, epoll, fenv, hashes, heapqueue, highlite, hotcodereloading, htmlgen, htmlparser, httpclient, httpcore, inotify, intsets, io, iterators, jsconsole, jsffi, json, kqueue, lenientops, lexbase, linenoise, lists, locks, logging, logic, macrocache, macros, marshal, math, md5, memfiles, mersenne, mimetypes, monotimes, nativesockets, net, nimhcr, nimprof, nimscript, nre, oids, options, os, osproc, parsecfg, parsecsv, parsejson, parseopt, parsesql, parseutils, parsexml, pathnorm, pegs, posix_utils, pragmas, punycode, quitprocs, random, rationals, rdstdin, re, registry, reservedmem, rex, rlocks, ropes, rst, rstast, rstgen, rtarrays, segfaults, selectors, sequtils, sets, sexp, sha1, sharedlist, sharedtables, smtp, ssl_certs, stackframes, stats, streams, strformat, strmisc, strscans, strtabs, strutils, sugar, sums, switch_memory, system, tables, terminal, threadpool, threads, time_t, times, typeinfo, typetraits, underscored_calls, unicode, unidecode, unittest, uri, util, varints, volatile, widestrs, 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

`!`:

• macros: `!`(s: string): NimIdent
• pegs: `!`(a: Peg): Peg

`$$`:

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

`$`:

• asyncfutures: `$`(entries: seq[StackTraceEntry]): string
• colors: `$`(c: Color): string
• complex: `$`(z: Complex): string
• critbits: `$`[T](c: CritBitTree[T]): string
• deques: `$`[T](deq: Deque[T]): 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: `$`(x: float): 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
• heapqueue: `$`[T](heap: HeapQueue[T]): string
• httpclient: `$`(data: MultipartData): string
• httpcore: `$`(code: HttpCode): string
• httpcore: `$`(headers: HttpHeaders): string
• httpcore: `$`(httpMethod: HttpMethod): string
• intsets: `$`(s: IntSet): string
• json: `$`(node: JsonNode): string
• lists: `$`[T](L: SomeLinkedCollection[T]): 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
• 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
• system: `$`(x: uint64): 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): untyped
• 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: `<//>`(t: 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

`<=`:

• intsets: `<=`(s1, s2: IntSet): 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
• 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

`<`:

• intsets: `<`(s1, s2: IntSet): 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
• 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

`*%`:

• 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

`*=`:

• complex: `*=`[T](x: var Complex[T]; y: Complex[T])
• 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: `*=`[T: TimesMutableTypes; U](a: var T; b: U)

`*`:

• 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]
• intsets: `*`(s1, s2: IntSet): IntSet
• 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
• 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])
• 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: enum | bool](x: var T; y: T)
• system: `+=`[T: float | float32 | float64](x: var T; y: T)
• times: `+=`[T, U: TimesMutableTypes](a: var T; b: U)

`+`:

• 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]
• intsets: `+`(s1, s2: IntSet): IntSet
• 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
• 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])
• 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: enum | bool](x: var T; y: T)
• system: `-=`[T: float | float32 | float64](x: var T; y: T)
• times: `-=`[T, U: TimesMutableTypes](a: var T; b: U)

`-`:

• 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]
• intsets: `-`(s1, s2: IntSet): IntSet
• 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
• 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
• wrapnils: `.`(a: Wrapnil; b): untyped

`/%`:

• 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])
• 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
• intsets: `==`(s1, s2: IntSet): 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: `==`(a, b: Option): bool
• os: `==`(err1, err2: OSErrorCode): bool
• rationals: `==`(x, y: Rational): 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: type(nil) | type(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: type(nil) | type(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)

`=destroy`:

• system: `=destroy`[T](x: var T)

`=sink`:

• system: `=sink`[T](x: var T; y: T)

`=~`:

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

`?.`:

• wrapnils: `?.`(a: untyped): untyped

`?`:

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

`@`:

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

`[]=`:

• critbits: `[]=`[T](c: var CritBitTree[T]; key: string; val: T)
• deques: `[]=`[T](deq: var Deque[T]; i: BackwardsIndex; x: T)
• deques: `[]=`[T](deq: var Deque[T]; i: Natural; val: 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)
• json: `[]=`(obj: JsonNode; key: string; val: JsonNode)
• macrocache: `[]=`(t: CacheTable; key: string; value: NimNode)
• macros: `[]=`(n: NimNode; i: BackwardsIndex; child: NimNode)
• macros: `[]=`(n: NimNode; i: int; child: NimNode)
• 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](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](s: var seq[T]; x: HSlice[U, V]; b: openArray[T])
• system: `[]=`(s: var string; i: BackwardsIndex; x: char)
• system: `[]=`[T, U](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: B)
• tables: `[]=`[A, B](t: OrderedTableRef[A, B]; key: A; val: B)
• tables: `[]=`[A, B](t: var Table[A, B]; key: A; val: B)
• tables: `[]=`[A, B](t: TableRef[A, B]; key: A; val: 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): T
• deques: `[]`[T](deq: var Deque[T]; i: BackwardsIndex): var T
• deques: `[]`[T](deq: Deque[T]; i: Natural): T
• deques: `[]`[T](deq: var Deque[T]; i: Natural): var T
• dom: `[]`(x: Node; idx: int): Element
• heapqueue: `[]`[T](heap: HeapQueue[T]; i: Natural): 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
• json: `[]`(node: JsonNode; index: int): JsonNode
• json: `[]`(node: JsonNode; name: string): JsonNode
• macrocache: `[]`(s: CacheSeq; i: int): NimNode
• macrocache: `[]`(t: CacheTable; key: string): NimNode
• macros: `[]`(n: NimNode; i: BackwardsIndex): NimNode
• macros: `[]`[T, U](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](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](s: openArray[T]; x: HSlice[U, V]): seq[T]
• system: `[]`(s: string; i: BackwardsIndex): char
• system: `[]`[T, U](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: `[]`(a: Wrapnil): untyped
• wrapnils: `[]`[I; ](a: Wrapnil; i: I): untyped
• xmltree: `[]`(n: XmlNode; i: int): XmlNode
• xmltree: `[]`(n: var XmlNode; i: int): var XmlNode

`^`:

• math: `^`[T](x: T; y: Natural): T
• system: `^`(x: int): BackwardsIndex
• threadpool: `^`[T](fv: FlowVar[ref T]): ref T
• 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]
• 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
• 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`:

• 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: S): bool
• system: `of`[T, S](x: T; y: typedesc[S]): bool
• system: `of`[T, S](x: typedesc[T]; y: typedesc[S]): bool

`or`:

• asyncfutures: `or`[T, Y](fut1: Future[T]; fut2: Future[Y]): Future[void]
• 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`:

• 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`:

• 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`:

• 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

abortOnError:

• unittest: abortOnError

abs:

• complex: abs[T](z: Complex[T]): T
• rationals: abs[T](x: Rational[T]): Rational[T]
• system: abs(x: float32): float32
• system: abs(x: float64): float64
• 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
• 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}): owned(Future[AsyncFD])
• asyncnet: accept(socket: AsyncSocket; flags = {SafeDisconn}): owned(Future[AsyncSocket])
• nativesockets: accept(fd: SocketHandle): (SocketHandle, string)
• net: accept(server: Socket; client: var owned(Socket); flags = {SafeDisconn})
• winlean: accept(s: SocketHandle; a: ptr SockAddr; addrlen: ptr SockLen): SocketHandle

acceptAddr:

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

AcceptNoClient:

• SslAcceptResult.AcceptNoClient

AcceptNoHandshake:

• SslAcceptResult.AcceptNoHandshake

AcceptSuccess:

• SslAcceptResult.AcceptSuccess

AccessViolationError:

• system: AccessViolationError

acquire:

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

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)
• json: add(father, child: JsonNode)
• json: add(obj: JsonNode; key: string; val: JsonNode)
• 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)
• system: add[T](x: var seq[T]; y: openArray[T])
• system: add[T](x: var seq[T]; y: T)
• system: add(x: var string; y: char)
• system: add(x: var string; y: cstring)
• system: add(result: var string; x: float)
• system: add(result: var string; x: int64)
• system: add(x: var string; y: string)
• tables: add[A, B](t: var OrderedTable[A, B]; key: A; val: B)
• tables: add[A, B](t: OrderedTableRef[A, B]; key: A; val: B)
• tables: add[A, B](t: var Table[A, B]; key: A; val: B)
• tables: add[A, B](t: TableRef[A, B]; key: A; val: 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

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: T)

addFloat:

• system: addFloat(result: var string; x: float)

addHandler:

• logging: addHandler(handler: Logger)

addIdentIfAbsent:

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

addIfNotNil:

• rstast: addIfNotNil(father, son: PRstNode)

addInt:

• system: addInt(result: var string; x: int64)

addLast:

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

addNodes:

• rst: addNodes(n: PRstNode): string

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)

addQuitClosure:

• quitprocs: addQuitClosure(cl: proc () {.closure.})

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)

adjTime:

• times: adjTime(zt: ZonedTime): Time

adjTime=:

• times: adjTime=(zt: var ZonedTime; adjTime: Time)

advice:

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

affinity:

• Examples

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

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

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

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:

• PEG construction

any rune:

• PEG construction

anyIt:

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

AnyKind:

• typeinfo: AnyKind

anyRune:

• pegs: anyRune(): Peg

append:

• chains: append(header, node)
• lists: append[T](L: var DoublyLinkedList[T]; n: DoublyLinkedNode[T])
• lists: append[T](L: var DoublyLinkedList[T]; value: T)
• lists: append[T](L: var DoublyLinkedRing[T]; n: DoublyLinkedNode[T])
• lists: append[T](L: var DoublyLinkedRing[T]; value: T)
• lists: append[T](L: var SinglyLinkedList[T]; n: SinglyLinkedNode[T])
• lists: append[T](L: var SinglyLinkedList[T]; value: T)
• lists: append[T](L: var SinglyLinkedRing[T]; n: SinglyLinkedNode[T])
• lists: append[T](L: var SinglyLinkedRing[T]; value: T)

appendChild:

• dom: appendChild(n, child: Node)

appendData:

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

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.})

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

ArithmeticError:

• system: ArithmeticError

arity:

• typetraits: arity(t: typedesc): int

array:

• system: array

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

assert:

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

AssertionError:

• system: AssertionError

assign:

• intsets: assign(dest: var IntSet; src: IntSet)
• typeinfo: assign(x, y: Any)

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

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

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:

• Creating JSON

AuxilaryButton:

• MouseButtons.AuxilaryButton

await:

• asyncdispatch: await[T](x: T)
• asyncmacro: await[T](x: T)

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]): Peg

backrefIgnoreCase:

• pegs: backrefIgnoreCase(index: range[1 .. MaxSubpatterns]): Peg

backrefIgnoreStyle:

• pegs: backrefIgnoreStyle(index: range[1 .. MaxSubpatterns]): 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

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

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

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): T

bitnot:

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

bitor:

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

BitsRange:

• bitops: BitsRange

bitxor:

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

Blob:

• dom: Blob

blob:

• Module typetraits

blockquote:

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

BlockTags:

• htmlparser: BlockTags

blockUntil:

• threadpool: blockUntil(fv: FlowVarBase)

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
• 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

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)
• pragmas: byaddr(lhs, typ, expr)

BY_HANDLE_FILE_INFORMATION:

• winlean: BY_HANDLE_FILE_INFORMATION

byte:

• system: byte

ByteAddress:

• system: ByteAddress

c_abort:

• segfaults: c_abort()

CacheCounter:

• macrocache: CacheCounter

CacheSeq:

• macrocache: CacheSeq

CacheTable:

• macrocache: CacheTable

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:

• Misc

CallNodes:

• macros: CallNodes

callsite:

• macros: callsite(): NimNode

callSoon:

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

cancelAnimationFrame:

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

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
• 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

captureEvents:

• dom: captureEvents(d: Document; eventMask: int)
• dom: captureEvents(w: Window; eventMask: 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:

• intsets: card(s: IntSet): 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

CatchableError:

• system: CatchableError

cbrt:

• 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:

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

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: float32; exponent: var int32): float32
• math: c_frexp(x: float64; exponent: var int32): float64

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: 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

checkedSymAddr:

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

checkpoint:

• unittest: checkpoint(msg: string)

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

cite:

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

C_JmpBuf:

• segfaults: C_JmpBuf

clamp:

• 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(ls: LocalStorage)
• heapqueue: clear[T](heap: var HeapQueue[T])
• httpcore: clear(headers: HttpHeaders)
• intsets: clear(result: var IntSet)
• jsconsole: clear(console: Console)
• 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(w: Window; interval: ref Interval)

clearMask:

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

clearScreen:

• linenoise: clearScreen()

clearTimeout:

• dom: clearTimeout(t: TimeOut)
• dom: clearTimeout(w: Window; timeout: ref 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

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: 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)
• osproc: close(p: Process)
• parsecfg: close(c: var CfgParser)
• parsecsv: close(my: 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

c_malloc:

• segfaults: c_malloc(size: csize_t): pointer

cmdArgument:

• CmdLineKind.cmdArgument

cmdEnd:

• CmdLineKind.cmdEnd

CmdLineKind:

• parseopt: CmdLineKind

cmdLineRest:

• parseopt: cmdLineRest(p: OptParser): TaintedString

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

cmpIgnoreStyle:

• cstrutils: cmpIgnoreStyle(a, b: cstring): int
• strutils: cmpIgnoreStyle(a, b: string): 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(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[TaintedString]

CommentNode:

• NodeType.CommentNode

commitedLen:

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

commonAttr:

• htmlgen: commonAttr

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

CompileDate:

• system: CompileDate

compileOption:

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

compiles:

• system: compiles(x: untyped): bool

CompileTime:

• system: CompileTime

complete:

• asyncfutures: complete[T](future: Future[T]; val: T)
• asyncfutures: complete(future: Future[void])
• 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): Complex[float32]

Complex64:

• complex: Complex64

complex64:

• complex: complex64(re: float64; im: float64 = 0.0): Complex[float64]

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
• httpcore: contains(values: HttpHeaderValues; value: string): bool
• httpcore: contains(methods: set[HttpMethod]; x: string): bool
• intsets: contains(s: IntSet; key: int): bool
• json: contains(node: JsonNode; val: JsonNode): bool
• json: contains(node: JsonNode; key: string): 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
• 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
• intsets: containsOrIncl(s: var IntSet; key: int): 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
• 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)

copyFileW:

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

copyFileWithPermissions:

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

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

coreAttr:

• htmlgen: coreAttr

CoroutineRef:

• coro: CoroutineRef

correlation:

• stats: correlation(r: RunningRegress): float

cos:

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

cosh:

• complex: cosh[T](z: Complex[T]): Complex[T]
• 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

countBits32:

• math: countBits32(n: int32): int

countDays:

• times: countDays(yearSpan: int): 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

countLeapYears:

• times: countLeapYears(yearSpan: int): 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

countYears:

• times: countYears(daySpan: int): int

countYearsAndDays:

• times: countYearsAndDays(daySpan: int): tuple[years: int, days: int]

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:

• Examples

cpuEndian:

• system: cpuEndian

cpuRelax:

• system: cpuRelax()

cpuTime:

• times: cpuTime(): float

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): AsyncFD
• asyncdispatch: createAsyncNativeSocket(domain: Domain = Domain.AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP): AsyncFD

createAttribute:

• dom: createAttribute(d: Document; identifier: 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

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

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): SocketHandle
• nativesockets: createNativeSocket(domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP): 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)

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: proc (a: cint) {.noconv.}): 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:

• Misc

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

DateTime:

• times: DateTime

DateTimeLocale:

• times: DateTimeLocale

Days:

• TimeUnit.Days

days:

• times: days(dur: Duration): int64
• times: days(d: int): TimeInterval

dbArray:

• DbTypeKind.dbArray

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

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

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, `$`])

dec:

• 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: TaintedString]
• cgi: decodeData(data: string): tuple[key, value: TaintedString]

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:

• Module strutils

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:type

defaultConfig:

• rstgen: defaultConfig(): StringTableRef

defaultConsoleFormatter:

• unittest: defaultConsoleFormatter(): ConsoleOutputFormatter

defaultFilename:

• logging: defaultFilename(): string

defaultFindFile:

• rst: defaultFindFile(filename: string): string

defaultFmtStr:

• logging: defaultFmtStr

defaultInitialSize:

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

DefaultLocale:

• times: DefaultLocale

defaultMsgHandler:

• rst: defaultMsgHandler(filename: string; line, col: int; msgkind: MsgKind; arg: string)

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: string): Future[AsyncResponse]
• httpclient: delete(client: HttpClient; url: string): Response
• json: delete(obj: JsonNode; key: string)
• sequtils: delete[T](s: var seq[T]; first, last: Natural)
• strutils: delete(s: var string; first, last: int)
• system: delete[T](x: var seq[T]; i: Natural)
• xmltree: delete(n: XmlNode; i: Natural)

deleteContent:

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

deleteData:

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

DeleteFiber:

• winlean: DeleteFiber(fiber: pointer): void

deleteFileW:

• winlean: deleteFileW(pathName: WideCString): int32

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:

• Misc

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:

• intsets: difference(s1, s2: IntSet): IntSet
• sets: difference[A](s1, s2: HashSet[A]): HashSet[A]

diffInt:

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

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

directory:

• Module os
• Module os

dirExists:

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

DirSep:

• os: DirSep

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:

• intsets: disjoint(s1, s2: IntSet): 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:

• sugar: distinctBase(T: typedesc): typedesc
• typetraits: distinctBase(T: typedesc): typedesc
• typetraits: distinctBase[T](a: T): untyped

distribute:

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

Distribution:

• distros: Distribution

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

DocumentTypeNode:

• NodeType.DocumentTypeNode

Domain:

• nativesockets: Domain

DomApiVersion:

• dom: DomApiVersion

DomEvent:

• dom: DomEvent

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: string; filename: string): Future[void]
• httpclient: downloadFile(client: HttpClient; url: 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: typed): untyped

dumpAllocstats:

• system: dumpAllocstats(code: untyped)

dumpAstGen:

• macros: dumpAstGen(s: untyped): untyped

dumpLisp:

• macros: dumpLisp(s: untyped): untyped

dumpLispImm:

• macros: dumpLispImm(s: untyped): untyped

dumpTree:

• macros: dumpTree(s: untyped): untyped

dumpTreeImm:

• macros: dumpTreeImm(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

elementName:

• parsexml: elementName(my: XmlParser): string

ElementNode:

• NodeType.ElementNode

elements:

• typeinfo: elements(x: Any): int

em:

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

embed:

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

EmbedElement:

• dom: EmbedElement

emit:

• macros: emit(e: static[string]): untyped

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 = "\c "): 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
• 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

entityName:

• parsexml: entityName(my: XmlParser): string

EntityNode:

• NodeType.EntityNode

EntityRefNode:

• NodeType.EntityRefNode

entityToRune:

• htmlparser: entityToRune(entity: string): Rune

entityToUtf8:

• htmlparser: entityToUtf8(entity: string): string

environment variable:

• Module os
• Module os
• Module os

environments variables:

• Module os

envPairs:

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

EOFError:

• system: EOFError

EParseError:

• rst: EParseError

epochTime:

• times: epochTime(): float

epoll:

• Limitations/Bugs

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:

• 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_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): 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)

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)
• intsets: excl(s: var IntSet; key: int)
• intsets: excl(s: var IntSet; other: IntSet)
• 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, `$`])
• 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; query: SqlQuery; args: varargs[string, `$`]): int64

execCmd:

• osproc: execCmd(command: string): int

execCmdEx:

• osproc: execCmdEx(command: string; options: set[ProcessOption] = {poStdErrToStdOut, poUsePath}): tuple[ output: TaintedString, exitCode: int]

ExecIOEffect:

• system: ExecIOEffect

execProcess:

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

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(dir: string): bool
• os: existsDir(dir: string): bool

existsEnv:

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

existsFile:

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

existsOrCreateDir:

• os: existsOrCreateDir(dir: string): bool

exitStatusLikeShell:

• os: exitStatusLikeShell(status: cint): cint

exp:

• complex: exp[T](z: Complex[T]): Complex[T]
• 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)

extendSeq:

• typeinfo: extendSeq(x: Any)

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)
• unittest: fail()

failed:

• asyncfutures: failed(future: FutureBase): 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)

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; 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, `$`])

fcInf:

• FloatClass.fcInf

fcNan:

• FloatClass.fcNan

fcNegInf:

• FloatClass.fcNegInf

fcNegZero:

• FloatClass.fcNegZero

fcNormal:

• FloatClass.fcNormal

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

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

fetchOr:

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

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

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:

• 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

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

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:

• sha1: finalize(ctx: var Sha1State): Sha1Digest

find:

• dom: find(w: Window; text: cstring; caseSensitive = false; backwards = false)
• 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 = 0): 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 = 0): 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

FindFileHandler:

• rst: FindFileHandler

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[A, B](self: Option[A]; callback: proc (input: A): Option[B]): Option[B]

flatten:

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

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; mask: T)

float:

• system: float

float32:

• system: float32

float64:

• system: float64

FloatClass:

• math: FloatClass

FloatDivByZeroError:

• system: FloatDivByZeroError

FloatFormatMode:

• strutils: FloatFormatMode

FloatInexactError:

• system: FloatInexactError

FloatingPointError:

• system: FloatingPointError

FloatInvalidOpError:

• system: FloatInvalidOpError

FloatOverflowError:

• system: FloatOverflowError

FloatUnderflowError:

• system: FloatUnderflowError

floatVal:

• macros: floatVal(n: NimNode): BiggestFloat

floatVal=:

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

floor:

• 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

fmod:

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

fmRead:

• FileMode.fmRead

fmReadWrite:

• FileMode.fmReadWrite

fmReadWriteExisting:

• FileMode.fmReadWriteExisting

fmt:

• strformat: fmt(pattern: string): untyped
• strformat: fmt(pattern: string; openChar, closeChar: char): 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

footer:

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

for-loop macro:

• Misc

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)

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

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)

FormElement:

• dom: FormElement

forward:

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

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

fractional:

• times: fractional(dur: Duration): Duration

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)

frexp:

• math: frexp[T, U](x: T; exponent: var U): T

fromBin:

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

fromHex:

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

fromOct:

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

fromSeconds:

• times: fromSeconds(since1970: float): Time
• times: fromSeconds(since1970: int64): Time

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

fspCur:

• FileSeekPos.fspCur

fspEnd:

• FileSeekPos.fspEnd

fspSet:

• FileSeekPos.fspSet

fsync:

• posix_utils: fsync(fd: int)

FtpEvent:

• asyncftpclient: FtpEvent

FtpEventType:

• asyncftpclient: FtpEventType

FtpJobType:

• asyncftpclient: FtpJobType

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

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)

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

get:

• httpclient: get(client: AsyncHttpClient; url: string): Future[AsyncResponse]
• httpclient: get(client: HttpClient; url: string): Response
• nimscript: get(key: string): string
• options: get[T](self: Option[T]): 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

getAlign:

• macros: getAlign(arg: NimNode): int

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; query: SqlQuery; args: varargs[string, `$`]): seq[Row]

getAppDir:

• os: getAppDir(): string

getAppFilename:

• os: getAppFilename(): string

getArgument:

• rst: getArgument(n: PRstNode): 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

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: string): Future[string]
• httpclient: getContent(client: HttpClient; url: string): string

getContentLength:

• cgi: getContentLength(): string

getContentType:

• cgi: getContentType(): string

getCookie:

• cgi: getCookie(name: string): TaintedString

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

getDateStr:

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

getDayOfWeek:

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

getDayOfWeekJulian:

• times: getDayOfWeekJulian(day, 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 = ""): TaintedString

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(4)): OrderedTable[string, JsonNode]

getFieldValue:

• rst: getFieldValue(n: PRstNode): string
• rst: getFieldValue(n: PRstNode; fieldname: string): string

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

getGatewayInterface:

• cgi: getGatewayInterface(): string

getGcFrame:

• system: getGcFrame(): GcFrame

getGlobalDispatcher:

• asyncdispatch: getGlobalDispatcher(): PDispatcher

getGMTime:

• times: getGMTime(time: Time): DateTime

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

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

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(ls: LocalStorage; 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)

getLocalTime:

• times: getLocalTime(time: Time): DateTime

getLogFilter:

• logging: getLogFilter(): Level

getMaxMem:

• system: getMaxMem(): int

getMD5:

• md5: getMD5(s: string): string

getMimetype:

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

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

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: TaintedString]
• parseopt: getopt(cmdline: seq[TaintedString] = commandLineParams(); shortNoVal: set[char] = {}; longNoVal: seq[string] = @[]): tuple[ kind: CmdLineKind, key, val: TaintedString]

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:

• Chat server
• Module nativesockets
• Creating a server
• winlean: getpeername(s: SocketHandle; name: ptr SockAddr; namelen: ptr SockLen): cint

getPFrame:

• stackframes: getPFrame(): PFrame

getPointer:

• typeinfo: getPointer(x: Any): pointer

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

getProjectPath:

• macros: getProjectPath(): string

getPropertyPriority:

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

getPropertyValue:

• dom: getPropertyValue(s: Style; property: cstring): 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

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

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

getSectionValue:

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

getSelection:

• dom: getSelection(d: Document): cstring

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:

• Chat server

getSockName:

• nativesockets: getSockName(socket: SocketHandle): Port

getsockname:

• Module nativesockets
• Creating a server
• 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): 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)

getSystemTimes:

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

getTempDir:

• os: getTempDir(): string

getThreadId:

• threads: getThreadId*(): int

getTime:

• times: getTime(): Time

getTimezone:

• times: getTimezone(): 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

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; query: SqlQuery; args: varargs[string, `$`]): string

getVersion:

• winlean: getVersion(): DWORD

getVersionExA:

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

getVersionExW:

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

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

gtOther:

• TokenClass.gtOther

gtPreprocessor:

• TokenClass.gtPreprocessor

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)

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

hasChildNodes:

• dom: hasChildNodes(n: Node): bool

hasCustomPragma:

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

hasData:

• osproc: hasData(p: Process): bool

hasDataBuffered:

• 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[A](x: set[A]): Hash
• hashes: hash(x: string): Hash
• hashes: hash(sBuf: string; sPos, ePos: int): Hash
• hashes: hash[T: proc](x: T): Hash
• hashes: hash[T: Ordinal](x: T): Hash
• hashes: hash[T: tuple](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

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

hasItem:

• dom: hasItem(ls: LocalStorage; key: cstring): bool

hasKey:

• critbits: hasKey[T](c: CritBitTree[T]; key: string): bool
• httpcore: hasKey(headers: HttpHeaders; key: string): 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

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: string): Future[AsyncResponse]
• httpclient: head(client: HttpClient; url: string): Response

header:

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

headerLimit:

• httpcore: headerLimit

HeapQueue:

• heapqueue: HeapQueue

hexbyte:

• oids: hexbyte(hex: char): int

HexDigits:

• strutils: HexDigits

HGLRC:

• winlean: HGLRC

hideCursor:

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

high:

• 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

home:

• dom: home(w: Window)

hostCPU:

• system: hostCPU

Hostent:

• nativesockets: Hostent
• winlean: Hostent

hostOS:

• system: hostOS

HourRange:

• times: HourRange

Hours:

• TimeUnit.Hours

hours:

• times: hours(dur: Duration): int64
• times: hours(h: int): TimeInterval

hr:

• htmlgen: hr(): untyped

HSlice:

• system: HSlice

html:

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

HTML:

• Module htmlgen
• Module parsexml

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

Http200:

• httpcore: Http200

Http201:

• httpcore: Http201

Http202:

• httpcore: Http202

Http203:

• httpcore: Http203

Http204:

• httpcore: Http204

Http205:

• httpcore: Http205

Http206:

• httpcore: Http206

Http300:

• httpcore: Http300

Http301:

• httpcore: Http301

Http302:

• httpcore: Http302

Http303:

• httpcore: Http303

Http304:

• httpcore: Http304

Http305:

• httpcore: Http305

Http307:

• httpcore: Http307

Http400:

• httpcore: Http400

Http401:

• httpcore: Http401

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

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

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:

• 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

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)
• 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: Positive = 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)
• intsets: incl(s: var IntSet; key: int)
• intsets: incl(s: var IntSet; other: IntSet)
• macrocache: incl(s: CacheSeq; value: NimNode)
• 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

index:

• pegs: index(p: Peg): range[0 .. MaxSubpatterns]

indexBy:

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

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 = 64)

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 = 4): 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]

initInterval:

• times: initInterval(seconds, minutes, hours, days, months, years: int = 0): TimeInterval

initIntSet:

• intsets: initIntSet(): IntSet

initLock:

• locks: initLock(lock: var Lock)

initOptParser:

• parseopt: initOptParser(cmdline: seq[TaintedString]; 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]

initRand:

• 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; options: RstParseOptions; findFile: FindFileHandler = nil; msgHandler: MsgHandler = nil)

initRtArray:

• rtarrays: initRtArray[T](len: Natural): RtArray[T]

initSet:

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

initSharedList:

• sharedlist: initSharedList[A](): SharedList[A]

initSharedTable:

• sharedtables: initSharedTable[A, B](initialSize = 64): SharedTable[A, B]

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

initUri:

• uri: initUri(): 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_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:

• 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

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; 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:

• intsets: intersection(s1, s2: IntSet): IntSet
• sets: intersection[A](s1, s2: HashSet[A]): HashSet[A]

Interval:

• dom: Interval

INT_MAX:

• Misc

INT_MIN:

• Misc

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

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

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

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

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

isDigit:

• strutils: isDigit(c: char): bool

isDisconnectionError:

• net: isDisconnectionError(flags: set[SocketFlag]; lastError: OSErrorCode): bool

isEmpty:

• selectors: isEmpty[T](s: Selector[T]): bool

isEmptyOrWhitespace:

• strutils: isEmptyOrWhitespace(s: string): bool

isExported:

• macros: isExported(n: NimNode): bool

isFinite:

• dom: isFinite(x: BiggestFloat): bool

isFutureLoggingEnabled:

• asyncfutures: isFutureLoggingEnabled

isHidden:

• os: isHidden(path: string): bool

isInstantiationOf:

• macros: isInstantiationOf(instanceProcSym, genProcSym: NimNode): bool

isIpAddress:

• net: isIpAddress(addressStr: string): bool

isLeapDay:

• times: isLeapDay(t: DateTime): bool

isLeapYear:

• times: isLeapYear(year: int): bool

isLower:

• unicode: isLower(c: Rune): bool
• unicode: isLower(s: string; skipNonAlpha: bool): bool

isLowerAscii:

• strutils: isLowerAscii(c: char): bool

isMainModule:

• system: isMainModule

isNamedTuple:

• typetraits: isNamedTuple(T: typedesc): bool

isNaN:

• dom: isNaN(x: BiggestFloat): bool

isNil:

• intsets: isNil(x: IntSet): 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

isNilOrWhitespace:

• strutils: isNilOrWhitespace(s: string): bool

isNone:

• options: isNone[T](self: Option[T]): bool

isNotForeign:

• system: isNotForeign(x: ForeignCell): bool

isNull:

• jsffi: isNull[T](x: T): bool

isPowerOfTwo:

• math: isPowerOfTwo(x: int): bool

isReady:

• threadpool: isReady(fv: FlowVarBase): bool

isRelativeTo:

• os: isRelativeTo(path: string; base: string): bool

isRootDir:

• os: isRootDir(path: string): 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

isTitle:

• unicode: isTitle(c: Rune): bool
• unicode: isTitle(s: string): bool

isTrueColorSupported:

• terminal: isTrueColorSupported(): bool

isUndefined:

• jsffi: isUndefined[T](x: T): bool

isUpper:

• unicode: isUpper(c: Rune): bool
• unicode: isUpper(s: string; skipNonAlpha: bool): bool

isUpperAscii:

• strutils: isUpperAscii(c: char): bool

isValid:

• sets: isValid[A](s: HashSet[A]): bool
• sets: isValid[A](s: OrderedSet[A]): bool

isValidFilename:

• os: isValidFilename(filename: string; maxLen = 259.Positive): 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]): T
• intsets: items(s: IntSet): int
• iterators: items[IX, T](a: array[IX, T]): T
• iterators: items(a: cstring): char
• iterators: items[T](s: HSlice[T, T]): T
• iterators: items[T](a: openArray[T]): T
• iterators: items[T](a: seq[T]): T
• iterators: items[T](a: set[T]): T
• iterators: items(a: string): char
• iterators: items(E: typedesc[enum]): E:type
• 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]
• 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; longestMatch = false): string

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]])

JRetr:

• FtpJobType.JRetr

JRetrText:

• FtpJobType.JRetrText

js:

• jsffi: js

jsArguments:

• jsffi: jsArguments

JsAssoc:

• jsffi: JsAssoc

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:

• 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

JsonNode:

• json: JsonNode

JsonNodeKind:

• json: JsonNodeKind

JsonNodeObj:

• json: JsonNodeObj

jsonNull:

• JsonEventKind.jsonNull

jsonObjectEnd:

• JsonEventKind.jsonObjectEnd

jsonObjectStart:

• JsonEventKind.jsonObjectStart

JsonParser:

• parsejson: JsonParser

JsonParsingError:

• parsejson: JsonParsingError

jsonString:

• JsonEventKind.jsonString

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

jsUndefined:

• jsffi: jsUndefined

JsURIError:

• jsffi: JsURIError

JUnitOutputFormatter:

• unittest: JUnitOutputFormatter

kbd:

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

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
• json: keys(node: JsonNode): string
• strtabs: keys(t: StringTableRef): string
• tables: keys[A](t: CountTable[A]): A
• tables: keys[A](t: CountTableRef[A]): A
• tables: keys[A, B](t: OrderedTable[A, B]): A
• tables: keys[A, B](t: OrderedTableRef[A, B]): A
• tables: keys[A, B](t: Table[A, B]): A
• tables: keys[A, B](t: TableRef[A, B]): A

keysWithPrefix:

• critbits: keysWithPrefix[T](c: CritBitTree[T]; prefix: string; longestMatch = false): 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

kqueue:

• Limitations/Bugs
• 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

langCpp:

• SourceLanguage.langCpp

langCsharp:

• SourceLanguage.langCsharp

langJava:

• SourceLanguage.langJava

langNim:

• SourceLanguage.langNim

langNone:

• SourceLanguage.langNone

langYaml:

• SourceLanguage.langYaml

largest:

• tables: largest[A](t: CountTable[A]): tuple[key: A, val: int]
• tables: largest[A](t: CountTableRef[A]): (A, 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
• intsets: len(s: IntSet): int
• json: len(n: JsonNode): int
• macrocache: len(s: CacheSeq): int
• macrocache: len(t: CacheTable): int
• macros: len(n: NimNode): 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:

• Misc

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): TaintedString
• io: lines(filename: string): TaintedString
• memfiles: lines(mfile: MemFile; delim = ' '; eat = '\c'): TaintedString
• memfiles: lines(mfile: MemFile; buf: var TaintedString; delim = ' '; eat = '\c'): TaintedString
• streams: lines(s: Stream): TaintedString

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:

• 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): XmlNode
• xmlparser: loadXml(path: string; errors: var seq[string]): 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

LocalStorage:

• dom: LocalStorage

Location:

• dom: Location

LocationBar:

• dom: LocationBar

Lock:

• locks: Lock

log:

• jsconsole: log(console: Console)
• 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]
• math: log10(x: float32): float32
• math: log10(x: float64): float64

log2:

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

Logger:

• logging: Logger

LONG:

• winlean: LONG

low:

• 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

markdown:

• Module rst

marquee:

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

match:

• 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

mAug:

• Month.mAug

max:

• 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

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:

• Misc

maxLen:

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

MaxLineLength:

• net: MaxLineLength

MAX_PATH:

• winlean: MAX_PATH

MaxSubpatterns:

• pegs: MaxSubpatterns
• re: MaxSubpatterns

MaxThreadPoolSize:

• threadpool: MaxThreadPoolSize

maxVarIntLen:

• varints: maxVarIntLen

mcError:

• MsgClass.mcError

mcHint:

• MsgClass.mcHint

mcWarning:

• MsgClass.mcWarning

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

meCannotOpenFile:

• MsgKind.meCannotOpenFile

meExpected:

• MsgKind.meExpected

meGeneralParseError:

• MsgKind.meGeneralParseError

meGridTableNotImplemented:

• MsgKind.meGridTableNotImplemented

meInvalidDirective:

• MsgKind.meInvalidDirective

MemAccessFlags:

• reservedmem: MemAccessFlags

memalign:

• switch_memory: memalign(bytes: csize; size: csize): pointer

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 = '\c'): MemSlice

menclose:

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

meNewSectionExpected:

• MsgKind.meNewSectionExpected

MenuBar:

• dom: MenuBar

merge:

• 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:

• 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:

• Misc

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(dur: Duration): int
• times: microseconds(micros: int): TimeInterval

Milliseconds:

• TimeUnit.Milliseconds

milliseconds:

• times: milliseconds(dur: Duration): int
• times: milliseconds(ms: int): TimeInterval

MimeDB:

• mimetypes: MimeDB

mimes:

• mimetypes: mimes

MimeType:

• dom: MimeType

min:

• 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:

• Misc

MinuteRange:

• times: MinuteRange

Minutes:

• TimeUnit.Minutes

minutes:

• times: minutes(dur: Duration): int64
• times: minutes(m: int): TimeInterval

missingOrExcl:

• critbits: missingOrExcl[T](c: var CritBitTree[T]; key: string): bool
• intsets: missingOrExcl(s: var IntSet; key: int): 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): (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

modeCaseInsensitive:

• StringTableMode.modeCaseInsensitive

modeCaseSensitive:

• StringTableMode.modeCaseSensitive

modeStyleInsensitive:

• StringTableMode.modeStyleInsensitive

MonoTime:

• monotimes: MonoTime

Month:

• times: Month

MonthdayRange:

• times: MonthdayRange

Months:

• TimeUnit.Months

months:

• times: months(m: int): TimeInterval

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; longestMatch = false): 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

MsgClass:

• rst: MsgClass

MsgHandler:

• rst: MsgHandler

MsgKind:

• rst: MsgKind

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

multiMatch:

• rex: multiMatch(inp: string; sections: 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; longestMatch = false): var T

mvDir:

• nimscript: mvDir(`from`, to: string)

mvFile:

• nimscript: mvFile(`from`, to: string)

mwRedefinitionOfLabel:

• MsgKind.mwRedefinitionOfLabel

mwUnknownSubstitution:

• MsgKind.mwUnknownSubstitution

mwUnsupportedField:

• MsgKind.mwUnsupportedField

mwUnsupportedLanguage:

• MsgKind.mwUnsupportedLanguage

mySQL:

• Module db_mysql

name:

• 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(time: Time): NanosecondRange

NanosecondRange:

• times: NanosecondRange

Nanoseconds:

• TimeUnit.Nanoseconds

nanoseconds:

• times: nanoseconds(dur: Duration): NanosecondRange
• times: nanoseconds(nanos: int): TimeInterval

nativeStackTraceSupported:

• system: nativeStackTraceSupported

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(theProc: NimIdent; x: NimNode): NimNode
• 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

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 = ""): 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

newAsyncNativeSocket:

• asyncdispatch: newAsyncNativeSocket(domain: cint; sockType: cint; protocol: cint): AsyncFD
• asyncdispatch: newAsyncNativeSocket(domain: Domain = Domain.AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP): AsyncFD

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): owned(AsyncSocket)
• asyncnet: newAsyncSocket(domain, sockType, protocol: cint; buffered = true): owned(AsyncSocket)
• asyncnet: newAsyncSocket(domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP; buffered = true): owned(AsyncSocket)

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: string): XmlNode

newColonExpr:

• macros: newColonExpr(a, b: NimNode): NimNode

newComment:

• xmltree: newComment(comment: 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 = OutputLevel.PRINT_ALL; colorOutput = true): ConsoleOutputFormatter

newConstStmt:

• macros: newConstStmt(name, value: NimNode): NimNode

newContext:

• net: newContext(protVersion = protSSLv23; verifyMode = CVerifyPeer; certFile = ""; keyFile = ""; cipherList = "ALL"; caDir = ""; caFile = ""): SslContext

newCountTable:

• tables: newCountTable[A](initialSize = defaultInitialSize): CountTableRef[A]
• tables: newCountTable[A](keys: openArray[A]): CountTableRef[A]

newCustom:

• asyncdispatch: newCustom(): CustomRef

newDispatcher:

• asyncdispatch: newDispatcher(): owned PDispatcher

newDotExpr:

• macros: newDotExpr(a, b: NimNode): NimNode

newDoublyLinkedNode:

• lists: newDoublyLinkedNode[T](value: T): (DoublyLinkedNode[T])

newElement:

• xmltree: newElement(tag: 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

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

newFileStream:

• streams: newFileStream(f: File): owned FileStream
• streams: newFileStream(filename: string; mode: FileMode = fmRead; bufSize: int = -1): owned FileStream

newFloatLitNode:

• macros: newFloatLitNode(f: BiggestFloat): NimNode

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])

newHeapQueue:

• heapqueue: newHeapQueue[T](): HeapQueue[T]
• heapqueue: newHeapQueue[T](heap: var HeapQueue[T])

newHttpClient:

• httpclient: newHttpClient(userAgent = defUserAgent; maxRedirects = 5; sslContext = getDefaultSSL(); proxy: Proxy = nil; timeout = -1; headers = newHttpHeaders()): HttpClient

newHttpHeaders:

• httpcore: newHttpHeaders(): HttpHeaders
• httpcore: newHttpHeaders(keyValuePairs: openArray[tuple[key: string, val: string]]): 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:

• PEG construction

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(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
• macros: newLit(arg: tuple): 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

newNativeSocket:

• nativesockets: newNativeSocket(domain: cint; sockType: cint; protocol: cint): SocketHandle
• nativesockets: newNativeSocket(domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP): SocketHandle

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

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

newRollingFileLogger:

• logging: newRollingFileLogger(filename = defaultFilename(); mode: FileMode = fmReadWrite; levelThreshold = lvlAll; fmtStr = defaultFmtStr; maxLines = 1000; bufSize: int = -1): RollingFileLogger

newRstNode:

• rstast: newRstNode(kind: RstNodeKind): PRstNode
• rstast: newRstNode(kind: RstNodeKind; s: string): 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): owned(Socket)
• net: newSocket(domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP; buffered = true): 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: 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: 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

newVarStmt:

• macros: newVarStmt(name, value: NimNode): NimNode

newWideCString:

• widestrs: newWideCString(s: cstring): WideCStringObj
• widestrs: newWideCString(source: cstring; L: int): WideCStringObj
• widestrs: newWideCString(s: string): WideCStringObj

newXmlTree:

• xmltree: newXmlTree(tag: 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

NilAccessError:

• system: NilAccessError

NimAsyncContinueSuffix:

• asyncfutures: NimAsyncContinueSuffix

nimcacheDir:

• nimscript: nimcacheDir(): string

nimCoroutines:

• system: nimCoroutines

nimEnableCovariance:

• system: nimEnableCovariance

nimGC_setStackBottom:

• system: nimGC_setStackBottom(theStackBottom: pointer)

NimIdent:

• macros: NimIdent

NimMajor:

• system: NimMajor

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

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

NoFakeVars:

• system: NoFakeVars

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:

• strutils: normalize(s: string): string

normalizedPath:

• os: normalizedPath(path: string): 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
• 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

ntyOpt:

• NimTypeKind.ntyOpt

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)

ObjectAssignmentError:

• system: ObjectAssignmentError

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

onThreadDestruction:

• threads: onThreadDestruction*(handler: proc () {.closure, gcsafe.})

onUnhandledException:

• system: onUnhandledException

open:

• channels: 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(my: var CsvParser; input: Stream; filename: string; separator = ','; quote = '\"'; escape = '\x00'; skipInitialSpace = false)
• parsecsv: open(my: 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:

• Misc
• Misc

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: 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

OSError:

• system: OSError

OSErrorCode:

• os: OSErrorCode

osErrorMsg:

• os: osErrorMsg(errorCode: OSErrorCode): string

osInvalidSocket:

• nativesockets: osInvalidSocket

osLastError:

• os: osLastError(): OSErrorCode

osOpenCmd:

• browsers: osOpenCmd

OSVERSIONINFO:

• winlean: OSVERSIONINFO

out of memory:

• Misc

outHtml:

• OutputTarget.outHtml

outLatex:

• OutputTarget.outLatex

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

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

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)
• 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; longestMatch = false): tuple[ key: string, val: T]

parallel:

• threadpool: parallel(body: untyped)

parallelReplace:

• pegs: parallelReplace(s: string; subs: varargs[tuple[pattern: Peg, repl: string]]): string
• re: parallelReplace(s: string; subs: openArray[tuple[pattern: Regex, 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): TaintedString

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:

• 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

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

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 = ""): JsonNode
• json: parseJson(buffer: string): JsonNode

parseJsonFragments:

• json: parseJsonFragments(s: Stream; filename: string = ""): 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

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): XmlNode
• xmlparser: parseXml(s: Stream; filename: string; errors: var seq[string]): XmlNode
• xmlparser: parseXml(str: string): XmlNode

partition:

• strmisc: partition(s: string; sep: string; right: bool = false): (string, string, string)

patch:

• httpclient: patch(client: AsyncHttpClient; url: string; body = ""; multipart: MultipartData = nil): Future[ AsyncResponse]
• httpclient: patch(client: HttpClient; url: string; body = ""; multipart: MultipartData = nil): Response

patchContent:

• httpclient: patchContent(client: AsyncHttpClient; url: string; body = ""; multipart: MultipartData = nil): Future[string]
• httpclient: patchContent(client: HttpClient; url: string; body = ""; multipart: MultipartData = nil): string

patchFile:

• nimscript: patchFile(package, filename, replacement: string)

PathComponent:

• os: PathComponent

PathIter:

• pathnorm: PathIter

PathSep:

• os: PathSep

patricia trie:

• Module critbits

pcDir:

• PathComponent.pcDir

pcFile:

• PathComponent.pcFile

pcLinkToDir:

• PathComponent.pcLinkToDir

pcLinkToFile:

• PathComponent.pcLinkToFile

PDispatcher:

• asyncdispatch: PDispatcher

PDWORD:

• winlean: PDWORD

peek:

• channels: peek*[TMsg](c: var Channel[TMsg]): int
• streams: peek[T](s: Stream; result: var T)

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]): 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]): T

peekLine:

• streams: peekLine(s: Stream): TaintedString
• streams: peekLine(s: Stream; line: var TaintedString): 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): TaintedString

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: typed): void

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

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

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

Positive:

• system: Positive

post:

• httpclient: post(client: AsyncHttpClient; url: string; body = ""; multipart: MultipartData = nil): Future[ AsyncResponse]
• httpclient: post(client: HttpClient; url: string; body = ""; multipart: MultipartData = nil): Response

postContent:

• httpclient: postContent(client: AsyncHttpClient; url: string; body = ""; multipart: MultipartData = nil): Future[string]
• httpclient: postContent(client: HttpClient; url: 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]
• 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

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)

pretty:

• json: pretty(node: JsonNode; indent = 2): string
• sexp: pretty(node: SexpNode; indent = 2): 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

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(my: 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

protSSLv2:

• SslProtVersion.protSSLv2

protSSLv23:

• SslProtVersion.protSSLv23

protSSLv3:

• SslProtVersion.protSSLv3

protTLSv1:

• SslProtVersion.protTLSv1

Proxy:

• httpclient: Proxy

PRstNode:

• rstast: PRstNode

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: 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: T): T

pushState:

• dom: pushState[T](h: History; stateObject: T; title, url: cstring)

put:

• httpclient: put(client: AsyncHttpClient; url: string; body = ""; multipart: MultipartData = nil): Future[ AsyncResponse]
• httpclient: put(client: HttpClient; url: string; body = ""; multipart: MultipartData = nil): Response
• nimscript: put(key, value: string)

putContent:

• httpclient: putContent(client: AsyncHttpClient; url: string; body = ""; multipart: MultipartData = nil): Future[string]
• httpclient: putContent(client: HttpClient; url: string; body = ""; multipart: MultipartData = nil): string

putEnv:

• nimscript: putEnv(key, val: string)
• os: putEnv(key, val: string)

pwd:

• asyncftpclient: pwd(ftp: AsyncFtpClient): Future[TaintedString]

PWOHandleArray:

• winlean: PWOHandleArray

q:

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

querySelector:

• dom: querySelector(d: Document; selectors: cstring): Element

querySelectorAll:

• dom: querySelectorAll(d: Document; 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](a: openArray[T]): T
• random: rand[T: Ordinal or SomeFloat](r: var Rand; x: HSlice[T, T]): T
• random: rand(r: var Rand; max: Natural): int
• random: rand[T](r: var Rand; a: openArray[T]): T
• random: rand(r: var Rand; max: range[0.0 .. high(float)]): float
• random: rand[T: SomeInteger](t: typedesc[T]): T

random:

• random: random(max: float): float
• random: random[T](x: HSlice[T, T]): T
• random: random(max: int): int
• random: random[T](a: openArray[T]): T

randomize:

• random: randomize()
• random: randomize(seed: int64)

range:

• system: range

rangeCheck:

• system: rangeCheck(cond)

RangeError:

• system: RangeError

Rational:

• rationals: Rational

rawData:

• parsexml: rawData(my: var XmlParser): string

rawData2:

• parsexml: rawData2(my: var XmlParser): 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)

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): TaintedString
• streams: readAll(s: Stream): string

readAllFromStdin:

• nimscript: readAllFromStdin(): TaintedString

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]; 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): TaintedString
• 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(my: 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): TaintedString
• io: readLine(f: File; line: var TaintedString): bool
• linenoise: readLine(prompt: cstring): cstring
• net: readLine(socket: Socket; line: var TaintedString; timeout = -1; flags = {SafeDisconn}; maxLength = MaxLineLength)
• streams: readLine(s: Stream): TaintedString
• streams: readLine(s: Stream; line: var TaintedString): bool

readLineFromStdin:

• nimscript: readLineFromStdin(): TaintedString
• rdstdin: readLineFromStdin(prompt: string): TaintedString
• rdstdin: readLineFromStdin(prompt: string; line: var TaintedString): bool

ReadLineResult:

• net: ReadLineResult

readLines:

• io: readLines(filename: string; n: Natural): seq[TaintedString]
• io: readLines(filename: string): seq[TaintedString]

ReadNone:

• ReadLineResult.ReadNone

ReadPartialLine:

• ReadLineResult.ReadPartialLine

readPasswordFromStdin:

• terminal: readPasswordFromStdin(prompt = "password: "): TaintedString
• terminal: readPasswordFromStdin(prompt: string; password: var TaintedString): bool

readRow:

• parsecsv: readRow(my: var CsvParser; columns = 0): bool

readStr:

• streams: readStr(s: Stream; length: int): TaintedString

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: ready*[TMsg](c: var Channel[TMsg]): bool

ReadyKey:

• selectors: ReadyKey

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: 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:

• 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): TaintedString

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

register:

• asyncdispatch: register(fd: AsyncFD)
• mimetypes: register(mimedb: var MimeDB; ext: string; mimetype: string)
• selectors: register[T](s: Selector[T]; fd: int | SocketHandle; events: set[Event]; data: T)

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

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)

releaseEvents:

• dom: releaseEvents(d: Document; eventMask: int)
• dom: releaseEvents(w: Window; eventMask: int)

reload:

• dom: reload(loc: Location)

remainingArgs:

• parseopt: remainingArgs(p: OptParser): seq[TaintedString]

remove:

• dom: remove(c: ClassList; class: cstring)
• lists: remove[T](L: var DoublyLinkedList[T]; n: DoublyLinkedNode[T])
• lists: remove[T](L: var DoublyLinkedRing[T]; n: DoublyLinkedNode[T])

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(ls: LocalStorage; 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

renderIndexTerm:

• rstgen: renderIndexTerm(d: PDoc; n: PRstNode; result: var string)

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)

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: T): T
• 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

Request:

• asynchttpserver: Request

request:

• httpclient: request(client: AsyncHttpClient; url: string; httpMethod = HttpGet; body = ""; headers: HttpHeaders = nil; multipart: MultipartData = nil): Future[ AsyncResponse]
• httpclient: request(client: AsyncHttpClient; url: string; httpMethod: string; body = ""; headers: HttpHeaders = nil; multipart: MultipartData = nil): Future[ AsyncResponse]
• httpclient: request(client: HttpClient; url: string; httpMethod = HttpGet; body = ""; headers: HttpHeaders = nil; multipart: MultipartData = nil): Response
• httpclient: request(client: HttpClient; url: string; httpMethod: string; body = ""; headers: HttpHeaders = nil; multipart: MultipartData = nil): Response

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

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()

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:

• Misc

ResourceExhaustedError:

• system: ResourceExhaustedError

respond:

• asynchttpserver: respond(req: Request; code: HttpCode; content: string; headers: HttpHeaders = nil): Future[ void]

Response:

• httpclient: Response

reStructuredText:

• Module rst
• Module rstast
• Module rstgen

reStudy:

• RegexFlag.reStudy

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]

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)

rnBlockQuote:

• RstNodeKind.rnBlockQuote

rnBulletItem:

• RstNodeKind.rnBulletItem

rnBulletList:

• RstNodeKind.rnBulletList

rnCitation:

• RstNodeKind.rnCitation

rnCodeBlock:

• RstNodeKind.rnCodeBlock

rnContainer:

• RstNodeKind.rnContainer

rnContents:

• RstNodeKind.rnContents

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

rnGeneralRole:

• RstNodeKind.rnGeneralRole

rnGridTable:

• RstNodeKind.rnGridTable

rnHeadline:

• RstNodeKind.rnHeadline

rnHyperlink:

• RstNodeKind.rnHyperlink

rnIdx:

• RstNodeKind.rnIdx

rnImage:

• RstNodeKind.rnImage

rnIndex:

• RstNodeKind.rnIndex

rnInlineLiteral:

• RstNodeKind.rnInlineLiteral

rnInner:

• RstNodeKind.rnInner

rnInterpretedText:

• RstNodeKind.rnInterpretedText

rnLabel:

• RstNodeKind.rnLabel

rnLeaf:

• RstNodeKind.rnLeaf

rnLineBlock:

• RstNodeKind.rnLineBlock

rnLineBlockItem:

• RstNodeKind.rnLineBlockItem

rnLiteralBlock:

• RstNodeKind.rnLiteralBlock

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

RollingFileLogger:

• logging: RollingFileLogger

roof:

• Misc

RootEffect:

• system: RootEffect

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

roSkipPounds:

• RstParseOption.roSkipPounds

roSupportMarkdown:

• RstParseOption.roSupportMarkdown

roSupportRawDirective:

• RstParseOption.roSupportRawDirective

roSupportSmilies:

• RstParseOption.roSupportSmilies

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(value: uint16; amount: range[0 .. 16]): uint16
• bitops: rotateLeftBits(value: uint32; amount: range[0 .. 32]): uint32
• bitops: rotateLeftBits(value: uint64; amount: range[0 .. 64]): uint64
• bitops: rotateLeftBits(value: uint8; amount: range[0 .. 8]): uint8

rotateRightBits:

• bitops: rotateRightBits(value: uint16; amount: range[0 .. 16]): uint16
• bitops: rotateRightBits(value: uint32; amount: range[0 .. 32]): uint32
• bitops: rotateRightBits(value: uint64; amount: range[0 .. 64]): uint64
• bitops: rotateRightBits(value: uint8; amount: range[0 .. 8]): uint8

round:

• 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(my: 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; 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

rstnodeToRefname:

• rst: rstnodeToRefname(n: PRstNode): string

rstParse:

• rst: rstParse(text, filename: string; line, column: int; hasToc: var bool; options: RstParseOptions; findFile: FindFileHandler = nil; msgHandler: MsgHandler = nil): PRstNode

RstParseOption:

• rst: RstParseOption

RstParseOptions:

• rst: RstParseOptions

rstToHtml:

• rstgen: rstToHtml(s: string; options: RstParseOptions; config: StringTableRef): 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:

• Misc

runnableExamples:

• system: runnableExamples(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

sameType:

• macros: sameType(a, b: NimNode): bool

samp:

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

sample:

• random: sample[T](a: openArray[T]): 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

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)

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

SecondaryButton:

• MouseButtons.SecondaryButton

SecondRange:

• times: SecondRange

Seconds:

• TimeUnit.Seconds

seconds:

• times: seconds(dur: Duration): int64
• times: seconds(s: int): TimeInterval

section:

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

SecureHash:

• sha1: SecureHash

secureHash:

• sha1: secureHash(str: openArray[char]): SecureHash

secureHashFile:

• sha1: secureHashFile(filename: string): SecureHash

SECURITY_ATTRIBUTES:

• winlean: SECURITY_ATTRIBUTES

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

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[TaintedString]
• 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: 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

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])
• 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 = ""): owned( Future[void])

Servent:

• nativesockets: Servent
• winlean: Servent

serverGetPskFunc:

• net: serverGetPskFunc(ctx: SslContext): SslServerGetPskFunc

serverGetPskFunc=:

• net: serverGetPskFunc=(ctx: SslContext; fun: SslServerGetPskFunc)

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: ptr 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): string
• cookies: setCookie(key, value: string; domain = ""; path = ""; expires = ""; noName = false; secure = false; httpOnly = false): 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

setEnvironmentVariableW:

• winlean: setEnvironmentVariableW(lpName, lpValue: WideCString): int32

setEvent:

• selectors: setEvent(ev: SelectEvent)
• 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])

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)

setGcFrame:

• system: setGcFrame(s: GcFrame)

setGlobalDispatcher:

• asyncdispatch: setGlobalDispatcher(disp: owned PDispatcher)

setHandleInformation:

• winlean: setHandleInformation(hObject: Handle; dwMask: DWORD; dwFlags: DWORD): WINBOOL

setIndexTerm:

• rstgen: setIndexTerm(d: var RstGenerator; htmlFile, id, term: string; linkTitle, linkDesc = "")

setInterval:

• dom: setInterval(w: Window; code: cstring; pause: int): ref Interval
• dom: setInterval(w: Window; function: proc (); pause: int): ref Interval

setItem:

• dom: setItem(ls: LocalStorage; 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; mask: 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)

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")

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): ref TimeOut
• dom: setTimeout(w: Window; function: proc (); pause: int): ref 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

shallow:

• system: shallow[T](s: var seq[T])
• system: shallow(s: var string)
• Misc
• Misc

shallow copy:

• Misc

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

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

SIGABRT:

• segfaults: SIGABRT

SIGFPE:

• segfaults: SIGFPE

SIGILL:

• segfaults: SIGILL

SIGINT:

• segfaults: SIGINT

signal:

• locks: signal(cond: var Cond)

signalFence:

• atomics: signalFence(order: MemoryOrder)

signatureHash:

• macros: signatureHash(n: NimNode): string

SIGSEGV:

• segfaults: SIGSEGV

simple assertions:

• Simple assertions

sin:

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

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]
• math: sinh(x: float32): float32
• math: sinh(x: float64): float64

sink:

• system: sink
• Misc

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:

• Misc
• Misc

SList:

• SexpNodeKind.SList

slope:

• stats: slope(r: RunningRegress): float

slot:

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

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]): (A, int)

smartBinarySearch:

• algorithm: smartBinarySearch[T](a: openArray[T]; key: T): 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): void

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: 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

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

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 intsets

spawn:

• threadpool: spawn(call: typed): void

spawnX:

• threadpool: spawnX(call): void

splice:

• Misc
• Misc

split:

• 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

SqlQuery:

• db_common: SqlQuery

sqrt:

• complex: sqrt[T](z: Complex[T]): Complex[T]
• 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

SslHandshakeType:

• net: SslHandshakeType

SslProtVersion:

• net: SslProtVersion

SslServerGetPskFunc:

• net: SslServerGetPskFunc

SString:

• SexpNodeKind.SString

SSymbol:

• SexpNodeKind.SSymbol

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
• 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

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)

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

StringStream:

• streams: StringStream

StringStreamObj:

• streams: StringStreamObj

StringTableMode:

• strtabs: StringTableMode

StringTableObj:

• strtabs: StringTableObj

StringTableRef:

• strtabs: StringTableRef

strip:

• 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:

• Misc

supportsCopyMem:

• typetraits: supportsCopyMem(t: typedesc): bool

suspend:

• coro: suspend(sleepTime: float = 0)
• osproc: suspend(p: Process)

suspendThread:

• winlean: suspendThread(hThread: Handle): int32

svcMapMemory:

• switch_memory: svcMapMemory(dst_addr: pointer; src_addr: pointer; size: uint64): uint32

svcUnmapMemory:

• switch_memory: svcUnmapMemory(dst_addr: pointer; src_addr: pointer; size: uint64): uint32

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): void

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)

symKind:

• macros: symKind(symbol: NimNode): NimSymKind

symlinkExists:

• os: symlinkExists(link: string): bool

symmetricDifference:

• intsets: symmetricDifference(s1, s2: IntSet): IntSet
• 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): string

tag=:

• xmltree: tag=(n: XmlNode; tag: 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

tainted:

• Misc

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]
• math: tan(x: float32): float32
• math: tan(x: float64): float64

tanh:

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

task:

• nimscript: task(name: untyped; description: string; body: untyped): untyped

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:

• 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:

• xmltree: text(n: XmlNode): string

text=:

• xmltree: text=(n: XmlNode; text: 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

tgamma:

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

th:

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

thead:

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

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

TimeUnit:

• times: TimeUnit

Timeval:

• winlean: Timeval

Timezone:

• times: 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

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]

toDll:

• nimscript: toDll(filename: string): string

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]

toHex:

• strutils: toHex(x: BiggestInt; len: Positive): string
• strutils: toHex(s: string): string
• strutils: toHex[T: SomeInteger](x: T): 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

toJs:

• jsffi: toJs[T](val: T): JsObject
• jsffi: toJs(s: string): JsObject

toJsKey:

• jsffi: toJsKey[T: SomeInteger](text: cstring; t: type T): T
• jsffi: toJsKey[T: enum](text: cstring; t: type T): T
• jsffi: toJsKey(text: cstring; t: type cstring): cstring
• jsffi: toJsKey[T: SomeFloat](text: cstring; t: type T): T

TokenClass:

• highlite: TokenClass

tokenClassToStr:

• highlite: tokenClassToStr

tokenize:

• strutils: tokenize(s: string; seps: set[char] = Whitespace): tuple[token: string, isSep: bool]

TokKind:

• parsejson: TokKind

toKnownDomain:

• nativesockets: toKnownDomain(family: cint): Option[Domain]

toLower:

• unicode: toLower(c: Rune): Rune
• unicode: toLower(s: string): string

toLowerAscii:

• strutils: toLowerAscii(c: char): char
• strutils: toLowerAscii(s: string): string

toMD5:

• md5: toMD5(s: string): MD5Digest

toNimIdent:

• macros: toNimIdent(s: string): NimIdent

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

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]

toSeconds:

• times: toSeconds(time: Time): float

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]

toSockAddr:

• net: toSockAddr(address: IpAddress; port: Port; sa: var Sockaddr_storage; sl: var SockLen)

toSockType:

• nativesockets: toSockType(protocol: Protocol): SockType

toString:

• Module dollars
• httpcore: toString(values: HttpHeaderValues): string

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]

toTime:

• times: toTime(dt: DateTime): Time

toTimeInterval:

• times: toTimeInterval(time: Time): TimeInterval

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

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)

track:

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

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

trigger:

• asyncdispatch: trigger(ev: AsyncEvent)
• selectors: trigger(ev: SelectEvent)

trimZeros:

• strutils: trimZeros(x: var string; decimalSep = '.')

trunc:

• 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; query: SqlQuery; args: varargs[string, `$`]): bool

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: tryRecv*[TMsg](c: var Channel[TMsg]): tuple[dataAvailable: bool, msg: TMsg]

tryRemoveFile:

• os: tryRemoveFile(file: string): bool

trySend:

• channels: 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:

• Special node kinds
• Special node kinds
• Special node kinds

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

uint64:

• system: uint64

uint8:

• system: uint8

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): string
• strutils: unindent(s: string; count: Natural; padding: string = " "): string

union:

• intsets: union(s1, s2: IntSet): IntSet
• sets: union[A](s1, s2: HashSet[A]): HashSet[A]

unixTimeToWinTime:

• times: unixTimeToWinTime(time: CTime): int64

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:

• Creating JSON

unown:

• system: unown(x: typed): untyped

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]): T

unsafeNew:

• system: unsafeNew[T](a: var ref T; size: Natural)

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:

• selectors: update[T](s: Selector[T]; fd: int | SocketHandle; events: set[Event])
• 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

Uri:

• uri: Uri

Url:

• uri: Url

useEmpty:

• FormatFlag.useEmpty

useEnvironment:

• FormatFlag.useEnvironment

useKey:

• FormatFlag.useKey

useWinUnicode:

• winlean: useWinUnicode

utc:

• times: utc(): Timezone
• times: utc(dt: DateTime): DateTime
• times: utc(t: Time): DateTime

Utf16Char:

• widestrs: Utf16Char

utf8:

• unicode: utf8(s: string): string

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
• 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]): B
• tables: values[A, B](t: OrderedTableRef[A, B]): B
• tables: values[A, B](t: Table[A, B]): B
• tables: values[A, B](t: TableRef[A, B]): B

valuesWithPrefix:

• critbits: valuesWithPrefix[T](c: CritBitTree[T]; prefix: string; longestMatch = false): 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

video:

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

virtmemReserveMap:

• switch_memory: virtmemReserveMap(size: csize): pointer

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

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

Weeks:

• TimeUnit.Weeks

weeks:

• times: weeks(dur: Duration): int64
• times: weeks(w: int): TimeInterval

whichMsgClass:

• rst: whichMsgClass(k: MsgKind): MsgClass

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

winTimeToUnixTime:

• times: winTimeToUnixTime(time: int64): CTime

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: var RLock; code: untyped): 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)

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)

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

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

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

zoneInfoFromTz:

• times: zoneInfoFromTz(zone: Timezone; adjTime: Time): ZonedTime

zoneInfoFromUtc:

• times: zoneInfoFromUtc(zone: Timezone; time: Time): ZonedTime