Index
Documents:
API naming design
,
Code owners
,
Contributing
,
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 Garbage Collector
,
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
,
asyncnet
,
asyncstreams
,
base64
,
bitops
,
browsers
,
cgi
,
chains
,
channels
,
colors
,
complex
,
cookies
,
coro
,
cpuinfo
,
cpuload
,
critbits
,
cstrutils
,
db_common
,
db_mysql
,
db_odbc
,
db_postgres
,
db_sqlite
,
deques
,
diff
,
distros
,
dollars
,
dom
,
dynlib
,
editdistance
,
encodings
,
endians
,
fenv
,
hashes
,
heapqueue
,
highlite
,
htmlgen
,
htmlparser
,
httpclient
,
httpcore
,
intsets
,
io
,
iterators
,
jsconsole
,
jsffi
,
json
,
lenientops
,
lexbase
,
linenoise
,
lists
,
locks
,
logging
,
macros
,
marshal
,
math
,
md5
,
memfiles
,
mersenne
,
mimetypes
,
monotimes
,
nativesockets
,
net
,
nimprof
,
nimscript
,
nre
,
oids
,
options
,
os
,
osproc
,
oswalkdir
,
parsecfg
,
parsecsv
,
parsejson
,
parseopt
,
parsesql
,
parseutils
,
parsexml
,
pegs
,
posix_utils
,
punycode
,
random
,
rationals
,
rdstdin
,
re
,
registry
,
rlocks
,
ropes
,
rst
,
rstast
,
rstgen
,
rtarrays
,
segfaults
,
selectors
,
sequtils
,
sets
,
sexp
,
sha1
,
sharedlist
,
sharedtables
,
smtp
,
stats
,
streams
,
strformat
,
strmisc
,
strscans
,
strtabs
,
strutils
,
sugar
,
sums
,
system
,
tables
,
terminal
,
threadpool
,
threads
,
time_t
,
times
,
typeinfo
,
typetraits
,
unicode
,
unidecode
,
unittest
,
uri
,
util
,
varints
,
volatile
,
widestrs
,
winlean
,
wordwrap
,
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
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: int64): int64
system: `%%`(x, y: IntMax32): IntMax32
`%*`:
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: int64): bool
system: `<%`(x, y: IntMax32): bool
unicode: `<%`(a, b: Rune): bool
`<>`:
xmltree: `<>`(x: untyped): untyped
`<//>`:
system: `<//>`(t: untyped): untyped
`<=%`:
system: `<=%`(x, y: int64): bool
system: `<=%`(x, y: IntMax32): 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: SomeUnsignedInt](x, y: T): bool
system: `<=`[T: tuple](x, y: T): 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: `<`[T](x: Ordinal[T]): T
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: SomeUnsignedInt](x, y: T): bool
system: `<`[T: tuple](x, y: T): bool
times: `<`(a, b: DateTime): bool
times: `<`(a, b: Duration): bool
times: `<`(a, b: Time): bool
`*%`:
system: `*%`(x, y: int64): int64
system: `*%`(x, y: IntMax32): IntMax32
`*=`:
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: `*`[T: SomeUnsignedInt](x, y: T): T
times: `*`(a: Duration; b: int64): Duration
times: `*`(a: int64; b: Duration): Duration
`+%`:
system: `+%`(x, y: int64): int64
system: `+%`(x, y: IntMax32): IntMax32
`++`:
jsffi: `++`(x: JsObject): JsObject
`+=`:
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: `+`[T: SomeUnsignedInt](x, y: T): T
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: int64): int64
system: `-%`(x, y: IntMax32): IntMax32
`->`:
sugar: `->`(p, b: untyped): untyped
`-+-`:
sets: `-+-`[A](s1, s2: HashSet[A]): HashSet[A]
`--`:
jsffi: `--`(x: JsObject): JsObject
nimscript: `--`(key: untyped)
nimscript: `--`(key, val: untyped)
`-=`:
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: `-`(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: `-`[T: SomeUnsignedInt](x, y: T): T
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: T): HSlice[int, T]
system: `..`[T, U](a: T; b: U): HSlice[T, U]
system: `..`(a, b: int32): int32
system: `..`(a, b: int64): int64
system: `..`[T](a, b: T): T
system: `..`(a, b: uint32): uint32
system: `..`(a, b: uint64): uint64
`.=`:
jsffi: `.=`[K: cstring; V](obj: JsAssoc[K, V]; field: untyped; value: V): untyped
jsffi: `.=`(obj: JsObject; field, value: untyped): untyped
`.`:
jsffi: `.`[K: cstring; V](obj: JsAssoc[K, V]; field: untyped): V
jsffi: `.`(obj: JsObject; field: untyped): JsObject
`/%`:
system: `/%`(x, y: int64): int64
system: `/%`(x, y: IntMax32): IntMax32
`/../`:
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: SomeUnsignedInt](x, y: T): bool
system: `==`[T: tuple | object](x, y: T): 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
`?`:
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: var MultipartData; name, content: string)
httpclient: `[]=`(p: var 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)
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: 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
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
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
sugar: `[]`(lc: ListComprehension; comp, typ: untyped): untyped
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
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`[T: SomeUnsignedInt](x, y: T): T
system: `and`(a, b: typedesc): typedesc
`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`[T: SomeUnsignedInt](x, y: T): T
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`[T: SomeUnsignedInt](x, y: T): T
`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`[T: SomeUnsignedInt](x: T): T
system: `not`(a: typedesc): typedesc
`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`[T: SomeUnsignedInt](x, y: T): T
system: `or`(a, b: typedesc): typedesc
`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`[T: SomeUnsignedInt](x: T; y: SomeInteger): T
`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`[T: SomeUnsignedInt](x: T; y: SomeInteger): T
`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`[T: SomeUnsignedInt](x, y: T): T
`{}=`:
json: `{}=`(node: JsonNode; keys: varargs[string]; value: JsonNode)
`{}`:
jsffi: `{}`(typ: typedesc; xs: varargs[untyped]): auto
json: `{}`(node: JsonNode; index: varargs[int]): JsonNode
json: `{}`(node: JsonNode; keys: varargs[string]): JsonNode
`|`:
sugar: `|`(lc: ListComprehension; comp: untyped): untyped
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
accumulateResult:
system: accumulateResult(iter: untyped)
acquire:
locks: acquire(lock: var Lock)
rlocks: acquire(lock: var RLock)
add:
dom: add(c: ClassList; class: cstring)
httpclient: add(p: var MultipartData; xs: MultipartEntries): MultipartData
httpclient: add(p: var MultipartData; name, content: string; filename: string = ""; contentType: string = "")
httpcore: add(headers: HttpHeaders; key, value: string)
json: add(father, child: JsonNode)
json: add(obj: JsonNode; key: string; val: JsonNode)
macros: add(father, child: NimNode): NimNode
macros: add(father: NimNode; children: varargs[NimNode]): NimNode
parsesql: add(father, n: SqlNode)
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: var MultipartData; xs: openArray[tuple[name, file: string]]): 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
addOutputFormatter:
unittest: addOutputFormatter(formatter: OutputFormatter)
addPragma:
macros: addPragma(someProc, pragma: NimNode)
addProcess:
asyncdispatch: addProcess(pid: int; cb: Callback)
addQuitProc:
system: addQuitProc(quitProc: proc () {.noconv.})
addQuoted:
system: addQuoted[T](s: var string; x: T)
addRead:
asyncdispatch: addRead(fd: AsyncFD; cb: Callback)
address:
htmlgen: address(e: varargs[untyped]): untyped
AddrInfo:
winlean: AddrInfo
addSep:
strutils: addSep(dest: var string; sep = ", "; startLen: Natural = 0)
addTimer:
asyncdispatch: addTimer(timeout: int; oneshot: bool; cb: Callback)
addWrite:
asyncdispatch: addWrite(fd: AsyncFD; cb: Callback)
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
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
allocCStringArray:
system: allocCStringArray(a: openArray[string]): cstringArray
allocShared:
system: allocShared(size: Natural): pointer
allocShared0:
system: allocShared0(size: Natural): pointer
allowEmptyAttribs:
XmlParseOption.allowEmptyAttribs
allowUnquotedAttribs:
XmlParseOption.allowUnquotedAttribs
allValues:
tables: allValues[A, B](t: Table[A, B]; key: A): B
AltSep:
os: AltSep
AnchorElement:
dom: AnchorElement
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
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
atomicDec:
system: atomicDec(memLoc: var int; x: int = 1): int
atomicInc:
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)
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
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
BY_HANDLE_FILE_INFORMATION:
winlean: BY_HANDLE_FILE_INFORMATION
byte:
system: byte
ByteAddress:
system: ByteAddress
c_abort:
segfaults: c_abort()
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
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
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
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; f: CFilePtr): cint
CgiError:
cgi: CgiError
cgiError:
cgi: cgiError(msg: string)
ch:
pegs: ch(p: Peg): char
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:
deques: clear[T](deq: var Deque[T])
heapqueue: clear[T](heap: var HeapQueue[T])
httpcore: clear(headers: HttpHeaders)
intsets: clear(result: var IntSet)
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; 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: var 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): 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): pointer
c_memcmp:
segfaults: c_memcmp(a, b: pointer; size: csize): cint
c_memcpy:
segfaults: c_memcpy(a, b: pointer; size: csize): pointer
c_memmove:
segfaults: c_memmove(a, b: pointer; size: csize): pointer
c_memset:
segfaults: c_memset(p: pointer; value: cint; size: csize): 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
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
commonAttr:
htmlgen: commonAttr
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
condition system:
Misc
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
convertToConsoleLoggable:
jsconsole: convertToConsoleLoggable[T](v: T): RootRef
jsconsole: convertToConsoleLoggable(v: string): RootRef
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:
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
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
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): 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
c_sprintf:
segfaults: c_sprintf(buf, frmt: cstring): cint
cstderr:
segfaults: cstderr
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
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
cut:
Misc
CVerifyNone:
SslCVerifyMode.CVerifyNone
CVerifyPeer:
SslCVerifyMode.CVerifyPeer
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)
deallocShared:
system: deallocShared(p: pointer)
debug:
jsconsole: debug(console: Console; args: varargs[RootRef, convertToConsoleLoggable]): untyped
logging: debug(args: varargs[string, `$`])
debugEcho:
system: debugEcho(x: varargs[typed, `$`])
dec:
system: dec[T: Ordinal | uint | uint64](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:
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, B](t: var OrderedTable[A, B]; key: A)
tables: del[A, B](t: var 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)
distinctBase:
sugar: distinctBase(T: typedesc): 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
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
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
strutils: 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]; lineLen = 75; newLine = ""): string
base64: encode(s: string; lineLen = 75; newLine = ""): string
punycode: encode(s: string): string
punycode: encode(prefix, s: string): 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
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; args: varargs[RootRef, convertToConsoleLoggable]): untyped
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)
Event:
dom: Event
selectors: Event
eventAttr:
htmlgen: eventAttr
eventParser:
pegs: eventParser(pegAst, handlers: untyped): (proc (s: string): int)
EventPhase:
dom: EventPhase
EventTarget:
dom: EventTarget
EvLines:
FtpEventType.EvLines
EvRetr:
FtpEventType.EvRetr
EvStore:
FtpEventType.EvStore
EvTransferProgress:
FtpEventType.EvTransferProgress
Exception:
system: Exception
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:
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
existsKey:
json: existsKey(node: JsonNode; key: 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
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
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
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[a, b: RootObj]
iterators: fieldPairs[T: tuple | object](x: T): RootObj
fields:
iterators: fields[S: tuple | object; T: tuple | object](x: S; y: T): tuple[a, b: 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
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
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
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
gcd:
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
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
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
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
getBVal:
json: getBVal(n: JsonNode; default: bool = false): bool
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:
json: getFNum(n: JsonNode; default: float = 0.0): float
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
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:
json: getNum(n: JsonNode; default: BiggestInt = 0): BiggestInt
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)
getpeername:
Chat server
Module nativesockets
Creating a server
winlean: getpeername(s: SocketHandle; name: ptr SockAddr; namelen: ptr SockLen): cint
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]
getRefcount:
system: getRefcount[T](x: ref T): int
system: getRefcount[T](x: seq[T]): int
system: getRefcount(x: string): int
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
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
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
handleMatches:
pegs: handleMatches(m: int; n: int; c: openArray[string]): string
handleRefillChar:
lexbase: handleRefillChar(L: var BaseLexer; pos: int): int
handshakeAsClient:
SslHandshakeType.handshakeAsClient
handshakeAsServer:
SslHandshakeType.handshakeAsServer
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: char): Hash
hashes: hash(x: cstring): Hash
hashes: hash(x: float): Hash
hashes: hash(x: int): Hash
hashes: hash(x: int64): 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
hashes: hash(x: uint): Hash
hashes: hash(x: uint64): 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
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
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
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
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
In6_addr:
winlean: In6_addr
InAddr:
winlean: InAddr
INADDR_ANY:
winlean: INADDR_ANY
INADDR_BROADCAST:
winlean: INADDR_BROADCAST
INADDR_LOOPBACK:
winlean: INADDR_LOOPBACK
INADDR_NONE:
winlean: INADDR_NONE
inc:
critbits: inc(c: var CritBitTree[int]; key: string; val: int = 1)
system: inc[T: Ordinal | uint | uint64](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)
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])
inclSetElement:
typeinfo: inclSetElement(x: Any; elem: int)
inDays:
times: inDays(dur: Duration): int64
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
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
Inf:
system: Inf
INFINITE:
winlean: INFINITE
infix:
macros: infix(a: NimNode; op: string; b: NimNode): NimNode
info:
jsconsole: info(console: Console; args: varargs[RootRef, convertToConsoleLoggable]): untyped
logging: info(args: varargs[string, `$`])
inHours:
times: inHours(dur: Duration): int64
init:
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
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
inMicroseconds:
times: inMicroseconds(dur: Duration): int64
inMilliseconds:
times: inMilliseconds(dur: Duration): int64
inMinutes:
times: inMinutes(dur: Duration): int64
inNanoseconds:
times: inNanoseconds(dur: Duration): int64
innerText:
xmltree: innerText(n: XmlNode): string
input:
htmlgen: input(e: varargs[untyped]): untyped
InputElement:
dom: InputElement
inputHandle:
osproc: inputHandle(p: Process): FileHandle
inputStream:
osproc: inputStream(p: Process): Stream
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: 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)
inv:
complex: inv[T](z: Complex[T]): Complex[T]
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
strutils: isAlphaAscii(s: string): bool
isAlphaNumeric:
strutils: isAlphaNumeric(c: char): bool
strutils: isAlphaNumeric(s: string): 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
strutils: isDigit(s: string): bool
isDisconnectionError:
net: isDisconnectionError(flags: set[SocketFlag]; lastError: OSErrorCode): bool
isEmpty:
selectors: isEmpty[T](s: Selector[T]): 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
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
strutils: isLowerAscii(s: string; skipNonAlpha: bool): 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
isNilOrEmpty:
strutils: isNilOrEmpty(s: string): 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
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
strutils: isSpaceAscii(s: string): 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
strutils: isUpperAscii(s: string; skipNonAlpha: bool): bool
isValid:
sets: isValid[A](s: HashSet[A]): bool
sets: isValid[A](s: OrderedSet[A]): 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
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)
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
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
lc:
sugar: lc
lcm:
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
macros: len(n: NimNode): int
parsesql: len(n: SqlNode): 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
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
Module strutils
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:
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
Location:
dom: Location
LocationBar:
dom: LocationBar
Lock:
locks: Lock
log:
jsconsole: log(console: Console; args: varargs[RootRef, convertToConsoleLoggable]): untyped
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
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
sequtils: mapIt(s, typ, 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
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
MAX_INT:
Misc
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
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)
memoryUnlock:
posix_utils: memoryUnlock(a1: pointer; a2: int)
memoryUnlockAll:
posix_utils: memoryUnlockAll()
MemSlice:
memfiles: MemSlice
memSlices:
memfiles: memSlices(mfile: MemFile; delim = ' '; eat = '\c'): MemSlice
meNewSectionExpected:
MsgKind.meNewSectionExpected
MenuBar:
dom: MenuBar
merge:
tables: merge[A](s: var CountTable[A]; t: CountTable[A])
tables: merge[A](s, t: CountTable[A]): CountTable[A]
tables: merge[A](s, t: CountTableRef[A])
mergeIndexes:
rstgen: mergeIndexes(dir: string): string
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
mget:
asyncfutures: mget[T](future: FutureVar[T]): var T
sharedtables: mget[A, B](t: var SharedTable[A, B]; key: A): var B
tables: mget[A](t: var CountTable[A]; key: A): var int
tables: mget[A](t: CountTableRef[A]; key: A): var int
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
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
minimumPositiveValue:
fenv: minimumPositiveValue(T: typedesc[float32]): float32
fenv: minimumPositiveValue(T: typedesc[float64]): float64
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)
mmap:
Module memfiles
mMar:
Month.mMar
mMay:
Month.mMay
mNov:
Month.mNov
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)
moveTo:
dom: moveTo(w: Window; x, y: int)
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]
mSep:
Month.mSep
MsgClass:
rst: MsgClass
MsgHandler:
rst: MsgHandler
MsgKind:
rst: MsgKind
MSG_PEEK:
winlean: MSG_PEEK
MultipartData:
httpclient: MultipartData
MultipartEntries:
httpclient: MultipartEntries
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
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): 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"): SslContext
newCountTable:
tables: newCountTable[A](initialSize = defaultInitialSize): CountTableRef[A]
tables: newCountTable[A](keys: openArray[A]): CountTableRef[A]
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): 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[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)
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)
NORMAL_PRIORITY_CLASS:
winlean: NORMAL_PRIORITY_CLASS
noscript:
htmlgen: noscript(e: varargs[untyped]): untyped
NotationNode:
NodeType.NotationNode
notice:
logging: notice(args: varargs[string, `$`])
now:
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
on:
system: on
once:
system: once(body: untyped): untyped
onFailedAssert:
assertions: onFailedAssert(msg, code: untyped): untyped
onRaise:
system: onRaise(action: proc (e: ref Exception): bool {.closure.})
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(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
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]
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
oswalkdir: PathComponent
PathSep:
os: PathSep
patricia trie:
Module critbits
pcDir:
PathComponent.pcDir
PathComponent.pcDir
pcFile:
PathComponent.pcFile
PathComponent.pcFile
pcLinkToDir:
PathComponent.pcLinkToDir
PathComponent.pcLinkToDir
pcLinkToFile:
PathComponent.pcLinkToFile
PathComponent.pcLinkToFile
PCustomOverlapped:
asyncdispatch: PCustomOverlapped
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
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
sets: pop[A](s: var HashSet[A]): A
system: pop[T](s: var seq[T]): T
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
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]
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: XmlParser): string
rawData2:
parsexml: rawData2(my: 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): seq[TaintedString]
io: readLines(filename: string; n: Natural): 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
reallocShared:
system: reallocShared(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)
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)
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): Future[AsyncResponse]
httpclient: request(client: AsyncHttpClient; url: string; httpMethod: string; body = ""; headers: HttpHeaders = nil): Future[AsyncResponse]
httpclient: request(client: HttpClient; url: string; httpMethod = HttpGet; body = ""; headers: HttpHeaders = nil): Response
httpclient: request(client: HttpClient; url: string; httpMethod: string; body = ""; headers: HttpHeaders = 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
reset:
dom: reset(f: FormElement)
system: reset[T](obj: var T)
resetAttributes:
terminal: resetAttributes()
terminal: resetAttributes(f: File)
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
tables: rightSize(count: Natural): int
RLock:
rlocks: RLock
rmDir:
nimscript: rmDir(dir: string)
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
safeAdd:
system: safeAdd[T](x: var seq[T]; y: T)
system: safeAdd(x: var string; y: char)
system: safeAdd(x: var string; y: string)
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
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
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)
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: 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)
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
setLastError:
winlean: setLastError(error: int32)
setLastModificationTime:
os: setLastModificationTime(file: string; t: times.Time)
setLen:
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
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)
signatureHash:
macros: signatureHash(n: NimNode): string
SIGSEGV:
segfaults: SIGSEGV
simple assertions:
Simple assertions
simpleGetOrDefault:
json: simpleGetOrDefault{ {}(node, [key]) }(node: JsonNode; key: string): JsonNode
sin:
complex: sin[T](z: Complex[T]): Complex[T]
math: sin(x: float32): float32
math: sin(x: float64): float64
SingleTags:
htmlparser: SingleTags
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
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])
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
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
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)
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
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
Time:
times: Time
time_t: Time
TimeEffect:
system: TimeEffect
TimeFormat:
times: TimeFormat
TimeFormatParseError:
times: TimeFormatParseError
TimeInterval:
times: TimeInterval
TimeIntervalParts:
times: TimeIntervalParts
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(node: JsonNode; T: typedesc): untyped
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
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
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)
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: TMsg): bool
net: trySend(socket: Socket; data: string): bool
tt:
htmlgen: tt(e: varargs[untyped]): untyped
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
unescape:
dom: unescape(uri: cstring): cstring
strutils: unescape(s: string; prefix = "\""; suffix = "\""): string
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
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
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
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
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): tuple[kind: PathComponent, path: string]
oswalkdir: walkDir(dir: string; relative = false): tuple[kind: PathComponent, path: string]
walkDirRec:
os: walkDirRec(dir: string; yieldFilter = {pcFile}; followFilter = {pcDir}; relative = false): string
oswalkdir: walkDirRec(dir: string; filter = {pcFile, pcDir}): string
walkDirs:
os: walkDirs(pattern: string): string
walkFiles:
os: walkFiles(pattern: string): string
walkPattern:
os: walkPattern(pattern: string): string
warn:
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
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
wordWrap:
strutils: wordWrap(s: string; maxLineWidth = 80; splitLongWords = true; seps: set[char] = Whitespace; newLine = " "): string
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, 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
xlen:
system: xlen[T](x: seq[T]): int
system: xlen(x: string): int
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[tuple[a: S, b: 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