Index
Documents:
API naming design
,
Continuous Integration
,
Contributing
,
Embedded Stack Trace Profiler (ESTP) User Guide
,
Language specification
,
Mid-end intermediate representation
,
Moderation
,
Nim Compiler User Guide
,
Nim Destructors and Move Semantics
,
Nim DocGen Tools Guide
,
Nim Documentation Overview
,
Nim Experimental Features
,
Nim IDE Integration Guide
,
Nim IDE Integration Guide
,
Nim maintenance script
,
Nim Standard Library
,
Nim Tutorial (Part I)
,
Nim Tutorial (Part II)
,
Nim Tutorial (Part III)
,
Nim's Memory Management
,
nimgrep User's manual
,
niminst User's manual
,
NimScript
,
Nimskull coding style
,
NimSkull Manual
,
Packaging Nim
,
rst
,
Source Code Filters
,
Testament
,
Tools available with NimSkull
.
Modules:
algorithm
,
asciitables
,
assertions
,
ast_pattern_matching
,
asyncjs
,
atomics
,
backends
,
base64
,
bitops
,
bitops_utils
,
browsers
,
cgi
,
colordiff
,
colors
,
colortext
,
compilesettings
,
complex
,
cookies
,
cpuinfo
,
cpuload
,
critbits
,
cstrutils
,
db_common
,
db_mysql
,
db_odbc
,
db_postgres
,
db_sqlite
,
dbutils
,
debug
,
decode_helpers
,
deques
,
diff
,
digitsutils
,
distros
,
dod_helpers
,
dollars
,
dom
,
dynlib
,
editdistance
,
effecttraits
,
encodings
,
endians
,
enumutils
,
epoll
,
exitprocs
,
fenv
,
genasts
,
gitutils
,
globs
,
graph
,
hashes
,
heapqueue
,
highlite
,
htmlgen
,
htmlparser
,
httpclient
,
httpcore
,
importutils
,
inotify
,
intern
,
intsets
,
io
,
isolation
,
iterators
,
jsbigints
,
jsconsole
,
jscore
,
jsfetch
,
jsffi
,
jsformdata
,
jsheaders
,
json
,
jsonutils
,
jsre
,
jsutils
,
kqueue
,
lenientops
,
lexbase
,
linenoise
,
lists
,
locks
,
logging
,
macrocache
,
macros
,
manual_experimental_strictnotnil
,
marshal
,
math
,
md5
,
memfiles
,
mersenne
,
mimetypes
,
miscdollars
,
monotimes
,
nativesockets
,
net
,
nimprof
,
nimscript
,
nre
,
oids
,
options
,
os
,
osproc
,
packedsets
,
parsecfg
,
parsecsv
,
parsejson
,
parseopt
,
parseopt2
,
parsesql
,
parseutils
,
parsexml
,
pathnorm
,
pegs
,
posix_utils
,
punycode
,
random
,
rationals
,
rdstdin
,
re
,
registry
,
reservedmem
,
results
,
rlocks
,
ropes
,
rstast
,
rstgen
,
rtarrays
,
selectors
,
sequtils
,
sets
,
setutils
,
sexp
,
sexp_diff
,
sexp_parse
,
sha1
,
sharedlist
,
shellrunner
,
since
,
smtp
,
socketstreams
,
ssl_certs
,
ssl_config
,
stackframes
,
stats
,
strbasics
,
streams
,
streamwrapper
,
strformat
,
strimpl
,
strmisc
,
strscans
,
strtabs
,
strutils
,
sugar
,
sums
,
sysrand
,
system
,
tables
,
tasks
,
tempfiles
,
terminal
,
text_layouter
,
threadpool
,
time_t
,
times
,
typeinfo
,
typetraits
,
underscored_calls
,
unicode
,
unidecode
,
unittest
,
uri
,
util
,
varints
,
vmutils
,
volatile
,
widestrs
,
win_getsysteminfo
,
winlean
,
with
,
wordwrap
,
wrapnils
,
xmlparser
,
xmltree
.
API symbols
`!$`:
hashes: `!$`(h: Hash): Hash
`!&`:
hashes: `!&`(h: Hash; val: int): Hash
`!*\`:
pegs: `!*\`(a: Peg): Peg
`!*`:
pegs: `!*`(a: Peg): Peg
`!=`:
system: `!=`(x, y: untyped): untyped
`!`:
pegs: `!`(a: Peg): Peg
`$$`:
marshal: `$$`[T](x: T): string
`$`:
ast_pattern_matching: `$`(arg: MatchingError): string
colors: `$`(c: Color): string
colortext: `$`(colored: ColRune): string
colortext: `$`(colr: ColRuneGrid): string
colortext: `$`(colr: ColRuneLine): string
colortext: `$`(text: ColText): string
complex: `$`(z: Complex): string
critbits: `$`[T](c: CritBitTree[T]): string
deques: `$`[T](deq: Deque[T]): string
dod_helpers: `$`(id: ValueId): string
dollars: `$`(x`gensym0: `{}`(int, lit)): string
dollars: `$`[T, IDX](x: array[IDX, T]): string
dollars: `$`(x: bool): string
dollars: `$`(x: char): string
dollars: `$`(x: cstring): string
dollars: `$`[T, U](x: HSlice[T, U]): string
dollars: `$`(x: int): string
dollars: `$`(x: int64): string
dollars: `$`[T](x: openArray[T]): string
dollars: `$`[T](x: seq[T]): string
dollars: `$`[T](x: set[T]): string
dollars: `$`(x: string): string
dollars: `$`[T: tuple | object](x: T): string
dollars: `$`(t: typedesc): string
dollars: `$`(x: uint64): string
dollars: `$`(x`gensym1: `{}`(uint64, lit)): string
dollars: `$`(x`gensym2: `{}`(int64, lit)): string
dollars: `$`(x: float | float32): string
dom: `$`(s: Selection): string
graph: `$`[Id](graph: Graph[Id]): string
heapqueue: `$`[T](heap: HeapQueue[T]): string
httpclient: `$`(data: MultipartData): string
httpcore: `$`(code: HttpCode): string
httpcore: `$`(headers: HttpHeaders): string
jsbigints: `$`(this: JsBigInt): string
jsfetch: `$`(self: Request | Response | FetchOptions): string
jsformdata: `$`(self: FormData): string
jsheaders: `$`(self: Headers): string
json: `$`(node: JsonNode): string
jsre: `$`(self: RegExp): string
lists: `$`[T](L: SomeLinkedCollection[T]): string
locks: `$`(lock: Lock): string
macros: `$`(arg: LineInfo): string
macros: `$`(node: NimNode): string
md5: `$`(d: MD5Digest): string
memfiles: `$`(ms: MemSlice): string
monotimes: `$`(t: MonoTime): string
nativesockets: `$`(p: Port): string
net: `$`(address: IpAddress): string
nre: `$`(pattern: RegexMatch): string
oids: `$`(oid: Oid): string
options: `$`[T](self: Option[T]): string
os: `$`(err: OSErrorCode): string
packedsets: `$`[A](s: PackedSet[A]): string
parsecfg: `$`(dict: Config): string
parsesql: `$`(n: SqlNode): string
pegs: `$`(r: Peg): string
rationals: `$`[T](x: Rational[T]): string
results: `$`[T: not void; E](self: Result[T, E]): string
results: `$`[E](self: Result[void, E]): 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: `$`[Enum: enum](x: Enum): 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
text_layouter: `$`(le: LayoutElement): string
text_layouter: `$`(blc: LytBlock): string
text_layouter: `$`(sln: LytSolution): string
text_layouter: `$`(id: LytStrId): string
text_layouter: `$`(sln: Option[LytSolution]): 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
widestrs: `$`(s: WideCStringObj): string
widestrs: `$`(s: WideCStringObj; estimate: int; replacement: int = 0x0000FFFD): string
xmltree: `$`(n: XmlNode): string
`%%`:
system: `%%`(x, y: int): int
system: `%%`(x, y: int16): int16
system: `%%`(x, y: int32): int32
system: `%%`(x, y: int64): int64
system: `%%`(x, y: int8): int8
`%*`:
json: `%*`(x: untyped): untyped
`%=`:
jsffi: `%=`(x, y: JsObject): JsObject
`%`:
colortext: `%`(format: string; interpolate: openArray[ColText]): ColText
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)
`&`:
colortext: `&`(t1: sink ColText; t2: ColText): ColText
colortext: `&`(t1: sink ColText; t2: string): ColText
colortext: `&`(t1: string; t2: ColText): ColText
jsffi: `&`(a, b: cstring): cstring
pegs: `&`(a: Peg): Peg
ropes: `&`(a: openArray[Rope]): Rope
ropes: `&`(a, b: Rope): Rope
ropes: `&`(a: Rope; b: string): Rope
ropes: `&`(a: string; b: Rope): Rope
strformat: `&`(pattern: string{lit}): string
system: `&`(x, y: char): string
system: `&`(x: char; y: string): string
system: `&`[T](x, y: sink seq[T]): seq[T]
system: `&`[T](x: sink seq[T]; y: sink T): seq[T]
system: `&`[T](x: sink T; y: sink seq[T]): seq[T]
system: `&`(x: string; y: char): string
system: `&`(x, y: string): string
`>%`:
system: `>%`(x, y: untyped): untyped
`>=%`:
system: `>=%`(x, y: untyped): untyped
`>=`:
jsffi: `>=`(x, y: JsObject): JsObject
system: `>=`(x, y: untyped): untyped
`>`:
jsffi: `>`(x, y: JsObject): JsObject
system: `>`(x, y: untyped): untyped
`<%`:
system: `<%`(x, y: int): bool
system: `<%`(x, y: int16): bool
system: `<%`(x, y: int32): bool
system: `<%`(x, y: int64): bool
system: `<%`(x, y: int8): bool
unicode: `<%`(a, b: Rune): bool
`<>`:
xmltree: `<>`(x: untyped): untyped
`<=%`:
system: `<=%`(x, y: int): bool
system: `<=%`(x, y: int16): bool
system: `<=%`(x, y: int32): bool
system: `<=%`(x, y: int64): bool
system: `<=%`(x, y: int8): bool
unicode: `<=%`(a, b: Rune): bool
`<=`:
jsbigints: `<=`(x, y: JsBigInt): bool
jsffi: `<=`(x, y: JsObject): JsObject
lenientops: `<=`[I: SomeInteger; F: SomeFloat](f: F; i: I): bool
lenientops: `<=`[I: SomeInteger; F: SomeFloat](i: I; f: F): bool
monotimes: `<=`(a, b: MonoTime): bool
packedsets: `<=`[A](s1, s2: PackedSet[A]): bool
rationals: `<=`(x, y: Rational): bool
sets: `<=`[A](s, t: HashSet[A]): bool
system: `<=`(x, y: bool): bool
system: `<=`(x, y: char): bool
system: `<=`(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: `<=`(x, y: pointer): bool
system: `<=`[T](x, y: ref T): bool
system: `<=`[T](x, y: set[T]): bool
system: `<=`(x, y: string): bool
system: `<=`[T: tuple](x, y: T): bool
system: `<=`(x, y: uint): bool
system: `<=`(x, y: uint16): bool
system: `<=`(x, y: uint32): bool
system: `<=`(x, y: uint64): bool
system: `<=`(x, y: uint8): bool
times: `<=`(a, b: DateTime): bool
times: `<=`(a, b: Duration): bool
times: `<=`(a, b: Time): bool
`<`:
jsbigints: `<`(x, y: JsBigInt): bool
jsffi: `<`(x, y: JsObject): JsObject
lenientops: `<`[I: SomeInteger; F: SomeFloat](f: F; i: I): bool
lenientops: `<`[I: SomeInteger; F: SomeFloat](i: I; f: F): bool
monotimes: `<`(a, b: MonoTime): bool
packedsets: `<`[A](s1, s2: PackedSet[A]): bool
rationals: `<`(x, y: Rational): bool
sets: `<`[A](s, t: HashSet[A]): bool
system: `<`(x, y: bool): bool
system: `<`(x, y: char): bool
system: `<`(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: `<`(x, y: pointer): bool
system: `<`[T](x, y: ptr T): bool
system: `<`[T](x, y: ref T): bool
system: `<`[T](x, y: set[T]): bool
system: `<`(x, y: string): bool
system: `<`[T: tuple](x, y: T): bool
system: `<`(x, y: uint): bool
system: `<`(x, y: uint16): bool
system: `<`(x, y: uint32): bool
system: `<`(x, y: uint64): bool
system: `<`(x, y: uint8): bool
times: `<`(a, b: DateTime): bool
times: `<`(a, b: Duration): bool
times: `<`(a, b: Time): bool
`'big`:
jsbigints: `'big`(num: cstring): JsBigInt
`*%`:
system: `*%`(x, y: int): int
system: `*%`(x, y: int16): int16
system: `*%`(x, y: int32): int32
system: `*%`(x, y: int64): int64
system: `*%`(x, y: int8): int8
`**`:
jsbigints: `**`(x, y: JsBigInt): JsBigInt
jsffi: `**`(x, y: JsObject): JsObject
`*=`:
complex: `*=`[T](x: var Complex[T]; y: Complex[T])
jsbigints: `*=`(x: var JsBigInt; y: JsBigInt)
jsffi: `*=`(x, y: JsObject): JsObject
rationals: `*=`[T](x: var Rational[T]; y: Rational[T])
rationals: `*=`[T](x: var Rational[T]; y: T)
system: `*=`[T: SomeInteger](x: var T; y: T)
system: `*=`[T: float | float32 | float64](x: var T; y: T)
times: `*=`(a: var Duration; b: int)
`*`:
algorithm: `*`(x: int; order: SortOrder): int
complex: `*`[T](x, y: Complex[T]): Complex[T]
complex: `*`[T](x: Complex[T]; y: T): Complex[T]
complex: `*`[T](x: T; y: Complex[T]): Complex[T]
jsbigints: `*`(x, y: JsBigInt): JsBigInt
jsffi: `*`(x, y: JsObject): JsObject
lenientops: `*`[I: SomeInteger; F: SomeFloat](f: F; i: I): F
lenientops: `*`[I: SomeInteger; F: SomeFloat](i: I; f: F): F
packedsets: `*`[A](s1, s2: PackedSet[A]): PackedSet[A]
pegs: `*`(a: Peg): Peg
rationals: `*`[T](x, y: Rational[T]): Rational[T]
rationals: `*`[T](x: Rational[T]; y: T): Rational[T]
rationals: `*`[T](x: T; y: Rational[T]): Rational[T]
sets: `*`[A](s1, s2: HashSet[A]): HashSet[A]
system: `*`(x, y: float): float
system: `*`(x, y: float32): float32
system: `*`(x, y: int): int
system: `*`(x, y: int16): int16
system: `*`(x, y: int32): int32
system: `*`(x, y: int64): int64
system: `*`(x, y: int8): int8
system: `*`[T](x, y: set[T]): set[T]
system: `*`(x, y: uint): uint
system: `*`(x, y: uint16): uint16
system: `*`(x, y: uint32): uint32
system: `*`(x, y: uint64): uint64
system: `*`(x, y: uint8): uint8
times: `*`(a: Duration; b: int64): Duration
times: `*`(a: int64; b: Duration): Duration
`+%`:
system: `+%`(x, y: int): int
system: `+%`(x, y: int16): int16
system: `+%`(x, y: int32): int32
system: `+%`(x, y: int64): int64
system: `+%`(x, y: int8): int8
`++`:
jsffi: `++`(x: JsObject): JsObject
`+=`:
atomics: `+=`[T: SomeInteger](location: var Atomic[T]; value: T)
colortext: `+=`(s1: var ColStyle; s2: ColStyle)
complex: `+=`[T](x: var Complex[T]; y: Complex[T])
jsbigints: `+=`(x: var JsBigInt; y: JsBigInt)
jsffi: `+=`(x, y: JsObject): JsObject
rationals: `+=`[T](x: var Rational[T]; y: Rational[T])
rationals: `+=`[T](x: var Rational[T]; y: T)
stats: `+=`(a: var RunningRegress; b: RunningRegress)
stats: `+=`(a: var RunningStat; b: RunningStat)
system: `+=`[T: SomeInteger](x: var T; y: T)
system: `+=`[T: float | float32 | float64](x: var T; y: T)
times: `+=`(a: var DateTime; b: Duration)
times: `+=`(a: var DateTime; b: TimeInterval)
times: `+=`(d1: var Duration; d2: Duration)
times: `+=`(t: var Time; b: Duration)
times: `+=`(t: var Time; b: TimeInterval)
times: `+=`(a: var TimeInterval; b: TimeInterval)
`+`:
colors: `+`(a, b: Color): Color
colortext: `+`(ch: char; style: ColModifier): ColRune
colortext: `+`(a: ColModifier; b: distinct ColModifier): ColStyle
colortext: `+`(s1, s2: ColStyle): ColStyle
colortext: `+`(r: Rune; style: ColModifier): ColRune
colortext: `+`(text: sink ColText; style: ColModifier): ColText
colortext: `+`(text: string; style: ColModifier): ColText
complex: `+`[T](x, y: Complex[T]): Complex[T]
complex: `+`[T](x: Complex[T]; y: T): Complex[T]
complex: `+`[T](x: T; y: Complex[T]): Complex[T]
jsbigints: `+`(_: JsBigInt): JsBigInt
jsbigints: `+`(x, y: JsBigInt): JsBigInt
jsffi: `+`(x, y: JsObject): JsObject
lenientops: `+`[I: SomeInteger; F: SomeFloat](f: F; i: I): F
lenientops: `+`[I: SomeInteger; F: SomeFloat](i: I; f: F): F
monotimes: `+`(a: MonoTime; b: Duration): MonoTime
packedsets: `+`[A](s1, s2: PackedSet[A]): PackedSet[A]
pegs: `+`(a: Peg): Peg
rationals: `+`[T](x, y: Rational[T]): Rational[T]
rationals: `+`[T](x: Rational[T]; y: T): Rational[T]
rationals: `+`[T](x: T; y: Rational[T]): Rational[T]
sets: `+`[A](s1, s2: HashSet[A]): HashSet[A]
stats: `+`(a, b: RunningRegress): RunningRegress
stats: `+`(a, b: RunningStat): RunningStat
system: `+`(x: float): float
system: `+`(x, y: float): float
system: `+`(x: float32): float32
system: `+`(x, y: float32): float32
system: `+`(x: int): int
system: `+`(x, y: int): int
system: `+`(x: int16): int16
system: `+`(x, y: int16): int16
system: `+`(x: int32): int32
system: `+`(x, y: int32): int32
system: `+`(x: int64): int64
system: `+`(x, y: int64): int64
system: `+`(x: int8): int8
system: `+`(x, y: int8): int8
system: `+`[T](x, y: set[T]): set[T]
system: `+`[T](x: set[T]; y: T): set[T]
system: `+`(x, y: uint): uint
system: `+`(x, y: uint16): uint16
system: `+`(x, y: uint32): uint32
system: `+`(x, y: uint64): uint64
system: `+`(x, y: uint8): uint8
times: `+`(dt: DateTime; dur: Duration): DateTime
times: `+`(dt: DateTime; interval: TimeInterval): DateTime
times: `+`(a, b: Duration): Duration
times: `+`(a: Time; b: Duration): Time
times: `+`(time: Time; interval: TimeInterval): Time
times: `+`(ti1, ti2: TimeInterval): TimeInterval
`-%`:
system: `-%`(x, y: int): int
system: `-%`(x, y: int16): int16
system: `-%`(x, y: int32): int32
system: `-%`(x, y: int64): int64
system: `-%`(x, y: int8): int8
`->`:
sugar: `->`(p, b: untyped): untyped
`-+-`:
sets: `-+-`[A](s1, s2: HashSet[A]): HashSet[A]
`--`:
jsffi: `--`(x: JsObject): JsObject
`-=`:
atomics: `-=`[T: SomeInteger](location: var Atomic[T]; value: T)
complex: `-=`[T](x: var Complex[T]; y: Complex[T])
jsbigints: `-=`(x: var JsBigInt; y: JsBigInt)
jsffi: `-=`(x, y: JsObject): JsObject
rationals: `-=`[T](x: var Rational[T]; y: Rational[T])
rationals: `-=`[T](x: var Rational[T]; y: T)
system: `-=`[T: SomeInteger](x: var T; y: T)
system: `-=`[T: float | float32 | float64](x: var T; y: T)
times: `-=`(a: var DateTime; b: Duration)
times: `-=`(a: var DateTime; b: TimeInterval)
times: `-=`(dt: var Duration; ti: Duration)
times: `-=`(t: var Time; b: Duration)
times: `-=`(t: var Time; b: TimeInterval)
times: `-=`(a: var TimeInterval; b: TimeInterval)
`-`:
colors: `-`(a, b: Color): Color
complex: `-`[T](z: Complex[T]): Complex[T]
complex: `-`[T](x, y: Complex[T]): Complex[T]
complex: `-`[T](x: Complex[T]; y: T): Complex[T]
complex: `-`[T](x: T; y: Complex[T]): Complex[T]
jsbigints: `-`(this: JsBigInt): JsBigInt
jsbigints: `-`(x, y: JsBigInt): JsBigInt
jsffi: `-`(x, y: JsObject): JsObject
lenientops: `-`[I: SomeInteger; F: SomeFloat](f: F; i: I): F
lenientops: `-`[I: SomeInteger; F: SomeFloat](i: I; f: F): F
monotimes: `-`(a: MonoTime; b: Duration): MonoTime
monotimes: `-`(a, b: MonoTime): Duration
packedsets: `-`[A](s1, s2: PackedSet[A]): PackedSet[A]
rationals: `-`[T](x: Rational[T]): Rational[T]
rationals: `-`[T](x, y: Rational[T]): Rational[T]
rationals: `-`[T](x: Rational[T]; y: T): Rational[T]
rationals: `-`[T](x: T; y: Rational[T]): Rational[T]
sets: `-`[A](s1, s2: HashSet[A]): HashSet[A]
system: `-`(a, b: AllocStats): AllocStats
system: `-`(x: float): float
system: `-`(x, y: float): float
system: `-`(x: float32): float32
system: `-`(x, y: float32): float32
system: `-`(x: int): int
system: `-`(x, y: int): int
system: `-`(x: int16): int16
system: `-`(x, y: int16): int16
system: `-`(x: int32): int32
system: `-`(x, y: int32): int32
system: `-`(x: int64): int64
system: `-`(x, y: int64): int64
system: `-`(x: int8): int8
system: `-`(x, y: int8): int8
system: `-`[T](x, y: set[T]): set[T]
system: `-`[T](x: set[T]; y: T): set[T]
system: `-`(x, y: uint): uint
system: `-`(x, y: uint16): uint16
system: `-`(x, y: uint32): uint32
system: `-`(x, y: uint64): uint64
system: `-`(x, y: uint8): uint8
times: `-`(dt1, dt2: DateTime): Duration
times: `-`(dt: DateTime; dur: Duration): DateTime
times: `-`(dt: DateTime; interval: TimeInterval): DateTime
times: `-`(a: Duration): Duration
times: `-`(a, b: Duration): Duration
times: `-`(a: Time; b: Duration): Time
times: `-`(a, b: Time): Duration
times: `-`(time: Time; interval: TimeInterval): Time
times: `-`(ti: TimeInterval): TimeInterval
times: `-`(ti1, ti2: TimeInterval): TimeInterval
`.()`:
jsffi: `.()`[K: cstring; V: proc](obj: JsAssoc[K, V]; field: untyped; args: varargs[untyped]): auto
jsffi: `.()`(obj: JsObject; field: untyped; args: varargs[JsObject, jsFromAst]): JsObject
`..<`:
system: `..<`(a, b: int32): int32
system: `..<`(a, b: int64): int64
system: `..<`[T](a, b: T): T
system: `..<`(a, b: uint32): uint32
system: `..<`(a, b: uint64): uint64
system: `..<`(a, b: untyped): untyped
`..^`:
system: `..^`(a, b: untyped): untyped
`..`:
system: `..`[T](b: sink T): HSlice[int, T]
system: `..`[T, U](a: sink T; b: sink U): HSlice[T, U]
system: `..`(a, b: int32): int32
system: `..`(a, b: int64): int64
system: `..`[T](a, b: T): T
system: `..`(a, b: uint32): uint32
system: `..`(a, b: uint64): uint64
`.=`:
jsffi: `.=`[K: cstring; V](obj: JsAssoc[K, V]; field: untyped; value: V): untyped
jsffi: `.=`(obj: JsObject; field, value: untyped): untyped
`.`:
jsffi: `.`[K: cstring; V](obj: JsAssoc[K, V]; field: untyped): V
jsffi: `.`(obj: JsObject; field: untyped): JsObject
`/%`:
system: `/%`(x, y: int): int
system: `/%`(x, y: int16): int16
system: `/%`(x, y: int32): int32
system: `/%`(x, y: int64): int64
system: `/%`(x, y: int8): int8
`/../`:
os: `/../`(head, tail: string): string
`//`:
rationals: `//`[T](num, den: T): Rational[T]
`/=`:
complex: `/=`[T](x: var Complex[T]; y: Complex[T])
jsbigints: `/=`(x: var JsBigInt; y: JsBigInt)
jsffi: `/=`(x, y: JsObject): JsObject
rationals: `/=`[T](x: var Rational[T]; y: Rational[T])
rationals: `/=`[T](x: var Rational[T]; y: T)
system: `/=`(x: var float64; y: float64)
system: `/=`[T: float | float32](x: var T; y: T)
`/`:
complex: `/`[T](x, y: Complex[T]): Complex[T]
complex: `/`[T](x: Complex[T]; y: T): Complex[T]
complex: `/`[T](x: T; y: Complex[T]): Complex[T]
jsffi: `/`(x, y: JsObject): JsObject
lenientops: `/`[I: SomeInteger; F: SomeFloat](f: F; i: I): F
lenientops: `/`[I: SomeInteger; F: SomeFloat](i: I; f: F): F
os: `/`(head, tail: string): string
pegs: `/`(a: varargs[Peg]): Peg
rationals: `/`[T](x, y: Rational[T]): Rational[T]
rationals: `/`[T](x: Rational[T]; y: T): Rational[T]
rationals: `/`[T](x: T; y: Rational[T]): Rational[T]
system: `/`(x, y: float): float
system: `/`(x, y: float32): float32
system: `/`(x, y: int): float
uri: `/`(x: Uri; path: string): Uri
`=>`:
sugar: `=>`(p, b: untyped): untyped
`==`:
colors: `==`(a, b: Color): bool
colortext: `==`(a, b: TermColorBg | TermColorFg): bool
colortext: `==`(rune: ColRune; ch: char): bool
colortext: `==`(s1, s2: ColStyle): bool
colortext: `==`(f1: TermColorBg; f2: BackgroundColor): bool
colortext: `==`(f1: TermColorFg; f2: ForegroundColor): bool
complex: `==`[T](x, y: Complex[T]): bool
dod_helpers: `==`(i1, i2: ValueId): bool
dod_helpers: `==`(m1`gensym14, m2`gensym14: ValueIdMask): bool
dod_helpers: `==`[T](a, b: OptIndex[T]): bool
httpcore: `==`(a, b: HttpCode): bool
httpcore: `==`(protocol: tuple[orig: string, major, minor: int]; ver: HttpVersion): bool
jsbigints: `==`(x, y: JsBigInt): bool
jsffi: `==`(x, y: JsRoot): bool
json: `==`(a, b: JsonNode): bool
macros: `==`(a, b: NimNode): bool
md5: `==`(D1, D2: MD5Digest): bool
memfiles: `==`(x, y: MemSlice): bool
monotimes: `==`(a, b: MonoTime): bool
nativesockets: `==`(a, b: Port): bool
net: `==`(lhs, rhs: IpAddress): bool
nre: `==`(a, b: Regex): bool
nre: `==`(a, b: RegexMatch): bool
oids: `==`(oid1: Oid; oid2: Oid): bool
options: `==`[T](a, b: Option[T]): bool
os: `==`(err1, err2: OSErrorCode): bool
packedsets: `==`[A](s1, s2: PackedSet[A]): bool
parseopt2: `==`(a, b: Opt): bool
rationals: `==`(x, y: Rational): bool
results: `==`(a, b: Result): bool
rstast: `==`(a, b: FileIndex): bool
sets: `==`[A](s, t: HashSet[A]): bool
sets: `==`[A](s, t: OrderedSet[A]): bool
sexp: `==`(a, b: SexpNode): bool
sha1: `==`(a, b: SecureHash): bool
system: `==`(x: typeof(nil) | typeof(nil); y: string): bool
system: `==`[I, T](x, y: array[I, T]): bool
system: `==`(x, y: bool): bool
system: `==`(x, y: char): bool
system: `==`(x, y: cstring): bool
system: `==`[Enum: enum](x, y: Enum): bool
system: `==`(x, y: float): bool
system: `==`(x, y: float32): bool
system: `==`(x, y: int): bool
system: `==`(x, y: int16): bool
system: `==`(x, y: int32): bool
system: `==`(x, y: int64): bool
system: `==`(x, y: int8): bool
system: `==`[T](x, y: openArray[T]): bool
system: `==`(x, y: pointer): bool
system: `==`[T](x, y: ptr T): bool
system: `==`[T](x, y: ref T): bool
system: `==`[T](x, y: seq[T]): bool
system: `==`[T](x, y: set[T]): bool
system: `==`(x: string; y: typeof(nil) | typeof(nil)): bool
system: `==`(x, y: string): bool
system: `==`[T: proc](x, y: T): bool
system: `==`[T: tuple | object](x, y: T): bool
system: `==`(x, y: uint): bool
system: `==`(x, y: uint16): bool
system: `==`(x, y: uint32): bool
system: `==`(x, y: uint64): bool
system: `==`(x, y: uint8): bool
tables: `==`[A](s, t: CountTable[A]): bool
tables: `==`[A](s, t: CountTableRef[A]): bool
tables: `==`[A, B](s, t: OrderedTable[A, B]): bool
tables: `==`[A, B](s, t: OrderedTableRef[A, B]): bool
tables: `==`[A, B](s, t: Table[A, B]): bool
tables: `==`[A, B](s, t: TableRef[A, B]): bool
text_layouter: `==`(i1, i2: LytStrId): bool
text_layouter: `==`(m1`gensym3, m2`gensym3: LytStrIdMask): bool
times: `==`(a, b: DateTime): bool
times: `==`(a, b: Duration): bool
times: `==`(a, b: Time): bool
times: `==`(zone1, zone2: Timezone): bool
unicode: `==`(a, b: Rune): bool
winlean: `==`(x, y: SocketHandle): bool
`=`:
system: `=`[T](dest: var T; src: T)
`=copy`:
isolation: `=copy`[T](dest: var Isolated[T]; src: Isolated[T])
system: `=copy`[T](dest: var T; src: T)
system: `=copy`[TArg](x: var Thread[TArg]; y: Thread[TArg])
tasks: `=copy`(x: var Task; y: Task)
`=destroy`:
isolation: `=destroy`[T](dest: var Isolated[T])
system: `=destroy`[T](x: var T)
tasks: `=destroy`(t: var Task)
`=dispose`:
system: `=dispose`[T](x: owned(ref T))
`=sink`:
isolation: `=sink`[T](dest: var Isolated[T]; src: Isolated[T])
system: `=sink`[T](x: var T; y: T)
`=trace`:
system: `=trace`[T](x: var T; env: pointer)
`=~`:
pegs: `=~`(s: string; pattern: Peg): bool
re: `=~`(s: string; pattern: Regex): untyped
`?.`:
wrapnils: `?.`(a: typed): auto
`??.`:
wrapnils: `??.`(a: typed): Option
`?`:
pegs: `?`(a: Peg): Peg
uri: `?`(u: Uri; query: openArray[(string, string)]): Uri
`@`:
system: `@`[T](a: openArray[T]): seq[T]
system: `@`[IDX, T](a: sink array[IDX, T]): seq[T]
`[]=`:
colortext: `[]=`(buf: var ColRuneGrid; row, col: int; ch: char)
colortext: `[]=`(buf: var ColRuneGrid; row, col: int; str: ColText)
colortext: `[]=`[R1, R2: openArray[int] | Slice[int] | int](buf: var ColRuneGrid; rowIdx: R1; colIdx: R2; ch: ColRune; fill: ColRune = clr(' '))
critbits: `[]=`[T](c: var CritBitTree[T]; key: string; val: T)
deques: `[]=`[T](deq: var Deque[T]; i: BackwardsIndex; x: sink T)
deques: `[]=`[T](deq: var Deque[T]; i: Natural; val: sink T)
httpclient: `[]=`(p: MultipartData; name, content: string)
httpclient: `[]=`(p: MultipartData; name: string; file: tuple[name, contentType, content: string])
httpcore: `[]=`(headers: HttpHeaders; key: string; value: seq[string])
httpcore: `[]=`(headers: HttpHeaders; key, value: string)
jsffi: `[]=`[V](obj: JsAssoc[cstring, V]; field: string; val: V)
jsffi: `[]=`[K: JsKey; V](obj: JsAssoc[K, V]; field: K; val: V)
jsffi: `[]=`[T](obj: JsObject; field: cstring; val: T)
jsffi: `[]=`[T](obj: JsObject; field: int; val: T)
jsformdata: `[]=`(self: FormData; name, value: cstring)
jsheaders: `[]=`(self: Headers; key: cstring; value: cstring)
json: `[]=`(obj: JsonNode; key: string; val: JsonNode)
jsutils: `[]=`(arr: Float64Array; i: int; v: float)
macrocache: `[]=`(t: CacheTable; key: string; value: NimNode)
macros: `[]=`(n: NimNode; i: BackwardsIndex; child: NimNode)
macros: `[]=`(n: NimNode; i: int; child: NimNode)
setutils: `[]=`[T](t: var set[T]; key: T; val: bool)
strtabs: `[]=`(t: StringTableRef; key, val: string)
system: `[]=`[Idx, T](a: var array[Idx, T]; i: BackwardsIndex; x: T)
system: `[]=`[Idx, T; U, V: Ordinal](a: var array[Idx, T]; x: HSlice[U, V]; b: openArray[T])
system: `[]=`[T](s: var openArray[T]; i: BackwardsIndex; x: T)
system: `[]=`[T; U, V: Ordinal](s: var seq[T]; x: HSlice[U, V]; b: openArray[T])
system: `[]=`(s: var string; i: BackwardsIndex; x: char)
system: `[]=`[T, U: Ordinal](s: var string; x: HSlice[T, U]; b: string)
system: `[]=`[I: Ordinal; T, S](a: T; i: I; x: sink S)
system: `[]=`(s: string; i: int; val: char)
tables: `[]=`[A](t: var CountTable[A]; key: A; val: int)
tables: `[]=`[A](t: CountTableRef[A]; key: A; val: int)
tables: `[]=`[A, B](t: var OrderedTable[A, B]; key: A; val: sink B)
tables: `[]=`[A, B](t: OrderedTableRef[A, B]; key: A; val: sink B)
tables: `[]=`[A, B](t: var Table[A, B]; key: A; val: sink B)
tables: `[]=`[A, B](t: TableRef[A, B]; key: A; val: sink B)
typeinfo: `[]=`(x, y: Any)
typeinfo: `[]=`(x: Any; i: int; y: Any)
typeinfo: `[]=`(x: Any; fieldName: string; value: Any)
widestrs: `[]=`(a: WideCStringObj; idx: int; val: Utf16Char)
`[]`:
critbits: `[]`[T](c: CritBitTree[T]; key: string): T
critbits: `[]`[T](c: var CritBitTree[T]; key: string): var T
db_mysql: `[]`(row: InstantRow; col: int): string
db_odbc: `[]`(row: InstantRow; col: int): string
db_postgres: `[]`(row: InstantRow; col: int): string
db_sqlite: `[]`(row: InstantRow; col: int32): string
deques: `[]`[T](deq: Deque[T]; i: BackwardsIndex): lent T
deques: `[]`[T](deq: var Deque[T]; i: BackwardsIndex): var T
deques: `[]`[T](deq: Deque[T]; i: Natural): lent T
deques: `[]`[T](deq: var Deque[T]; i: Natural): var T
dod_helpers: `[]`[T](i: OptIndex[T]): T
dod_helpers: `[]`(store: var ValueStore; index: ValueId): Value
dom: `[]`(x: Node; idx: int): Element
heapqueue: `[]`[T](heap: HeapQueue[T]; i: Natural): lent T
httpcore: `[]`(headers: HttpHeaders; key: string): HttpHeaderValues
httpcore: `[]`(headers: HttpHeaders; key: string; i: int): string
jsffi: `[]`[V](obj: JsAssoc[cstring, V]; field: string): V
jsffi: `[]`[K: JsKey; V](obj: JsAssoc[K, V]; field: K): V
jsffi: `[]`(obj: JsObject; field: cstring): JsObject
jsffi: `[]`(obj: JsObject; field: int): JsObject
jsformdata: `[]`(self: FormData; name: cstring): cstring
jsheaders: `[]`(self: Headers; key: cstring): cstring
json: `[]`(node: JsonNode; index: BackwardsIndex): JsonNode
json: `[]`[U, V](a: JsonNode; x: HSlice[U, V]): JsonNode
json: `[]`(node: JsonNode; index: int): JsonNode
json: `[]`(node: JsonNode; name: string): JsonNode
jsutils: `[]`(arr: BigUint64Array; i: int): JsBigInt
jsutils: `[]`(arr: Uint32Array; i: int): uint32
jsutils: `[]`(arr: Uint8Array; i: int): uint8
macrocache: `[]`(s: CacheSeq; i: int): NimNode
macrocache: `[]`(t: CacheTable; key: string): NimNode
macros: `[]`(n: NimNode; i: BackwardsIndex): NimNode
macros: `[]`[T, U: Ordinal](n: NimNode; x: HSlice[T, U]): seq[NimNode]
macros: `[]`(n: NimNode; i: int): NimNode
nre: `[]`(pattern: CaptureBounds; i: int): HSlice[int, int]
nre: `[]`(pattern: CaptureBounds; name: string): HSlice[int, int]
nre: `[]`(pattern: Captures; i: int): string
nre: `[]`(pattern: Captures; name: string): string
parsesql: `[]`(n: SqlNode; i: BackwardsIndex): SqlNode
parsesql: `[]`(n: SqlNode; i: int): SqlNode
reservedmem: `[]`[T](s: ReservedMemSeq[T]; rpos: BackwardsIndex): lent T
reservedmem: `[]`[T](s: var ReservedMemSeq[T]; rpos: BackwardsIndex): var T
reservedmem: `[]`[T](s: ReservedMemSeq[T]; pos: Natural): lent T
reservedmem: `[]`[T](s: var ReservedMemSeq[T]; pos: Natural): var T
ropes: `[]`(r: Rope; i: int): char
sets: `[]`[A](s: var HashSet[A]; key: A): var A
sexp: `[]`(node: SexpNode; index: int): SexpNode
strtabs: `[]`(t: StringTableRef; key: string): var string
system: `[]`[Idx, T](a: array[Idx, T]; i: BackwardsIndex): T
system: `[]`[Idx, T](a: var array[Idx, T]; i: BackwardsIndex): var T
system: `[]`[Idx, T; U, V: Ordinal](a: array[Idx, T]; x: HSlice[U, V]): seq[T]
system: `[]`[T](s: openArray[T]; i: BackwardsIndex): T
system: `[]`[T](s: var openArray[T]; i: BackwardsIndex): var T
system: `[]`[T; U, V: Ordinal](s: openArray[T]; x: HSlice[U, V]): seq[T]
system: `[]`(s: string; i: BackwardsIndex): char
system: `[]`(s: var string; i: BackwardsIndex): var char
system: `[]`[T, U: Ordinal](s: string; x: HSlice[T, U]): string
system: `[]`[I: Ordinal; T](a: T; i: I): T
system: `[]`(s: string; i: int): char
tables: `[]`[A](t: CountTable[A]; key: A): int
tables: `[]`[A](t: CountTableRef[A]; key: A): int
tables: `[]`[A, B](t: OrderedTable[A, B]; key: A): B
tables: `[]`[A, B](t: var OrderedTable[A, B]; key: A): var B
tables: `[]`[A, B](t: OrderedTableRef[A, B]; key: A): var B
tables: `[]`[A, B](t: Table[A, B]; key: A): B
tables: `[]`[A, B](t: var Table[A, B]; key: A): var B
tables: `[]`[A, B](t: TableRef[A, B]; key: A): var B
text_layouter: `[]`(blc: LytBlock; idx: int): LytBlock
text_layouter: `[]`(blc: var LytBlock; idx: int): var LytBlock
typeinfo: `[]`(x: Any): Any
typeinfo: `[]`(x: Any; i: int): Any
typeinfo: `[]`(x: Any; fieldName: string): Any
widestrs: `[]`(a: WideCStringObj; idx: int): Utf16Char
wrapnils: `[]`[T, I](a: Option[T]; i: I): auto
wrapnils: `[]`[U](a: Option[U]): auto
xmltree: `[]`(n: XmlNode; i: int): XmlNode
xmltree: `[]`(n: var XmlNode; i: int): var XmlNode
`^`:
math: `^`[T: SomeNumber](x: T; y: Natural): T
system: `^`(x: int): BackwardsIndex
threadpool: `^`[T](fv: FlowVar[T]): T
`addr`:
system: `addr`[T](x: T): ptr T
`and`:
jsbigints: `and`(x, y: JsBigInt): JsBigInt
jsffi: `and`(x, y: JsObject): JsObject
system: `and`(x, y: bool): bool
system: `and`(x, y: int): int
system: `and`(x, y: int16): int16
system: `and`(x, y: int32): int32
system: `and`(x, y: int64): int64
system: `and`(x, y: int8): int8
system: `and`(a, b: typedesc): typedesc
system: `and`(x, y: uint): uint
system: `and`(x, y: uint16): uint16
system: `and`(x, y: uint32): uint32
system: `and`(x, y: uint64): uint64
system: `and`(x, y: uint8): uint8
`div`:
htmlgen: `div`(e: varargs[untyped]): untyped
jsbigints: `div`(x, y: JsBigInt): JsBigInt
rationals: `div`[T: SomeInteger](x, y: Rational[T]): T
system: `div`(x, y: int): int
system: `div`(x, y: int16): int16
system: `div`(x, y: int32): int32
system: `div`(x, y: int64): int64
system: `div`(x, y: int8): int8
system: `div`(x, y: uint): uint
system: `div`(x, y: uint16): uint16
system: `div`(x, y: uint32): uint32
system: `div`(x, y: uint64): uint64
system: `div`(x, y: uint8): uint8
times: `div`(a: Duration; b: int64): Duration
`in`:
jsffi: `in`(x, y: JsObject): JsObject
system: `in`(x, y: untyped): untyped
`is`:
system: `is`[T, S](x: T; y: S): bool
`isnot`:
system: `isnot`(x, y: untyped): untyped
`mod`:
jsbigints: `mod`(x, y: JsBigInt): JsBigInt
math: `mod`(x, y: float32): float32
math: `mod`(x, y: float64): float64
rationals: `mod`[T: SomeInteger](x, y: Rational[T]): Rational[T]
system: `mod`(x, y: int): int
system: `mod`(x, y: int16): int16
system: `mod`(x, y: int32): int32
system: `mod`(x, y: int64): int64
system: `mod`(x, y: int8): int8
system: `mod`(x, y: uint): uint
system: `mod`(x, y: uint16): uint16
system: `mod`(x, y: uint32): uint32
system: `mod`(x, y: uint64): uint64
system: `mod`(x, y: uint8): uint8
`not`:
jsffi: `not`(x: JsObject): JsObject
system: `not`(x: bool): bool
system: `not`(x: int): int
system: `not`(x: int16): int16
system: `not`(x: int32): int32
system: `not`(x: int64): int64
system: `not`(x: int8): int8
system: `not`(a: typedesc): typedesc
system: `not`[T: ref or ptr](a: typedesc[T]; b: typeof(nil)): typedesc
system: `not`(x: uint): uint
system: `not`(x: uint16): uint16
system: `not`(x: uint32): uint32
system: `not`(x: uint64): uint64
system: `not`(x: uint8): uint8
`notin`:
system: `notin`(x, y: untyped): untyped
`object`:
htmlgen: `object`(e: varargs[untyped]): untyped
`of`:
system: `of`[T, S](x: T; y: typedesc[S]): bool
`or`:
jsbigints: `or`(x, y: JsBigInt): JsBigInt
jsffi: `or`(x, y: JsObject): JsObject
macros: `or`(x, y: NimNode): NimNode
system: `or`(x, y: bool): bool
system: `or`(x, y: int): int
system: `or`(x, y: int16): int16
system: `or`(x, y: int32): int32
system: `or`(x, y: int64): int64
system: `or`(x, y: int8): int8
system: `or`(a, b: typedesc): typedesc
system: `or`(x, y: uint): uint
system: `or`(x, y: uint16): uint16
system: `or`(x, y: uint32): uint32
system: `or`(x, y: uint64): uint64
system: `or`(x, y: uint8): uint8
`ptr`:
system: ptr
`ref`:
system: ref
`shl`:
jsbigints: `shl`(a, b: JsBigInt): JsBigInt
system: `shl`(x: int; y: SomeInteger): int
system: `shl`(x: int16; y: SomeInteger): int16
system: `shl`(x: int32; y: SomeInteger): int32
system: `shl`(x: int64; y: SomeInteger): int64
system: `shl`(x: int8; y: SomeInteger): int8
system: `shl`(x: uint; y: SomeInteger): uint
system: `shl`(x: uint16; y: SomeInteger): uint16
system: `shl`(x: uint32; y: SomeInteger): uint32
system: `shl`(x: uint64; y: SomeInteger): uint64
system: `shl`(x: uint8; y: SomeInteger): uint8
`shr`:
jsbigints: `shr`(a, b: JsBigInt): JsBigInt
system: `shr`(x: int; y: SomeInteger): int
system: `shr`(x: int16; y: SomeInteger): int16
system: `shr`(x: int32; y: SomeInteger): int32
system: `shr`(x: int64; y: SomeInteger): int64
system: `shr`(x: int8; y: SomeInteger): int8
system: `shr`(x: uint; y: SomeInteger): uint
system: `shr`(x: uint16; y: SomeInteger): uint16
system: `shr`(x: uint32; y: SomeInteger): uint32
system: `shr`(x: uint64; y: SomeInteger): uint64
system: `shr`(x: uint8; y: SomeInteger): uint8
`static`:
system: static
`template`:
htmlgen: `template`(e: varargs[untyped]): untyped
`type`:
system: type
`var`:
htmlgen: `var`(e: varargs[untyped]): untyped
`xor`:
jsbigints: `xor`(x, y: JsBigInt): JsBigInt
system: `xor`(x, y: bool): bool
system: `xor`(x, y: int): int
system: `xor`(x, y: int16): int16
system: `xor`(x, y: int32): int32
system: `xor`(x, y: int64): int64
system: `xor`(x, y: int8): int8
system: `xor`(x, y: uint): uint
system: `xor`(x, y: uint16): uint16
system: `xor`(x, y: uint32): uint32
system: `xor`(x, y: uint64): uint64
system: `xor`(x, y: uint8): uint8
`{}=`:
json: `{}=`(node: JsonNode; keys: varargs[string]; value: JsonNode)
`{}`:
jsffi: `{}`(typ: typedesc; xs: varargs[untyped]): auto
json: `{}`(node: JsonNode; key: string): JsonNode
json: `{}`(node: JsonNode; index: varargs[int]): JsonNode
json: `{}`(node: JsonNode; keys: varargs[string]): JsonNode
`|>>`:
colortext: `|>>`(s: sink ColText; l: int): ColText
`|<<`:
colortext: `|<<`(s: sink ColText; l: int): ColText
`|`:
system: `|`(a, b: typedesc): typedesc
a:
htmlgen: a(e: varargs[untyped]): untyped
abbr:
htmlgen: abbr(e: varargs[untyped]): untyped
abbrev:
strutils: abbrev(s: string; possibilities: openArray[string]): int
abort:
dom: abort(f: FileReader)
abortOnError:
unittest: abortOnError
abs:
complex: abs[T](z: Complex[T]): T
jscore: abs(m: MathLib; a: SomeNumber): SomeNumber
rationals: abs[T](x: Rational[T]): Rational[T]
system: abs(x: int): int
system: abs(x: int16): int16
system: abs(x: int32): int32
system: abs(x: int64): int64
system: abs(x: int8): int8
system: abs[T: float64 | float32](x: T): T
times: abs(a: Duration): Duration
abs2:
complex: abs2[T](z: Complex[T]): T
absolute:
Module os
absolutePath:
os: absolutePath(path: string; root = getCurrentDir()): string
accept:
nativesockets: accept(fd: SocketHandle; inheritable = defined(nimInheritHandles)): ( SocketHandle, string)
net: accept(server: Socket; client: var owned(Socket); flags = {SocketFlag.SafeDisconn}; inheritable = defined(nimInheritHandles))
winlean: accept(s: SocketHandle; a: ptr SockAddr; addrlen: ptr SockLen): SocketHandle
acceptAddr:
net: acceptAddr(server: Socket; client: var owned(Socket); address: var string; flags = {SocketFlag.SafeDisconn}; inheritable = defined(nimInheritHandles))
AcceptNoClient:
SslAcceptResult.AcceptNoClient
AcceptNoHandshake:
SslAcceptResult.AcceptNoHandshake
AcceptSuccess:
SslAcceptResult.AcceptSuccess
AccessViolationDefect:
system: AccessViolationDefect
AccessViolationError:
system: AccessViolationError
acos:
jscore: acos(m: MathLib; a: SomeNumber): float
acosh:
jscore: acosh(m: MathLib; a: SomeNumber): float
acquire:
locks: acquire(lock: var Lock)
rlocks: acquire(lock: var RLock)
add:
colortext: add(text: var ColText; rune: ColRune | seq[ColRune])
colortext: add(colored: var ColText; ch: string | char)
colortext: add(colored: var ColText; rune: ColRune)
colortext: add(colored: var ColText; other: ColRuneLine)
colortext: add(colored: var ColText; other: ColText)
dod_helpers: add(store: var ValueStore; item: Value): ValueId
dom: add(c: ClassList; class: cstring)
httpclient: add(p: MultipartData; xs: MultipartEntries): MultipartData
httpclient: add(p: MultipartData; name, content: string; filename: string = ""; contentType: string = ""; useStream = true)
httpcore: add(headers: HttpHeaders; key, value: string)
jsformdata: add(self: FormData; name: cstring; value: SomeNumber | bool | cstring)
jsformdata: add(self: FormData; name: cstring; value: SomeNumber | bool | cstring; filename: cstring)
jsheaders: add(self: Headers; key: cstring; value: cstring)
json: add(father, child: JsonNode)
json: add(obj: JsonNode; key: string; val: JsonNode)
lists: add[T](L: var DoublyLinkedList[T]; n: DoublyLinkedNode[T])
lists: add[T](L: var DoublyLinkedList[T]; value: T)
lists: add[T](L: var DoublyLinkedRing[T]; n: DoublyLinkedNode[T])
lists: add[T](L: var DoublyLinkedRing[T]; value: T)
lists: add[T](L: var SinglyLinkedList[T]; n: SinglyLinkedNode[T])
lists: add[T](L: var SinglyLinkedList[T]; value: T)
lists: add[T](L: var SinglyLinkedRing[T]; n: SinglyLinkedNode[T])
lists: add[T](L: var SinglyLinkedRing[T]; value: T)
lists: add[T: SomeLinkedList](a: var T; b: T)
macrocache: add(s: CacheSeq; value: NimNode)
macros: add(father, child: NimNode): NimNode
macros: add(father: NimNode; children: varargs[NimNode]): NimNode
parsesql: add(father, n: SqlNode)
reservedmem: add[T](s: var ReservedMemSeq[T]; val: T)
ropes: add(a: var Rope; b: Rope)
ropes: add(a: var Rope; b: string)
rstast: add(father, son: PRstNode)
rstast: add(father: PRstNode; s: string)
sexp: add(father, child: SexpNode)
sharedlist: add[A](x: var SharedList[A]; y: A)
shellrunner: add(cmd: var ShellCmd; args: openArray[ShellArg])
shellrunner: add(cmd: var ShellCmd; arg: ShellArg)
strbasics: add(x: var string; y: openArray[char])
system: add(x: var cstring; y: cstring)
system: add[T](x: var seq[T]; y: openArray[T])
system: add[T](x: var seq[T]; value: sink T)
system: add(x: var string; y: char)
system: add(x: var string; y: cstring)
system: add(x: var string; y: string)
text_layouter: add(target: var LytBlock; other: varargs[LytBlock])
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)
addCompletion:
linenoise: addCompletion(a2: ptr Completions; a3: cstring)
addEscaped:
xmltree: addEscaped(result: var string; s: string)
addEscapedChar:
system: addEscapedChar(s: var string; c: char)
addEventListener:
dom: addEventListener(et: EventTarget; ev: cstring; cb: proc (ev: Event); options: AddEventListenerOptions)
dom: addEventListener(et: EventTarget; ev: cstring; cb: proc (ev: Event); useCapture: bool = false)
AddEventListenerOptions:
dom: AddEventListenerOptions
addExitProc:
exitprocs: addExitProc(cl: proc () {.closure.})
exitprocs: addExitProc(cl: proc () {.noconv.})
addf:
colortext: addf(text: var ColText; formatstr: string; colored: varargs[ColText, toColText])
ropes: addf(c: var Rope; frmt: string; args: openArray[Rope])
strutils: addf(s: var string; formatstr: string; a: varargs[string, `$`])
addfBackIndexed:
AddfFragmentKind.addfBackIndexed
addfDollar:
AddfFragmentKind.addfDollar
addfExpr:
AddfFragmentKind.addfExpr
AddfFragment:
strutils: AddfFragment
AddfFragmentKind:
strutils: AddfFragmentKind
addfFragments:
strutils: addfFragments(formatstr: string): AddfFragment
addField:
sexp: addField(node: SexpNode; name: string; value: SexpNode)
addFileExt:
os: addFileExt(filename, ext: string): string
addFiles:
httpclient: addFiles(p: MultipartData; xs: openArray[tuple[name, file: string]]; mimeDb = newMimetypes(); useStream = true): MultipartData
addfIndexed:
AddfFragmentKind.addfIndexed
addFirst:
deques: addFirst[T](deq: var Deque[T]; item: sink T)
addfPositional:
AddfFragmentKind.addfPositional
addfText:
AddfFragmentKind.addfText
addfVar:
AddfFragmentKind.addfVar
addHandler:
logging: addHandler(handler: Logger)
addIdentIfAbsent:
macros: addIdentIfAbsent(dest: NimNode; ident: string)
addIfNotNil:
rstast: addIfNotNil(father, son: PRstNode)
addIndent:
colortext: addIndent(res: var ColText; level: int; sep: int = 2; prefix: ColRune = clr(' '))
addInt:
digitsutils: addInt(result: var string; x: int)
digitsutils: addInt(result: var string; x: int64)
digitsutils: addInt(result: var string; x: uint64)
addItBlock:
text_layouter: addItBlock(res: LytBlock; item: typed; expr: untyped; join: LytBlock): untyped
addLast:
deques: addLast[T](deq: var Deque[T]; item: sink T)
addMoved:
lists: addMoved[T](a, b: var DoublyLinkedList[T])
lists: addMoved[T](a, b: var SinglyLinkedList[T])
addNormalizePath:
pathnorm: addNormalizePath(x: string; result: var string; state: var int; dirSep = DirSep)
addOutputFormatter:
unittest: addOutputFormatter(formatter: OutputFormatter)
addPragma:
macros: addPragma(someProc, pragma: NimNode)
addQuitProc:
system: addQuitProc(quitProc: proc () {.noconv.})
addQuoted:
system: addQuoted[T](s: var string; x: T)
address:
htmlgen: address(e: varargs[untyped]): untyped
AddrInfo:
winlean: AddrInfo
addSep:
strutils: addSep(dest: var string; sep = ", "; startLen: Natural = 0)
advice:
cpuload: advice(s: var ThreadPoolState): ThreadPoolAdvice
affinity:
Module system
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
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
alignCenter:
colortext: alignCenter(text: sink ColText; length: int; padding: ColRune = clr(' ')): ColText
alignLeft:
colortext: alignLeft(text: sink ColText; length: int; padding: ColRune = clr(' ')): ColText
strutils: alignLeft(s: string; count: Natural; padding = ' '): string
text_layouter: alignLeft(span: sink LytStrSpan; target: int): LytStrSpan
unicode: alignLeft(s: string; count: Natural; padding = ' '.Rune): string
alignof:
system: alignof[T](x: T): int
system: alignof(x: typedesc): int
alignRight:
colortext: alignRight(text: ColText; length: int; padding: ColRune = clr(' ')): ColText
alignString:
strformat: alignString(s: string; minimumWidth: int; align = '\x00'; fill = ' '): string
alignTable:
asciitables: alignTable(s: string; delim = ' '; fill = ' '; sep = " "): string
all:
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
allNodes:
graph: allNodes[Id](graph: Graph[Id]): seq[Id]
alloc:
system: alloc(size: Natural): pointer
alloc0:
system: alloc0(size: Natural): pointer
alloc0Impl:
system: alloc0Impl(size: Natural): pointer
allocateAndInitializeSid:
winlean: allocateAndInitializeSid(pIdentifierAuthority: ptr SID_IDENTIFIER_AUTHORITY; nSubAuthorityCount: BYTE; nSubAuthority0: DWORD; nSubAuthority1: DWORD; nSubAuthority2: DWORD; nSubAuthority3: DWORD; nSubAuthority4: DWORD; nSubAuthority5: DWORD; nSubAuthority6: DWORD; nSubAuthority7: DWORD; pSid: ptr PSID): WINBOOL
allocCStringArray:
system: allocCStringArray(a: openArray[string]): cstringArray
allocImpl:
system: allocImpl(size: Natural): pointer
allocShared:
system: allocShared(size: Natural): pointer
allocShared0:
system: allocShared0(size: Natural): pointer
allocShared0Impl:
system: allocShared0Impl(size: Natural): pointer
allocSharedImpl:
system: allocSharedImpl(size: Natural): pointer
AllocStats:
system: AllocStats
allowEmptyAttribs:
XmlParseOption.allowEmptyAttribs
allowUnquotedAttribs:
XmlParseOption.allowUnquotedAttribs
almostEqual:
math: almostEqual[T: SomeFloat](x, y: T; unitsInLastPlace: Natural = 4): bool
AltSep:
os: AltSep
AnchorElement:
dom: AnchorElement
annotation:
htmlgen: annotation(e: varargs[untyped]): untyped
annotation-xml:
htmlgen: annotation-xml(e: varargs[untyped]): untyped
ansiBackgroundColorCode:
terminal: ansiBackgroundColorCode(color: Color): string
terminal: ansiBackgroundColorCode(color: static[Color]): string
ansiForegroundColorCode:
terminal: ansiForegroundColorCode(color: Color): string
terminal: ansiForegroundColorCode(fg: ForegroundColor; bright = false): string
terminal: ansiForegroundColorCode(color: static[Color]): string
terminal: ansiForegroundColorCode(fg: static[ForegroundColor]; bright: static[bool] = false): string
ansiResetCode:
terminal: ansiResetCode
ansiStyleCode:
terminal: ansiStyleCode(style: int): string
terminal: ansiStyleCode(style: static[Style]): string
terminal: ansiStyleCode(style: Style): string
any:
pegs: any(): Peg
sequtils: any[T](s: openArray[T]; pred: proc (x: T): bool {.closure.}): bool
system: any
Any:
typeinfo: Any
any character:
Module pegs
any rune:
Module pegs
anyIt:
sequtils: anyIt(s, pred: untyped): bool
AnyKind:
typeinfo: AnyKind
anyRune:
pegs: anyRune(): Peg
append:
lists: append[T](a: var (SinglyLinkedList[T] | SinglyLinkedRing[T]); b: SinglyLinkedList[T] | SinglyLinkedNode[T] | T)
lists: append[T](a: var (DoublyLinkedList[T] | DoublyLinkedRing[T]); b: DoublyLinkedList[T] | DoublyLinkedNode[T] | T)
appendChild:
dom: appendChild(n, child: Node)
appendData:
dom: appendData(n: Node; data: cstring)
appendMoved:
lists: appendMoved[T: SomeLinkedList](a, b: var T)
apply:
sequtils: apply[T](s: var openArray[T]; op: proc (x: var T) {.closure.})
sequtils: apply[T](s: var openArray[T]; op: proc (x: T): T {.closure.})
sequtils: apply[T](s: openArray[T]; op: proc (x: T) {.closure.})
applyIt:
sequtils: applyIt(varSeq, op: untyped)
appType:
system: appType
arccos:
complex: arccos[T](z: Complex[T]): Complex[T]
math: arccos(x: float32): float32
math: arccos(x: float64): float64
arccosh:
complex: arccosh[T](z: Complex[T]): Complex[T]
math: arccosh(x: float32): float32
math: arccosh(x: float64): float64
arccot:
complex: arccot[T](z: Complex[T]): Complex[T]
math: arccot[T: float32 | float64](x: T): T
arccoth:
complex: arccoth[T](z: Complex[T]): Complex[T]
math: arccoth[T: float32 | float64](x: T): T
arccsc:
complex: arccsc[T](z: Complex[T]): Complex[T]
math: arccsc[T: float32 | float64](x: T): T
arccsch:
complex: arccsch[T](z: Complex[T]): Complex[T]
math: arccsch[T: float32 | float64](x: T): T
arcsec:
complex: arcsec[T](z: Complex[T]): Complex[T]
math: arcsec[T: float32 | float64](x: T): T
arcsech:
complex: arcsech[T](z: Complex[T]): Complex[T]
math: arcsech[T: float32 | float64](x: T): T
arcsin:
complex: arcsin[T](z: Complex[T]): Complex[T]
math: arcsin(x: float32): float32
math: arcsin(x: float64): float64
arcsinh:
complex: arcsinh[T](z: Complex[T]): Complex[T]
math: arcsinh(x: float32): float32
math: arcsinh(x: float64): float64
arctan:
complex: arctan[T](z: Complex[T]): Complex[T]
math: arctan(x: float32): float32
math: arctan(x: float64): float64
arctan2:
math: arctan2(y, x: float32): float32
math: arctan2(y, x: float64): float64
arctanh:
complex: arctanh[T](z: Complex[T]): Complex[T]
math: arctanh(x: float32): float32
math: arctanh(x: float64): float64
area:
htmlgen: area(e: varargs[untyped]): untyped
arg:
shellrunner: arg(cmd: var ShellCmd; format: string; args: varargs[string])
argc:
Module os
args:
shellrunner: args(cmd: var ShellCmd; args: openArray[ShellArg])
shellrunner: args(cmd: var ShellCmd; args: openArray[string])
argsToStr:
shellrunner: argsToStr(cmd: ShellCmd): seq[string]
argv:
Module os
ariaAttr:
htmlgen: ariaAttr
ArithmeticDefect:
system: ArithmeticDefect
ArithmeticError:
system: ArithmeticError
arity:
typetraits: arity(t: typedesc): int
array:
system: array
ArrayBuffer:
jsutils: ArrayBuffer
article:
htmlgen: article(e: varargs[untyped]): untyped
Ascending:
SortOrder.Ascending
ashr:
system: ashr(x: int; y: SomeInteger): int
system: ashr(x: int16; y: SomeInteger): int16
system: ashr(x: int32; y: SomeInteger): int32
system: ashr(x: int64; y: SomeInteger): int64
system: ashr(x: int8; y: SomeInteger): int8
aside:
htmlgen: aside(e: varargs[untyped]): untyped
asin:
jscore: asin(m: MathLib; a: SomeNumber): float
asinh:
jscore: asinh(m: MathLib; a: SomeNumber): float
assert:
assertions: assert(cond: untyped; msg = "")
AssertionDefect:
system: AssertionDefect
AssertionError:
system: AssertionError
assign:
packedsets: assign[A](dest: var PackedSet[A]; src: PackedSet[A])
typeinfo: assign(x, y: Any)
assignedElements:
dom: assignedElements(n: HTMLSlotElement; options: SlotOptions): seq[Element]
assignedNodes:
dom: assignedNodes(n: HTMLSlotElement; options: SlotOptions): seq[Node]
AST:
Module macros
astGenRepr:
macros: astGenRepr(n: NimNode): string
astToStr:
system: astToStr[T](x: T): string
async:
asyncjs: async(arg: untyped): untyped
atan:
jscore: atan(m: MathLib; a: SomeNumber): float
atan2:
jscore: atan2(m: MathLib; a: SomeNumber): float
atanh:
jscore: atanh(m: MathLib; a: SomeNumber): float
atEnd:
streams: atEnd(s: Stream): bool
atom:
strscans: atom(input: string; idx: int; c: char): bool
strscans: atom(input: string; idx: int; s: set[char]): bool
Atomic:
atomics: Atomic
ATOMIC_ACQ_REL:
system: ATOMIC_ACQ_REL
ATOMIC_ACQUIRE:
system: ATOMIC_ACQUIRE
atomicAddFetch:
system: atomicAddFetch[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T
atomicAlwaysLockFree:
system: atomicAlwaysLockFree(size: int; p: pointer): bool
atomicAndFetch:
system: atomicAndFetch[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T
atomicClear:
system: atomicClear(p: pointer; mem: AtomMemModel)
atomicCompareExchange:
system: atomicCompareExchange[T: AtomType](p, expected, desired: ptr T; weak: bool; success_memmodel: AtomMemModel; failure_memmodel: AtomMemModel): bool
atomicCompareExchangeN:
system: atomicCompareExchangeN[T: AtomType](p, expected: ptr T; desired: T; weak: bool; success_memmodel: AtomMemModel; failure_memmodel: AtomMemModel): bool
ATOMIC_CONSUME:
system: ATOMIC_CONSUME
atomicDec:
atomics: atomicDec[T: SomeInteger](location: var Atomic[T]; value: T = 1)
system: atomicDec(memLoc: var int; x: int = 1; order = ATOMIC_RELAXED): int
atomicExchange:
system: atomicExchange[T: AtomType](p, val, ret: ptr T; mem: AtomMemModel)
atomicExchangeN:
system: atomicExchangeN[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T
atomicFetchAdd:
system: atomicFetchAdd[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T
atomicFetchAnd:
system: atomicFetchAnd[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T
atomicFetchNand:
system: atomicFetchNand[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T
atomicFetchOr:
system: atomicFetchOr[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T
atomicFetchSub:
system: atomicFetchSub[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T
atomicFetchXor:
system: atomicFetchXor[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T
AtomicFlag:
atomics: AtomicFlag
atomicInc:
atomics: atomicInc[T: SomeInteger](location: var Atomic[T]; value: T = 1)
system: atomicInc(memLoc: var int; x: int = 1; order = ATOMIC_RELAXED): int
atomicIsLockFree:
system: atomicIsLockFree(size: int; p: pointer): bool
atomicLoad:
system: atomicLoad[T: AtomType](p, ret: ptr T; mem: AtomMemModel)
atomicLoadN:
system: atomicLoadN[T: AtomType](p: ptr T; mem: AtomMemModel): T
atomicNandFetch:
system: atomicNandFetch[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T
AtomicNodes:
macros: AtomicNodes
atomicOrFetch:
system: atomicOrFetch[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T
ATOMIC_RELAXED:
system: ATOMIC_RELAXED
ATOMIC_RELEASE:
system: ATOMIC_RELEASE
ATOMIC_SEQ_CST:
system: ATOMIC_SEQ_CST
atomicSignalFence:
system: atomicSignalFence(mem: AtomMemModel)
atomicStore:
system: atomicStore[T: AtomType](p, val: ptr T; mem: AtomMemModel)
atomicStoreN:
system: atomicStoreN[T: AtomType](p: ptr T; val: T; mem: AtomMemModel)
atomicSubFetch:
system: atomicSubFetch[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T
atomicTestAndSet:
system: atomicTestAndSet(p: pointer; mem: AtomMemModel): bool
atomicThreadFence:
system: atomicThreadFence(mem: AtomMemModel)
atomicXorFetch:
system: atomicXorFetch[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T
AtomMemModel:
system: AtomMemModel
AtomType:
system: AtomType
attachShadow:
dom: attachShadow(n: Element): ShadowRoot
AtTarget:
EventPhase.AtTarget
attr:
xmltree: attr(n: XmlNode; name: string): string
AttributeNode:
NodeType.AttributeNode
attrKey:
parsexml: attrKey(my: XmlParser): string
attrs:
xmltree: attrs(n: XmlNode): XmlAttributes
attrs=:
xmltree: attrs=(n: XmlNode; attr: XmlAttributes)
attrsLen:
xmltree: attrsLen(n: XmlNode): int
attrValue:
parsexml: attrValue(my: XmlParser): string
audio:
htmlgen: audio(e: varargs[untyped]): untyped
auth:
smtp: auth(smtp: Smtp; username, password: string)
auto:
system: auto
autovivification:
Module json
AuxilaryButton:
MouseButtons.AuxilaryButton
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)
BackgroundColor:
terminal: BackgroundColor
backref:
pegs: backref(index: range[1 .. MaxSubpatterns]; reverse: bool = false): Peg
backrefIgnoreCase:
pegs: backrefIgnoreCase(index: range[1 .. MaxSubpatterns]; reverse: bool = false): Peg
backrefIgnoreStyle:
pegs: backrefIgnoreStyle(index: range[1 .. MaxSubpatterns]; reverse: bool = false): Peg
backslash:
Backslash
BackwardsIndex:
system: BackwardsIndex
base:
htmlgen: base(e: varargs[untyped]): untyped
typeinfo: base(x: Any): Any
BaseLexer:
lexbase: BaseLexer
basename:
macros: basename(a: NimNode): NimNode
baseName:
Module os
basename=:
macros: basename=(a: NimNode; val: string)
baseTypeKind:
typeinfo: baseTypeKind(x: Any): AnyKind
baseTypeSize:
typeinfo: baseTypeSize(x: Any): int
bdi:
htmlgen: bdi(e: varargs[untyped]): untyped
bdo:
htmlgen: bdo(e: varargs[untyped]): untyped
between:
times: between(startDt, endDt: DateTime): TimeInterval
bg8Bit:
BackgroundColor.bg8Bit
bgBlack:
BackgroundColor.bgBlack
bgBlue:
BackgroundColor.bgBlue
bgColor:
TerminalCmd.bgColor
bgCyan:
BackgroundColor.bgCyan
bgDefault:
BackgroundColor.bgDefault
bgGreen:
BackgroundColor.bgGreen
bgMagenta:
BackgroundColor.bgMagenta
bgRed:
BackgroundColor.bgRed
bgWhite:
BackgroundColor.bgWhite
bgYellow:
BackgroundColor.bgYellow
big:
htmlgen: big(e: varargs[untyped]): untyped
jsbigints: big(integer: cstring): JsBigInt
jsbigints: big(integer: SomeInteger): JsBigInt
bigEndian:
Endianness.bigEndian
bigEndian16:
endians: bigEndian16(outp, inp: pointer)
bigEndian32:
endians: bigEndian32(outp, inp: pointer)
bigEndian64:
endians: bigEndian64(outp, inp: pointer)
BiggestFloat:
system: BiggestFloat
BiggestInt:
system: BiggestInt
BiggestUInt:
system: BiggestUInt
BigUint64Array:
jsutils: BigUint64Array
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:
nativesockets: bindAddr(socket: SocketHandle; name: ptr SockAddr; namelen: SockLen): cint
net: bindAddr(socket: Socket; port = Port(0); address = "")
bindNull:
db_sqlite: bindNull(ps: SqlPrepared; paramIdx: int)
bindParam:
db_sqlite: bindParam(ps: SqlPrepared; paramIdx: int; val: float64)
db_sqlite: bindParam(ps: SqlPrepared; paramIdx: int; val: int)
db_sqlite: bindParam(ps: SqlPrepared; paramIdx: int; val: int32)
db_sqlite: bindParam(ps: SqlPrepared; paramIdx: int; val: int64)
db_sqlite: bindParam(ps: SqlPrepared; paramIdx: int; val: openArray[byte]; copy = true)
db_sqlite: bindParam(ps: SqlPrepared; paramIdx: int; val: string; copy = true)
bindParams:
db_sqlite: bindParams(ps: SqlPrepared; params: varargs[untyped]): untyped
bindSocket:
winlean: bindSocket(s: SocketHandle; name: ptr SockAddr; namelen: SockLen): cint
bindSym:
macros: bindSym(ident: string | NimNode; rule: BindSymRule = brClosed): NimNode
BindSymRule:
macros: BindSymRule
bindUnix:
net: bindUnix(socket: Socket; path: string)
binom:
math: binom(n, k: int): int
bitand:
bitops: bitand[T: SomeInteger](x, y: T; z: varargs[T]): T
bitnot:
bitops: bitnot[T: SomeInteger](x: T): T
bitor:
bitops: bitor[T: SomeInteger](x, y: T; z: varargs[T]): T
bitslice:
bitops: bitslice[T: SomeInteger](v: var T; slice: Slice[int])
bitsliced:
bitops: bitsliced[T: SomeInteger](v: T; slice: Slice[int]): T
BitsRange:
bitops: BitsRange
bitxor:
bitops: bitxor[T: SomeInteger](x, y: T; z: varargs[T]): T
bkChoice:
LytBlockKind.bkChoice
bkEmpty:
LytBlockKind.bkEmpty
bkLine:
LytBlockKind.bkLine
bkStack:
LytBlockKind.bkStack
bkText:
LytBlockKind.bkText
bkVerb:
LytBlockKind.bkVerb
bkWrap:
LytBlockKind.bkWrap
Blob:
dom: Blob
blob:
Module typetraits
blockquote:
htmlgen: blockquote(e: varargs[untyped]): untyped
BlockTags:
htmlparser: BlockTags
blockUntil:
threadpool: blockUntil(fv: var FlowVarBaseObj)
blockUntilAny:
threadpool: blockUntilAny(flowVars: openArray[FlowVarBase]): int
blur:
dom: blur(e: Element)
dom: blur(w: Window)
body:
htmlgen: body(e: varargs[untyped]): untyped
httpclient: body(response: 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 .. MaxSubpatterns - 1]): tuple[first, last: int]
bpColloquial:
BinaryPrefixMode.bpColloquial
bpIEC:
BinaryPrefixMode.bpIEC
br:
htmlgen: br(e: varargs[untyped]): untyped
brClosed:
BindSymRule.brClosed
breadthFirst:
graph: breadthFirst[Id](graph: Graph[Id]; root: Id): Id
brForceOpen:
BindSymRule.brForceOpen
broadcast:
locks: broadcast(cond: var Cond)
brOpen:
BindSymRule.brOpen
BubblingPhase:
EventPhase.BubblingPhase
BufferSize:
net: BufferSize
button:
htmlgen: button(e: varargs[untyped]): untyped
BY_HANDLE_FILE_INFORMATION:
winlean: BY_HANDLE_FILE_INFORMATION
byte:
system: byte
BYTE:
winlean: BYTE
ByteAddress:
system: ByteAddress
CacheCounter:
macrocache: CacheCounter
CacheSeq:
macrocache: CacheSeq
CacheTable:
macrocache: CacheTable
caller info:
Module system
CallNodes:
macros: CallNodes
callsite:
macros: callsite(): NimNode
cancelAnimationFrame:
dom: cancelAnimationFrame(w: Window; id: int)
canShare:
dom: canShare(self: Navigator; data: cstring): bool
canvas:
htmlgen: canvas(e: varargs[untyped]): untyped
capitalize:
unicode: capitalize(s: string): string
capitalizeAscii:
strutils: capitalizeAscii(s: string): string
caption:
htmlgen: caption(e: varargs[untyped]): untyped
capture:
pegs: capture(a: Peg = Peg(kind: pkEmpty)): Peg
sugar: capture(locals: varargs[typed]; body: untyped): untyped
captureBetween:
parseutils: captureBetween(s: string; first: char; second = '\x00'; start = 0): string
CaptureBounds:
nre: CaptureBounds
captureBounds:
nre: captureBounds(pattern: RegexMatch): CaptureBounds
captureCount:
nre: captureCount(pattern: Regex): int
captureCurrString:
sexp_parse: captureCurrString(p: var SexpParser): string
captureNameId:
nre: captureNameId(pattern: Regex): Table[string, int]
Captures:
nre: Captures
captures:
nre: captures(pattern: RegexMatch): Captures
Captures:
pegs: Captures
CapturingPhase:
EventPhase.CapturingPhase
card:
packedsets: card[A](s: PackedSet[A]): int
sets: card[A](s: HashSet[A]): int
sets: card[A](s: OrderedSet[A]): int
system: card[T](x: set[T]): int
cas:
system: cas[T: bool | int | ptr](p: ptr T; oldValue, newValue: T): bool
catch:
asyncjs: catch[T](future: Future[T]; onReject: OnReject): Future[void]
CatchableError:
system: CatchableError
cbrt:
jscore: cbrt(m: MathLib; f: SomeFloat): SomeFloat
math: cbrt(x: float32): float32
math: cbrt(x: float64): float64
cchar:
system: cchar
cd:
nimscript: cd(dir: string)
CDATANode:
NodeType.CDATANode
cdouble:
system: cdouble
ceil:
jscore: ceil(m: MathLib; f: SomeFloat): SomeFloat
math: ceil(x: float32): float32
math: ceil(x: float64): float64
ceilDiv:
math: ceilDiv[T: SomeInteger](x, y: T): T
Cell:
asciitables: Cell
center:
htmlgen: center(e: varargs[untyped]): untyped
strutils: center(s: string; width: int; fillChar: char = ' '): string
Certificate:
net: Certificate
cfgEof:
CfgEventKind.cfgEof
cfgError:
CfgEventKind.cfgError
CfgEvent:
parsecfg: CfgEvent
CfgEventKind:
parsecfg: CfgEventKind
cfgKeyValuePair:
CfgEventKind.cfgKeyValuePair
cfgOption:
CfgEventKind.cfgOption
CfgParser:
parsecfg: CfgParser
cfgSectionStart:
CfgEventKind.cfgSectionStart
cfloat:
system: cfloat
cfSymlinkAsIs:
CopyFlag.cfSymlinkAsIs
cfSymlinkFollow:
CopyFlag.cfSymlinkFollow
cfSymlinkIgnore:
CopyFlag.cfSymlinkIgnore
CgiError:
cgi: CgiError
cgiError:
cgi: cgiError(msg: string)
ch:
pegs: ch(p: Peg): char
chaining:
Module with
changeFileExt:
os: changeFileExt(filename, ext: string): string
Channel:
system: 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
checkCustomExpr:
ast_pattern_matching: checkCustomExpr(arg: NimNode; cond: bool; exprstr: string): MatchingError
checked:
dom: checked(n: Node): bool
checked=:
dom: checked=(n: Node; v: bool)
checkedSymAddr:
dynlib: checkedSymAddr(lib: LibHandle; name: cstring): pointer
checkpoint:
unittest: checkpoint(msg: string)
checkReply:
smtp: checkReply(smtp: Smtp; reply: string)
checkTokenMembership:
winlean: checkTokenMembership(tokenHandle: Handle; sidToCheck: PSID; isMember: PBOOL): WINBOOL
checkValidity:
dom: checkValidity(e: FormElement): bool
dom: checkValidity(e: InputElement): bool
child:
xmltree: child(n: XmlNode; name: string): XmlNode
children:
macros: children(n: NimNode): NimNode
chomp:
Module strutils
chr:
system: chr(u: range[0 .. 255]): char
cint:
system: cint
CiphersIntermediate:
ssl_config: CiphersIntermediate
CiphersModern:
ssl_config: CiphersModern
CiphersOld:
ssl_config: CiphersOld
cite:
htmlgen: cite(e: varargs[untyped]): untyped
clamp:
math: clamp[T](val: T; bounds: Slice[T]): T
system: clamp[T](x, a, b: T): T
class:
dom: class(n: Node): cstring
class=:
dom: class=(n: Node; v: cstring)
classify:
math: classify(x: float): FloatClass
ClassList:
dom: ClassList
clear:
atomics: clear(location: var AtomicFlag; order: MemoryOrder = moSequentiallyConsistent)
deques: clear[T](deq: var Deque[T])
dom: clear(s: Storage)
heapqueue: clear[T](heap: var HeapQueue[T])
httpcore: clear(headers: HttpHeaders)
jsconsole: clear(console: Console)
jsformdata: clear(self: FormData)
jsheaders: clear(self: Headers)
packedsets: clear[A](result: var PackedSet[A])
sets: clear[A](s: var HashSet[A])
sets: clear[A](s: var OrderedSet[A])
sharedlist: clear[A](t: var SharedList[A])
stats: clear(r: var RunningRegress)
stats: clear(s: var RunningStat)
strtabs: clear(s: StringTableRef)
strtabs: clear(s: StringTableRef; mode: StringTableMode)
tables: clear[A](t: var CountTable[A])
tables: clear[A](t: CountTableRef[A])
tables: clear[A, B](t: var OrderedTable[A, B])
tables: clear[A, B](t: OrderedTableRef[A, B])
tables: clear[A, B](t: var Table[A, B])
tables: clear[A, B](t: TableRef[A, B])
xmltree: clear(n: var XmlNode)
clearBit:
bitops: clearBit[T: SomeInteger](v: var T; bit: BitsRange[T])
clearBits:
bitops: clearBits(v: typed; bits: varargs[typed]): untyped
clearData:
dom: clearData(dt: DataTransfer; format: cstring)
clearInterval:
dom: clearInterval(i: Interval)
dom: clearInterval(w: Window; interval: Interval)
clearMask:
bitops: clearMask[T: SomeInteger](v: var T; slice: Slice[int])
bitops: clearMask[T: SomeInteger](v: var T; mask: T)
clearMasked:
bitops: clearMasked[T: SomeInteger](v: T; slice: Slice[int]): T
bitops: clearMasked[T: SomeInteger](v, mask: T): T
clearScreen:
linenoise: clearScreen()
clearTimeout:
dom: clearTimeout(t: TimeOut)
dom: clearTimeout(w: Window; timeout: TimeOut)
click:
dom: click(e: Element)
clientData:
xmltree: clientData(n: XmlNode): int
clientData=:
xmltree: clientData=(n: XmlNode; data: int)
clientGetPskFunc:
net: clientGetPskFunc(ctx: SslContext): SslClientGetPskFunc
clientGetPskFunc=:
net: clientGetPskFunc=(ctx: SslContext; fun: SslClientGetPskFunc)
clientHeight:
dom: clientHeight(): int
clientWidth:
dom: clientWidth(): int
ClipboardEvent:
dom: ClipboardEvent
clone:
jsfetch: clone(self: Response | Request): Response
cloneNode:
dom: cloneNode(n: Node; copyContent: bool): Node
clong:
system: clong
clongdouble:
system: clongdouble
clonglong:
system: clonglong
close:
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)
io: close(f: File)
lexbase: close(L: var BaseLexer)
memfiles: close(f: var MemFile)
nativesockets: close(socket: SocketHandle)
net: close(socket: Socket; flags = {SocketFlag.SafeDisconn})
osproc: close(p: Process)
parsecfg: close(c: var CfgParser)
parsecsv: close(self: var CsvParser)
parsejson: close(my: var JsonParser)
parsexml: close(my: var XmlParser)
selectors: close(ev: SelectEvent)
selectors: close[T](s: Selector[T])
sexp_parse: close(parser: var SexpParser)
smtp: close(smtp: Smtp)
streams: close(s: Stream)
system: close[TMsg](c: var Channel[TMsg])
unittest: close(formatter: JUnitOutputFormatter)
closeHandle:
winlean: closeHandle(hObject: Handle): WINBOOL
closesocket:
winlean: closesocket(s: SocketHandle): cint
closureScope:
system: closureScope(body: untyped): untyped
clr:
colortext: clr(ch: char): ColRune
clt:
colortext: clt(ch: char): ColText
colortext: clt(str: string): ColText
clz32:
jscore: clz32(m: MathLib; f: SomeInteger): int
cmdArgument:
CmdLineKind.cmdArgument
cmdEnd:
CmdLineKind.cmdEnd
CmdLineKind:
parseopt: CmdLineKind
cmdLineRest:
parseopt: cmdLineRest(p: OptParser): string
cmdLongOption:
CmdLineKind.cmdLongOption
cmdShortOption:
CmdLineKind.cmdShortOption
cmp:
rationals: cmp(x, y: Rational): int
system: cmp(x, y: string): int
system: cmp[T](x, y: T): int
cmpic:
nimscript: cmpic(a, b: string): int
cmpIgnoreCase:
cstrutils: cmpIgnoreCase(a, b: cstring): int
strutils: cmpIgnoreCase(a, b: string): int
cmpIgnoreCaseImpl:
strimpl: cmpIgnoreCaseImpl[T: string | cstring](a, b: T; firstCharCaseSensitive: static bool = false)
cmpIgnoreStyle:
cstrutils: cmpIgnoreStyle(a, b: cstring): int
strutils: cmpIgnoreStyle(a, b: string): int
cmpIgnoreStyleImpl:
strimpl: cmpIgnoreStyleImpl[T: string | cstring](a, b: T; firstCharCaseSensitive: static bool = false)
cmpMem:
system: cmpMem(a, b: pointer; size: Natural): int
cmpNimIdentifier:
strimpl: cmpNimIdentifier[T: string | cstring](a, b: T): int
cmpPaths:
os: cmpPaths(pathA, pathB: string): int
cmpRunesIgnoreCase:
unicode: cmpRunesIgnoreCase(a, b: string): int
code:
htmlgen: code(e: varargs[untyped]): untyped
httpclient: code(response: Response): HttpCode
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
colDarkGrey:
colors: colDarkGrey
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
colDarkSlateGrey:
colors: colDarkSlateGrey
colDarkTurquoise:
colors: colDarkTurquoise
colDarkViolet:
colors: colDarkViolet
colDeepPink:
colors: colDeepPink
colDeepSkyBlue:
colors: colDeepSkyBlue
colDimGray:
colors: colDimGray
colDimGrey:
colors: colDimGrey
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
colGrey:
colors: colGrey
colgroup:
htmlgen: colgroup(e: varargs[untyped]): untyped
colHoneyDew:
colors: colHoneyDew
colHotPink:
colors: colHotPink
colIndianRed:
colors: colIndianRed
colIndigo:
colors: colIndigo
colIvory:
colors: colIvory
colKhaki:
colors: colKhaki
colLavender:
colors: colLavender
colLavenderBlush:
colors: colLavenderBlush
colLawnGreen:
colors: colLawnGreen
collect:
sugar: collect(body: untyped): untyped
sugar: collect(init, body: untyped): untyped
colLemonChiffon:
colors: colLemonChiffon
colLightBlue:
colors: colLightBlue
colLightCoral:
colors: colLightCoral
colLightCyan:
colors: colLightCyan
colLightGoldenRodYellow:
colors: colLightGoldenRodYellow
colLightGray:
colors: colLightGray
colLightGreen:
colors: colLightGreen
colLightGrey:
colors: colLightGrey
colLightPink:
colors: colLightPink
colLightSalmon:
colors: colLightSalmon
colLightSeaGreen:
colors: colLightSeaGreen
colLightSkyBlue:
colors: colLightSkyBlue
colLightSlateGray:
colors: colLightSlateGray
colLightSlateGrey:
colors: colLightSlateGrey
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
ColModifier:
colortext: ColModifier
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
colorDollar:
colordiff: colorDollar[T](arg: T): ColText
coloredResult:
colortext: coloredResult(indentationStep: int = 2): untyped
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
colRebeccaPurple:
colors: colRebeccaPurple
colRed:
colors: colRed
colRosyBrown:
colors: colRosyBrown
colRoyalBlue:
colors: colRoyalBlue
ColRune:
colortext: ColRune
ColRuneGrid:
colortext: ColRuneGrid
ColRuneLine:
colortext: ColRuneLine
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
colSlateGrey:
colors: colSlateGrey
colSnow:
colors: colSnow
colSpringGreen:
colors: colSpringGreen
colSteelBlue:
colors: colSteelBlue
ColStyle:
colortext: ColStyle
colStyle:
colortext: colStyle(bg: BackgroundColor): ColStyle
colortext: colStyle(style: ColStyle): ColStyle
colortext: colStyle(fg: ForegroundColor): ColStyle
colortext: colStyle(style: set[Style]): ColStyle
colortext: colStyle(style: Style): ColStyle
colortext: colStyle(bg: TermColorBg): ColStyle
colortext: colStyle(fg: TermColorFg): ColStyle
colTan:
colors: colTan
colTeal:
colors: colTeal
ColText:
colortext: ColText
colThistle:
colors: colThistle
colTomato:
colors: colTomato
colTurquoise:
colors: colTurquoise
colViolet:
colors: colViolet
colWheat:
colors: colWheat
colWhite:
colors: colWhite
colWhiteSmoke:
colors: colWhiteSmoke
colYellow:
colors: colYellow
colYellowGreen:
colors: colYellowGreen
combine:
uri: combine(base: Uri; reference: Uri): Uri
uri: combine(uris: varargs[Uri]): Uri
comma separated value:
Module parsecsv
command line:
Module os
command line argument:
Module os
command line arguments:
Module os
commandLineParams:
os: commandLineParams(): seq[string]
CommentNode:
NodeType.CommentNode
commitedLen:
reservedmem: commitedLen(m: ReservedMem): int
reservedmem: commitedLen[T](s: ReservedMemSeq[T]): int
commitHead:
gitutils: commitHead
commonAttr:
htmlgen: commonAttr
commonPrefixLen:
critbits: commonPrefixLen[T](c: CritBitTree[T]): int
compareDocumentPosition:
dom: compareDocumentPosition(n: Node; otherNode: Node): int
compareExchange:
atomics: compareExchange[T: Trivial](location: var Atomic[T]; expected: var T; desired: T; order: MemoryOrder = moSequentiallyConsistent): bool
atomics: compareExchange[T: Trivial](location: var Atomic[T]; expected: var T; desired: T; success, failure: MemoryOrder): bool
atomics: compareExchange[T: not Trivial](location: var Atomic[T]; expected: var T; desired: T; success, failure: MemoryOrder): bool
atomics: compareExchange[T: not Trivial](location: var Atomic[T]; expected: var T; desired: T; order: MemoryOrder = moSequentiallyConsistent): bool
compareExchangeWeak:
atomics: compareExchangeWeak[T: Trivial](location: var Atomic[T]; expected: var T; desired: T; order: MemoryOrder = moSequentiallyConsistent): bool
atomics: compareExchangeWeak[T: Trivial](location: var Atomic[T]; expected: var T; desired: T; success, failure: MemoryOrder): bool
atomics: compareExchangeWeak[T: not Trivial](location: var Atomic[T]; expected: var T; desired: T; success, failure: MemoryOrder): bool
atomics: compareExchangeWeak[T: not Trivial](location: var Atomic[T]; expected: var T; desired: T; order: MemoryOrder = moSequentiallyConsistent): bool
compile:
jsre: compile(self: RegExp; pattern: cstring; flags: cstring)
CompileDate:
system: CompileDate
compileOption:
system: compileOption(option: string): bool
system: compileOption(option, arg: string): bool
CompilerVersionMajor:
system: CompilerVersionMajor
CompilerVersionMinor:
system: CompilerVersionMinor
CompilerVersionPatch:
system: CompilerVersionPatch
compiles:
system: compiles(x: untyped): bool
CompileTime:
system: CompileTime
complement:
setutils: complement[T](s: set[T]): set[T]
CompletionCallback:
linenoise: CompletionCallback
Completions:
linenoise: Completions
Complex:
complex: Complex
complex:
complex: complex[T: SomeFloat](re: T; im: T = 0.0): Complex[T]
Complex32:
complex: Complex32
complex32:
complex: complex32(re: float32; im: float32 = 0.0): Complex32
Complex64:
complex: Complex64
complex64:
complex: complex64(re: float64; im: float64 = 0.0): Complex64
computeInDegrees:
graph: computeInDegrees[Id](graph: Graph[Id]): CountTable[Id]
concat:
sequtils: concat[T](seqs: varargs[seq[T]]): seq[T]
Cond:
locks: Cond
Config:
parsecfg: Config
confirm:
dom: confirm(w: Window; msg: cstring): bool
conjugate:
complex: conjugate[T](z: Complex[T]): Complex[T]
connect:
net: connect(socket: Socket; address: string; port = Port(0))
net: connect(socket: Socket; address: string; port = Port(0); timeout: int)
smtp: connect(smtp: Smtp; address: string; port: Port)
winlean: connect(s: SocketHandle; name: ptr SockAddr; namelen: SockLen): cint
connectedComponents:
graph: connectedComponents[Id](graph: Graph[Id]; overrideDirected: bool = false): seq[ HashSet[Id]]
connectUnix:
net: connectUnix(socket: Socket; path: string)
Console:
jsconsole: Console
console:
jsconsole: console
ConsoleLogger:
logging: ConsoleLogger
ConsoleOutputFormatter:
unittest: ConsoleOutputFormatter
contains:
colortext: contains(ps: ColStyle; s: Style): bool
critbits: contains[T](c: CritBitTree[T]; key: string): bool
deques: contains[T](deq: Deque[T]; item: T): bool
dom: contains(c: ClassList; class: cstring): bool
dom: contains(n: Node): bool
graph: contains[Id](graph: Graph[Id]; edge: GraphEdge[Id]): bool
graph: contains[Id](graph: Graph[Id]; node: Id): bool
httpcore: contains(values: HttpHeaderValues; value: string): bool
httpcore: contains(methods: set[HttpMethod]; x: string): bool
json: contains(node: JsonNode; val: JsonNode): bool
json: contains(node: JsonNode; key: string): bool
jsre: contains(pattern: cstring; self: RegExp): bool
lists: contains[T](L: SomeLinkedCollection[T]; value: T): bool
nre: contains(pattern: CaptureBounds; i: int): bool
nre: contains(pattern: CaptureBounds; name: string): bool
nre: contains(pattern: Captures; i: int): bool
nre: contains(pattern: Captures; name: string): bool
nre: contains(str: string; pattern: Regex; start = 0; endpos = int.high): bool
packedsets: contains[A](s: PackedSet[A]; key: A): bool
pegs: contains(s: string; pattern: Peg; start = 0): bool
pegs: contains(s: string; pattern: Peg; matches: var openArray[string]; start = 0): bool
re: contains(s: string; pattern: Regex; start = 0): bool
re: contains(s: string; pattern: Regex; matches: var openArray[string]; start = 0): bool
selectors: contains[T](s: Selector[T]; fd: SocketHandle | int): bool
sets: contains[A](s: HashSet[A]; key: A): bool
sets: contains[A](s: OrderedSet[A]; key: A): bool
strtabs: contains(t: StringTableRef; key: string): bool
strutils: contains(s: string; chars: set[char]): bool
strutils: contains(s, sub: string): bool
system: contains[U, V, W](s: HSlice[U, V]; value: W): bool
system: contains[T](a: openArray[T]; item: T): bool
system: contains[T](x: set[T]; y: T): bool
tables: contains[A](t: CountTable[A]; key: A): bool
tables: contains[A](t: CountTableRef[A]; key: A): bool
tables: contains[A, B](t: OrderedTable[A, B]; key: A): bool
tables: contains[A, B](t: OrderedTableRef[A, B]; key: A): bool
tables: contains[A, B](t: Table[A, B]; key: A): bool
tables: contains[A, B](t: TableRef[A, B]; key: A): bool
containsOrIncl:
critbits: containsOrIncl[T](c: var CritBitTree[T]; key: string; val: T): bool
critbits: containsOrIncl(c: var CritBitTree[void]; key: string): bool
packedsets: containsOrIncl[A](s: var PackedSet[A]; key: A): bool
sets: containsOrIncl[A](s: var HashSet[A]; key: A): bool
sets: containsOrIncl[A](s: var OrderedSet[A]; key: A): bool
contentLength:
httpclient: contentLength(response: Response): int
contentType:
httpclient: contentType(response: Response): 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
convertBlock:
text_layouter: convertBlock(bk: LytBlock; newKind: LytBlockKind): LytBlock
convertSexp:
sexp: convertSexp(x: untyped): untyped
ConvertThreadToFiber:
winlean: ConvertThreadToFiber(param: pointer): pointer
ConvertThreadToFiberEx:
winlean: ConvertThreadToFiberEx(param: pointer; flags: int32): pointer
copy:
json: copy(p: JsonNode): JsonNode
lists: copy[T](a: DoublyLinkedList[T]): DoublyLinkedList[T]
lists: copy[T](a: SinglyLinkedList[T]): SinglyLinkedList[T]
macros: copy(node: NimNode): NimNode
sexp: copy(p: SexpNode): SexpNode
copyChildrenTo:
macros: copyChildrenTo(src, dest: NimNode)
copyDir:
os: copyDir(source, dest: string)
copyDirWithPermissions:
os: copyDirWithPermissions(source, dest: string; ignorePermissionErrors = true)
copyFile:
os: copyFile(source, dest: string; options = {cfSymlinkFollow})
copyFileToDir:
os: copyFileToDir(source, dir: string; options = {cfSymlinkFollow})
copyFileW:
winlean: copyFileW(lpExistingFileName, lpNewFileName: WideCString; bFailIfExists: WINBOOL): WINBOOL
copyFileWithPermissions:
os: copyFileWithPermissions(source, dest: string; ignorePermissionErrors = true; options = {cfSymlinkFollow})
CopyFlag:
os: CopyFlag
copyLineInfo:
macros: copyLineInfo(arg: NimNode; info: NimNode)
copyMem:
system: copyMem(dest, source: pointer; size: Natural)
Module typetraits
copyNimNode:
macros: copyNimNode(n: NimNode): NimNode
copyNimTree:
macros: copyNimTree(n: NimNode): NimNode
copySign:
math: copySign[T: SomeFloat](x, y: T): T
coreAttr:
htmlgen: coreAttr
correlation:
stats: correlation(r: RunningRegress): float
cos:
complex: cos[T](z: Complex[T]): Complex[T]
jscore: cos(m: MathLib; a: SomeNumber): float
math: cos(x: float32): float32
math: cos(x: float64): float64
cosh:
complex: cosh[T](z: Complex[T]): Complex[T]
jscore: cosh(m: MathLib; a: SomeNumber): float
math: cosh(x: float32): float32
math: cosh(x: float64): float64
cot:
complex: cot[T](z: Complex[T]): Complex[T]
math: cot[T: float32 | float64](x: T): T
coth:
complex: coth[T](z: Complex[T]): Complex[T]
math: coth[T: float32 | float64](x: T): T
count:
jsconsole: count(console: Console; label = "".cstring)
sequtils: count[T](s: openArray[T]; x: T): int
strutils: count(s: string; sub: char): int
strutils: count(s: string; subs: set[char]): int
strutils: count(s: string; sub: string; overlapping: bool = false): int
countdown:
system: countdown[T](a, b: T; step: Positive = 1): T
countIt:
sequtils: countIt(s, pred: untyped): int
countLeadingZeroBits:
bitops: countLeadingZeroBits(x: SomeInteger): int
countLines:
strutils: countLines(s: string): int
countProcessors:
cpuinfo: countProcessors(): int
osproc: countProcessors(): int
countReset:
jsconsole: countReset(console: Console; label = "".cstring)
countSetBits:
bitops: countSetBits(x: SomeInteger): int
CountTable:
tables: CountTable
CountTableRef:
tables: CountTableRef
countTrailingZeroBits:
bitops: countTrailingZeroBits(x: SomeInteger): int
countup:
system: countup[T](a, b: T; step: Positive = 1): T
cpDir:
nimscript: cpDir(from, to: string)
cpFile:
nimscript: cpFile(from, to: string)
cpkArgument:
ShellArgKind.cpkArgument
cpkTemplated:
ShellArgKind.cpkTemplated
CPU:
Module system
cpuEndian:
system: cpuEndian
cpuRelax:
system: cpuRelax()
cpuTime:
times: cpuTime(): float
create:
system: create(T: typedesc; size = 1.Positive): ptr T:type
CREATE_ALWAYS:
winlean: CREATE_ALWAYS
createAttribute:
dom: createAttribute(d: Document; identifier: cstring): Node
createComment:
dom: createComment(d: Document; data: cstring): Node
createDir:
os: createDir(dir: string)
createDirectoryW:
winlean: createDirectoryW(pathName: WideCString; security: pointer = nil): int32
createElement:
dom: createElement(d: Document; identifier: cstring): Element
createElementNS:
dom: createElementNS(d: Document; namespaceURI, qualifiedIdentifier: cstring): Element
createEvent:
winlean: createEvent(lpEventAttributes: ptr SECURITY_ATTRIBUTES; bManualReset: DWORD; bInitialState: DWORD; lpName: ptr Utf16Char): Handle
CreateFiber:
winlean: CreateFiber(stackSize: int; fn: LPFIBER_START_ROUTINE; param: pointer): pointer
CreateFiberEx:
winlean: CreateFiberEx(stkCommit: int; stkReserve: int; flags: int32; fn: LPFIBER_START_ROUTINE; param: pointer): pointer
createFileA:
winlean: createFileA(lpFileName: cstring; dwDesiredAccess, dwShareMode: DWORD; lpSecurityAttributes: pointer; dwCreationDisposition, dwFlagsAndAttributes: DWORD; hTemplateFile: Handle): Handle
createFileMappingW:
winlean: createFileMappingW(hFile: Handle; lpFileMappingAttributes: pointer; flProtect, dwMaximumSizeHigh: DWORD; dwMaximumSizeLow: DWORD; lpName: pointer): Handle
createFileW:
winlean: createFileW(lpFileName: WideCString; dwDesiredAccess, dwShareMode: DWORD; lpSecurityAttributes: pointer; dwCreationDisposition, dwFlagsAndAttributes: DWORD; hTemplateFile: Handle): Handle
createHardlink:
os: createHardlink(src, dest: string)
createHardLinkW:
winlean: createHardLinkW(lpFileName, lpExistingFileName: WideCString; security: pointer = nil): int32
createIoCompletionPort:
winlean: createIoCompletionPort(FileHandle: Handle; ExistingCompletionPort: Handle; CompletionKey: ULONG_PTR; NumberOfConcurrentThreads: DWORD): Handle
createMessage:
smtp: createMessage(mSubject, mBody: string; mTo, mCc: seq[string] = @[]): Message
smtp: createMessage(mSubject, mBody: string; mTo, mCc: seq[string]; otherHeaders: openArray[tuple[name, value: string]]): Message
createNamedPipe:
winlean: createNamedPipe(lpName: WideCString; dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut: int32; lpSecurityAttributes: ptr SECURITY_ATTRIBUTES): Handle
createNativeSocket:
nativesockets: createNativeSocket(domain: cint; sockType: cint; protocol: cint; inheritable: bool = defined(nimInheritHandles)): SocketHandle
nativesockets: createNativeSocket(domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP; inheritable: bool = defined(nimInheritHandles)): SocketHandle
CREATE_NEW:
winlean: CREATE_NEW
CREATE_NO_WINDOW:
winlean: CREATE_NO_WINDOW
createPipe:
winlean: createPipe(hReadPipe, hWritePipe: var Handle; lpPipeAttributes: var SECURITY_ATTRIBUTES; nSize: int32): WINBOOL
createProcessW:
winlean: createProcessW(lpApplicationName, lpCommandLine: WideCString; lpProcessAttributes: ptr SECURITY_ATTRIBUTES; lpThreadAttributes: ptr SECURITY_ATTRIBUTES; bInheritHandles: WINBOOL; dwCreationFlags: int32; lpEnvironment, lpCurrentDirectory: WideCString; lpStartupInfo: var STARTUPINFO; lpProcessInformation: var PROCESS_INFORMATION): WINBOOL
createShared:
system: createShared(T: typedesc; size = 1.Positive): ptr T:type
createSharedU:
system: createSharedU(T: typedesc; size = 1.Positive): ptr T:type
createSymbolicLinkW:
winlean: createSymbolicLinkW(lpSymlinkFileName, lpTargetFileName: WideCString; flags: DWORD): int32
createSymlink:
os: createSymlink(src, dest: string)
createTempDir:
tempfiles: createTempDir(prefix, suffix: string; dir = ""): string
createTempFile:
tempfiles: createTempFile(prefix, suffix: string; dir = ""): tuple[cfile: File, path: string]
createTextNode:
dom: createTextNode(d: Document; identifier: cstring): Node
createThread:
system: createThread[TArg](tp: proc (arg: TArg) {.thread, nimcall.}; param: TArg): Thread[ TArg]
system: createThread[TArg](t: var Thread[TArg]; tp: proc (arg: TArg) {.thread, nimcall.}; param: TArg)
system: 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
cshort:
system: cshort
csize:
system: csize
csize_t:
system: csize_t
cstring:
system: cstring
cstringArray:
system: cstringArray
cstringArrayToSeq:
system: cstringArrayToSeq(a: cstringArray): seq[string]
system: cstringArrayToSeq(a: cstringArray; len: Natural): seq[string]
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
currString:
sexp_parse: currString(p: SexpParser): string
currToken:
sexp_parse: currToken(p: SexpParser): TTokKind
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:
Module system
CVerifyNone:
SslCVerifyMode.CVerifyNone
CVerifyPeer:
SslCVerifyMode.CVerifyPeer
CVerifyPeerUseEnvVars:
SslCVerifyMode.CVerifyPeerUseEnvVars
cycle:
sequtils: cycle[T](s: openArray[T]; n: Natural): seq[T]
data:
htmlgen: data(e: varargs[untyped]): untyped
datalist:
htmlgen: datalist(e: varargs[untyped]): untyped
DataTransfer:
dom: DataTransfer
DataTransferDropEffect:
dom: DataTransferDropEffect
DataTransferEffectAllowed:
dom: DataTransferEffectAllowed
DataTransferItem:
dom: DataTransferItem
DataTransferItemKind:
dom: DataTransferItemKind
Date:
jscore: Date
DateLib:
jscore: DateLib
DateTime:
jscore: DateTime
times: DateTime
dateTime:
times: dateTime(year: int; month: Month; monthday: MonthdayRange; hour: HourRange = 0; minute: MinuteRange = 0; second: SecondRange = 0; nanosecond: NanosecondRange = 0; zone: Timezone = local()): DateTime
DateTimeLocale:
times: DateTimeLocale
Days:
TimeUnit.Days
days:
times: days(d: int): TimeInterval
dbArray:
DbTypeKind.dbArray
dbBindParamError:
db_sqlite: dbBindParamError(paramIdx: int; val: varargs[untyped])
dbBit:
DbTypeKind.dbBit
dbBlob:
DbTypeKind.dbBlob
dbBool:
DbTypeKind.dbBool
dbBox:
DbTypeKind.dbBox
dbCircle:
DbTypeKind.dbCircle
DbColumn:
db_common: DbColumn
DbColumns:
db_common: DbColumns
dbComposite:
DbTypeKind.dbComposite
DbConn:
db_mysql: DbConn
db_odbc: DbConn
db_postgres: DbConn
db_sqlite: DbConn
dbDate:
DbTypeKind.dbDate
dbDatetime:
DbTypeKind.dbDatetime
dbDecimal:
DbTypeKind.dbDecimal
DbEffect:
db_common: DbEffect
dbEnum:
DbTypeKind.dbEnum
DbError:
db_common: DbError
dbError:
db_common: dbError(msg: string)
db_mysql: dbError(db: DbConn)
db_odbc: dbError(db: var DbConn)
db_postgres: dbError(db: DbConn)
db_sqlite: dbError(db: DbConn)
dbFixedChar:
DbTypeKind.dbFixedChar
dbFloat:
DbTypeKind.dbFloat
dbFormatImpl:
dbutils: dbFormatImpl(formatstr: SqlQuery; dbQuote: proc (s: string): string; args: varargs[string]): string
dbGeometry:
DbTypeKind.dbGeometry
dbInet:
DbTypeKind.dbInet
dbInt:
DbTypeKind.dbInt
dbJson:
DbTypeKind.dbJson
dbLine:
DbTypeKind.dbLine
dbLseg:
DbTypeKind.dbLseg
dbMacAddress:
DbTypeKind.dbMacAddress
dbNull:
DbTypeKind.dbNull
dbPath:
DbTypeKind.dbPath
dbPoint:
DbTypeKind.dbPoint
dbPolygon:
DbTypeKind.dbPolygon
dbQuote:
db_mysql: dbQuote(s: string): string
db_odbc: dbQuote(s: string): string
db_postgres: dbQuote(s: string): string
db_sqlite: dbQuote(s: string): string
dbSerial:
DbTypeKind.dbSerial
dbSet:
DbTypeKind.dbSet
dbTime:
DbTypeKind.dbTime
dbTimeInterval:
DbTypeKind.dbTimeInterval
dbTimestamp:
DbTypeKind.dbTimestamp
DbType:
db_common: DbType
DbTypeKind:
db_common: DbTypeKind
dbUInt:
DbTypeKind.dbUInt
dbUnknown:
DbTypeKind.dbUnknown
dbUrl:
DbTypeKind.dbUrl
dbUser1:
DbTypeKind.dbUser1
dbUser2:
DbTypeKind.dbUser2
dbUser3:
DbTypeKind.dbUser3
dbUser4:
DbTypeKind.dbUser4
dbUser5:
DbTypeKind.dbUser5
dbUuid:
DbTypeKind.dbUuid
dbVarchar:
DbTypeKind.dbVarchar
dbXml:
DbTypeKind.dbXml
dd:
htmlgen: dd(e: varargs[untyped]): untyped
DeadThreadDefect:
system: DeadThreadDefect
DeadThreadError:
system: DeadThreadError
dealloc:
system: dealloc(p: pointer)
deallocCStringArray:
system: deallocCStringArray(a: cstringArray)
deallocImpl:
system: deallocImpl(p: pointer)
deallocShared:
system: deallocShared(p: pointer)
deallocSharedImpl:
system: deallocSharedImpl(p: pointer)
debug:
jsconsole: debug(console: Console)
logging: debug(args: varargs[string, `$`])
debugEcho:
system: debugEcho(x: varargs[typed, `$`])
debugger:
jscore: debugger()
debugRecv:
smtp: debugRecv(smtp: Smtp): string
debugSend:
smtp: debugSend(smtp: Smtp; cmd: string)
dec:
jsbigints: dec(this: var JsBigInt)
jsbigints: dec(this: var JsBigInt; amount: JsBigInt)
system: dec[T: Ordinal](x: var T; y = 1)
declared:
system: declared(x: untyped): bool
declaredInScope:
system: declaredInScope(x: untyped): bool
declareHighMasking:
dod_helpers: declareHighMasking(Name: untyped; highMaskRange: static[range[0 .. 64]] = 0; BaseType: typed = uint64): untyped
declareIdType:
dod_helpers: declareIdType(Name: untyped; addHash: static[bool] = false; BaseType: typed = uint64): untyped
declareStoredTableField:
dod_helpers: declareStoredTableField(Db, field, Name, Typ: untyped): untyped
declareStoredTableSeqField:
dod_helpers: declareStoredTableSeqField(Db, field, Name, Typ: untyped): untyped
declareStoreField:
dod_helpers: declareStoreField(Type, field, Name: untyped): untyped
declareStoreType:
dod_helpers: declareStoreType(Name: untyped): untyped
decode:
base64: decode(s: string): string
punycode: decode(encoded: string): string
decodeData:
cgi: decodeData(allowedMethods: set[RequestMethod] = {methodNone, methodPost, methodGet}): tuple[key, value: string]
cgi: decodeData(data: string): tuple[key, value: string]
decodePercent:
decode_helpers: decodePercent(s: openArray[char]; i: var int): char
decodeQuery:
uri: decodeQuery(data: string): tuple[key, value: string]
decodeURI:
dom: decodeURI(uri: cstring): cstring
decodeURIComponent:
dom: decodeURIComponent(uri: cstring): cstring
decodeUrl:
uri: decodeUrl(s: string; decodePlus = true): string
decodeZigzag:
varints: decodeZigzag(x: uint64): int64
dedent:
strutils: dedent(s: string; count: Natural = indentation(s)): string
deduplicate:
sequtils: deduplicate[T](s: openArray[T]; isSorted: bool = false): seq[T]
deepCopy:
system: deepCopy[T](y: T): T
system: deepCopy[T](x: var T; y: T)
default:
colortext: default(rune: typedesc[ColRune]): ColRune
colortext: default(style: typedesc[ColStyle]): ColStyle
graph: default[Id](graph: typedesc[Graph[Id]]): Graph[Id]
system: default[T](_: typedesc[T]): T
defaultConfig:
rstgen: defaultConfig(): StringTableRef
defaultConsoleFormatter:
unittest: defaultConsoleFormatter(): ConsoleOutputFormatter
defaultFilename:
logging: defaultFilename(): string
defaultFmtStr:
logging: defaultFmtStr
defaultInitialSize:
deques: defaultInitialSize
sets: defaultInitialSize
tables: defaultInitialSize
DefaultLocale:
times: DefaultLocale
defaultOptSeparators:
parseopt2: defaultOptSeparators
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])
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)
strtabs: del(t: StringTableRef; key: string)
system: del[T](x: var seq[T]; i: Natural)
tables: del[A](t: var CountTable[A]; key: A)
tables: del[A](t: CountTableRef[A]; key: A)
tables: del[A, B](t: var OrderedTable[A, B]; key: A)
tables: del[A, B](t: OrderedTableRef[A, B]; key: A)
tables: del[A, B](t: var Table[A, B]; key: A)
tables: del[A, B](t: TableRef[A, B]; key: A)
delEnv:
nimscript: delEnv(key: string)
os: delEnv(key: string)
delete:
httpclient: delete(client: HttpClient; url: Uri | string): Response
jsformdata: delete(self: FormData; name: cstring)
jsheaders: delete(self: Headers; key: cstring)
json: delete(obj: JsonNode; key: string)
sequtils: delete[T](s: var seq[T]; slice: Slice[int])
strutils: delete(s: var string; slice: Slice[int])
system: delete[T](x: var seq[T]; i: Natural)
xmltree: delete(n: XmlNode; i: Natural)
deleteContent:
httpclient: deleteContent(client: HttpClient; url: Uri | string): string
deleteData:
dom: deleteData(n: Node; start, len: int)
DeleteFiber:
winlean: DeleteFiber(fiber: pointer)
deleteFileA:
winlean: deleteFileA(pathName: cstring): int32
deleteFileW:
winlean: deleteFileW(pathName: WideCString): int32
deleteFromDocument:
dom: deleteFromDocument(s: Selection)
delOutputFormatter:
unittest: delOutputFormatter(formatter: OutputFormatter)
delSection:
parsecfg: delSection(dict: var Config; section: string)
delSectionKey:
parsecfg: delSectionKey(dict: var Config; section, key: string)
depthFirst:
graph: depthFirst[Id](graph: Graph[Id]; root: Id): tuple[id: Id, depth: int]
Deque:
deques: Deque
deque:
Module deques
Descending:
SortOrder.Descending
describeDiff:
sexp_diff: describeDiff(diff: seq[SexpMismatch]; conf: DiffFormatConf): ColText
deserialization:
Module marshal
destroyContext:
net: destroyContext(ctx: SslContext)
destructor:
Module system
DETACHED_PROCESS:
winlean: DETACHED_PROCESS
details:
htmlgen: details(e: varargs[untyped]): untyped
detectOs:
distros: detectOs(d: untyped): bool
DeviceId:
os: DeviceId
dfn:
htmlgen: dfn(e: varargs[untyped]): untyped
dFri:
WeekDay.dFri
dial:
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
sexp_diff: diff(target, input: SexpNode): seq[SexpMismatch]
difference:
packedsets: difference[A](s1, s2: PackedSet[A]): PackedSet[A]
sets: difference[A](s1, s2: HashSet[A]): HashSet[A]
diffFiles:
gitutils: diffFiles(path1, path2: string): tuple[output: string, same: bool]
DiffFormatConf:
colordiff: DiffFormatConf
diffFormatter:
colordiff: diffFormatter(useUnicode: bool = true): DiffFormatConf
diffInt:
diff: diffInt(arrayA, arrayB: openArray[int]): seq[Item]
diffStrings:
gitutils: diffStrings(a, b: string): tuple[output: string, same: bool]
diffText:
diff: diffText(textA, textB: string): seq[Item]
diff: diffText(text1, text2: string; sideBySide: bool; showLineNumbers: bool = false): string
digits:
fenv: digits(T: typedesc[float32]): int
fenv: digits(T: typedesc[float64]): int
pegs: digits(): Peg
Digits:
strutils: Digits
dir:
jsconsole: dir(console: Console; obj: auto)
directory:
Module os
Module os
dirExists:
nimscript: dirExists(dir: string): bool
os: dirExists(dir: string): bool
DirSep:
os: DirSep
dirxml:
jsconsole: dirxml(console: Console; obj: auto)
disableCache:
ropes: disableCache()
disabled=:
dom: disabled=(n: Node; v: bool)
disableExternalCapture:
dom: disableExternalCapture(w: Window)
disableParamFiltering:
unittest: disableParamFiltering()
disableProfiling:
nimprof: disableProfiling()
disableTrueColors:
terminal: disableTrueColors()
disarm:
system: disarm(x: typed)
disjoint:
packedsets: disjoint[A](s1, s2: PackedSet[A]): bool
sets: disjoint[A](s1, s2: HashSet[A]): bool
dispatchEvent:
dom: dispatchEvent(et: EventTarget; ev: Event)
distance:
reservedmem: distance(lhs, rhs: pointer): int
distinctBase:
typetraits: distinctBase(T: typedesc; recursive: static bool = true): typedesc
typetraits: distinctBase[T](a: T; recursive: static bool = true): untyped
distribute:
sequtils: distribute[T](s: seq[T]; num: Positive; spread = true): seq[seq[T]]
Distribution:
distros: Distribution
DivByZeroDefect:
system: DivByZeroDefect
DivByZeroError:
system: DivByZeroError
dl:
htmlgen: dl(e: varargs[untyped]): untyped
DLL:
Module os
dMon:
WeekDay.dMon
doAssert:
assertions: doAssert(cond: untyped; msg = "")
doAssertRaises:
assertions: doAssertRaises(exception: typedesc; code: untyped)
doCreateThread:
ThreadPoolAdvice.doCreateThread
Document:
dom: Document
document:
dom: document
DocumentFragmentNode:
NodeType.DocumentFragmentNode
DocumentNode:
NodeType.DocumentNode
DocumentOrShadowRoot:
dom: DocumentOrShadowRoot
DocumentTypeNode:
NodeType.DocumentTypeNode
Domain:
nativesockets: Domain
DOMAIN_ALIAS_RID_ADMINS:
winlean: DOMAIN_ALIAS_RID_ADMINS
DomApiVersion:
dom: DomApiVersion
DomEvent:
dom: DomEvent
DomException:
dom: DomException
DomParser:
dom: DomParser
doNothing:
ThreadPoolAdvice.doNothing
doOptLayout:
text_layouter: doOptLayout(self: var LytBlock; rest: var Option[LytSolution]; opts: LytOptions): Option[ LytSolution]
doShutdownThread:
ThreadPoolAdvice.doShutdownThread
doslikeFileSystem:
os: doslikeFileSystem
DoublyLinkedList:
lists: DoublyLinkedList
DoublyLinkedNode:
lists: DoublyLinkedNode
DoublyLinkedNodeObj:
lists: DoublyLinkedNodeObj
DoublyLinkedRing:
lists: DoublyLinkedRing
downloadFile:
httpclient: downloadFile(client: HttpClient; url: Uri | string; filename: string)
Drag:
DragEventTypes.Drag
DragEnd:
DragEventTypes.DragEnd
DragEnter:
DragEventTypes.DragEnter
DragEvent:
dom: DragEvent
DragEventTypes:
dom: DragEventTypes
DragExit:
DragEventTypes.DragExit
DragLeave:
DragEventTypes.DragLeave
DragOver:
DragEventTypes.DragOver
DragStart:
DragEventTypes.DragStart
Drop:
DragEventTypes.Drop
dSat:
WeekDay.dSat
dSun:
WeekDay.dSun
dt:
htmlgen: dt(e: varargs[untyped]): untyped
dThu:
WeekDay.dThu
dTue:
WeekDay.dTue
dump:
sugar: dump(x: untyped): untyped
dumpAllocstats:
system: dumpAllocstats(code: untyped)
dumpAstGen:
macros: dumpAstGen(s: untyped): untyped
dumpLisp:
macros: dumpLisp(s: untyped): untyped
dumpToString:
sugar: dumpToString(x: untyped): string
dumpTree:
macros: dumpTree(s: untyped): untyped
dup:
sugar: dup[T](arg: T; calls: varargs[untyped]): T
duplicateHandle:
winlean: duplicateHandle(hSourceProcessHandle: Handle; hSourceHandle: Handle; hTargetProcessHandle: Handle; lpTargetHandle: ptr Handle; dwDesiredAccess: DWORD; bInheritHandle: WINBOOL; dwOptions: DWORD): WINBOOL
DUPLICATE_SAME_ACCESS:
winlean: DUPLICATE_SAME_ACCESS
Duration:
times: Duration
DurationParts:
times: DurationParts
DurationZero:
times: DurationZero
dWed:
WeekDay.dWed
DWORD:
winlean: DWORD
DynlibFormat:
os: DynlibFormat
E:
math: E
eat:
parsejson: eat(p: var JsonParser; tok: TokKind)
echo:
system: echo(x: varargs[typed, `$`])
echoForeignDeps:
distros: echoForeignDeps()
edgeCount:
graph: edgeCount[Id](graph: Graph[Id]): int
edgePairs:
graph: edgePairs[Id](graph: Graph[Id]): GraphEdge[Id]
edit distance:
Module editdistance
editDistance:
editdistance: editDistance(a, b: string): int
editDistanceAscii:
editdistance: editDistanceAscii(a, b: string): int
EInvalidPeg:
pegs: EInvalidPeg
Element:
dom: Element
elementFromPoint:
dom: elementFromPoint(n: DocumentOrShadowRoot; x, y: float): Element
elementName:
parsexml: elementName(my: XmlParser): string
ElementNode:
NodeType.ElementNode
elements:
typeinfo: elements(x: Any): int
elementsFromPoint:
dom: elementsFromPoint(n: DocumentOrShadowRoot; x, y: float): seq[Element]
elementType:
typetraits: elementType(a: untyped): typedesc
em:
htmlgen: em(e: varargs[untyped]): untyped
embed:
htmlgen: embed(e: varargs[untyped]): untyped
EmbedElement:
dom: EmbedElement
EmptyLytStr:
text_layouter: EmptyLytStr
EmptyLytStrId:
text_layouter: EmptyLytStrId
EmptyValueId:
dod_helpers: EmptyValueId
enableCache:
ropes: enableCache()
enableExternalCapture:
dom: enableExternalCapture(w: Window)
enableProfiling:
nimprof: enableProfiling()
enableTrueColors:
terminal: enableTrueColors()
encode:
base64: encode[T: SomeInteger | char](s: openArray[T]; safe = false): string
base64: encode(s: string; safe = false): string
punycode: encode(s: string): string
punycode: encode(prefix, s: string): string
encodeMime:
base64: encodeMime(s: string; lineLen = 75; newLine = "\r "): string
encodeQuery:
uri: encodeQuery(query: openArray[(string, string)]; usePlus = true; omitEq = true): string
encodeURI:
dom: encodeURI(uri: cstring): cstring
encodeURIComponent:
dom: encodeURIComponent(uri: cstring): cstring
encodeUrl:
uri: encodeUrl(s: string; usePlus = true): string
encodeZigzag:
varints: encodeZigzag(x: int64): uint64
EncodingConverter:
encodings: EncodingConverter
EncodingError:
encodings: EncodingError
endAnchor:
pegs: endAnchor(): Peg
endian:
Module endians
Endianness:
system: Endianness
endOfFile:
io: endOfFile(f: File): bool
EndOfFile:
lexbase: EndOfFile
endsWith:
cstrutils: endsWith(s, suffix: cstring): bool
jsre: endsWith(pattern: cstring; self: RegExp): bool
pegs: endsWith(s: string; suffix: Peg; start = 0): bool
re: endsWith(s: string; suffix: Regex): bool
strutils: endsWith(s: string; suffix: char): bool
strutils: endsWith(s, suffix: string): bool
endsWithImpl:
strimpl: endsWithImpl[T: string | cstring](s, suffix: T)
entityName:
parsexml: entityName(my: XmlParser): string
EntityNode:
NodeType.EntityNode
EntityRefNode:
NodeType.EntityRefNode
entityToRune:
htmlparser: entityToRune(entity: string): Rune
entityToUtf8:
htmlparser: entityToUtf8(entity: string): string
entries:
jsheaders: entries(self: Headers): seq[tuple[key, value: cstring]]
enumerate:
lists: enumerate[T](L: SomeLinkedList[T]): (int, T)
lists: enumerate[T](L: SomeLinkedRing[T]): (int, T)
enumLen:
typetraits: enumLen(T: typedesc[enum]): int
EnumMode:
jsonutils: EnumMode
environment variable:
Module os
Module os
Module os
environments variables:
Module os
envPairs:
os: envPairs(): tuple[key, value: string]
EOFError:
system: EOFError
epochTime:
times: epochTime(): float
epoll_create:
epoll: epoll_create(size: cint): cint
epoll_create1:
epoll: epoll_create1(flags: cint): cint
epoll_ctl:
epoll: epoll_ctl(epfd: cint; op: cint; fd: cint | SocketHandle; event: ptr EpollEvent): cint
EPOLL_CTL_ADD:
epoll: EPOLL_CTL_ADD
EPOLL_CTL_DEL:
epoll: EPOLL_CTL_DEL
EPOLL_CTL_MOD:
epoll: EPOLL_CTL_MOD
EpollData:
epoll: EpollData
EPOLLERR:
epoll: EPOLLERR
EPOLLET:
epoll: EPOLLET
EpollEvent:
epoll: EpollEvent
EPOLLEXCLUSIVE:
epoll: EPOLLEXCLUSIVE
EPOLLHUP:
epoll: EPOLLHUP
EPOLLIN:
epoll: EPOLLIN
EPOLLMSG:
epoll: EPOLLMSG
EPOLLONESHOT:
epoll: EPOLLONESHOT
EPOLLOUT:
epoll: EPOLLOUT
EPOLLPRI:
epoll: EPOLLPRI
EPOLLRDBAND:
epoll: EPOLLRDBAND
EPOLLRDHUP:
epoll: EPOLLRDHUP
EPOLLRDNORM:
epoll: EPOLLRDNORM
epoll_wait:
epoll: epoll_wait(epfd: cint; events: ptr EpollEvent; maxevents: cint; timeout: cint): cint
EPOLLWAKEUP:
epoll: EPOLLWAKEUP
EPOLLWRBAND:
epoll: EPOLLWRBAND
EPOLLWRNORM:
epoll: EPOLLWRNORM
epsilon:
fenv: epsilon(T: typedesc[float32]): float32
fenv: epsilon(T: typedesc[float64]): float64
eqIdent:
macros: eqIdent(a: NimNode; b: NimNode): bool
macros: eqIdent(a: NimNode; b: string): bool
macros: eqIdent(a: string; b: NimNode): bool
macros: eqIdent(a: string; b: string): bool
equalMem:
system: equalMem(a, b: pointer; size: Natural): bool
equalsFile:
ropes: equalsFile(r: Rope; f: File): bool
ropes: equalsFile(r: Rope; filename: string): bool
eraseLine:
terminal: eraseLine(f: File)
terminal: eraseLine()
eraseScreen:
terminal: eraseScreen(f: File)
terminal: eraseScreen()
erf:
math: erf(x: float32): float32
math: erf(x: float64): float64
erfc:
math: erfc(x: float32): float32
math: erfc(x: float64): float64
err:
results: err[T, E](R: typedesc[Result[T, E]]; e: sink E): Result[T, E]
errAttributeValueExpected:
XmlErrorKind.errAttributeValueExpected
errBracketRiExpected:
JsonError.errBracketRiExpected
errColonExpected:
JsonError.errColonExpected
errCommaExpected:
JsonError.errCommaExpected
errCurlyRiExpected:
JsonError.errCurlyRiExpected
errEndOfCDataExpected:
XmlErrorKind.errEndOfCDataExpected
errEndOfCommentExpected:
XmlErrorKind.errEndOfCommentExpected
errEOC_Expected:
JsonError.errEOC_Expected
errEofExpected:
JsonError.errEofExpected
SexpError.errEofExpected
errEqExpected:
XmlErrorKind.errEqExpected
errExprExpected:
JsonError.errExprExpected
errGtExpected:
XmlErrorKind.errGtExpected
errInvalidToken:
JsonError.errInvalidToken
SexpError.errInvalidToken
errNameExpected:
XmlErrorKind.errNameExpected
errNone:
JsonError.errNone
XmlErrorKind.errNone
SexpError.errNone
Error:
asyncjs: Error
error:
dom: error(f: FileReader): DomException
jsconsole: error(console: Console)
logging: error(args: varargs[string, `$`])
macros: error(msg: string; n: NimNode = nil)
results: error[T, E](self: Result[T, E]): lent E
sexp_parse: error(p: SexpParser): SexpError
ERROR_ACCESS_DENIED:
winlean: ERROR_ACCESS_DENIED
ERROR_BAD_ARGUMENTS:
winlean: ERROR_BAD_ARGUMENTS
ERROR_FILE_EXISTS:
winlean: ERROR_FILE_EXISTS
ERROR_FILE_NOT_FOUND:
winlean: ERROR_FILE_NOT_FOUND
errorHandle:
osproc: errorHandle(p: Process): FileHandle
ERROR_HANDLE_EOF:
winlean: ERROR_HANDLE_EOF
ERROR_IO_PENDING:
winlean: ERROR_IO_PENDING
ERROR_LOCK_VIOLATION:
winlean: ERROR_LOCK_VIOLATION
errorMessages:
parsejson: errorMessages
errorMessageWriter:
system: errorMessageWriter
errorMsg:
parsejson: errorMsg(my: JsonParser): string
parsexml: errorMsg(my: XmlParser): string
parsexml: errorMsg(my: XmlParser; msg: string): string
sexp: errorMsg(parser: SexpParser): string
errorMsgExpected:
parsejson: errorMsgExpected(my: JsonParser; e: string): string
parsexml: errorMsgExpected(my: XmlParser; tag: string): string
sexp: errorMsgExpected(parser: SexpParser; e: string): string
ERROR_NETNAME_DELETED:
winlean: ERROR_NETNAME_DELETED
ERROR_NO_MORE_FILES:
winlean: ERROR_NO_MORE_FILES
ERROR_PATH_NOT_FOUND:
winlean: ERROR_PATH_NOT_FOUND
errorStr:
parsecfg: errorStr(c: CfgParser; msg: string): string
errorStream:
osproc: errorStream(p: Process): Stream
errParensRiExpected:
SexpError.errParensRiExpected
errQmGtExpected:
XmlErrorKind.errQmGtExpected
errQuoteExpected:
JsonError.errQuoteExpected
XmlErrorKind.errQuoteExpected
SexpError.errQuoteExpected
errSemicolonExpected:
XmlErrorKind.errSemicolonExpected
errStringExpected:
JsonError.errStringExpected
esc:
rstgen: esc(target: OutputTarget; s: string; splitAfter = -1; escMode = emText): string
escape:
dom: escape(uri: cstring): cstring
strutils: escape(s: string; prefix = "\""; suffix = "\""): string
xmltree: escape(s: string): string
escapeJson:
json: escapeJson(s: string): string
json: escapeJson(s: string; result: var string)
sexp: escapeJson(s: string): string
escapeJsonUnquoted:
json: escapeJsonUnquoted(s: string): string
json: escapeJsonUnquoted(s: string; result: var string)
escapePeg:
pegs: escapePeg(s: string): string
escapeRe:
nre: escapeRe(str: string): string
re: escapeRe(s: string): string
escChar:
rstgen: escChar(target: OutputTarget; dest: var string; c: char; escMode: EscapeMode)
euclDiv:
math: euclDiv[T: SomeInteger](x, y: T): T
euclMod:
math: euclMod[T: SomeNumber](x, y: T): T
EV_ADD:
kqueue: EV_ADD
evalToAst:
macros: evalToAst[T](x: T): NimNode
EV_CLEAR:
kqueue: EV_CLEAR
EV_DELETE:
kqueue: EV_DELETE
EV_DISABLE:
kqueue: EV_DISABLE
EV_DISPATCH:
kqueue: EV_DISPATCH
EV_DROP:
kqueue: EV_DROP
EV_ENABLE:
kqueue: EV_ENABLE
Event:
dom: Event
selectors: Event
eventAttr:
htmlgen: eventAttr
eventParser:
pegs: eventParser(pegAst, handlers: untyped): (proc (s: string): int)
EventPhase:
dom: EventPhase
EventTarget:
dom: EventTarget
EV_EOF:
kqueue: EV_EOF
EV_ERROR:
kqueue: EV_ERROR
EV_FLAG1:
kqueue: EV_FLAG1
EV_NODATA:
kqueue: EV_NODATA
EV_ONESHOT:
kqueue: EV_ONESHOT
EV_RECEIPT:
kqueue: EV_RECEIPT
EV_SET:
kqueue: EV_SET(event: ptr KEvent; ident: uint; filter: cshort; flags: cushort; fflags: cuint; data: int; udata: pointer)
EV_SYSFLAGS:
kqueue: EV_SYSFLAGS
exception:
jsconsole: exception(console: Console; args: varargs[untyped])
Exception:
system: Exception
exchange:
atomics: exchange[T: Trivial](location: var Atomic[T]; desired: T; order: MemoryOrder = moSequentiallyConsistent): T
atomics: exchange[T: not Trivial](location: var Atomic[T]; desired: T; order: MemoryOrder = moSequentiallyConsistent): T
excl:
critbits: excl[T](c: var CritBitTree[T]; key: string)
packedsets: excl[A](s: var PackedSet[A]; key: A)
packedsets: excl[A](s: var PackedSet[A]; other: PackedSet[A])
sets: excl[A](s: var HashSet[A]; key: A)
sets: excl[A](s: var HashSet[A]; other: HashSet[A])
sets: excl[A](s: var OrderedSet[A]; key: A)
system: excl[T](x: var set[T]; y: T)
system: excl[T](x: var set[T]; y: set[T])
exclFilePermissions:
os: exclFilePermissions(filename: string; permissions: set[FilePermission])
exec:
db_mysql: exec(db: DbConn; query: SqlQuery; args: varargs[string, `$`])
db_odbc: exec(db: var DbConn; query: SqlQuery; args: varargs[string, `$`])
db_postgres: exec(db: DbConn; stmtName: SqlPrepared; args: varargs[string])
db_postgres: exec(db: DbConn; query: SqlQuery; args: varargs[string, `$`])
db_sqlite: exec(db: DbConn; query: SqlQuery; args: varargs[string, `$`])
db_sqlite: exec(db: DbConn; stmtName: SqlPrepared; args: varargs[typed]): untyped
jsre: exec(self: RegExp; pattern: cstring): seq[cstring]
nimscript: exec(command: string)
nimscript: exec(command: string; input: string; cache = ""): string
shellrunner: exec(cmds: openArray[ShellCmd]; options: set[ProcessOption] = {poUsePath}; maxParallel: int = countProcessors(); dir: string = ""; beforeRunEvent: proc (idx: int) = nil; afterRunEvent: proc (idx: int; p: Process) = nil): seq[ShellResult]
shellrunner: exec(cmd: ShellCmd; dir: string = ""; stdin: string = ""; options: set[ProcessOption] = {poUsePath}; maxOutSize: int = 40960 * 1024): ShellResult
execAffectedRows:
db_mysql: execAffectedRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
db_odbc: execAffectedRows(db: var DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
db_postgres: execAffectedRows(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): int64
db_postgres: execAffectedRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
db_sqlite: execAffectedRows(db: DbConn; stmtName: SqlPrepared): int64
db_sqlite: execAffectedRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
execCmd:
osproc: execCmd(command: string): int
execCmdEx:
osproc: execCmdEx(command: string; options: set[ProcessOption] = {poStdErrToStdOut, poUsePath}; env: StringTableRef = nil; workingDir = ""; input = ""): tuple[ output: string, exitCode: int]
ExecIOEffect:
system: ExecIOEffect
execProcess:
osproc: execProcess(command: string; workingDir: string = ""; args: openArray[string] = []; env: StringTableRef = nil; options: set[ ProcessOption] = {poStdErrToStdOut, poUsePath, poEvalCommand}): string
execProcesses:
osproc: execProcesses(cmds: openArray[string]; options = {poStdErrToStdOut, poParentStreams}; n = countProcessors(); beforeRunEvent: proc (idx: int) = nil; startRunEvent: proc (idx: int; p: Process) = 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
existsEnv:
nimscript: existsEnv(key: string): bool
os: existsEnv(key: string): bool
existsOrCreateDir:
os: existsOrCreateDir(dir: string): bool
exitStatusLikeShell:
os: exitStatusLikeShell(status: cint): cint
exp:
complex: exp[T](z: Complex[T]): Complex[T]
jscore: exp(m: MathLib; a: SomeNumber): float
math: exp(x: float32): float32
math: exp(x: float64): float64
expandFilename:
os: expandFilename(filename: string): string
expandMacros:
macros: expandMacros(body: typed): untyped
expandSymlink:
os: expandSymlink(symlinkPath: string): string
expandTabs:
strmisc: expandTabs(s: string; tabSize: int = 8): string
expandTilde:
os: expandTilde(path: string): string
expect:
unittest: expect(args: varargs[untyped]): untyped
expectIdent:
macros: expectIdent(n: NimNode; name: string)
expectKind:
macros: expectKind(n: NimNode; k: NimNodeKind)
macros: expectKind(n: NimNode; k: set[NimNodeKind])
expectLen:
macros: expectLen(n: NimNode; len: int)
macros: expectLen(n: NimNode; min, max: int)
expectMinLen:
macros: expectMinLen(n: NimNode; min: int)
expectValid:
text_layouter: expectValid(bl: LytBlock; msg: string = "")
expm1:
jscore: expm1(m: MathLib; a: SomeNumber): float
extendSeq:
typeinfo: extendSeq(x: Any)
extract:
isolation: extract[T](src: var Isolated[T]): T
extractDocCommentsAndRunnables:
macros: extractDocCommentsAndRunnables(n: NimNode): NimNode
extractFilename:
os: extractFilename(path: string): string
extractRGB:
colors: extractRGB(a: Color): tuple[r, g, b: range[0 .. 255]]
ExtSep:
os: ExtSep
fac:
math: fac(n: int): int
fail:
unittest: fail()
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)
failWithMatchingError:
ast_pattern_matching: failWithMatchingError(arg: MatchingError): void
fakeDot:
wrapnils: fakeDot(a: Option; b): untyped
fastLog2:
bitops: fastLog2(x: SomeInteger): int
fastRows:
db_mysql: fastRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
db_odbc: fastRows(db: var DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
db_postgres: fastRows(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): Row
db_postgres: fastRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
db_sqlite: fastRows(db: DbConn; stmtName: SqlPrepared): Row
db_sqlite: fastRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
fastRuneAt:
unicode: fastRuneAt(s: string; i: int; result: untyped; doInc = true)
fastToUTF8Copy:
unicode: fastToUTF8Copy(c: Rune; s: var string; pos: int; doInc = true)
fatal:
logging: fatal(args: varargs[string, `$`])
fchDefault:
FetchCaches.fchDefault
fchForceCache:
FetchCaches.fchForceCache
fchNoCache:
FetchCaches.fchNoCache
fchNoStore:
FetchCaches.fchNoStore
fchReload:
FetchCaches.fchReload
fcInclude:
FetchCredentials.fcInclude
fcInf:
FloatClass.fcInf
fcNan:
FloatClass.fcNan
fcNegInf:
FloatClass.fcNegInf
fcNegZero:
FloatClass.fcNegZero
fcNormal:
FloatClass.fcNormal
fcOmit:
FetchCredentials.fcOmit
fcSameOrigin:
FetchCredentials.fcSameOrigin
fcSubnormal:
FloatClass.fcSubnormal
fcZero:
FloatClass.fcZero
FD_ACCEPT:
winlean: FD_ACCEPT
FD_ADDRESS_LIST_CHANGE:
winlean: FD_ADDRESS_LIST_CHANGE
FD_ALL_EVENTS:
winlean: FD_ALL_EVENTS
FD_CLOSE:
winlean: FD_CLOSE
FD_CONNECT:
winlean: FD_CONNECT
FD_GROUP_QQS:
winlean: FD_GROUP_QQS
FD_ISSET:
winlean: FD_ISSET(socket: SocketHandle; set: var TFdSet): cint
FD_OOB:
winlean: FD_OOB
FD_QQS:
winlean: FD_QQS
FD_READ:
winlean: FD_READ
FD_ROUTING_INTERFACE_CHANGE:
winlean: FD_ROUTING_INTERFACE_CHANGE
FD_SET:
winlean: FD_SET(socket: SocketHandle; s: var TFdSet)
FD_SETSIZE:
winlean: FD_SETSIZE
FD_WRITE:
winlean: FD_WRITE
FD_ZERO:
winlean: FD_ZERO(s: var TFdSet)
FE_ALL_EXCEPT:
fenv: FE_ALL_EXCEPT
feclearexcept:
fenv: feclearexcept(excepts: cint): cint
FE_DFL_ENV:
fenv: FE_DFL_ENV
FE_DIVBYZERO:
fenv: FE_DIVBYZERO
FE_DOWNWARD:
fenv: FE_DOWNWARD
fegetenv:
fenv: fegetenv(envp: ptr Tfenv): cint
fegetexceptflag:
fenv: fegetexceptflag(flagp: ptr Tfexcept; excepts: cint): cint
fegetround:
fenv: fegetround(): cint
feholdexcept:
fenv: feholdexcept(envp: ptr Tfenv): cint
FE_INEXACT:
fenv: FE_INEXACT
FE_INVALID:
fenv: FE_INVALID
fence:
atomics: fence(order: MemoryOrder)
system: fence()
FE_OVERFLOW:
fenv: FE_OVERFLOW
feraiseexcept:
fenv: feraiseexcept(excepts: cint): cint
fesetenv:
fenv: fesetenv(a1: ptr Tfenv): cint
fesetexceptflag:
fenv: fesetexceptflag(flagp: ptr Tfexcept; excepts: cint): cint
fesetround:
fenv: fesetround(roundingDirection: cint): cint
fetch:
jsfetch: fetch(url: cstring | Request): Future[Response]
jsfetch: fetch(url: cstring | Request; options: FetchOptions): Future[Response]
fetchAdd:
atomics: fetchAdd[T: SomeInteger](location: var Atomic[T]; value: T; order: MemoryOrder = moSequentiallyConsistent): T
fetchAnd:
atomics: fetchAnd[T: SomeInteger](location: var Atomic[T]; value: T; order: MemoryOrder = moSequentiallyConsistent): T
FetchCaches:
jsfetch: FetchCaches
FetchCredentials:
jsfetch: FetchCredentials
FetchModes:
jsfetch: FetchModes
FetchOptions:
jsfetch: FetchOptions
fetchOr:
atomics: fetchOr[T: SomeInteger](location: var Atomic[T]; value: T; order: MemoryOrder = moSequentiallyConsistent): T
FetchRedirects:
jsfetch: FetchRedirects
FetchReferrerPolicies:
jsfetch: FetchReferrerPolicies
fetchSub:
atomics: fetchSub[T: SomeInteger](location: var Atomic[T]; value: T; order: MemoryOrder = moSequentiallyConsistent): T
fetchXor:
atomics: fetchXor[T: SomeInteger](location: var Atomic[T]; value: T; order: MemoryOrder = moSequentiallyConsistent): T
fetestexcept:
fenv: fetestexcept(excepts: cint): cint
FE_TONEAREST:
fenv: FE_TONEAREST
FE_TOWARDZERO:
fenv: FE_TOWARDZERO
FE_UNDERFLOW:
fenv: FE_UNDERFLOW
feupdateenv:
fenv: feupdateenv(envp: ptr Tfenv): cint
FE_UPWARD:
fenv: FE_UPWARD
ffDecimal:
FloatFormatMode.ffDecimal
ffDefault:
FloatFormatMode.ffDefault
ffScientific:
FloatFormatMode.ffScientific
fg8Bit:
ForegroundColor.fg8Bit
fgBlack:
ForegroundColor.fgBlack
fgBlue:
ForegroundColor.fgBlue
fgColor:
TerminalCmd.fgColor
fgCyan:
ForegroundColor.fgCyan
fgDefault:
ForegroundColor.fgDefault
fgGreen:
ForegroundColor.fgGreen
fgMagenta:
ForegroundColor.fgMagenta
fgRed:
ForegroundColor.fgRed
fgWhite:
ForegroundColor.fgWhite
fgYellow:
ForegroundColor.fgYellow
FIBER_FLAG_FLOAT_SWITCH:
winlean: FIBER_FLAG_FLOAT_SWITCH
FieldDefect:
system: FieldDefect
FieldError:
system: FieldError
fieldPairs:
iterators: fieldPairs[S: tuple | object; T: tuple | object](x: S; y: T): tuple[key: string, a, b: RootObj]
iterators: fieldPairs[T: tuple | object](x: T): tuple[key: string, val: RootObj]
fields:
iterators: fields[S: tuple | object; T: tuple | object](x: S; y: T): tuple[key: string, val: RootObj]
iterators: fields[T: tuple | object](x: T): RootObj
typeinfo: fields(x: Any): tuple[name: string, any: Any]
fieldset:
htmlgen: fieldset(e: varargs[untyped]): untyped
FifthButton:
MouseButtons.FifthButton
figcaption:
htmlgen: figcaption(e: varargs[untyped]): untyped
figure:
htmlgen: figure(e: varargs[untyped]): untyped
File:
dom: File
io: File
FILE_ATTRIBUTE_ARCHIVE:
winlean: FILE_ATTRIBUTE_ARCHIVE
FILE_ATTRIBUTE_COMPRESSED:
winlean: FILE_ATTRIBUTE_COMPRESSED
FILE_ATTRIBUTE_DEVICE:
winlean: FILE_ATTRIBUTE_DEVICE
FILE_ATTRIBUTE_DIRECTORY:
winlean: FILE_ATTRIBUTE_DIRECTORY
FILE_ATTRIBUTE_HIDDEN:
winlean: FILE_ATTRIBUTE_HIDDEN
FILE_ATTRIBUTE_NORMAL:
winlean: FILE_ATTRIBUTE_NORMAL
FILE_ATTRIBUTE_NOT_CONTENT_INDEXED:
winlean: FILE_ATTRIBUTE_NOT_CONTENT_INDEXED
FILE_ATTRIBUTE_OFFLINE:
winlean: FILE_ATTRIBUTE_OFFLINE
FILE_ATTRIBUTE_READONLY:
winlean: FILE_ATTRIBUTE_READONLY
FILE_ATTRIBUTE_REPARSE_POINT:
winlean: FILE_ATTRIBUTE_REPARSE_POINT
FILE_ATTRIBUTE_SPARSE_FILE:
winlean: FILE_ATTRIBUTE_SPARSE_FILE
FILE_ATTRIBUTE_SYSTEM:
winlean: FILE_ATTRIBUTE_SYSTEM
FILE_ATTRIBUTE_TEMPORARY:
winlean: FILE_ATTRIBUTE_TEMPORARY
FILE_BEGIN:
winlean: FILE_BEGIN
fileExists:
nimscript: fileExists(filename: string): bool
os: fileExists(filename: string): bool
FILE_FLAG_BACKUP_SEMANTICS:
winlean: FILE_FLAG_BACKUP_SEMANTICS
FILE_FLAG_DELETE_ON_CLOSE:
winlean: FILE_FLAG_DELETE_ON_CLOSE
FILE_FLAG_FIRST_PIPE_INSTANCE:
winlean: FILE_FLAG_FIRST_PIPE_INSTANCE
FILE_FLAG_NO_BUFFERING:
winlean: FILE_FLAG_NO_BUFFERING
FILE_FLAG_OPEN_NO_RECALL:
winlean: FILE_FLAG_OPEN_NO_RECALL
FILE_FLAG_OPEN_REPARSE_POINT:
winlean: FILE_FLAG_OPEN_REPARSE_POINT
FILE_FLAG_OVERLAPPED:
winlean: FILE_FLAG_OVERLAPPED
FILE_FLAG_POSIX_SEMANTICS:
winlean: FILE_FLAG_POSIX_SEMANTICS
FILE_FLAG_RANDOM_ACCESS:
winlean: FILE_FLAG_RANDOM_ACCESS
FILE_FLAG_SEQUENTIAL_SCAN:
winlean: FILE_FLAG_SEQUENTIAL_SCAN
FILE_FLAG_WRITE_THROUGH:
winlean: FILE_FLAG_WRITE_THROUGH
FileHandle:
io: FileHandle
FileId:
os: FileId
FileIndex:
rstast: FileIndex
FileInfo:
os: FileInfo
FileLogger:
logging: FileLogger
FILE_MAP_READ:
winlean: FILE_MAP_READ
FILE_MAP_WRITE:
winlean: FILE_MAP_WRITE
FileMode:
io: FileMode
fileNewer:
os: fileNewer(a, b: string): bool
FilePermission:
os: FilePermission
FILE_READ_DATA:
winlean: FILE_READ_DATA
FileReader:
dom: FileReader
fileReaderDone:
dom: fileReaderDone
fileReaderEmpty:
dom: fileReaderEmpty
fileReaderLoading:
dom: fileReaderLoading
FileReaderState:
dom: FileReaderState
FileSeekPos:
system: FileSeekPos
FILE_SHARE_DELETE:
winlean: FILE_SHARE_DELETE
FILE_SHARE_READ:
winlean: FILE_SHARE_READ
FILE_SHARE_WRITE:
winlean: FILE_SHARE_WRITE
FileStream:
streams: FileStream
FileStreamObj:
streams: FileStreamObj
FileSystemCaseSensitive:
os: FileSystemCaseSensitive
FILETIME:
winlean: FILETIME
FILE_WRITE_DATA:
winlean: FILE_WRITE_DATA
fill:
algorithm: fill[T](a: var openArray[T]; first, last: Natural; value: T)
algorithm: fill[T](a: var openArray[T]; value: T)
filter:
options: filter[T](self: Option[T]; callback: proc (input: T): bool): Option[T]
results: filter[T: not void; E](r: Result[T, E]; callback: proc (v: 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
sequtils: filter[T](s: seq[T]; pred: proc (x: T): bool {.closure.}): T
filterEmpty:
text_layouter: filterEmpty(blocks: openArray[LytBlock]): seq[LytBlock]
filterErr:
results: filterErr[T, E](r: Result[T, E]; callback: proc (e: E): bool): Option[E]
filterIt:
sequtils: filterIt(s, pred: untyped): untyped
finalize:
db_sqlite: finalize(sqlPrepared: SqlPrepared)
sha1: finalize(ctx: var Sha1State): Sha1Digest
find:
dom: find(w: Window; text: cstring; caseSensitive = false; backwards = false)
heapqueue: find[T](heap: HeapQueue[T]; x: T): int
lists: find[T](L: SomeLinkedCollection[T]; value: T): SomeLinkedNode[T]
nre: find(str: string; pattern: Regex; start = 0; endpos = int.high): Option[ RegexMatch]
pegs: find(s: string; pattern: Peg; start = 0): int
pegs: find(s: string; pattern: Peg; matches: var openArray[string]; start = 0): int
re: find(buf: cstring; pattern: Regex; start = 0; bufSize: int): int
re: find(buf: cstring; pattern: Regex; matches: var openArray[string]; start = 0; bufSize: int): int
re: find(s: string; pattern: Regex; start = 0): int
re: find(s: string; pattern: Regex; matches: var openArray[string]; start = 0): int
strutils: find(a: SkipTable; s, sub: string; start: Natural = 0; last = 0): int
strutils: find(s: string; sub: char; start: Natural = 0; last = 0): int
strutils: find(s: string; chars: set[char]; start: Natural = 0; last = 0): int
strutils: find(s, sub: string; start: Natural = 0; last = 0): int
system: find[T, S](a: T; item: S): int
findAll:
nre: findAll(str: string; pattern: Regex; start = 0; endpos = int.high): seq[string]
pegs: findAll(s: string; pattern: Peg; start = 0): seq[string]
pegs: findAll(s: string; pattern: Peg; start = 0): string
re: findAll(s: string; pattern: Regex; start = 0): seq[string]
re: findAll(buf: cstring; pattern: Regex; start = 0; bufSize: int): string
re: findAll(s: string; pattern: Regex; start = 0): string
xmltree: findAll(n: XmlNode; tag: string; caseInsensitive = false): seq[XmlNode]
xmltree: findAll(n: XmlNode; tag: string; result: var seq[XmlNode]; caseInsensitive = false)
findBounds:
pegs: findBounds(s: string; pattern: Peg; matches: var openArray[string]; start = 0): tuple[ first, last: int]
re: findBounds(buf: cstring; pattern: Regex; start = 0; bufSize: int): tuple[ first, last: int]
re: findBounds(buf: cstring; pattern: Regex; matches: var openArray[string]; start = 0; bufSize: int): tuple[first, last: int]
re: findBounds(buf: cstring; pattern: Regex; matches: var openArray[tuple[first, last: int]]; start = 0; bufSize: int): tuple[first, last: int]
re: findBounds(s: string; pattern: Regex; start = 0): tuple[first, last: int]
re: findBounds(s: string; pattern: Regex; matches: var openArray[string]; start = 0): tuple[ first, last: int]
re: findBounds(s: string; pattern: Regex; matches: var openArray[tuple[first, last: int]]; start = 0): tuple[ first, last: int]
findChild:
macros: findChild(n: NimNode; cond: untyped): NimNode
findClose:
winlean: findClose(hFindFile: Handle)
findCycles:
graph: findCycles[Id](graph: Graph[Id]; ignoreSelf: bool = false; overrideDirected: bool = false; yieldMultiedge: bool = false): seq[ Path[Id]]
findExe:
nimscript: findExe(bin: string): string
os: findExe(exe: string; followSymlinks: bool = true; extensions: openArray[string] = ExeExts): string
findFirstFileW:
winlean: findFirstFileW(lpFileName: WideCString; lpFindFileData: var WIN32_FIND_DATA): Handle
findIt:
graph: findIt(s: typed; op: untyped): int
findIter:
nre: findIter(str: string; pattern: Regex; start = 0; endpos = int.high): RegexMatch
findMaxIt:
graph: findMaxIt(s: untyped; op: untyped): untyped
findNextFileW:
winlean: findNextFileW(hFindFile: Handle; lpFindFileData: var WIN32_FIND_DATA): int32
findSingle:
text_layouter: findSingle(elems: typed; targetKind: typed): untyped
finished:
system: finished[T: proc](x: T): bool
FIONBIO:
nativesockets: FIONBIO
firstSetBit:
bitops: firstSetBit(x: SomeInteger): int
FixedTimeUnit:
times: FixedTimeUnit
flags:
pegs: flags(nt: NonTerminal): set[NonTerminalFlag]
flatMap:
options: flatMap[T, R](self: Option[T]; callback: proc (input: T): Option[R]): Option[R]
results: flatMap[T: not void; E, R](r: Result[T, E]; callback: proc (v: T): Result[R, E]): Result[ R, E]
flatMapErr:
results: flatMapErr[T: not void; E, R](r: Result[T, E]; callback: proc (e: E): Result[T, R]): Result[T, R]
flatten:
options: flatten[T](self: Option[Option[T]]): Option[T]
text_layouter: flatten(bl: LytBlock; kind: set[LytBlockKind]): LytBlock
flipBit:
bitops: flipBit[T: SomeInteger](v: var T; bit: BitsRange[T])
flipBits:
bitops: flipBits(v: typed; bits: varargs[typed]): untyped
flipMask:
bitops: flipMask[T: SomeInteger](v: var T; slice: Slice[int])
bitops: flipMask[T: SomeInteger](v: var T; mask: T)
flipMasked:
bitops: flipMasked[T: SomeInteger](v: T; slice: Slice[int]): T
bitops: flipMasked[T: SomeInteger](v, mask: T): T
float:
system: float
float32:
system: float32
float64:
system: float64
Float64Array:
jsutils: Float64Array
FloatClass:
math: FloatClass
FloatDivByZeroDefect:
system: FloatDivByZeroDefect
FloatDivByZeroError:
system: FloatDivByZeroError
FloatFormatMode:
strutils: FloatFormatMode
FloatInexactDefect:
system: FloatInexactDefect
FloatInexactError:
system: FloatInexactError
FloatingPointDefect:
system: FloatingPointDefect
FloatingPointError:
system: FloatingPointError
FloatInvalidOpDefect:
system: FloatInvalidOpDefect
FloatInvalidOpError:
system: FloatInvalidOpError
FloatOverflowDefect:
system: FloatOverflowDefect
FloatOverflowError:
system: FloatOverflowError
FloatUnderflowDefect:
system: FloatUnderflowDefect
FloatUnderflowError:
system: FloatUnderflowError
floatVal:
macros: floatVal(n: NimNode): BiggestFloat
floatVal=:
macros: floatVal=(n: NimNode; val: BiggestFloat)
floor:
jscore: floor(m: MathLib; f: SomeFloat): int
math: floor(x: float32): float32
math: floor(x: float64): float64
floorDiv:
math: floorDiv[T: SomeInteger](x, y: T): T
rationals: floorDiv[T: SomeInteger](x, y: Rational[T]): T
floorMod:
math: floorMod[T: SomeNumber](x, y: T): T
rationals: floorMod[T: SomeInteger](x, y: Rational[T]): Rational[T]
FlowVar:
threadpool: FlowVar
FlowVarBase:
threadpool: FlowVarBase
flush:
memfiles: flush(f: var MemFile; attempts: Natural = 3)
streams: flush(s: Stream)
flushFile:
io: flushFile(f: File)
flushFileBuffers:
winlean: flushFileBuffers(hFile: Handle): WINBOOL
flushViewOfFile:
winlean: flushViewOfFile(lpBaseAddress: pointer; dwNumberOfBytesToFlush: DWORD): WINBOOL
fmAppend:
FileMode.fmAppend
fmCors:
FetchModes.fmCors
fmNoCors:
FetchModes.fmNoCors
fmRead:
FileMode.fmRead
fmReadWrite:
FileMode.fmReadWrite
fmReadWriteExisting:
FileMode.fmReadWriteExisting
fmSameOrigin:
FetchModes.fmSameOrigin
fmt:
strformat: fmt(pattern: static string; openChar: static char; closeChar: static char): string
strformat: fmt(pattern: static string): untyped
fmWrite:
FileMode.fmWrite
focus:
dom: focus(e: Element)
dom: focus(e: Node)
dom: focus(w: Window)
foldl:
sequtils: foldl(sequence, operation, first): untyped
sequtils: foldl(sequence, operation: untyped): untyped
foldr:
sequtils: foldr(sequence, operation: untyped): untyped
FontFaceSet:
dom: FontFaceSet
FontFaceSetReady:
dom: FontFaceSetReady
footer:
htmlgen: footer(e: varargs[untyped]): untyped
ForegroundColor:
terminal: ForegroundColor
foreignCmd:
distros: foreignCmd(cmd: string; requiresSudo = false)
foreignDep:
distros: foreignDep(foreignPackageName: string)
foreignDepInstallCmd:
distros: foreignDepInstallCmd(foreignPackageName: string): (string, bool)
foreignDeps:
distros: foreignDeps
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
formatDiffed:
colordiff: formatDiffed[T](oldSeq, newSeq: openArray[T]; conf: DiffFormatConf; eqCmp: proc ( a, b: T): bool = (proc (a, b: T): bool = a == b); strConv: proc (a: T): string = (proc (a: T): string = $a)): ColText
colordiff: formatDiffed[T](ops: seq[SeqEdit]; oldSeq, newSeq: seq[T]; conf: DiffFormatConf): tuple[ oldLine, newLine: ColText]
colordiff: formatDiffed(shifted: ShiftedDiff; oldSeq, newSeq: openArray[string]; conf: DiffFormatConf = diffFormatter()): ColText
colordiff: formatDiffed(text1, text2: string; conf: DiffFormatConf = diffFormatter()): ColText
diff: formatDiffed(shifted: ShiftedDiff; oldSeq, newSeq: seq[string]; sideBySide: bool; showLineNumbers: bool = false): 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
formatEvents:
text_layouter: formatEvents(lyt: Layout): LytEvent
formatFieldDefect:
system: formatFieldDefect(f, discVal: sink string): string
FormatFlag:
strtabs: FormatFlag
formatFloat:
strutils: formatFloat(f: float; format: FloatFormatMode = ffDefault; precision: range[-1 .. 32] = 16; decimalSep = '.'): string
formatInlineDiff:
colordiff: formatInlineDiff(src, target: seq[string]; diffed: seq[SeqEdit]; conf: DiffFormatConf): ColText
colordiff: formatInlineDiff(src, target: string; conf: DiffFormatConf): ColText
formatLineDiff:
colordiff: formatLineDiff(old, new: string; conf: DiffFormatConf): tuple[ oldLine, newLine: ColText]
formatMessageW:
winlean: formatMessageW(dwFlags: int32; lpSource: pointer; dwMessageId, dwLanguageId: int32; lpBuffer: pointer; nSize: int32; arguments: pointer): int32
formatNamedVars:
rstgen: formatNamedVars(frmt: string; varnames: openArray[string]; varvalues: openArray[string]): string
formatSize:
strutils: formatSize(bytes: int64; decimalSep = '.'; prefix = bpIEC; includeSpace = false): string
formatStr:
util: formatStr(howExpr, namegetter, idgetter): untyped
formatValue:
strformat: formatValue(result: var string; value: SomeFloat; specifier: string)
strformat: formatValue(result: var string; value: string; specifier: string)
strformat: formatValue[T: SomeInteger](result: var string; value: T; specifier: string)
times: formatValue(result: var string; value: DateTime; specifier: string)
times: formatValue(result: var string; value: Time; specifier: string)
formData:
jsfetch: formData(self: Response): Future[FormData]
FormData:
jsformdata: FormData
FormElement:
dom: FormElement
forward:
dom: forward(h: History)
dom: forward(w: Window)
forwardImpl:
bitops_utils: forwardImpl(impl, arg)
FourthButton:
MouseButtons.FourthButton
fpGroupExec:
FilePermission.fpGroupExec
fpGroupRead:
FilePermission.fpGroupRead
fpGroupWrite:
FilePermission.fpGroupWrite
fpOthersExec:
FilePermission.fpOthersExec
fpOthersRead:
FilePermission.fpOthersRead
fpOthersWrite:
FilePermission.fpOthersWrite
fpRadix:
fenv: fpRadix(): int
fpUserExec:
FilePermission.fpUserExec
fpUserRead:
FilePermission.fpUserRead
fpUserWrite:
FilePermission.fpUserWrite
Frame:
dom: Frame
free:
linenoise: free(s: cstring)
freeaddrinfo:
winlean: freeaddrinfo(ai: ptr AddrInfo)
freeEnvironmentStringsW:
winlean: freeEnvironmentStringsW(para1: WideCString): int32
freeShared:
system: freeShared[T](p: ptr T)
freeSid:
winlean: freeSid(pSid: PSID): PSID
frError:
FetchRedirects.frError
frexp:
math: frexp[T: float32 | float64](x: T): tuple[frac: T, exp: int]
math: frexp[T: float32 | float64](x: T; exponent: var int): T
frFollow:
FetchRedirects.frFollow
frManual:
FetchRedirects.frManual
fromBin:
strutils: fromBin[T: SomeInteger](s: string): T
fromHex:
strutils: fromHex[T: SomeInteger](s: string): T
fromJson:
jsonutils: fromJson[T](a: var T; b: JsonNode; opt = Joptions())
fromJsonHook:
jsonutils: fromJsonHook[K: string; V](t: var (Table[K, V] | OrderedTable[K, V]); jsonNode: JsonNode)
jsonutils: fromJsonHook[T](self: var Option[T]; jsonNode: JsonNode)
jsonutils: fromJsonHook[A](s: var SomeSet[A]; jsonNode: JsonNode)
jsonutils: fromJsonHook(a: var StringTableRef; b: JsonNode)
fromOct:
strutils: fromOct[T: SomeInteger](s: string): T
fromSockAddr:
net: fromSockAddr(sa: Sockaddr_storage | SockAddr | Sockaddr_in | Sockaddr_in6; sl: SockLen; address: var IpAddress; port: var Port)
fromUnix:
times: fromUnix(unix: int64): Time
fromUnixFloat:
times: fromUnixFloat(seconds: float): Time
fromWinTime:
times: fromWinTime(win: int64): Time
fround:
jscore: fround(m: MathLib; f: SomeFloat): float32
frpNoReferrer:
FetchReferrerPolicies.frpNoReferrer
frpNoReferrerWhenDowngrade:
FetchReferrerPolicies.frpNoReferrerWhenDowngrade
frpOrigin:
FetchReferrerPolicies.frpOrigin
frpOriginWhenCrossOrigin:
FetchReferrerPolicies.frpOriginWhenCrossOrigin
frpUnsafeUrl:
FetchReferrerPolicies.frpUnsafeUrl
fspCur:
FileSeekPos.fspCur
fspEnd:
FileSeekPos.fspEnd
fspSet:
FileSeekPos.fspSet
fsync:
posix_utils: fsync(fd: int)
fullSet:
setutils: fullSet[T](U: typedesc[T]): set[T]
Future:
asyncjs: Future
gamma:
math: gamma(x: float32): float32
math: gamma(x: float64): float64
gauss:
random: gauss(mu = 0.0; sigma = 1.0): float
random: gauss(r: var Rand; mu = 0.0; sigma = 1.0): float
gcd:
math: gcd[T](x: openArray[T]): T
math: gcd(x, y: SomeInteger): SomeInteger
math: gcd[T](x, y: T): T
GC_disableMarkAndSweep:
system: GC_disableMarkAndSweep()
GC_disableOrc:
system: GC_disableOrc()
GC_enableMarkAndSweep:
system: GC_enableMarkAndSweep()
GC_enableOrc:
system: GC_enableOrc()
GC_fullCollect:
system: GC_fullCollect()
GC_getStatistics:
system: GC_getStatistics(): string
GC_partialCollect:
system: GC_partialCollect(limit: int)
GC_prepareOrc:
system: GC_prepareOrc(): int
GC_ref:
system: GC_ref[T](x: ref T)
GC_runOrc:
system: GC_runOrc()
GC_unref:
system: GC_unref[T](x: ref T)
genAst:
genasts: genAst(args: varargs[untyped]): untyped
GenAstOpt:
genasts: GenAstOpt
genAstOpt:
genasts: genAstOpt(options: static set[GenAstOpt]; args: varargs[untyped]): untyped
genEnumCaseStmt:
enumutils: genEnumCaseStmt(typ: typedesc[enum]; arg: typed; default: typed; userMin, userMax: static[int]; normalizer: typed): untyped
GeneralTokenizer:
highlite: GeneralTokenizer
generatedTime:
oids: generatedTime(oid: Oid): Time
generic character types:
Generic character types
GENERIC_ALL:
winlean: GENERIC_ALL
genericHead:
typetraits: genericHead(t: typedesc): typedesc
genericParams:
typetraits: genericParams(T: typedesc): untyped
GENERIC_READ:
winlean: GENERIC_READ
GENERIC_WRITE:
winlean: GENERIC_WRITE
genOid:
oids: genOid(): Oid
genSym:
macros: genSym(kind: NimSymKind = nskLet; ident = ""): NimNode
genTempPath:
tempfiles: genTempPath(prefix, suffix: string; dir = ""): string
get:
httpclient: get(client: HttpClient; url: Uri | string): Response
nimscript: get(key: string): string
options: get[T](self: Option[T]): lent T
options: get[T](self: Option[T]; otherwise: T): T
options: get[T](self: var Option[T]): var T
results: get[T: not void; E](self: Result[T, E]): untyped
results: get[T, E](self: Result[T, E]; otherwise: T): untyped
results: get[T, E](self: var Result[T, E]): untyped
results: get[E](self: Result[void, E])
typetraits: get(T: typedesc[tuple]; i: static int): untyped
getAddrInfo:
nativesockets: getAddrInfo(address: string; port: Port; domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP): ptr AddrInfo
getaddrinfo:
winlean: getaddrinfo(nodename, servname: cstring; hints: ptr AddrInfo; res: var ptr AddrInfo): cint
getAddrString:
nativesockets: getAddrString(sockAddr: ptr SockAddr): string
nativesockets: getAddrString(sockAddr: ptr SockAddr; strAddress: var string)
getAlign:
macros: getAlign(arg: NimNode): int
getAll:
jsformdata: getAll(self: FormData; name: cstring): seq[cstring]
getAllocStats:
system: getAllocStats(): AllocStats
getAllRows:
db_mysql: getAllRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): seq[Row]
db_odbc: getAllRows(db: var DbConn; query: SqlQuery; args: varargs[string, `$`]): seq[Row]
db_postgres: getAllRows(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): seq[ Row]
db_postgres: getAllRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): seq[Row]
db_sqlite: getAllRows(db: DbConn; stmtName: SqlPrepared): seq[Row]
db_sqlite: getAllRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): seq[Row]
getAppDir:
os: getAppDir(): string
getAppFilename:
os: getAppFilename(): string
getAsFile:
dom: getAsFile(dti: DataTransferItem): File
getAst:
macros: getAst(macroOrTemplate: untyped): NimNode
getAttribute:
dom: getAttribute(n: Node; attr: cstring): cstring
getAttributeNode:
dom: getAttributeNode(n: Node; attr: cstring): Node
getBiggestFloat:
typeinfo: getBiggestFloat(x: Any): BiggestFloat
getBiggestInt:
json: getBiggestInt(n: JsonNode; default: BiggestInt = 0): BiggestInt
typeinfo: getBiggestInt(x: Any): BiggestInt
getBiggestUint:
typeinfo: getBiggestUint(x: Any): uint64
getBool:
json: getBool(n: JsonNode; default: bool = false): bool
typeinfo: getBool(x: Any): bool
getBoundingClientRect:
dom: getBoundingClientRect(e: Node): BoundingRect
getCacheDir:
os: getCacheDir(): string
os: getCacheDir(app: string): string
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_parse: getColumn(parser: SexpParser): int
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: HttpClient; url: Uri | string): string
getContentLength:
cgi: getContentLength(): string
getContentType:
cgi: getContentType(): string
getCookie:
cgi: getCookie(name: string): string
getCreationTime:
os: getCreationTime(file: string): times.Time
getCString:
typeinfo: getCString(x: Any): cstring
getCurrentCompilerExe:
os: getCurrentCompilerExe(): string
getCurrentDir:
nimscript: getCurrentDir(): string
os: getCurrentDir(): string
getCurrentDirectoryW:
winlean: getCurrentDirectoryW(nBufferLength: int32; lpBuffer: WideCString): int32
getCurrentEncoding:
encodings: getCurrentEncoding(uiApp = false): string
getCurrentException:
system: getCurrentException(): ref Exception
getCurrentExceptionMsg:
system: getCurrentExceptionMsg(): string
GetCurrentFiber:
winlean: GetCurrentFiber(): pointer
getCurrentLine:
lexbase: getCurrentLine(L: BaseLexer; marker: bool = true): string
getCurrentProcess:
winlean: getCurrentProcess(): Handle
getCurrentProcessId:
os: getCurrentProcessId(): int
getCustomPragmaVal:
macros: getCustomPragmaVal(n: typed; cp: typed{nkSym}): untyped
getData:
dom: getData(dt: DataTransfer; format: cstring): cstring
selectors: getData[T](s: Selector[T]; fd: SocketHandle | int): var T
getDataUri:
uri: getDataUri(data, mime: string; encoding = "utf-8"): string
getDateStr:
times: getDateStr(dt = now()): string
getDay:
jscore: getDay(d: DateTime): int
getDayOfWeek:
times: getDayOfWeek(monthday: MonthdayRange; month: Month; year: int): WeekDay
getDayOfYear:
times: getDayOfYear(monthday: MonthdayRange; month: Month; year: int): YeardayRange
getDaysInMonth:
times: getDaysInMonth(month: Month; year: int): int
getDaysInYear:
times: getDaysInYear(year: int): int
getDocumentRoot:
cgi: getDocumentRoot(): string
getEdge:
graph: getEdge[Id](graph: Graph[Id]; source, target: Id): GraphEdge[Id]
getElementById:
dom: getElementById(id: cstring): Element
dom: getElementById(d: Document; id: cstring): Element
getElementsByClass:
dom: getElementsByClass(n: Node; name: cstring): seq[Node]
getElementsByClassName:
dom: getElementsByClassName(d: Document; name: cstring): seq[Element]
dom: getElementsByClassName(e: Element; name: cstring): seq[Element]
getElementsByName:
dom: getElementsByName(d: Document; name: cstring): seq[Element]
getElementsByTagName:
dom: getElementsByTagName(d: Document; name: cstring): seq[Element]
dom: getElementsByTagName(e: Element; name: cstring): seq[Element]
getElems:
json: getElems(n: JsonNode; default: seq[JsonNode] = @[]): seq[JsonNode]
sexp: getElems(n: SexpNode; default: seq[SexpNode] = @[]): seq[SexpNode]
getEnumField:
typeinfo: getEnumField(x: Any): string
typeinfo: getEnumField(x: Any; ordinalValue: int): string
getEnumOrdinal:
typeinfo: getEnumOrdinal(x: Any; name: string): int
getEnv:
nimscript: getEnv(key: string; default = ""): string
os: getEnv(key: string; default = ""): string
getEnvironmentStringsW:
winlean: getEnvironmentStringsW(): WideCString
getExecArgs:
os: getExecArgs(): seq[string]
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:
net: getFd(socket: Socket): SocketHandle
selectors: getFd[T](s: Selector[T]): int
getField:
sexp: getField(node: SexpNode; name: string; default: SexpNode = nil): SexpNode
getFields:
json: getFields(n: JsonNode; default = initOrderedTable[string, JsonNode](2)): OrderedTable[ string, JsonNode]
getFileAttributesW:
winlean: getFileAttributesW(lpFileName: WideCString): int32
getFileHandle:
io: getFileHandle(f: File): FileHandle
getFileInfo:
os: getFileInfo(file: File): FileInfo
os: getFileInfo(handle: FileHandle): FileInfo
os: getFileInfo(path: string; followSymlink = true): FileInfo
getFileInformationByHandle:
winlean: getFileInformationByHandle(hFile: Handle; lpFileInformation: ptr BY_HANDLE_FILE_INFORMATION): WINBOOL
getFilename:
parsecfg: getFilename(c: CfgParser): string
parsejson: getFilename(my: JsonParser): string
parsexml: getFilename(my: XmlParser): string
getFilePermissions:
os: getFilePermissions(filename: string): set[FilePermission]
getFilePos:
io: getFilePos(f: File): int64
getFileSize:
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_parse: getFloat(parser: SexpParser): float
typeinfo: getFloat(x: Any): float
getFloat32:
typeinfo: getFloat32(x: Any): float32
getFloat64:
typeinfo: getFloat64(x: Any): float64
getFNum:
sexp: getFNum(n: SexpNode; default: float = 0.0): float
getFrame:
system: getFrame(): PFrame
getFrameState:
system: getFrameState(): FrameState
getFreeMem:
system: getFreeMem(): int
getFreeSharedMem:
system: getFreeSharedMem(): int
getFullPathNameW:
winlean: getFullPathNameW(lpFileName: WideCString; nBufferLength: int32; lpBuffer: WideCString; lpFilePart: var WideCString): int32
getFullYear:
jscore: getFullYear(d: DateTime): int
getGatewayInterface:
cgi: getGatewayInterface(): string
getGcFrame:
system: getGcFrame(): GcFrame
getHandleInformation:
winlean: getHandleInformation(hObject: Handle; lpdwFlags: ptr DWORD): WINBOOL
getHandlers:
logging: getHandlers(): seq[Logger]
getHomeDir:
os: getHomeDir(): string
getHostByAddr:
nativesockets: getHostByAddr(ip: string): Hostent
gethostbyaddr:
winlean: gethostbyaddr(ip: ptr InAddr; len: cuint; theType: cint): ptr Hostent
getHostByName:
nativesockets: getHostByName(name: string): Hostent
gethostbyname:
winlean: gethostbyname(name: cstring): ptr Hostent
getHostname:
nativesockets: getHostname(): string
gethostname:
winlean: gethostname(hostname: cstring; len: cint): cint
getHours:
jscore: getHours(d: DateTime): int
getHttpAccept:
cgi: getHttpAccept(): string
getHttpAcceptCharset:
cgi: getHttpAcceptCharset(): string
getHttpAcceptEncoding:
cgi: getHttpAcceptEncoding(): string
getHttpAcceptLanguage:
cgi: getHttpAcceptLanguage(): string
getHttpConnection:
cgi: getHttpConnection(): string
getHttpCookie:
cgi: getHttpCookie(): string
getHttpHost:
cgi: getHttpHost(): string
getHttpReferer:
cgi: getHttpReferer(): string
getHttpUserAgent:
cgi: getHttpUserAgent(): string
getImpl:
macros: getImpl(symbol: NimNode): NimNode
getImplTransformed:
macros: getImplTransformed(symbol: NimNode): NimNode
getInt:
json: getInt(n: JsonNode; default: int = 0): int
parsejson: getInt(my: JsonParser): BiggestInt
sexp_parse: getInt(parser: 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
getItem:
dom: getItem(s: Storage; key: cstring): cstring
getKey:
sexp: getKey(n: SexpNode; default: string = ""): string
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_parse: getLine(parser: SexpParser): int
getLocalAddr:
nativesockets: getLocalAddr(socket: SocketHandle; domain: Domain): (string, Port)
net: getLocalAddr(socket: Socket): (string, Port)
getLogFilter:
logging: getLogFilter(): Level
getMask:
dod_helpers: getMask(id`gensym14: ValueId): ValueIdMask
text_layouter: getMask(id`gensym3: LytStrId): LytStrIdMask
getMaxMem:
system: getMaxMem(): int
getMD5:
md5: getMD5(s: string): string
getMilliseconds:
jscore: getMilliseconds(d: DateTime): int
getMimetype:
mimetypes: getMimetype(mimedb: MimeDB; ext: string; default = "text/plain"): string
getMinutes:
jscore: getMinutes(d: DateTime): int
getModifierState:
dom: getModifierState(ev: KeyboardEvent; keyArg: cstring): bool
dom: getModifierState(ev: MouseEvent; keyArg: cstring): bool
getModuleFileNameW:
winlean: getModuleFileNameW(handle: Handle; buf: WideCString; size: int32): int32
getMonoTime:
monotimes: getMonoTime(): MonoTime
getMonth:
jscore: getMonth(d: DateTime): int
getnameinfo:
winlean: getnameinfo(a1: ptr SockAddr; a2: SockLen; a3: cstring; a4: SockLen; a5: cstring; a6: SockLen; a7: cint): cint
getNextToken:
highlite: getNextToken(g: var GeneralTokenizer; lang: SourceLanguage)
getNoIncoming:
graph: getNoIncoming[Id](graph: Graph[Id]): seq[Id]
getNum:
mersenne: getNum(m: var MersenneTwister): uint32
sexp: getNum(n: SexpNode; default: BiggestInt = 0): BiggestInt
getOccupiedMem:
system: getOccupiedMem(): int
getOccupiedSharedMem:
system: getOccupiedSharedMem(): int
getOffset:
macros: getOffset(arg: NimNode): int
getopt:
parseopt: getopt(p: var OptParser): tuple[kind: CmdLineKind, key, val: string]
parseopt: getopt(cmdline: seq[string]; shortNoVal: set[char] = {}; longNoVal: seq[string] = @[]): tuple[kind: CmdLineKind, key, val: string]
getOrDefault:
httpcore: getOrDefault(headers: HttpHeaders; key: string; default = @[""].HttpHeaderValues): HttpHeaderValues
json: getOrDefault(node: JsonNode; key: string): JsonNode
strtabs: getOrDefault(t: StringTableRef; key: string; default: string = ""): string
tables: getOrDefault[A](t: CountTable[A]; key: A; default: int = 0): int
tables: getOrDefault[A](t: CountTableRef[A]; key: A; default: int): int
tables: getOrDefault[A, B](t: OrderedTable[A, B]; key: A): B
tables: getOrDefault[A, B](t: OrderedTable[A, B]; key: A; default: B): B
tables: getOrDefault[A, B](t: OrderedTableRef[A, B]; key: A): B
tables: getOrDefault[A, B](t: OrderedTableRef[A, B]; key: A; default: B): B
tables: getOrDefault[A, B](t: Table[A, B]; key: A): B
tables: getOrDefault[A, B](t: Table[A, B]; key: A; default: B): B
tables: getOrDefault[A, B](t: TableRef[A, B]; key: A): B
tables: getOrDefault[A, B](t: TableRef[A, B]; key: A; default: B): B
get_osfhandle:
winlean: get_osfhandle(fd: FileHandle): Handle
getOsFileHandle:
io: getOsFileHandle(f: File): FileHandle
getOverlappedResult:
winlean: getOverlappedResult(hFile: Handle; lpOverlapped: POVERLAPPED; lpNumberOfBytesTransferred: var DWORD; bWait: WINBOOL): WINBOOL
getPathInfo:
cgi: getPathInfo(): string
getPathTranslated:
cgi: getPathTranslated(): string
getPeerAddr:
nativesockets: getPeerAddr(socket: SocketHandle; domain: Domain): (string, Port)
net: getPeerAddr(socket: Socket): (string, Port)
getPeerCertificates:
net: getPeerCertificates(socket: Socket): seq[Certificate]
net: getPeerCertificates(sslHandle: SslPtr): seq[Certificate]
getpeername:
Module nativesockets
Module net
winlean: getpeername(s: SocketHandle; name: ptr SockAddr; namelen: ptr SockLen): cint
getPFrame:
stackframes: getPFrame(): PFrame
getPointer:
typeinfo: getPointer(x: Any): pointer
getPosition:
streams: getPosition(s: Stream): int
getPrimaryIPAddr:
net: getPrimaryIPAddr(dest = parseIpAddress("8.8.8.8")): IpAddress
getProcessTimes:
winlean: getProcessTimes(hProcess: Handle; lpCreationTime, lpExitTime, lpKernelTime, lpUserTime: var FILETIME): WINBOOL
getProgramResult:
exitprocs: getProgramResult(): int
getProjectPath:
macros: getProjectPath(): string
getPropertyPriority:
dom: getPropertyPriority(s: Style; property: cstring): cstring
getPropertyValue:
dom: getPropertyValue(s: Style; property: cstring): cstring
getProtoByName:
nativesockets: getProtoByName(name: string): int
getprotobyname:
winlean: getprotobyname(name: cstring): ptr Protoent
getprotobynumber:
winlean: getprotobynumber(proto: cint): ptr Protoent
getProtoName:
jsutils: getProtoName[T](a: T): cstring
getPskIdentity:
net: getPskIdentity(socket: Socket): string
getQueryString:
cgi: getQueryString(): string
getQueuedCompletionStatus:
winlean: getQueuedCompletionStatus(CompletionPort: Handle; lpNumberOfBytesTransferred: PDWORD; lpCompletionKey: PULONG_PTR; lpOverlapped: ptr POVERLAPPED; dwMilliseconds: DWORD): WINBOOL
getRaisesList:
effecttraits: getRaisesList(fn: NimNode): NimNode
getRangeAt:
dom: getRangeAt(s: Selection; index: int): Range
getRawData:
rtarrays: getRawData[T](x: var RtArray[T]): ptr UncheckedArray[T]
getRemoteAddr:
cgi: getRemoteAddr(): string
getRemoteHost:
cgi: getRemoteHost(): string
getRemoteIdent:
cgi: getRemoteIdent(): string
getRemotePort:
cgi: getRemotePort(): string
getRemoteUser:
cgi: getRemoteUser(): string
getRequestMethod:
cgi: getRequestMethod(): string
getRequestURI:
cgi: getRequestURI(): string
getRootNode:
dom: getRootNode(n: Node; options: RootNodeOptions): Node
getRow:
db_mysql: getRow(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
db_odbc: getRow(db: var DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
db_postgres: getRow(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): Row
db_postgres: getRow(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
db_sqlite: getRow(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
getScriptFilename:
cgi: getScriptFilename(): string
getScriptName:
cgi: getScriptName(): string
getSeconds:
jscore: getSeconds(d: DateTime): int
getSectionValue:
parsecfg: getSectionValue(dict: Config; section, key: string; defaultVal = ""): string
getSelection:
dom: getSelection(d: Document): Selection
dom: getSelection(n: DocumentOrShadowRoot): Selection
getServByName:
nativesockets: getServByName(name, proto: string): Servent
getservbyname:
winlean: getservbyname(name, proto: cstring): ptr Servent
getServByPort:
nativesockets: getServByPort(port: Port; proto: string): Servent
getservbyport:
winlean: getservbyport(port: cint; proto: cstring): ptr Servent
getServerAddr:
cgi: getServerAddr(): string
getServerAdmin:
cgi: getServerAdmin(): string
getServerName:
cgi: getServerName(): string
getServerPort:
cgi: getServerPort(): string
getServerProtocol:
cgi: getServerProtocol(): string
getServerSignature:
cgi: getServerSignature(): string
getServerSoftware:
cgi: getServerSoftware(): string
getSize:
macros: getSize(arg: NimNode): int
getSockDomain:
nativesockets: getSockDomain(socket: SocketHandle): Domain
getSocket:
httpclient: getSocket(client: HttpClient): Socket
getSocketError:
net: getSocketError(socket: Socket): OSErrorCode
getSockName:
nativesockets: getSockName(socket: SocketHandle): Port
getsockname:
Module nativesockets
Module net
winlean: getsockname(s: SocketHandle; name: ptr SockAddr; namelen: ptr SockLen): cint
getSockOpt:
net: getSockOpt(socket: Socket; opt: SOBool; level = SOL_SOCKET): bool
getsockopt:
winlean: getsockopt(s: SocketHandle; level, optname: cint; optval: pointer; optlen: ptr SockLen): cint
getSockOptInt:
nativesockets: getSockOptInt(socket: SocketHandle; level, optname: int): int
getSourceLanguage:
highlite: getSourceLanguage(name: string): SourceLanguage
getStackTrace:
system: getStackTrace(): string
system: getStackTrace(e: ref Exception): string
getStackTraceEntries:
system: getStackTraceEntries(): seq[StackTraceEntry]
system: getStackTraceEntries(e: ref Exception): lent seq[StackTraceEntry]
getStdHandle:
winlean: getStdHandle(nStdHandle: int32): Handle
getStr:
json: getStr(n: JsonNode; default: string = ""): string
sexp: getStr(n: SexpNode; default: string = ""): string
getString:
typeinfo: getString(x: Any): string
getSymbol:
sexp: getSymbol(n: SexpNode; default: string = ""): string
getSystemInfo:
win_getsysteminfo: getSystemInfo(lpSystemInfo: ptr SystemInfo)
getSystemTimeAsFileTime:
winlean: getSystemTimeAsFileTime(lpSystemTimeAsFileTime: var FILETIME)
getSystemTimePreciseAsFileTime:
winlean: getSystemTimePreciseAsFileTime(lpSystemTimeAsFileTime: var FILETIME)
getSystemTimes:
winlean: getSystemTimes(lpIdleTime, lpKernelTime, lpUserTime: var FILETIME): WINBOOL
getTagsList:
effecttraits: getTagsList(fn: NimNode): NimNode
getTempDir:
os: getTempDir(): string
getThreadId:
system: getThreadId(): int
getTime:
jscore: getTime(d: DateTime): int
times: getTime(): Time
getTimezoneOffset:
jscore: getTimezoneOffset(d: DateTime): int
getTok:
parsejson: getTok(my: var JsonParser): TokKind
sexp_parse: getTok(parser: var SexpParser): TTokKind
getTotalMem:
system: getTotalMem(): int
getTotalSharedMem:
system: getTotalSharedMem(): int
getType:
macros: getType(n: NimNode): NimNode
macros: getType(n: typedesc): NimNode
getTypeImpl:
macros: getTypeImpl(n: NimNode): NimNode
macros: getTypeImpl(n: typedesc): NimNode
getTypeInfo:
system: getTypeInfo[T](x: T): pointer
getTypeInst:
macros: getTypeInst(n: NimNode): NimNode
macros: getTypeInst(n: typedesc): NimNode
getUInt:
typeinfo: getUInt(x: Any): uint
getUInt16:
typeinfo: getUInt16(x: Any): uint16
getUInt32:
typeinfo: getUInt32(x: Any): uint32
getUInt64:
typeinfo: getUInt64(x: Any): uint64
getUInt8:
typeinfo: getUInt8(x: Any): uint8
getUnicodeValue:
registry: getUnicodeValue(path, key: string; handle: HKEY): string
getUTCDate:
jscore: getUTCDate(d: DateTime): int
getUTCDay:
jscore: getUTCDay(d: DateTime): int
getUTCFullYear:
jscore: getUTCFullYear(d: DateTime): int
getUTCHours:
jscore: getUTCHours(d: DateTime): int
getUTCMilliseconds:
jscore: getUTCMilliseconds(d: DateTime): int
getUTCMinutes:
jscore: getUTCMinutes(d: DateTime): int
getUTCMonth:
jscore: getUTCMonth(d: DateTime): int
getUTCSeconds:
jscore: getUTCSeconds(d: DateTime): int
getValue:
db_mysql: getValue(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): string
db_odbc: getValue(db: var DbConn; query: SqlQuery; args: varargs[string, `$`]): string
db_postgres: getValue(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): string
db_postgres: getValue(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): string
db_sqlite: getValue(db: DbConn; stmtName: SqlPrepared): string
db_sqlite: getValue(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): string
getVersion:
winlean: getVersion(): DWORD
getVersionExA:
winlean: getVersionExA(lpVersionInfo: ptr OSVERSIONINFO): WINBOOL
getVersionExW:
winlean: getVersionExW(lpVersionInfo: ptr OSVERSIONINFO): WINBOOL
getYear:
jscore: getYear(d: DateTime): int
glob:
Module os
Module os
Module os
globalRaiseHook:
system: globalRaiseHook
go:
dom: go(h: History; pagesToJump: int)
gorge:
system: gorge(command: string; input = ""; cache = ""): string
gorgeEx:
system: gorgeEx(command: string; input = ""; cache = ""): tuple[output: string, exitCode: int]
Graph:
graph: Graph
GraphCyclesError:
graph: GraphCyclesError
graphEasyRepr:
graph: graphEasyRepr[Id](graph: Graph[Id]; name: proc (id: Id): string): string
GraphEdge:
graph: GraphEdge
graphemeLen:
unicode: graphemeLen(s: string; i: Natural): Natural
GraphError:
graph: GraphError
grid:
colortext: grid(text: ColText): ColRuneGrid
group:
jsconsole: group(console: Console; label = "".cstring)
groupCollapsed:
jsconsole: groupCollapsed(console: Console; label = "".cstring)
groupEnd:
jsconsole: groupEnd(console: Console)
grow:
system: grow[T](x: var seq[T]; newLen: Natural; value: T)
gtAssembler:
TokenClass.gtAssembler
gtBinNumber:
TokenClass.gtBinNumber
gtCharLit:
TokenClass.gtCharLit
gtCommand:
TokenClass.gtCommand
gtComment:
TokenClass.gtComment
gtDecNumber:
TokenClass.gtDecNumber
gtDirective:
TokenClass.gtDirective
gtEof:
TokenClass.gtEof
gtEscapeSequence:
TokenClass.gtEscapeSequence
gtFloatNumber:
TokenClass.gtFloatNumber
gtHexNumber:
TokenClass.gtHexNumber
gtHyperlink:
TokenClass.gtHyperlink
gtIdentifier:
TokenClass.gtIdentifier
gtKey:
TokenClass.gtKey
gtKeyword:
TokenClass.gtKeyword
gtLabel:
TokenClass.gtLabel
gtLongComment:
TokenClass.gtLongComment
gtLongStringLit:
TokenClass.gtLongStringLit
gtNone:
TokenClass.gtNone
gtOctNumber:
TokenClass.gtOctNumber
gtOperator:
TokenClass.gtOperator
gtOption:
TokenClass.gtOption
gtOther:
TokenClass.gtOther
gtPreprocessor:
TokenClass.gtPreprocessor
gtProgram:
TokenClass.gtProgram
gtProgramOutput:
TokenClass.gtProgramOutput
gtPrompt:
TokenClass.gtPrompt
gtPunctuation:
TokenClass.gtPunctuation
gtRawData:
TokenClass.gtRawData
gtReference:
TokenClass.gtReference
gtRegularExpression:
TokenClass.gtRegularExpression
gtRule:
TokenClass.gtRule
gtStringLit:
TokenClass.gtStringLit
gtTagEnd:
TokenClass.gtTagEnd
gtTagStart:
TokenClass.gtTagStart
gtValue:
TokenClass.gtValue
gtWhitespace:
TokenClass.gtWhitespace
GUID:
winlean: GUID
h1:
htmlgen: h1(e: varargs[untyped]): untyped
h2:
htmlgen: h2(e: varargs[untyped]): untyped
h3:
htmlgen: h3(e: varargs[untyped]): untyped
h4:
htmlgen: h4(e: varargs[untyped]): untyped
h5:
htmlgen: h5(e: varargs[untyped]): untyped
h6:
htmlgen: h6(e: varargs[untyped]): untyped
Hamming weight:
Module bitops
handle:
system: handle[TArg](t: Thread[TArg]): SysThread
Handle:
winlean: Handle
handleCR:
lexbase: handleCR(L: var BaseLexer; pos: int): int
handleEvent:
dom: handleEvent(d: Document; event: Event)
dom: handleEvent(e: Element; event: Event)
dom: handleEvent(w: Window; e: Event)
HANDLE_FLAG_INHERIT:
winlean: HANDLE_FLAG_INHERIT
handleHexChar:
decode_helpers: handleHexChar(c: char): int
decode_helpers: handleHexChar(c: char; x: var int): bool
handleLF:
lexbase: handleLF(L: var BaseLexer; pos: int): int
handleRefillChar:
lexbase: handleRefillChar(L: var BaseLexer; pos: int): int
handshakeAsClient:
SslHandshakeType.handshakeAsClient
handshakeAsServer:
SslHandshakeType.handshakeAsServer
hasArgOfName:
macros: hasArgOfName(params: NimNode; name: string): bool
hasAttribute:
dom: hasAttribute(n: Node; attr: cstring): bool
hasBigUint64Array:
jsutils: hasBigUint64Array(): bool
hasChildNodes:
dom: hasChildNodes(n: Node): bool
hasClosure:
typetraits: hasClosure(fn: NimNode): bool
hasCustomPragma:
macros: hasCustomPragma(n: typed; cp: typed{nkSym}): untyped
hasData:
osproc: hasData(p: Process): bool
hasDataBuffered:
net: hasDataBuffered(s: Socket): bool
Hash:
hashes: Hash
hash:
hashes: hash(x: cstring): Hash
hashes: hash(x: float): Hash
hashes: hash[A](x: openArray[A]): Hash
hashes: hash[A](aBuf: openArray[A]; sPos, ePos: int): Hash
hashes: hash(x: pointer): Hash
hashes: hash[T](x: ptr [T]): Hash
hashes: hash[T](x: ref [T]): Hash
hashes: hash[A](x: set[A]): Hash
hashes: hash(x: string): Hash
hashes: hash(sBuf: string; sPos, ePos: int): Hash
hashes: hash[T: Ordinal | enum](x: T): Hash
hashes: hash[T: tuple | object | proc](x: T): Hash
json: hash(n: JsonNode): Hash
json: hash(n: OrderedTable[string, JsonNode]): Hash
oids: hash(oid: Oid): Hash
rationals: hash[T](x: Rational[T]): Hash
sets: hash[A](s: HashSet[A]): Hash
sets: hash[A](s: OrderedSet[A]): Hash
sexp: hash(n: SexpNode): Hash
hash set:
Module sets
hash table:
Module tables
hashData:
hashes: hashData(data: pointer; size: int): Hash
hashIdentity:
hashes: hashIdentity[T: Ordinal | enum](x: T): Hash
hashIgnoreCase:
hashes: hashIgnoreCase(x: string): Hash
hashes: hashIgnoreCase(sBuf: string; sPos, ePos: int): Hash
hashIgnoreStyle:
hashes: hashIgnoreStyle(x: string): Hash
hashes: hashIgnoreStyle(sBuf: string; sPos, ePos: int): Hash
HashSet:
sets: HashSet
hashWangYi1:
hashes: hashWangYi1(x: int64 | uint64 | Hash): Hash
hasInvisible:
colordiff: hasInvisible(text: seq[string]): bool
colordiff: hasInvisible(text: string; startSet: set[char] = Invis + {' '}): bool
hasItem:
dom: hasItem(s: Storage; key: cstring): bool
hasJsBigInt:
jsutils: hasJsBigInt(): bool
hasKey:
critbits: hasKey[T](c: CritBitTree[T]; key: string): bool
httpcore: hasKey(headers: HttpHeaders; key: string): bool
jsformdata: hasKey(self: FormData; name: cstring): bool
jsheaders: hasKey(self: Headers; key: cstring): bool
json: hasKey(node: JsonNode; key: string): bool
strtabs: hasKey(t: StringTableRef; key: string): bool
tables: hasKey[A](t: CountTable[A]; key: A): bool
tables: hasKey[A](t: CountTableRef[A]; key: A): bool
tables: hasKey[A, B](t: OrderedTable[A, B]; key: A): bool
tables: hasKey[A, B](t: OrderedTableRef[A, B]; key: A): bool
tables: hasKey[A, B](t: Table[A, B]; key: A): bool
tables: hasKey[A, B](t: TableRef[A, B]; key: A): bool
hasKeyOrPut:
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
hasNewline:
colortext: hasNewline(text: ColText): bool
hasNext:
pathnorm: hasNext(it: PathIter; x: string): bool
hasNoSideEffects:
effecttraits: hasNoSideEffects(fn: NimNode): bool
hasNxt:
strscans: hasNxt(input: string; idx: int): bool
hasOnlyTailNewline:
colortext: hasOnlyTailNewline(text: ColText): bool
hasOverlappedIoCompleted:
winlean: hasOverlappedIoCompleted(lpOverlapped): bool
hasOwnProperty:
jsffi: hasOwnProperty(x: JsObject; prop: cstring): bool
HDC:
winlean: HDC
head:
htmlgen: head(e: varargs[untyped]): untyped
httpclient: head(client: HttpClient; url: Uri | string): Response
header:
htmlgen: header(e: varargs[untyped]): untyped
headerLimit:
httpcore: headerLimit
Headers:
jsheaders: Headers
HeapQueue:
heapqueue: HeapQueue
helo:
smtp: helo(smtp: Smtp)
hexbyte:
oids: hexbyte(hex: char): int
HexDigits:
strutils: HexDigits
HGLRC:
winlean: HGLRC
hideCursor:
terminal: hideCursor(f: File)
terminal: hideCursor()
high:
jsbigints: high(_: typedesc[JsBigInt]): JsBigInt
monotimes: high(typ: typedesc[MonoTime]): MonoTime
system: high[I, T](x: array[I, T]): I
system: high(x: cstring): int
system: high[T](x: openArray[T]): int
system: high(x: string): int
system: high[T: Ordinal | enum | range](x: T): T
system: high[I, T](x: typedesc[array[I, T]]): I
system: high(T: typedesc[SomeFloat]): T:type
system: high[T: Ordinal | enum | range](x: typedesc[T]): T
times: high(typ: typedesc[Duration]): Duration
times: high(typ: typedesc[Time]): Time
HIGH_PRIORITY_CLASS:
winlean: HIGH_PRIORITY_CLASS
hint:
macros: hint(msg: string; n: NimNode = nil)
History:
dom: History
historyAdd:
linenoise: historyAdd(line: cstring): cint
historyLoad:
linenoise: historyLoad(filename: cstring): cint
historySave:
linenoise: historySave(filename: cstring): cint
historySetMaxLen:
linenoise: historySetMaxLen(len: cint): cint
HKEY:
registry: HKEY
HKEY_CURRENT_USER:
registry: HKEY_CURRENT_USER
HKEY_LOCAL_MACHINE:
registry: HKEY_LOCAL_MACHINE
HoleyEnum:
typetraits: HoleyEnum
home:
dom: home(w: Window)
hostCPU:
system: hostCPU
Hostent:
nativesockets: Hostent
winlean: Hostent
hostOS:
system: hostOS
hour:
times: hour(dt: DateTime): HourRange
HourRange:
times: HourRange
Hours:
TimeUnit.Hours
hours:
times: hours(h: int): TimeInterval
hr:
htmlgen: hr(): untyped
HSlice:
system: HSlice
html:
htmlgen: html(e: varargs[untyped]): untyped
HTML:
Module htmlgen
Module parsexml
HTMLSlotElement:
dom: HTMLSlotElement
HtmlTag:
htmlparser: HtmlTag
htmlTag:
htmlparser: htmlTag(s: string): HtmlTag
htmlparser: htmlTag(n: XmlNode): HtmlTag
htonl:
nativesockets: htonl(x: uint32): untyped
htons:
nativesockets: htons(x: uint16): untyped
Http100:
httpcore: Http100
Http101:
httpcore: Http101
Http102:
httpcore: Http102
Http103:
httpcore: Http103
Http200:
httpcore: Http200
Http201:
httpcore: Http201
Http202:
httpcore: Http202
Http203:
httpcore: Http203
Http204:
httpcore: Http204
Http205:
httpcore: Http205
Http206:
httpcore: Http206
Http207:
httpcore: Http207
Http208:
httpcore: Http208
Http226:
httpcore: Http226
Http300:
httpcore: Http300
Http301:
httpcore: Http301
Http302:
httpcore: Http302
Http303:
httpcore: Http303
Http304:
httpcore: Http304
Http305:
httpcore: Http305
Http307:
httpcore: Http307
Http308:
httpcore: Http308
Http400:
httpcore: Http400
Http401:
httpcore: Http401
Http402:
httpcore: Http402
Http403:
httpcore: Http403
Http404:
httpcore: Http404
Http405:
httpcore: Http405
Http406:
httpcore: Http406
Http407:
httpcore: Http407
Http408:
httpcore: Http408
Http409:
httpcore: Http409
Http410:
httpcore: Http410
Http411:
httpcore: Http411
Http412:
httpcore: Http412
Http413:
httpcore: Http413
Http414:
httpcore: Http414
Http415:
httpcore: Http415
Http416:
httpcore: Http416
Http417:
httpcore: Http417
Http418:
httpcore: Http418
Http421:
httpcore: Http421
Http422:
httpcore: Http422
Http423:
httpcore: Http423
Http424:
httpcore: Http424
Http425:
httpcore: Http425
Http426:
httpcore: Http426
Http428:
httpcore: Http428
Http429:
httpcore: Http429
Http431:
httpcore: Http431
Http451:
httpcore: Http451
Http500:
httpcore: Http500
Http501:
httpcore: Http501
Http502:
httpcore: Http502
Http503:
httpcore: Http503
Http504:
httpcore: Http504
Http505:
httpcore: Http505
Http506:
httpcore: Http506
Http507:
httpcore: Http507
Http508:
httpcore: Http508
Http510:
httpcore: Http510
Http511:
httpcore: Http511
HttpClient:
httpclient: HttpClient
HttpClientBase:
httpclient: HttpClientBase
HttpCode:
httpcore: HttpCode
HttpConnect:
HttpMethod.HttpConnect
HttpDelete:
HttpMethod.HttpDelete
HttpGet:
HttpMethod.HttpGet
HttpHead:
HttpMethod.HttpHead
HttpHeaders:
httpcore: HttpHeaders
HttpHeaderValues:
httpcore: HttpHeaderValues
HttpMethod:
httpcore: HttpMethod
httpNewLine:
httpcore: httpNewLine
HttpOptions:
HttpMethod.HttpOptions
HttpPatch:
HttpMethod.HttpPatch
HttpPost:
HttpMethod.HttpPost
HttpPut:
HttpMethod.HttpPut
HttpRequestError:
httpclient: HttpRequestError
HttpTrace:
HttpMethod.HttpTrace
HttpVer10:
HttpVersion.HttpVer10
HttpVer11:
HttpVersion.HttpVer11
HttpVersion:
httpcore: HttpVersion
hypot:
jscore: hypot(m: MathLib; args: varargs[distinct SomeNumber]): float
math: hypot(x, y: float32): float32
math: hypot(x, y: float64): float64
i:
htmlgen: i(e: varargs[untyped]): untyped
iconv:
Module encodings
id:
dom: id(n: Node): cstring
id=:
dom: id=(n: Node; x: cstring)
ident:
macros: ident(name: string): NimNode
pegs: ident(): Peg
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
IdxCostMap:
sexp_diff: IdxCostMap
iframe:
htmlgen: iframe(e: varargs[untyped]): untyped
ignoreMsg:
parsecfg: ignoreMsg(c: CfgParser; e: CfgEvent): string
ikDollar:
InterpolatedKind.ikDollar
ikExpr:
InterpolatedKind.ikExpr
ikStr:
InterpolatedKind.ikStr
ikVar:
InterpolatedKind.ikVar
im:
complex: im(arg: float32): Complex32
complex: im(arg: float64): Complex64
complex: im(arg: typedesc[float32]): Complex32
complex: im(arg: typedesc[float64]): Complex64
ImageElement:
dom: ImageElement
img:
htmlgen: img(e: varargs[untyped]): untyped
imul:
jscore: imul(m: MathLib; a, b: int32): int32
in-place:
Module sugar
In6_addr:
winlean: In6_addr
IN_ACCESS:
inotify: IN_ACCESS
InAddr:
winlean: InAddr
INADDR_ANY:
winlean: INADDR_ANY
INADDR_BROADCAST:
winlean: INADDR_BROADCAST
INADDR_LOOPBACK:
winlean: INADDR_LOOPBACK
INADDR_NONE:
winlean: INADDR_NONE
IN_ALL_EVENTS:
inotify: IN_ALL_EVENTS
IN_ATTRIB:
inotify: IN_ATTRIB
inc:
critbits: inc(c: var CritBitTree[int]; key: string; val: int = 1)
jsbigints: inc(this: var JsBigInt)
jsbigints: inc(this: var JsBigInt; amount: JsBigInt)
macrocache: inc(c: CacheCounter; by = 1)
system: inc[T: Ordinal](x: var T; y = 1)
tables: inc[A](t: var CountTable[A]; key: A; val = 1)
tables: inc[A](t: CountTableRef[A]; key: A; val = 1)
incl:
critbits: incl[T](c: var CritBitTree[T]; key: string; val: T)
critbits: incl(c: var CritBitTree[void]; key: string)
macrocache: incl(s: CacheSeq; value: NimNode)
packedsets: incl[A](s: var PackedSet[A]; key: A)
packedsets: incl[A](s: var PackedSet[A]; other: PackedSet[A])
sets: incl[A](s: var HashSet[A]; key: A)
sets: incl[A](s: var HashSet[A]; other: HashSet[A])
sets: incl[A](s: var HashSet[A]; other: OrderedSet[A])
sets: incl[A](s: var OrderedSet[A]; key: A)
system: incl[T](x: var set[T]; y: T)
system: incl[T](x: var set[T]; y: set[T])
inclFilePermissions:
os: inclFilePermissions(filename: string; permissions: set[FilePermission])
IN_CLOSE:
inotify: IN_CLOSE
IN_CLOSE_NOWRITE:
inotify: IN_CLOSE_NOWRITE
IN_CLOSE_WRITE:
inotify: IN_CLOSE_WRITE
inclSetElement:
typeinfo: inclSetElement(x: Any; elem: int)
IN_CREATE:
inotify: IN_CREATE
inDays:
times: inDays(dur: Duration): int64
inDeg:
graph: inDeg[Id](graph: Graph[Id]; node: Id): int
IN_DELETE:
inotify: IN_DELETE
IN_DELETE_SELF:
inotify: IN_DELETE_SELF
indent:
colortext: indent(str: ColText; count: int; indentAfter: int = -1; indent: ColText = clt(" "); prefix: ColText = clt("")): ColText
strutils: indent(s: string; count: Natural; padding: string = " "): string
indentation:
strutils: indentation(s: string): Natural
index:
pegs: index(p: Peg): range[-MaxSubpatterns .. MaxSubpatterns - 1]
indexBy:
tables: indexBy[A, B, C](collection: A; index: proc (x: B): C): Table[C, B]
IndexDefect:
system: IndexDefect
IndexError:
system: IndexError
IndexExt:
rstgen: IndexExt
IN_DONT_FOLLOW:
inotify: IN_DONT_FOLLOW
inEdges:
graph: inEdges[Id](graph: Graph[Id]; target: Id): GraphEdge[Id]
inet_addr:
winlean: inet_addr(cp: cstring): uint32
inet_ntoa:
winlean: inet_ntoa(i: InAddr): cstring
inet_ntop:
winlean: inet_ntop(family: cint; paddr: pointer; pStringBuffer: cstring; stringBufSize: int32): cstring
IN_EXCL_UNLINK:
inotify: IN_EXCL_UNLINK
Inf:
system: Inf
INFINITE:
winlean: INFINITE
infix:
macros: infix(a: NimNode; op: string; b: NimNode): NimNode
info:
jsconsole: info(console: Console)
logging: info(args: varargs[string, `$`])
inHours:
times: inHours(dur: Duration): int64
IN_IGNORED:
inotify: IN_IGNORED
IN_ISDIR:
inotify: IN_ISDIR
init:
reservedmem: init(T: type ReservedMem; maxLen: Natural; initLen: Natural = 0; initCommitLen = initLen; memStart = pointer(nil); accessFlags = memReadWrite; maxCommittedAndUnusedPages = 3): ReservedMem
reservedmem: init(SeqType: type ReservedMemSeq; maxLen: Natural; initLen: Natural = 0; initCommitLen: Natural = 0; memStart = pointer(nil); accessFlags = memReadWrite; maxCommittedAndUnusedPages = 3): SeqType:type
sets: init[A](s: var HashSet[A]; initialSize = defaultInitialSize)
sets: init[A](s: var OrderedSet[A]; initialSize = defaultInitialSize)
sharedlist: init[A](t: var SharedList[A])
initAlignedGrid:
text_layouter: initAlignedGrid(blocks: seq[seq[LytBlock]]; aligns: openArray[LytAlignDirection]): LytBlock
text_layouter: initAlignedGrid(blocks: seq[seq[LytBlock]]; aligns: openArray[ tuple[leftPad, rightPad: int, direction: LytAlignDirection]]): LytBlock
initBlock:
text_layouter: initBlock(kind: LytBlockKind; breakMult: int = 1): LytBlock
initBlockFormatDSL:
text_layouter: initBlockFormatDSL()
initChoiceBlock:
text_layouter: initChoiceBlock(elems: openArray[LytBlock]; breakMult: int = 1): LytBlock
initColStyle:
colortext: initColStyle(fg: ForegroundColor = fgDefault; bg: BackgroundColor = bgDefault; style: set[Style] = {}): ColStyle
initCond:
locks: initCond(cond: var Cond)
initCountTable:
tables: initCountTable[A](initialSize = defaultInitialSize): CountTable[A]
initDecodeTable:
base64: initDecodeTable(): array[256, char]
initDeque:
deques: initDeque[T](initialSize: int = defaultInitialSize): Deque[T]
initDoublyLinkedList:
lists: initDoublyLinkedList[T](): DoublyLinkedList[T]
initDoublyLinkedRing:
lists: initDoublyLinkedRing[T](): DoublyLinkedRing[T]
initDuration:
times: initDuration(nanoseconds, microseconds, milliseconds, seconds, minutes, hours, days, weeks: int64 = 0): Duration
initEmptyBlock:
text_layouter: initEmptyBlock(): LytBlock
initFailure:
results: initFailure[T, E](self: var Result[T, E]; e: sink E)
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]
initHSeparated:
text_layouter: initHSeparated(blocks: seq[LytBlock]; sep: LytBlock): LytBlock
initIndentBlock:
text_layouter: initIndentBlock(blc: LytBlock; indent: int; breakMult: int = 1): LytBlock
initIntSet:
intsets: initIntSet(): IntSet
initLineBlock:
text_layouter: initLineBlock(elems: openArray[LytBlock]; breakMult: int = 1): LytBlock
initLock:
locks: initLock(lock: var Lock)
initLytOptions:
text_layouter: initLytOptions(): LytOptions
initOptParser:
parseopt: initOptParser(args: openArray[string]; shortNoVal: set[char] = {}; longNoVal: seq[string] = @[]; allowWhitespaceAfterColon = true): OptParser
initOrderedSet:
sets: initOrderedSet[A](initialSize = defaultInitialSize): OrderedSet[A]
initOrderedTable:
tables: initOrderedTable[A, B](initialSize = defaultInitialSize): OrderedTable[A, B]
initPackedSet:
packedsets: initPackedSet[A](): PackedSet[A]
initRand:
random: initRand(): Rand
random: initRand(seed: int64): Rand
random: initRand(seed: int64): Rand
initRational:
rationals: initRational[T: SomeInteger](num, den: T): Rational[T]
initRLock:
rlocks: initRLock(lock: var RLock)
initRstGenerator:
rstgen: initRstGenerator(g: var RstGenerator; target: OutputTarget; config: StringTableRef; filename: string; findFile: FindFileHandler = nil; msgHandler: MsgHandler = nil; filenames = default(RstFileTable))
initRtArray:
rtarrays: initRtArray[T](len: Natural): RtArray[T]
initSeparated:
text_layouter: initSeparated(blocks: seq[LytBlock]; vertical: bool; sep: LytBlock): LytBlock
initSet:
sets: initSet[A](initialSize = defaultInitialSize): HashSet[A]
initSinglyLinkedList:
lists: initSinglyLinkedList[T](): SinglyLinkedList[T]
initSinglyLinkedRing:
lists: initSinglyLinkedRing[T](): SinglyLinkedRing[T]
initSkipTable:
strutils: initSkipTable(a: var SkipTable; sub: string)
initStackBlock:
text_layouter: initStackBlock(elems: openArray[LytBlock]; breakMult: int = 1): LytBlock
initSuccess:
results: initSuccess[T, E](self: var Result[T, E]; v: sink T)
results: initSuccess[E](self: var Result[void, E])
initTable:
tables: initTable[A, B](initialSize = defaultInitialSize): Table[A, B]
initTextBlock:
text_layouter: initTextBlock(text: LytStr; breakMult: int = 1; breaking: bool = false): LytBlock
text_layouter: initTextBlock(text: LytStrSpan; breakMult: int = 1; breaking: bool = false): LytBlock
initTime:
times: initTime(unix: int64; nanosecond: NanosecondRange): Time
initTimeFormat:
times: initTimeFormat(format: string): TimeFormat
initTimeInterval:
times: initTimeInterval(nanoseconds, microseconds, milliseconds, seconds, minutes, hours, days, weeks, months, years: int = 0): TimeInterval
initToJsonOptions:
jsonutils: initToJsonOptions(): ToJsonOptions
initUri:
uri: initUri(isIpv6 = false): Uri
initVerbBlock:
text_layouter: initVerbBlock(textLines: openArray[LytStrSpan]; breaking: bool = true; firstNl: bool = false; breakMult: int = 1): LytBlock
initVSeparated:
text_layouter: initVSeparated(blocks: seq[LytBlock]; sep: LytBlock): LytBlock
initWrapBlock:
text_layouter: initWrapBlock(elems: openArray[LytBlock]; sep: LytStr; breakMult: int = 1): LytBlock
InlineTags:
htmlparser: InlineTags
IN_MASK_ADD:
inotify: IN_MASK_ADD
inMicroseconds:
times: inMicroseconds(dur: Duration): int64
inMilliseconds:
times: inMilliseconds(dur: Duration): int64
inMinutes:
times: inMinutes(dur: Duration): int64
IN_MODIFY:
inotify: IN_MODIFY
IN_MOVE:
inotify: IN_MOVE
IN_MOVED_FROM:
inotify: IN_MOVED_FROM
IN_MOVED_TO:
inotify: IN_MOVED_TO
IN_MOVE_SELF:
inotify: IN_MOVE_SELF
inNanoseconds:
times: inNanoseconds(dur: Duration): int64
innerText:
xmltree: innerText(n: XmlNode): string
IN_ONESHOT:
inotify: IN_ONESHOT
IN_ONLYDIR:
inotify: IN_ONLYDIR
IN_OPEN:
inotify: IN_OPEN
inotify_add_watch:
inotify: inotify_add_watch(fd: cint; name: cstring; mask: uint32): cint
InotifyEvent:
inotify: InotifyEvent
inotify_events:
inotify: inotify_events(evs: pointer; n: int): ptr InotifyEvent
inotify_init:
inotify: inotify_init(): FileHandle
inotify_init1:
inotify: inotify_init1(flags: cint): FileHandle
inotify_rm_watch:
inotify: inotify_rm_watch(fd: cint; wd: cint): cint
input:
htmlgen: input(e: varargs[untyped]): untyped
InputElement:
dom: InputElement
inputHandle:
osproc: inputHandle(p: Process): FileHandle
inputStream:
osproc: inputStream(p: Process): Stream
IN_Q_OVERFLOW:
inotify: IN_Q_OVERFLOW
ins:
htmlgen: ins(e: varargs[untyped]): untyped
inSeconds:
times: inSeconds(dur: Duration): int64
insert:
db_mysql: insert(db: DbConn; query: SqlQuery; pkName: string; args: varargs[string, `$`]): int64
db_odbc: insert(db: var DbConn; query: SqlQuery; pkName: string; args: varargs[string, `$`]): int64
db_postgres: insert(db: DbConn; query: SqlQuery; pkName: string; args: varargs[string, `$`]): int64
db_sqlite: insert(db: DbConn; query: SqlQuery; pkName: string; args: varargs[string, `$`]): int64
macros: insert(a: NimNode; pos: int; b: NimNode)
sequtils: insert[T](dest: var seq[T]; src: openArray[T]; pos = 0)
system: insert[T](x: var seq[T]; item: sink T; i = 0.Natural)
system: insert(x: var string; item: string; i = 0.Natural)
xmltree: insert(father, son: XmlNode; index: int)
insertBefore:
dom: insertBefore(n, newNode, before: Node)
insertData:
dom: insertData(n: Node; position: int; data: cstring)
insertId:
db_mysql: insertId(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
db_odbc: insertId(db: var DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
insertID:
db_postgres: insertID(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
db_sqlite: insertID(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
insertNode:
dom: insertNode(range: Range; node: Node)
insertSep:
strutils: insertSep(s: string; sep = '_'; digits = 3): string
instantiationInfo:
system: instantiationInfo(index = -1; fullPaths = false): tuple[filename: string, line: int, column: int]
InstantRow:
db_mysql: InstantRow
db_odbc: InstantRow
db_postgres: InstantRow
db_sqlite: InstantRow
instantRows:
db_mysql: instantRows(db: DbConn; columns: var DbColumns; query: SqlQuery; args: varargs[string, `$`]): InstantRow
db_mysql: instantRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): InstantRow
db_odbc: instantRows(db: var DbConn; query: SqlQuery; args: varargs[string, `$`]): InstantRow
db_postgres: instantRows(db: DbConn; columns: var DbColumns; query: SqlQuery; args: varargs[string, `$`]): InstantRow
db_postgres: instantRows(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): InstantRow
db_postgres: instantRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): InstantRow
db_sqlite: instantRows(db: DbConn; columns: var DbColumns; query: SqlQuery; args: varargs[string, `$`]): InstantRow
db_sqlite: instantRows(db: DbConn; stmtName: SqlPrepared): InstantRow
db_sqlite: instantRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): InstantRow
int:
system: int
int16:
system: int16
int32:
system: int32
int64:
system: int64
int8:
system: int8
intensity:
colors: intensity(a: Color; f: float): Color
intercept:
stats: intercept(r: RunningRegress): float
interpolate:
shellrunner: interpolate(part: ShellArg; map: ShInterpolate): seq[ShellArg]
shellrunner: interpolate(cmd: ShellCmd; map: openArray[(string, seq[string])]): ShellCmd
shellrunner: interpolate(cmd: ShellCmd; map: ShInterpolate): ShellCmd
interpolatedFragments:
parseutils: interpolatedFragments(s: string): tuple[kind: InterpolatedKind, value: string]
InterpolatedKind:
parseutils: InterpolatedKind
interpolation:
Module strformat
intersection:
packedsets: intersection[A](s1, s2: PackedSet[A]): PackedSet[A]
sets: intersection[A](s1, s2: HashSet[A]): HashSet[A]
Interval:
dom: Interval
INT_MAX:
Module system
INT_MIN:
Module system
IntSet:
intsets: IntSet
intToStr:
strutils: intToStr(x: int; minchars: Positive = 1): string
intVal:
macros: intVal(n: NimNode): BiggestInt
intVal=:
macros: intVal=(n: NimNode; val: BiggestInt)
IN_UNMOUNT:
inotify: IN_UNMOUNT
inv:
complex: inv[T](z: Complex[T]): Complex[T]
invalidFilenameChars:
os: invalidFilenameChars
invalidFilenames:
os: invalidFilenames
INVALID_FILE_SIZE:
winlean: INVALID_FILE_SIZE
INVALID_HANDLE_VALUE:
winlean: INVALID_HANDLE_VALUE
INVALID_SET_FILE_POINTER:
winlean: INVALID_SET_FILE_POINTER
INVALID_SOCKET:
winlean: INVALID_SOCKET
InvalidUnicodeError:
nre: InvalidUnicodeError
inViewport:
dom: inViewport(el: Node): bool
invoke:
tasks: invoke(task: Task)
invokeNew:
typeinfo: invokeNew(x: Any)
invokeNewSeq:
typeinfo: invokeNewSeq(x: Any; len: int)
inWeeks:
times: inWeeks(dur: Duration): int64
inZone:
times: inZone(dt: DateTime; zone: Timezone): DateTime
times: inZone(time: Time; zone: Timezone): DateTime
IOC_IN:
nativesockets: IOC_IN
winlean: IOC_IN
IOC_INOUT:
winlean: IOC_INOUT
IOC_OUT:
winlean: IOC_OUT
IOCPARM_MASK:
nativesockets: IOCPARM_MASK
ioctlsocket:
nativesockets: ioctlsocket(s: SocketHandle; cmd: clong; argptr: ptr clong): cint
IOC_WS2:
winlean: IOC_WS2
IOEffect:
system: IOEffect
IOError:
system: IOError
IOSelectorsException:
selectors: IOSelectorsException
ioselSupportedPlatform:
selectors: ioselSupportedPlatform
IpAddress:
net: IpAddress
IpAddressFamily:
net: IpAddressFamily
IPPROTO_ICMP:
Protocol.IPPROTO_ICMP
IPPROTO_ICMPV6:
Protocol.IPPROTO_ICMPV6
IPPROTO_IP:
Protocol.IPPROTO_IP
IPPROTO_IPV6:
Protocol.IPPROTO_IPV6
IPPROTO_RAW:
Protocol.IPPROTO_RAW
IPPROTO_TCP:
Protocol.IPPROTO_TCP
IPPROTO_UDP:
Protocol.IPPROTO_UDP
IPv4_any:
net: IPv4_any(): IpAddress
IPv4_broadcast:
net: IPv4_broadcast(): IpAddress
IPv4_loopback:
net: IPv4_loopback(): IpAddress
IPv6_any:
net: IPv6_any(): IpAddress
IPv6_loopback:
net: IPv6_loopback(): IpAddress
is1xx:
httpcore: is1xx(code: HttpCode): bool
is2xx:
httpcore: is2xx(code: HttpCode): bool
is3xx:
httpcore: is3xx(code: HttpCode): bool
is4xx:
httpcore: is4xx(code: HttpCode): bool
is5xx:
httpcore: is5xx(code: HttpCode): bool
isAbsolute:
os: isAbsolute(path: string): bool
uri: isAbsolute(uri: Uri): bool
isAdmin:
os: isAdmin(): bool
isAlpha:
unicode: isAlpha(c: Rune): bool
unicode: isAlpha(s: string): bool
isAlphaAscii:
strutils: isAlphaAscii(c: char): bool
isAlphaNumeric:
strutils: isAlphaNumeric(c: char): bool
isatty:
terminal: isatty(f: File): bool
isColor:
colors: isColor(name: string): bool
isCombining:
unicode: isCombining(c: Rune): bool
isCyclical:
typetraits: isCyclical(t: typedesc): bool
isDefault:
colortext: isDefault(col: TermColorFg | TermColorBg): bool
isDefaultNamespace:
dom: isDefaultNamespace(n: Node): bool
isDigit:
strutils: isDigit(c: char): bool
isDisconnectionError:
net: isDisconnectionError(flags: set[SocketFlag]; lastError: OSErrorCode): bool
isDst:
times: isDst(dt: DateTime): bool
isEmpty:
selectors: isEmpty[T](s: Selector[T]): bool
text_layouter: isEmpty(bl: LytBlock): bool
text_layouter: isEmpty(s: LytStr): bool
isEmptyOrWhitespace:
strutils: isEmptyOrWhitespace(s: string): bool
isEqualNode:
dom: isEqualNode(n: Node): bool
isErr:
results: isErr(self: Result): bool
isExported:
macros: isExported(n: NimNode): bool
isFinite:
dom: isFinite(x: BiggestFloat): bool
isGcSafe:
effecttraits: isGcSafe(fn: NimNode): bool
isGitRepo:
gitutils: isGitRepo(dir: string): bool
isHidden:
os: isHidden(path: string): bool
isInitialized:
times: isInitialized(dt: DateTime): bool
isInstantiationOf:
macros: isInstantiationOf(instanceProcSym, genProcSym: NimNode): bool
isInteger:
jsutils: isInteger[T](x: T): bool
isIpAddress:
net: isIpAddress(addressStr: string): bool
isLeapDay:
times: isLeapDay(dt: DateTime): bool
isLeapYear:
times: isLeapYear(year: int): bool
isLower:
unicode: isLower(c: Rune): bool
isLowerAscii:
strutils: isLowerAscii(c: char): bool
isMainModule:
system: isMainModule
isNamedTuple:
typetraits: isNamedTuple(T: typedesc): bool
isNaN:
dom: isNaN(x: BiggestFloat): bool
math: isNaN(x: SomeFloat): bool
isNewline:
colortext: isNewline(rune: ColRune): bool
isNil:
dod_helpers: isNil(i: ValueId): bool
packedsets: isNil[A](x: PackedSet[A]): bool
system: isNil(x: cstring): bool
system: isNil(x: pointer): bool
system: isNil[T](x: ptr T): bool
system: isNil[T](x: ref T): bool
system: isNil[T](x: seq[T]): bool
system: isNil(x: string): bool
system: isNil[T: proc](x: T): bool
text_layouter: isNil(i: LytStrId): bool
typeinfo: isNil(x: Any): bool
isNone:
dod_helpers: isNone[T](i: OptIndex[T]): bool
options: isNone[T](self: Option[T]): bool
isNull:
jsffi: isNull[T](x: T): bool
isOk:
results: isOk(self: Result): bool
isolate:
isolation: isolate[T](value: sink T): Isolated[T]
Isolated:
isolation: Isolated
isPowerOfTwo:
math: isPowerOfTwo(x: int): bool
isReady:
threadpool: isReady(fv: FlowVarBase): bool
isRelativeTo:
os: isRelativeTo(path: string; base: string): bool
isRootDir:
os: isRootDir(path: string): bool
isSafeInteger:
jsutils: isSafeInteger[T](x: T): bool
isSameNode:
dom: isSameNode(n: Node): bool
isSome:
dod_helpers: isSome[T](i: OptIndex[T]): bool
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
isSpaces:
text_layouter: isSpaces(s: LytStr): bool
isSsl:
net: isSsl(socket: Socket): bool
isSuccess:
winlean: isSuccess(a: WINBOOL): bool
isTitle:
unicode: isTitle(c: Rune): bool
isTok:
sexp_parse: isTok(p: SexpParser; tok: TTokKind): bool
isTrueColorSupported:
terminal: isTrueColorSupported(): bool
isUndefined:
jsffi: isUndefined[T](x: T): bool
isUpper:
unicode: isUpper(c: Rune): bool
isUpperAscii:
strutils: isUpperAscii(c: char): bool
isValid:
sets: isValid[A](s: HashSet[A]): bool
isValidFilename:
os: isValidFilename(filename: string; maxLen = 259.Positive): bool
isValidSha1Hash:
sha1: isValidSha1Hash(s: string): bool
isWhiteSpace:
unicode: isWhiteSpace(c: Rune): bool
Item:
diff: Item
item:
dom: item(list: TouchList; i: int): Touch
items:
colortext: items(text: ColText): ColRune
critbits: items[T](c: CritBitTree[T]): string
deques: items[T](deq: Deque[T]): lent T
dod_helpers: items(store: ValueStore): Value
enumutils: items[T: HoleyEnum](E: typedesc[T]): T
iterators: items[IX, T](a: array[IX, T]): T
iterators: items(a: cstring): char
iterators: items[T: not char](a: openArray[T]): lent2 T
iterators: items[T: char](a: openArray[T]): T
iterators: items[T](a: seq[T]): lent2 T
iterators: items[T](a: set[T]): T
iterators: items[T: Ordinal](s: Slice[T]): T
iterators: items(a: string): char
iterators: items[T: enum and Ordinal](E: typedesc[T]): T
jsffi: items[K, V](assoc: JsAssoc[K, V]): V
jsffi: items(obj: JsObject): JsObject
json: items(node: JsonNode): JsonNode
lists: items[T](L: SomeLinkedList[T]): T
lists: items[T](L: SomeLinkedRing[T]): T
macrocache: items(s: CacheSeq): NimNode
macros: items(n: NimNode): NimNode
nre: items(pattern: CaptureBounds; default = none(HSlice[int, int])): Option[ HSlice[int, int]]
nre: items(pattern: Captures; default: Option[string] = none(string)): Option[string]
packedsets: items[A](s: PackedSet[A]): A
pegs: items(p: Peg): Peg
ropes: items(r: Rope): char
sequtils: items[T](xs: iterator (): T): T
sets: items[A](s: HashSet[A]): A
sets: items[A](s: OrderedSet[A]): A
sexp: items(node: SexpNode): SexpNode
sharedlist: items[A](x: var SharedList[A]): A
text_layouter: items(blc: LytBlock): LytBlock
xmltree: items(n: XmlNode): XmlNode
itemsWithPrefix:
critbits: itemsWithPrefix[T](c: CritBitTree[T]; prefix: string): 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
JavaScript:
The JavaScript target
JBool:
JsonNodeKind.JBool
JFloat:
JsonNodeKind.JFloat
JInt:
JsonNodeKind.JInt
JNull:
JsonNodeKind.JNull
JObject:
JsonNodeKind.JObject
join:
colortext: join(text: seq[ColText]; sep: ColText): ColText
strutils: join(a: openArray[string]; sep: string = ""): string
strutils: join[T: not string](a: openArray[T]; sep: string = ""): string
text_layouter: join(blocks: LytBlock; sep: LytBlock; vertLines: bool = true): LytBlock
text_layouter: join(blocks: seq[LytBlock]; sep: LytBlock; direction: LytBlockKind): LytBlock
joinItBlock:
text_layouter: joinItBlock(direction: LytBlockKind; item: typed; expr: untyped; join: LytBlock): untyped
joinItLine:
text_layouter: joinItLine(item: typed; expr: untyped; join: LytBlock): untyped
joinPath:
os: joinPath(head, tail: string): string
os: joinPath(parts: varargs[string]): string
joinThread:
system: joinThread[TArg](t: Thread[TArg])
joinThreads:
system: joinThreads[TArg](t: varargs[Thread[TArg]])
joptEnumOrd:
EnumMode.joptEnumOrd
joptEnumString:
EnumMode.joptEnumString
joptEnumSymbol:
EnumMode.joptEnumSymbol
Joptions:
jsonutils: Joptions
joptJsonNodeAsCopy:
JsonNodeMode.joptJsonNodeAsCopy
joptJsonNodeAsObject:
JsonNodeMode.joptJsonNodeAsObject
joptJsonNodeAsRef:
JsonNodeMode.joptJsonNodeAsRef
js:
jsffi: js
jsArguments:
jsffi: jsArguments
jsAssert:
jsconsole: jsAssert(console: Console; assertion)
JsAssoc:
jsffi: JsAssoc
JsBigInt:
jsbigints: JsBigInt
jsConstructorName:
jsutils: jsConstructorName[T](a: T): cstring
jsDelete:
jsffi: jsDelete(x: auto): JsObject
jsDirname:
jsffi: jsDirname
JsError:
jsffi: JsError
JsEvalError:
jsffi: JsEvalError
jsFilename:
jsffi: jsFilename
jsFromAst:
jsffi: jsFromAst(n: untyped): untyped
JsKey:
jsffi: JsKey
jsNew:
jsffi: jsNew(x: auto): JsObject
jsNull:
jsffi: jsNull
JsObject:
jsffi: JsObject
JSON:
jscore: JSON
json:
jsfetch: json(self: Response): Future[JsObject]
JSON:
Module json
Module marshal
jsonArrayEnd:
JsonEventKind.jsonArrayEnd
jsonArrayStart:
JsonEventKind.jsonArrayStart
jsonEof:
JsonEventKind.jsonEof
jsonError:
JsonEventKind.jsonError
JsonError:
parsejson: JsonError
JsonEventKind:
parsejson: JsonEventKind
jsonFalse:
JsonEventKind.jsonFalse
jsonFloat:
JsonEventKind.jsonFloat
jsonInt:
JsonEventKind.jsonInt
JsonKindError:
parsejson: JsonKindError
JsonLib:
jscore: JsonLib
JsonNode:
json: JsonNode
JsonNodeKind:
json: JsonNodeKind
JsonNodeMode:
jsonutils: JsonNodeMode
JsonNodeObj:
json: JsonNodeObj
jsonNull:
JsonEventKind.jsonNull
jsonObjectEnd:
JsonEventKind.jsonObjectEnd
jsonObjectStart:
JsonEventKind.jsonObjectStart
JsonParser:
parsejson: JsonParser
JsonParsingError:
parsejson: JsonParsingError
jsonString:
JsonEventKind.jsonString
jsonTo:
jsonutils: jsonTo(b: JsonNode; T: typedesc; opt = Joptions()): T:type
jsonTrue:
JsonEventKind.jsonTrue
JsRangeError:
jsffi: JsRangeError
JsReferenceError:
jsffi: JsReferenceError
JsRoot:
system: JsRoot
JsSyntaxError:
jsffi: JsSyntaxError
JString:
JsonNodeKind.JString
JsTypeError:
jsffi: JsTypeError
jsTypeOf:
jsffi: jsTypeOf(x: JsObject): cstring
jsutils: jsTypeOf[T](x: T): cstring
jsUndefined:
jsffi: jsUndefined
JsURIError:
jsffi: JsURIError
JUnitOutputFormatter:
unittest: JUnitOutputFormatter
kbd:
htmlgen: kbd(e: varargs[untyped]): untyped
kDirtyTemplate:
GenAstOpt.kDirtyTemplate
keepIf:
sequtils: keepIf[T](s: var seq[T]; pred: proc (x: T): bool {.closure.})
keepItIf:
sequtils: keepItIf(varSeq: seq; pred: untyped)
KEvent:
kqueue: KEvent
kevent:
kqueue: kevent(kqFD: cint; changelist: ptr KEvent; nchanges: cint; eventlist: ptr KEvent; nevents: cint; timeout: ptr Timespec): cint
KeyboardEvent:
dom: KeyboardEvent
KeyboardEventKey:
dom: KeyboardEventKey
KeyError:
system: KeyError
KEY_EVENT_RECORD:
winlean: KEY_EVENT_RECORD
keygen:
htmlgen: keygen(e: varargs[untyped]): untyped
keys:
critbits: keys[T](c: CritBitTree[T]): string
jsffi: keys[K: JsKey; V](assoc: JsAssoc[K, V]): K
jsffi: keys(obj: JsObject): cstring
jsformdata: keys(self: FormData): seq[cstring]
jsheaders: keys(self: Headers): seq[cstring]
json: keys(node: JsonNode): string
strtabs: keys(t: StringTableRef): string
tables: keys[A](t: CountTable[A]): lent A
tables: keys[A](t: CountTableRef[A]): A
tables: keys[A, B](t: OrderedTable[A, B]): lent A
tables: keys[A, B](t: OrderedTableRef[A, B]): lent A
tables: keys[A, B](t: Table[A, B]): lent A
tables: keys[A, B](t: TableRef[A, B]): lent A
keysWithPrefix:
critbits: keysWithPrefix[T](c: CritBitTree[T]; prefix: string): string
kill:
osproc: kill(p: Process)
kind:
macros: kind(n: NimNode): NimNodeKind
parsejson: kind(my: JsonParser): JsonEventKind
parsexml: kind(my: XmlParser): XmlEventKind
pegs: kind(p: Peg): PegKind
sexp_parse: kind(parser: SexpParser): SexpEventKind
typeinfo: kind(x: Any): AnyKind
xmltree: kind(n: XmlNode): XmlNodeKind
kNoNewLit:
GenAstOpt.kNoNewLit
kqueue:
kqueue: kqueue(): cint
kurtosis:
stats: kurtosis[T](x: openArray[T]): float
stats: kurtosis(s: RunningStat): float
kurtosisS:
stats: kurtosisS[T](x: openArray[T]): float
stats: kurtosisS(s: RunningStat): float
label:
htmlgen: label(e: varargs[untyped]): untyped
LacksDevPackages:
distros: LacksDevPackages
lAlignCenter:
LytAlignDirection.lAlignCenter
lAlignLeft:
LytAlignDirection.lAlignLeft
lAlignRight:
LytAlignDirection.lAlignRight
lambda lifting:
Code generation for closures
langC:
SourceLanguage.langC
langCmd:
SourceLanguage.langCmd
langConsole:
SourceLanguage.langConsole
langCsharp:
SourceLanguage.langCsharp
langJava:
SourceLanguage.langJava
langNim:
SourceLanguage.langNim
langNone:
SourceLanguage.langNone
langPython:
SourceLanguage.langPython
langYaml:
SourceLanguage.langYaml
largest:
tables: largest[A](t: CountTable[A]): tuple[key: A, val: int]
tables: largest[A](t: CountTableRef[A]): tuple[key: A, val: int]
last:
macros: last(node: NimNode): NimNode
lastModified:
httpclient: lastModified(response: Response): DateTime
lastPathPart:
os: lastPathPart(path: string): string
lastRune:
unicode: lastRune(s: string; last: int): (Rune, int)
lastSon:
rstast: lastSon(n: PRstNode): PRstNode
layEvNewline:
LytEventKind.layEvNewline
layEvSpaces:
LytEventKind.layEvSpaces
layEvStr:
LytEventKind.layEvStr
Layout:
text_layouter: Layout
lcm:
math: lcm[T](x: openArray[T]): T
math: lcm[T](x, y: T): T
leaves:
ropes: leaves(r: Rope): string
legend:
htmlgen: legend(e: varargs[untyped]): untyped
len:
colortext: len(text: ColText): 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
dod_helpers: len(store: ValueStore): int
dom: len(x: Node): int
heapqueue: len[T](heap: HeapQueue[T]): int
httpcore: len(headers: HttpHeaders): int
jsformdata: len(self: FormData): int
jsheaders: len(self: Headers): int
json: len(n: JsonNode): int
macrocache: len(s: CacheSeq): int
macrocache: len(t: CacheTable): int
macros: len(n: NimNode): int
packedsets: len[A](s: PackedSet[A]): int
parsesql: len(n: SqlNode): int
reservedmem: len(m: ReservedMem): int
reservedmem: len[T](s: ReservedMemSeq[T]): int
ropes: len(a: Rope): int
rstast: len(n: PRstNode): int
sets: len[A](s: HashSet[A]): int
sets: len[A](s: OrderedSet[A]): int
sexp: len(n: SexpNode): int
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
text_layouter: len(blc: LytBlock): 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
levenshteinDistance:
diff: levenshteinDistance[T](str1, str2: openArray[T]): tuple[distance: int, operations: seq[SeqEdit]]
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
likely:
system: likely(val: bool): bool
limit:
Module system
line:
pegs: line(nt: NonTerminal): int
LineInfo:
macros: LineInfo
lineInfo:
macros: lineInfo(arg: NimNode): string
lineInfoObj:
macros: lineInfoObj(n: NimNode): LineInfo
LinenoiseData:
linenoise: LinenoiseData
lines:
colortext: lines(text: ColText): ColRuneLine
io: lines(f: File): string
io: lines(filename: string): string
memfiles: lines(mfile: MemFile; delim = ' '; eat = '\r'): string
memfiles: lines(mfile: MemFile; buf: var string; delim = ' '; eat = '\r'): string
osproc: lines(p: Process): string
streams: lines(s: Stream): string
link:
htmlgen: link(e: varargs[untyped]): untyped
LinkElement:
dom: LinkElement
lispRepr:
colortext: lispRepr(rune: ColRune): string
colortext: lispRepr(rune: ColText): string
macros: lispRepr(n: NimNode; indented = false): string
listDirs:
nimscript: listDirs(dir: string): seq[string]
listen:
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
lnCtrlC:
Status.lnCtrlC
lnCtrlD:
Status.lnCtrlD
lnCtrlUnkown:
Status.lnCtrlUnkown
load:
atomics: load[T: Trivial](location: var Atomic[T]; order: MemoryOrder = moSequentiallyConsistent): T
atomics: load[T: not Trivial](location: var Atomic[T]; order: MemoryOrder = moSequentiallyConsistent): T
marshal: load[T](s: Stream; data: var T)
loadConfig:
parsecfg: loadConfig(stream: Stream; filename: string = "[stream]"): Config
parsecfg: loadConfig(filename: string): Config
loadHtml:
htmlparser: loadHtml(path: string): XmlNode
htmlparser: loadHtml(path: string; errors: var seq[string]): XmlNode
loadLib:
dynlib: loadLib(): LibHandle
dynlib: loadLib(path: string; globalSymbols = false): LibHandle
loadLibPattern:
dynlib: loadLibPattern(pattern: string; globalSymbols = false): LibHandle
loadUnidecodeTable:
unidecode: loadUnidecodeTable(datafile = "unidecode.dat")
loadXml:
xmlparser: loadXml(path: string; errors: var seq[string]; options: set[XmlParseOption] = {reportComments}): XmlNode
xmlparser: loadXml(path: string; options: set[XmlParseOption] = {reportComments}): XmlNode
local:
times: local(): Timezone
times: local(dt: DateTime): DateTime
times: local(t: Time): DateTime
localFree:
winlean: localFree(p: pointer)
localRaiseHook:
system: localRaiseHook
locals:
system: locals(): RootObj
Location:
dom: Location
LocationBar:
dom: LocationBar
Lock:
locks: Lock
log:
jsconsole: log(console: Console)
jscore: log(m: MathLib; a: SomeNumber): float
logging: log(logger: ConsoleLogger; level: Level; args: varargs[string, `$`])
logging: log(logger: FileLogger; level: Level; args: varargs[string, `$`])
logging: log(logger: Logger; level: Level; args: varargs[string, `$`])
logging: log(logger: RollingFileLogger; level: Level; args: varargs[string, `$`])
logging: log(level: Level; args: varargs[string, `$`])
math: log[T: SomeFloat](x, base: T): T
log10:
complex: log10[T](z: Complex[T]): Complex[T]
jscore: log10(m: MathLib; a: SomeNumber): float
math: log10(x: float32): float32
math: log10(x: float64): float64
log1p:
jscore: log1p(m: MathLib; a: SomeNumber): float
log2:
complex: log2[T](z: Complex[T]): Complex[T]
jscore: log2(m: MathLib; a: SomeNumber): float
math: log2(x: float32): float32
math: log2(x: float64): float64
Logger:
logging: Logger
LONG:
winlean: LONG
lookupNamespaceURI:
dom: lookupNamespaceURI(n: Node): cstring
lookupPrefix:
dom: lookupPrefix(n: Node): cstring
low:
jsbigints: low(_: typedesc[JsBigInt]): JsBigInt
monotimes: low(typ: typedesc[MonoTime]): MonoTime
system: low[I, T](x: array[I, T]): I
system: low(x: cstring): int
system: low[T](x: openArray[T]): int
system: low(x: string): int
system: low[T: Ordinal | enum | range](x: T): T
system: low[I, T](x: typedesc[array[I, T]]): I
system: low(T: typedesc[SomeFloat]): T:type
system: low[T: Ordinal | enum | range](x: typedesc[T]): T
times: low(typ: typedesc[Duration]): Duration
times: low(typ: typedesc[Time]): Time
lowerBound:
algorithm: lowerBound[T, K](a: openArray[T]; key: K; cmp: proc (x: T; k: K): int {.closure.}): int
algorithm: lowerBound[T](a: openArray[T]; key: T): int
LPFIBER_START_ROUTINE:
winlean: LPFIBER_START_ROUTINE
LPFILETIME:
winlean: LPFILETIME
LPINT:
winlean: LPINT
lvlAll:
Level.lvlAll
lvlDebug:
Level.lvlDebug
lvlError:
Level.lvlError
lvlFatal:
Level.lvlFatal
lvlInfo:
Level.lvlInfo
lvlNone:
Level.lvlNone
lvlNotice:
Level.lvlNotice
lvlWarn:
Level.lvlWarn
LytAlignDirection:
text_layouter: LytAlignDirection
LytBlock:
text_layouter: LytBlock
LytBlockKind:
text_layouter: LytBlockKind
LytEvent:
text_layouter: LytEvent
LytEventKind:
text_layouter: LytEventKind
LytOptions:
text_layouter: LytOptions
lytSpaces:
text_layouter: lytSpaces(count: int = 1): LytStr
LytSpacesId:
text_layouter: LytSpacesId
LytStr:
text_layouter: LytStr
LytStrId:
text_layouter: LytStrId
LytStrIdMask:
text_layouter: LytStrIdMask
lytStrIdx:
text_layouter: lytStrIdx(idx: int; len: int): LytStr
LytStrSpan:
text_layouter: LytStrSpan
lytStrSpan:
text_layouter: lytStrSpan(str: LytStr): LytStrSpan
text_layouter: lytStrSpan(strs: openArray[LytStr]): LytStrSpan
maction:
htmlgen: maction(e: varargs[untyped]): untyped
main:
htmlgen: main(e: varargs[untyped]): untyped
mantissaDigits:
fenv: mantissaDigits(T: typedesc[float32]): int
fenv: mantissaDigits(T: typedesc[float64]): int
map:
htmlgen: map(e: varargs[untyped]): untyped
options: map[T](self: Option[T]; callback: proc (input: T))
options: map[T, R](self: Option[T]; callback: proc (input: T): R): Option[R]
results: map[T: not void; E, R](r: Result[T, E]; callback: proc (v: T): R): Result[R, E]
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]
mapErr:
results: mapErr[T: not void; E, R](r: Result[T, E]; callback: proc (e: E): R): Result[T, R]
mapIt:
sequtils: mapIt(s: typed; op: untyped): untyped
mapLiterals:
sequtils: mapLiterals(constructor, op: untyped; nested = true): untyped
mapMem:
memfiles: mapMem(m: var MemFile; mode: FileMode = fmRead; mappedSize = -1; offset = 0; mapFlags = cint(-1)): pointer
mApr:
Month.mApr
mapViewOfFileEx:
winlean: mapViewOfFileEx(hFileMappingObject: Handle; dwDesiredAccess: DWORD; dwFileOffsetHigh, dwFileOffsetLow: DWORD; dwNumberOfBytesToMap: WinSizeT; lpBaseAddress: pointer): pointer
mark:
htmlgen: mark(e: varargs[untyped]): untyped
marquee:
htmlgen: marquee(e: varargs[untyped]): untyped
mask:
bitops: mask[T: SomeInteger](v: var T; slice: Slice[int])
bitops: mask[T: SomeInteger](v: var T; mask: T)
masked:
bitops: masked[T: SomeInteger](v: T; slice: Slice[int]): T
bitops: masked[T: SomeInteger](v, mask: T): T
match:
jsre: match(pattern: cstring; self: RegExp): seq[cstring]
nre: match(pattern: RegexMatch): string
nre: match(str: string; pattern: Regex; start = 0; endpos = int.high): Option[ RegexMatch]
pegs: match(s: string; pattern: Peg; start = 0): bool
pegs: match(s: string; pattern: Peg; matches: var openArray[string]; start = 0): bool
re: match(buf: cstring; pattern: Regex; matches: var openArray[string]; start = 0; bufSize: int): bool
re: match(s: string; pattern: Regex; start = 0): bool
re: match(s: string; pattern: Regex; matches: var openArray[string]; start = 0): bool
matchAst:
ast_pattern_matching: matchAst(astExpr: NimNode; args: varargs[untyped]): untyped
matchAstRecursive:
ast_pattern_matching: matchAstRecursive(ast: NimNode; args: varargs[untyped]): untyped
matchBounds:
nre: matchBounds(pattern: RegexMatch): HSlice[int, int]
matchIdent:
ast_pattern_matching: matchIdent(arg: NimNode; value: string): MatchingError
MatchingError:
ast_pattern_matching: MatchingError
MatchingErrorKind:
ast_pattern_matching: MatchingErrorKind
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
matchLengthKind:
ast_pattern_matching: matchLengthKind(arg: NimNode; kind: NimNodeKind; length: int): MatchingError
ast_pattern_matching: matchLengthKind(arg: NimNode; kind: set[NimNodeKind]; length: int): MatchingError
math:
htmlgen: math(e: varargs[untyped]): untyped
Math:
jscore: Math
MathLib:
jscore: MathLib
mAug:
Month.mAug
max:
jscore: max(m: MathLib; a, b: SomeNumber): SomeNumber
system: max(x, y: float32): float32
system: max(x, y: float64): float64
system: max(x, y: int): int
system: max(x, y: int16): int16
system: max(x, y: int32): int32
system: max(x, y: int64): int64
system: max(x, y: int8): int8
system: max[T](x: openArray[T]): T
system: max[T: not SomeFloat](x, y: T): T
max10Exponent:
fenv: max10Exponent(T: typedesc[float32]): int
fenv: max10Exponent(T: typedesc[float64]): int
MaxDistinguishedThread:
threadpool: MaxDistinguishedThread
maxExponent:
fenv: maxExponent(T: typedesc[float32]): int
fenv: maxExponent(T: typedesc[float64]): int
MaxFloat32Precision:
math: MaxFloat32Precision
MaxFloat64Precision:
math: MaxFloat64Precision
MaxFloatPrecision:
math: MaxFloatPrecision
maximumPositiveValue:
fenv: maximumPositiveValue(T: typedesc[float32]): float32
fenv: maximumPositiveValue(T: typedesc[float64]): float64
MAXIMUM_WAIT_OBJECTS:
winlean: MAXIMUM_WAIT_OBJECTS
maxIndex:
sequtils: maxIndex[T](s: openArray[T]): int
MAX_INT:
Module system
maxLen:
reservedmem: maxLen(m: ReservedMem): int
reservedmem: maxLen[T](s: ReservedMemSeq[T]): int
MaxLineLength:
net: MaxLineLength
MAX_PATH:
winlean: MAX_PATH
MaxReBufSize:
re: MaxReBufSize
maxSafeInteger:
jsutils: maxSafeInteger
MaxSubpatterns:
pegs: MaxSubpatterns
re: MaxSubpatterns
MaxThreadPoolSize:
threadpool: MaxThreadPoolSize
maxVarIntLen:
varints: maxVarIntLen
MD5Context:
md5: MD5Context
MD5Digest:
md5: MD5Digest
md5Final:
md5: md5Final(c: var MD5Context; digest: var MD5Digest)
md5Init:
md5: md5Init(c: var MD5Context)
md5Update:
md5: md5Update(c: var MD5Context; input: cstring; len: int)
mDec:
Month.mDec
mean:
stats: mean[T](x: openArray[T]): float
stats: mean(s: RunningStat): float
MemAccessFlags:
reservedmem: MemAccessFlags
memExec:
reservedmem: memExec
memExecRead:
reservedmem: memExecRead
memExecReadWrite:
reservedmem: memExecReadWrite
MemFile:
memfiles: MemFile
MemMapFileStream:
memfiles: MemMapFileStream
MemMapFileStreamObj:
memfiles: MemMapFileStreamObj
memory mapped files:
Module memfiles
memoryLock:
posix_utils: memoryLock(a1: pointer; a2: int)
memoryLockAll:
posix_utils: memoryLockAll(flags: int)
MemoryOrder:
atomics: MemoryOrder
memoryUnlock:
posix_utils: memoryUnlock(a1: pointer; a2: int)
memoryUnlockAll:
posix_utils: memoryUnlockAll()
memRead:
reservedmem: memRead
memReadWrite:
reservedmem: memReadWrite
MemSlice:
memfiles: MemSlice
memSlices:
memfiles: memSlices(mfile: MemFile; delim = ' '; eat = '\r'): MemSlice
menclose:
htmlgen: menclose(e: varargs[untyped]): untyped
MenuBar:
dom: MenuBar
merge:
algorithm: merge[T](result: var seq[T]; x, y: openArray[T])
algorithm: merge[T](result: var seq[T]; x, y: openArray[T]; cmp: proc (x, y: T): int {.closure.})
tables: merge[A](s: var CountTable[A]; t: CountTable[A])
tables: merge[A](s, t: CountTableRef[A])
mergeCycleSets:
graph: mergeCycleSets[Id](cycles: seq[seq[Id]]): seq[HashSet[Id]]
mergeIndexes:
rstgen: mergeIndexes(dir: string): string
merror:
htmlgen: merror(e: varargs[untyped]): untyped
MersenneTwister:
mersenne: MersenneTwister
message:
dom: message(ex: DomException): cstring
Message:
smtp: Message
meta:
htmlgen: meta(e: varargs[untyped]): untyped
metaAuthor:
MetaEnum.metaAuthor
MetaEnum:
rstgen: MetaEnum
metaNone:
MetaEnum.metaNone
metaSubtitle:
MetaEnum.metaSubtitle
metaTitle:
MetaEnum.metaTitle
metaVersion:
MetaEnum.metaVersion
meter:
htmlgen: meter(e: varargs[untyped]): untyped
method:
Module system
methodGet:
RequestMethod.methodGet
methodNone:
RequestMethod.methodNone
methodPost:
RequestMethod.methodPost
mFeb:
Month.mFeb
mfenced:
htmlgen: mfenced(e: varargs[untyped]): untyped
mfrac:
htmlgen: mfrac(e: varargs[untyped]): untyped
mgetOrPut:
tables: mgetOrPut[A, B](t: var OrderedTable[A, B]; key: A; val: B): var B
tables: mgetOrPut[A, B](t: OrderedTableRef[A, B]; key: A; val: B): var B
tables: mgetOrPut[A, B](t: var Table[A, B]; key: A; val: B): var B
tables: mgetOrPut[A, B](t: TableRef[A, B]; key: A; val: B): var B
mglyph:
htmlgen: mglyph(e: varargs[untyped]): untyped
mi:
htmlgen: mi(e: varargs[untyped]): untyped
Microseconds:
TimeUnit.Microseconds
microseconds:
times: microseconds(micros: int): TimeInterval
Milliseconds:
TimeUnit.Milliseconds
milliseconds:
times: milliseconds(ms: int): TimeInterval
MimeDB:
mimetypes: MimeDB
mimes:
mimetypes: mimes
MimeType:
dom: MimeType
min:
jscore: min[T: SomeNumber | JsRoot](m: MathLib; a, b: T): T
system: min(x, y: float32): float32
system: min(x, y: float64): float64
system: min(x, y: int): int
system: min(x, y: int16): int16
system: min(x, y: int32): int32
system: min(x, y: int64): int64
system: min(x, y: int8): int8
system: min[T](x: openArray[T]): T
system: min[T: not SomeFloat](x, y: T): T
min10Exponent:
fenv: min10Exponent(T: typedesc[float32]): int
fenv: min10Exponent(T: typedesc[float64]): int
minExponent:
fenv: minExponent(T: typedesc[float32]): int
fenv: minExponent(T: typedesc[float64]): int
MinFloatNormal:
math: MinFloatNormal
minimumPositiveValue:
fenv: minimumPositiveValue(T: typedesc[float32]): float32
fenv: minimumPositiveValue(T: typedesc[float64]): float64
minIndex:
sequtils: minIndex[T](s: openArray[T]): int
MIN_INT:
Module system
minute:
times: minute(dt: DateTime): MinuteRange
MinuteRange:
times: MinuteRange
Minutes:
TimeUnit.Minutes
minutes:
times: minutes(m: int): TimeInterval
mismatch:
sexp_diff: mismatch(path: SexpPath; key: string): SexpMismatch
missingOrExcl:
critbits: missingOrExcl[T](c: var CritBitTree[T]; key: string): bool
packedsets: missingOrExcl[A](s: var PackedSet[A]; key: A): bool
sets: missingOrExcl[A](s: var HashSet[A]; key: A): bool
sets: missingOrExcl[A](s: var OrderedSet[A]; key: A): bool
mitems:
deques: mitems[T](deq: var Deque[T]): var T
dod_helpers: mitems(store: var ValueStore): var Value
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
text_layouter: mitems(blc: var LytBlock): var LytBlock
xmltree: mitems(n: var XmlNode): var XmlNode
mix:
colors: mix(a, b: Color; fn: untyped): untyped
mJan:
Month.mJan
mJul:
Month.mJul
mJun:
Month.mJun
mkDir:
nimscript: mkDir(dir: string)
mkdtemp:
posix_utils: mkdtemp(prefix: string): string
mkstemp:
posix_utils: mkstemp(prefix: string; suffix = ""): (string, File)
mlabeledtr:
htmlgen: mlabeledtr(e: varargs[untyped]): untyped
mmap:
Module memfiles
mMar:
Month.mMar
mMay:
Month.mMay
mmultiscripts:
htmlgen: mmultiscripts(e: varargs[untyped]): untyped
mn:
htmlgen: mn(e: varargs[untyped]): untyped
mNov:
Month.mNov
mo:
htmlgen: mo(e: varargs[untyped]): untyped
mOct:
Month.mOct
mode:
nimscript: mode
strtabs: mode(t: StringTableRef): StringTableMode
modeCaseInsensitive:
StringTableMode.modeCaseInsensitive
modeCaseSensitive:
StringTableMode.modeCaseSensitive
modeStyleInsensitive:
StringTableMode.modeStyleInsensitive
MonoTime:
monotimes: MonoTime
Month:
times: Month
month:
times: month(dt: DateTime): Month
monthday:
times: monthday(dt: DateTime): MonthdayRange
MonthdayRange:
times: MonthdayRange
Months:
TimeUnit.Months
months:
times: months(m: int): TimeInterval
MouseButtons:
dom: MouseButtons
MouseEvent:
dom: MouseEvent
move:
system: move[T](x: var T): T
moveBy:
dom: moveBy(w: Window; x, y: int)
moveDir:
os: moveDir(source, dest: string)
moveFile:
os: moveFile(source, dest: string)
MOVEFILE_COPY_ALLOWED:
winlean: MOVEFILE_COPY_ALLOWED
MOVEFILE_CREATE_HARDLINK:
winlean: MOVEFILE_CREATE_HARDLINK
MOVEFILE_DELAY_UNTIL_REBOOT:
winlean: MOVEFILE_DELAY_UNTIL_REBOOT
moveFileExW:
winlean: moveFileExW(lpExistingFileName, lpNewFileName: WideCString; flags: DWORD): WINBOOL
MOVEFILE_FAIL_IF_NOT_TRACKABLE:
winlean: MOVEFILE_FAIL_IF_NOT_TRACKABLE
MOVEFILE_REPLACE_EXISTING:
winlean: MOVEFILE_REPLACE_EXISTING
moveFileW:
winlean: moveFileW(lpExistingFileName, lpNewFileName: WideCString): WINBOOL
MOVEFILE_WRITE_THROUGH:
winlean: MOVEFILE_WRITE_THROUGH
moveMem:
system: moveMem(dest, source: pointer; size: Natural)
mover:
htmlgen: mover(e: varargs[untyped]): untyped
moveTo:
dom: moveTo(w: Window; x, y: int)
mpadded:
htmlgen: mpadded(e: varargs[untyped]): untyped
mpairs:
critbits: mpairs[T](c: var CritBitTree[T]): tuple[key: string, val: var T]
dod_helpers: mpairs(store: var ValueStore): (ValueId, var Value)
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]
sexp: mpairs(node: var SexpNode): (int, var SexpNode)
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)
text_layouter: mpairs(blc: var LytBlock): (int, var LytBlock)
mpairsWithPrefix:
critbits: mpairsWithPrefix[T](c: var CritBitTree[T]; prefix: string): tuple[key: string, val: var T]
mphantom:
htmlgen: mphantom(e: varargs[untyped]): untyped
mroot:
htmlgen: mroot(e: varargs[untyped]): untyped
mrow:
htmlgen: mrow(e: varargs[untyped]): untyped
ms:
htmlgen: ms(e: varargs[untyped]): untyped
mSep:
Month.mSep
MSG_PEEK:
winlean: MSG_PEEK
mspace:
htmlgen: mspace(e: varargs[untyped]): untyped
msqrt:
htmlgen: msqrt(e: varargs[untyped]): untyped
mstyle:
htmlgen: mstyle(e: varargs[untyped]): untyped
msub:
htmlgen: msub(e: varargs[untyped]): untyped
msubsup:
htmlgen: msubsup(e: varargs[untyped]): untyped
msup:
htmlgen: msup(e: varargs[untyped]): untyped
mtable:
htmlgen: mtable(e: varargs[untyped]): untyped
mtd:
htmlgen: mtd(e: varargs[untyped]): untyped
mtext:
htmlgen: mtext(e: varargs[untyped]): untyped
MultipartData:
httpclient: MultipartData
MultipartEntries:
httpclient: MultipartEntries
MultipleValueSetting:
compilesettings: MultipleValueSetting
multiReplace:
re: multiReplace(s: string; subs: openArray[tuple[pattern: Regex, repl: string]]): string
strutils: multiReplace(s: string; replacements: varargs[(string, string)]): string
munder:
htmlgen: munder(e: varargs[untyped]): untyped
munderover:
htmlgen: munderover(e: varargs[untyped]): untyped
mvalues:
critbits: mvalues[T](c: var CritBitTree[T]): var T
tables: mvalues[A](t: var CountTable[A]): var int
tables: mvalues[A](t: CountTableRef[A]): var int
tables: mvalues[A, B](t: var OrderedTable[A, B]): var B
tables: mvalues[A, B](t: OrderedTableRef[A, B]): var B
tables: mvalues[A, B](t: var Table[A, B]): var B
tables: mvalues[A, B](t: TableRef[A, B]): var B
mvaluesWithPrefix:
critbits: mvaluesWithPrefix[T](c: var CritBitTree[T]; prefix: string): var T
mvDir:
nimscript: mvDir(from, to: string)
mvFile:
nimscript: mvFile(from, to: string)
myersDiff:
diff: myersDiff[T](aSeq, bSeq: openArray[T]): seq[SeqEdit]
diff: myersDiff[T](aSeq, bSeq: openArray[T]; itemCmp: proc (x, y: T): bool): seq[ SeqEdit]
mySQL:
Module db_mysql
name:
dom: name(ex: DomException): cstring
macros: name(someProc: NimNode): NimNode
pegs: name(nt: NonTerminal): string
times: name(zone: Timezone): string
typetraits: name(t: typedesc): string
name=:
macros: name=(someProc: NimNode; val: NimNode)
NaN:
system: NaN
nanosecond:
times: nanosecond(dt: DateTime): NanosecondRange
times: nanosecond(time: Time): NanosecondRange
NanosecondRange:
times: NanosecondRange
Nanoseconds:
TimeUnit.Nanoseconds
nanoseconds:
times: nanoseconds(nanos: int): TimeInterval
nativeToUnixPath:
globs: nativeToUnixPath(path: string): string
natural:
pegs: natural(): Peg
Natural:
system: Natural
nav:
htmlgen: nav(e: varargs[untyped]): untyped
Navigator:
dom: Navigator
navigator:
dom: navigator
NegInf:
system: NegInf
nestList:
macros: nestList(op: NimNode; pack: NimNode): NimNode
macros: nestList(op: NimNode; pack: NimNode; init: NimNode): NimNode
new:
system: new(t: typedesc): auto
system: new[T: ref](a: var T)
newArrayBuffer:
jsutils: newArrayBuffer(n: int): ArrayBuffer
newAssignment:
macros: newAssignment(lhs, rhs: NimNode): NimNode
newBigUint64Array:
jsutils: newBigUint64Array(buffer: ArrayBuffer): BigUint64Array
newBlockStmt:
macros: newBlockStmt(body: NimNode): NimNode
macros: newBlockStmt(label, body: NimNode): NimNode
newCall:
macros: newCall(theProc: NimNode; args: varargs[NimNode]): NimNode
macros: newCall(theProc: string; args: varargs[NimNode]): NimNode
newCData:
xmltree: newCData(cdata: sink string): XmlNode
newColonExpr:
macros: newColonExpr(a, b: NimNode): NimNode
newComment:
xmltree: newComment(comment: sink string): XmlNode
newCommentStmtNode:
macros: newCommentStmtNode(s: string): NimNode
newConfig:
parsecfg: newConfig(): Config
newConsoleLogger:
logging: newConsoleLogger(levelThreshold = lvlAll; fmtStr = defaultFmtStr; useStderr = false): ConsoleLogger
newConsoleOutputFormatter:
unittest: newConsoleOutputFormatter(outputLevel: OutputLevel = outputLevelDefault; colorOutput = true): ConsoleOutputFormatter
newConstStmt:
macros: newConstStmt(name, value: NimNode): NimNode
newContext:
net: newContext(protVersion = protSSLv23; verifyMode = CVerifyPeer; certFile = ""; keyFile = ""; cipherList = CiphersIntermediate; caDir = ""; caFile = ""): SslContext
newCountTable:
tables: newCountTable[A](initialSize = defaultInitialSize): CountTableRef[A]
tables: newCountTable[A](keys: openArray[A]): CountTableRef[A]
newDate:
jscore: newDate(): DateTime
jscore: newDate(year, month, day, hours, minutes, seconds, milliseconds: int): DateTime
jscore: newDate(date: int | int64 | string): DateTime
newDomException:
dom: newDomException(): DomException
newDomParser:
dom: newDomParser(): DomParser
newDotExpr:
macros: newDotExpr(a, b: NimNode): NimNode
newDoublyLinkedNode:
lists: newDoublyLinkedNode[T](value: T): DoublyLinkedNode[T]
newElement:
xmltree: newElement(tag: sink string): XmlNode
newEmptyNode:
macros: newEmptyNode(): NimNode
newEntity:
xmltree: newEntity(entity: string): XmlNode
newEnum:
macros: newEnum(name: NimNode; fields: openArray[NimNode]; public, pure: bool): NimNode
newEvent:
dom: newEvent(name: cstring): Event
newException:
system: newException(exceptn: typedesc; message: string; parentException: ref Exception = nil): untyped
newfetchOptions:
jsfetch: newfetchOptions(metod: HttpMethod; body: cstring; mode: FetchModes; credentials: FetchCredentials; cache: FetchCaches; referrerPolicy: FetchReferrerPolicies; keepalive: bool; redirect = frFollow; referrer = "client".cstring; integrity = "".cstring; headers: Headers = newHeaders()): FetchOptions
newFileLogger:
logging: newFileLogger(file: File; levelThreshold = lvlAll; fmtStr = defaultFmtStr): FileLogger
logging: newFileLogger(filename = defaultFilename(); mode: FileMode = fmAppend; levelThreshold = lvlAll; fmtStr = defaultFmtStr; bufSize: int = -1): FileLogger
newFileReader:
dom: newFileReader(): FileReader
newFileStream:
streams: newFileStream(f: File): owned FileStream
streams: newFileStream(filename: string; mode: FileMode = fmRead; bufSize: int = -1): owned FileStream
newFloat64Array:
jsutils: newFloat64Array(buffer: ArrayBuffer): Float64Array
newFloatLitNode:
macros: newFloatLitNode(f: BiggestFloat): NimNode
newFormData:
jsformdata: newFormData(): FormData
newGraph:
graph: newGraph[Id](isDirected: bool = true): Graph[Id]
graph: newGraph[Id](values: openArray[(Id, Id)]; isDirected: bool = true): Graph[Id]
newHeaders:
jsheaders: newHeaders(): Headers
newHttpClient:
httpclient: newHttpClient(userAgent = defUserAgent; maxRedirects = 5; sslContext = getDefaultSSL(); proxy: Proxy = nil; timeout = -1; headers = newHttpHeaders()): HttpClient
newHttpHeaders:
httpcore: newHttpHeaders(titleCase = false): HttpHeaders
httpcore: newHttpHeaders(keyValuePairs: openArray[tuple[key: string, val: string]]; titleCase = false): HttpHeaders
newIdentDefs:
macros: newIdentDefs(name, kind: NimNode; default = newEmptyNode()): NimNode
newIdentNode:
macros: newIdentNode(i: 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:
colortext: newline(text: var ColText)
newLine:
pegs: newLine(): Peg
newline:
Module pegs
NewLines:
lexbase: NewLines
Newlines:
strutils: Newlines
newLit:
macros: newLit(arg: enum): NimNode
macros: newLit[N, T](arg: array[N, T]): NimNode
macros: newLit(b: bool): NimNode
macros: newLit(c: char): NimNode
macros: newLit(f: float32): NimNode
macros: newLit(f: float64): NimNode
macros: newLit(i: int): NimNode
macros: newLit(i: int16): NimNode
macros: newLit(i: int32): NimNode
macros: newLit(i: int64): NimNode
macros: newLit(i: int8): NimNode
macros: newLit(arg: ref object): NimNode
macros: newLit[T](arg: seq[T]): NimNode
macros: newLit[T](s: set[T]): NimNode
macros: newLit(s: string): NimNode
macros: newLit[T: tuple](arg: T): NimNode
macros: newLit(i: uint): NimNode
macros: newLit(i: uint16): NimNode
macros: newLit(i: uint32): NimNode
macros: newLit(i: uint64): NimNode
macros: newLit(i: uint8): NimNode
macros: newLit(arg: object): NimNode
newMemMapFileStream:
memfiles: newMemMapFileStream(filename: string; mode: FileMode = fmRead; fileSize: int = -1): MemMapFileStream
newMersenneTwister:
mersenne: newMersenneTwister(seed: uint32): MersenneTwister
newMimetypes:
mimetypes: newMimetypes(): MimeDB
newMultipartData:
httpclient: newMultipartData(): MultipartData
httpclient: newMultipartData(xs: MultipartEntries): MultipartData
newNilLit:
macros: newNilLit(): NimNode
newNimNode:
macros: newNimNode(kind: NimNodeKind; lineInfoFrom: NimNode = nil): NimNode
newNode:
parsesql: newNode(k: SqlNodeKind): SqlNode
parsesql: newNode(k: SqlNodeKind; sons: seq[SqlNode]): SqlNode
parsesql: newNode(k: SqlNodeKind; s: string): SqlNode
newNonTerminal:
pegs: newNonTerminal(name: string; line, column: int): NonTerminal
newOrderedTable:
tables: newOrderedTable[A, B](initialSize = defaultInitialSize): OrderedTableRef[A, B]
tables: newOrderedTable[A, B](pairs: openArray[(A, B)]): OrderedTableRef[A, B]
newOSError:
os: newOSError(errorCode: OSErrorCode; additionalInfo = ""): owned(ref OSError)
newPar:
macros: newPar(expr: NimNode): NimNode
macros: newPar(exprs: varargs[NimNode]): NimNode
newPipeOutStream:
streamwrapper: newPipeOutStream[T](s: sink (ref T)): owned PipeOutStream[T]
newProc:
macros: newProc(name = newEmptyNode(); params: openArray[NimNode] = [newEmptyNode()]; body: NimNode = newStmtList(); procType = nnkProcDef; pragmas: NimNode = newEmptyNode()): NimNode
newPromise:
asyncjs: newPromise[T](handler: proc (resolve: proc (response: T))): Future[T]
asyncjs: newPromise(handler: proc (resolve: proc ())): Future[void]
newProxy:
httpclient: newProxy(url: string; auth = ""): Proxy
httpclient: newProxy(url: Uri; auth = ""): Proxy
newReadSocketStream:
socketstreams: newReadSocketStream(s: Socket): owned ReadSocketStream
newRegExp:
jsre: newRegExp(pattern: cstring): RegExp
jsre: newRegExp(pattern: cstring; flags: cstring): RegExp
newRequest:
jsfetch: newRequest(url: cstring): Request
jsfetch: newRequest(url: cstring; fetchOptions: FetchOptions): Request
newResponse:
jsfetch: newResponse(body: cstring | FormData): Response
newRollingFileLogger:
logging: newRollingFileLogger(filename = defaultFilename(); mode: FileMode = fmReadWrite; levelThreshold = lvlAll; fmtStr = defaultFmtStr; maxLines: Positive = 1000; bufSize: int = -1): RollingFileLogger
newRstLeaf:
rstast: newRstLeaf(s: string): PRstNode
newRstNode:
rstast: newRstNode(kind: RstNodeKind; sons: seq[PRstNode] = @[]; anchor = ""): PRstNode
rstast: newRstNode(kind: RstNodeKind; s: string): PRstNode
rstast: newRstNode(kind: RstNodeKind; info: TLineInfo; sons: seq[PRstNode] = @[]): PRstNode
newSCons:
sexp: newSCons(car, cdr: SexpNode): SexpNode
newSelectEvent:
selectors: newSelectEvent(): SelectEvent
newSelector:
selectors: newSelector[T](): Selector[T]
newSeq:
system: newSeq[T](len = 0.Natural): seq[T]
system: newSeq[T](s: var seq[T]; len: Natural)
newSeqOfCap:
system: newSeqOfCap[T](cap: Natural): seq[T]
newSeqUninitialized:
system: newSeqUninitialized[T: SomeNumber](len: Natural): seq[T]
newSeqWith:
sequtils: newSeqWith(len: int; init: untyped): untyped
newSFloat:
sexp: newSFloat(n: float): SexpNode
newSha1State:
sha1: newSha1State(): Sha1State
newSinglyLinkedNode:
lists: newSinglyLinkedNode[T](value: T): SinglyLinkedNode[T]
newSInt:
sexp: newSInt(n: BiggestInt): SexpNode
newSKeyword:
sexp: newSKeyword(key: string; value: SexpNode): SexpNode
newSList:
sexp: newSList(items: varargs[SexpNode]): SexpNode
newSmtp:
smtp: newSmtp(useSsl = false; debug = false; sslContext: SslContext = nil): Smtp
newSNil:
sexp: newSNil(): SexpNode
newSocket:
net: newSocket(domain, sockType, protocol: cint; buffered = true; inheritable = defined(nimInheritHandles)): owned(Socket)
net: newSocket(domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP; buffered = true; inheritable = defined(nimInheritHandles)): owned(Socket)
net: newSocket(fd: SocketHandle; domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP; buffered = true): owned(Socket)
newSString:
sexp: newSString(s: string): SexpNode
newSSymbol:
sexp: newSSymbol(s: string): SexpNode
newStmtList:
macros: newStmtList(stmts: varargs[NimNode]): NimNode
newString:
system: newString(len: Natural): string
newStringOfCap:
system: newStringOfCap(cap: Natural): string
newStringStream:
streams: newStringStream(s: sink string = ""): owned StringStream
newStringTable:
strtabs: newStringTable(mode: StringTableMode): owned(StringTableRef)
strtabs: newStringTable(keyValuePairs: varargs[string]; mode: StringTableMode): owned( StringTableRef)
strtabs: newStringTable(keyValuePairs: varargs[tuple[key, val: string]]; mode: StringTableMode = modeCaseSensitive): owned(StringTableRef)
newStrLitNode:
macros: newStrLitNode(s: string): NimNode
newTable:
tables: newTable[A, B](initialSize = defaultInitialSize): TableRef[A, B]
tables: newTable[A, B](pairs: openArray[(A, B)]): TableRef[A, B]
newTableFrom:
tables: newTableFrom[A, B, C](collection: A; index: proc (x: B): C): TableRef[C, B]
newText:
xmltree: newText(text: sink string): XmlNode
newTimezone:
times: newTimezone(name: string; zonedTimeFromTimeImpl: proc (time: Time): ZonedTime {. tags: [], raises: [], gcsafe, locks: 0.}; zonedTimeFromAdjTimeImpl: proc ( adjTime: Time): ZonedTime {.tags: [], raises: [], gcsafe, locks: 0.}): owned Timezone
newTree:
macros: newTree(kind: NimNodeKind; children: varargs[NimNode]): NimNode
newUint32Array:
jsutils: newUint32Array(buffer: ArrayBuffer): Uint32Array
newUint8Array:
jsutils: newUint8Array(n: int): Uint8Array
newVarStmt:
macros: newVarStmt(name, value: NimNode): NimNode
newVerbatimText:
xmltree: newVerbatimText(text: sink string): XmlNode
newWideCString:
widestrs: newWideCString(s: cstring): WideCStringObj
widestrs: newWideCString(source: cstring; L: int): WideCStringObj
widestrs: newWideCString(size: int): WideCStringObj
widestrs: newWideCString(s: string): WideCStringObj
newWriteSocketStream:
socketstreams: newWriteSocketStream(s: Socket): owned WriteSocketStream
newXmlTree:
xmltree: newXmlTree(tag: sink string; children: openArray[XmlNode]; attributes: XmlAttributes = nil): XmlNode
next:
parsecfg: next(c: var CfgParser): CfgEvent
parsejson: next(my: var JsonParser)
parseopt: next(p: var OptParser)
parsexml: next(my: var XmlParser)
pathnorm: next(it: var PathIter; x: string): (int, int)
random: next(r: var Rand): uint64
nextPermutation:
algorithm: nextPermutation[T](x: var openArray[T]): bool
nextPowerOfTwo:
math: nextPowerOfTwo(x: int): int
nextSplitPoint:
rstgen: nextSplitPoint(s: string; start: int): int
NilAccessDefect:
system: NilAccessDefect
NilAccessError:
system: NilAccessError
nimcache:
Nimcache naming logic
nimcacheDir:
nimscript: nimcacheDir(): string
nimIdentNormalize:
strutils: nimIdentNormalize(s: string): string
nimKeywordsSynchronizationCheck:
highlite: nimKeywordsSynchronizationCheck(keywordFileContent: string)
NimMajor:
system: NimMajor
NimMinor:
system: NimMinor
NimNode:
system: NimNode
NimNodeKind:
macros: NimNodeKind
NimNodeKinds:
macros: NimNodeKinds
NimPatch:
system: NimPatch
NimSeqV2:
system: NimSeqV2
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
nnkBracket:
NimNodeKind.nnkBracket
nnkBracketExpr:
NimNodeKind.nnkBracketExpr
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
nnkCommand:
NimNodeKind.nnkCommand
nnkCommentStmt:
NimNodeKind.nnkCommentStmt
nnkConstDef:
NimNodeKind.nnkConstDef
nnkConstSection:
NimNodeKind.nnkConstSection
nnkConstTy:
NimNodeKind.nnkConstTy
nnkContinueStmt:
NimNodeKind.nnkContinueStmt
nnkConv:
NimNodeKind.nnkConv
nnkConverterDef:
NimNodeKind.nnkConverterDef
nnkCStringToString:
NimNodeKind.nnkCStringToString
nnkCurly:
NimNodeKind.nnkCurly
nnkCurlyExpr:
NimNodeKind.nnkCurlyExpr
nnkDefer:
NimNodeKind.nnkDefer
nnkDerefExpr:
NimNodeKind.nnkDerefExpr
nnkDiscardStmt:
NimNodeKind.nnkDiscardStmt
nnkDistinctTy:
NimNodeKind.nnkDistinctTy
nnkDo:
NimNodeKind.nnkDo
nnkDotCall:
NimNodeKind.nnkDotCall
nnkDotExpr:
NimNodeKind.nnkDotExpr
nnkElifBranch:
NimNodeKind.nnkElifBranch
nnkElifExpr:
NimNodeKind.nnkElifExpr
nnkElse:
NimNodeKind.nnkElse
nnkElseExpr:
NimNodeKind.nnkElseExpr
nnkEmpty:
NimNodeKind.nnkEmpty
nnkEnumFieldDef:
NimNodeKind.nnkEnumFieldDef
nnkEnumTy:
NimNodeKind.nnkEnumTy
nnkError:
NimNodeKind.nnkError
nnkExceptBranch:
NimNodeKind.nnkExceptBranch
nnkExportExceptStmt:
NimNodeKind.nnkExportExceptStmt
nnkExportStmt:
NimNodeKind.nnkExportStmt
nnkExprColonExpr:
NimNodeKind.nnkExprColonExpr
nnkExprEqExpr:
NimNodeKind.nnkExprEqExpr
nnkFastAsgn:
NimNodeKind.nnkFastAsgn
nnkFinally:
NimNodeKind.nnkFinally
nnkFloat32Lit:
NimNodeKind.nnkFloat32Lit
nnkFloat64Lit:
NimNodeKind.nnkFloat64Lit
nnkFloatLit:
NimNodeKind.nnkFloatLit
nnkFloatLiterals:
ast_pattern_matching: nnkFloatLiterals
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
nnkIntLiterals:
ast_pattern_matching: nnkIntLiterals
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
nnkNimNodeLit:
NimNodeKind.nnkNimNodeLit
nnkObjConstr:
NimNodeKind.nnkObjConstr
nnkObjDownConv:
NimNodeKind.nnkObjDownConv
nnkObjectTy:
NimNodeKind.nnkObjectTy
nnkObjUpConv:
NimNodeKind.nnkObjUpConv
nnkOfBranch:
NimNodeKind.nnkOfBranch
nnkOfInherit:
NimNodeKind.nnkOfInherit
nnkOpenSymChoice:
NimNodeKind.nnkOpenSymChoice
nnkPar:
NimNodeKind.nnkPar
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
nnkRequireInitKinds:
macros: nnkRequireInitKinds
nnkReturnStmt:
NimNodeKind.nnkReturnStmt
nnkRStrLit:
NimNodeKind.nnkRStrLit
nnkSharedTy:
NimNodeKind.nnkSharedTy
nnkStaticExpr:
NimNodeKind.nnkStaticExpr
nnkStaticStmt:
NimNodeKind.nnkStaticStmt
nnkStaticTy:
NimNodeKind.nnkStaticTy
nnkStmtList:
NimNodeKind.nnkStmtList
nnkStmtListExpr:
NimNodeKind.nnkStmtListExpr
nnkStringLiterals:
ast_pattern_matching: nnkStringLiterals
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
nodeCount:
graph: nodeCount[Id](graph: Graph[Id]): int
nodeID:
macros: nodeID(n: NimNode): int
nodejs:
The JavaScript target
nodes:
graph: nodes[Id](graph: Graph[Id]): Id
lists: nodes[T](L: SomeLinkedList[T]): SomeLinkedNode[T]
lists: nodes[T](L: SomeLinkedRing[T]): SomeLinkedNode[T]
NodeType:
dom: NodeType
NoError:
MatchingErrorKind.NoError
NO_ERROR:
winlean: NO_ERROR
nonAtomicType:
atomics: nonAtomicType(T: typedesc[Trivial]): untyped
None:
EventPhase.None
none:
options: none[T](): Option[T]
options: none(T: typedesc): Option[T]
noneOpt:
dod_helpers: noneOpt[T](t: typedesc[T]): untyped
NonTerminal:
pegs: NonTerminal
nonterminal:
pegs: nonterminal(n: NonTerminal): Peg
NonTerminalFlag:
pegs: NonTerminalFlag
normalize:
dom: normalize(n: Node)
strutils: normalize(s: string): string
normalizedPath:
os: normalizedPath(path: string): string
normalizeExe:
os: normalizeExe(file: var string)
normalizePath:
os: normalizePath(path: var string)
pathnorm: normalizePath(path: string; dirSep = DirSep): string
normalizePathEnd:
os: normalizePathEnd(path: var string; trailingSep = false)
os: normalizePathEnd(path: string; trailingSep = false): string
NORMAL_PRIORITY_CLASS:
winlean: NORMAL_PRIORITY_CLASS
noscript:
htmlgen: noscript(e: varargs[untyped]): untyped
NotationNode:
NodeType.NotationNode
NOTE_ATTRIB:
kqueue: NOTE_ATTRIB
NOTE_CHILD:
kqueue: NOTE_CHILD
NOTE_DELETE:
kqueue: NOTE_DELETE
NOTE_EXEC:
kqueue: NOTE_EXEC
NOTE_EXIT:
kqueue: NOTE_EXIT
NOTE_EXTEND:
kqueue: NOTE_EXTEND
NOTE_FORK:
kqueue: NOTE_FORK
NOTE_LINK:
kqueue: NOTE_LINK
NOTE_LOWAT:
kqueue: NOTE_LOWAT
NOTE_MSECONDS:
kqueue: NOTE_MSECONDS
NOTE_PCTRLMASK:
kqueue: NOTE_PCTRLMASK
NOTE_PDATAMASK:
kqueue: NOTE_PDATAMASK
NOTE_RENAME:
kqueue: NOTE_RENAME
NOTE_REVOKE:
kqueue: NOTE_REVOKE
NOTE_TRACK:
kqueue: NOTE_TRACK
NOTE_TRACKERR:
kqueue: NOTE_TRACKERR
NOTE_WRITE:
kqueue: NOTE_WRITE
notice:
logging: notice(args: varargs[string, `$`])
now:
dom: now(p: Performance): float
jscore: now(d: DateLib): int
times: now(): DateTime
nskConditional:
NimSymKind.nskConditional
nskConst:
NimSymKind.nskConst
nskConverter:
NimSymKind.nskConverter
nskDynLib:
NimSymKind.nskDynLib
nskEnumField:
NimSymKind.nskEnumField
nskField:
NimSymKind.nskField
nskForVar:
NimSymKind.nskForVar
nskFunc:
NimSymKind.nskFunc
nskGenericParam:
NimSymKind.nskGenericParam
nskIterator:
NimSymKind.nskIterator
nskLabel:
NimSymKind.nskLabel
nskLet:
NimSymKind.nskLet
nskMacro:
NimSymKind.nskMacro
nskMethod:
NimSymKind.nskMethod
nskModule:
NimSymKind.nskModule
nskParam:
NimSymKind.nskParam
nskProc:
NimSymKind.nskProc
nskResult:
NimSymKind.nskResult
nskStub:
NimSymKind.nskStub
nskTemp:
NimSymKind.nskTemp
nskTemplate:
NimSymKind.nskTemplate
nskType:
NimSymKind.nskType
nskUnknown:
NimSymKind.nskUnknown
nskVar:
NimSymKind.nskVar
nt:
pegs: nt(p: Peg): NonTerminal
ntDeclared:
NonTerminalFlag.ntDeclared
ntohl:
nativesockets: ntohl(x: uint32): uint32
ntohs:
nativesockets: ntohs(x: uint16): uint16
ntUsed:
NonTerminalFlag.ntUsed
ntyAlias:
NimTypeKind.ntyAlias
ntyAnd:
NimTypeKind.ntyAnd
ntyAnything:
NimTypeKind.ntyAnything
ntyArray:
NimTypeKind.ntyArray
ntyBool:
NimTypeKind.ntyBool
ntyBuiltinTypeClass:
NimTypeKind.ntyBuiltinTypeClass
ntyChar:
NimTypeKind.ntyChar
ntyCompositeTypeClass:
NimTypeKind.ntyCompositeTypeClass
ntyCString:
NimTypeKind.ntyCString
ntyDistinct:
NimTypeKind.ntyDistinct
ntyEmpty:
NimTypeKind.ntyEmpty
ntyEnum:
NimTypeKind.ntyEnum
ntyError:
NimTypeKind.ntyError
ntyExpr:
NimTypeKind.ntyExpr
ntyFloat:
NimTypeKind.ntyFloat
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
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
ntyUnused1:
NimTypeKind.ntyUnused1
ntyUnused2:
NimTypeKind.ntyUnused2
ntyUserTypeClass:
NimTypeKind.ntyUserTypeClass
ntyUserTypeClassInst:
NimTypeKind.ntyUserTypeClassInst
ntyVar:
NimTypeKind.ntyVar
ntyVarargs:
NimTypeKind.ntyVarargs
ntyVoid:
NimTypeKind.ntyVoid
nxt:
strscans: nxt(input: string; idx, step: int = 1)
ObjectAssignmentDefect:
system: ObjectAssignmentDefect
ObjectAssignmentError:
system: ObjectAssignmentError
ObjectConversionDefect:
system: ObjectConversionDefect
ObjectConversionError:
system: ObjectConversionError
off:
system: off
offsetHeight:
dom: offsetHeight(e: Node): int
offsetLeft:
dom: offsetLeft(e: Node): int
offsetOf:
system: offsetOf[T](value: T; member: untyped): int
system: offsetOf[T](t: typedesc[T]; member: untyped): int
offsetTop:
dom: offsetTop(e: Node): int
offsetWidth:
dom: offsetWidth(e: Node): int
Oid:
oids: Oid
ok:
results: ok[T, E](R: typedesc[Result[T, E]]; v: sink T): Result[T, E]
results: ok[E](R: typedesc[Result[void, E]]): Result[void, E]
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
OnReject:
asyncjs: OnReject
onThreadDestruction:
system: onThreadDestruction(handler: proc () {.closure, gcsafe, raises: [].})
onUnhandledException:
system: onUnhandledException
open:
db_mysql: open(connection, user, password, database: string): DbConn
db_odbc: open(connection, user, password, database: string): DbConn
db_postgres: open(connection, user, password, database: string): DbConn
db_sqlite: open(connection, user, password, database: string): DbConn
dom: open(d: Document)
dom: open(w: Window; uri, windowname: cstring; properties: cstring = nil): Window
encodings: open(destEncoding = "UTF-8"; srcEncoding = "CP1252"): EncodingConverter
io: open(f: var File; filehandle: FileHandle; mode: FileMode = fmRead): bool
io: open(f: var File; filename: string; mode: FileMode = fmRead; bufSize: int = -1): bool
io: open(filename: string; mode: FileMode = fmRead; bufSize: int = -1): File
lexbase: open(L: var BaseLexer; input: Stream; bufLen: int = 8192; refillChars: set[char] = NewLines)
memfiles: open(filename: string; mode: FileMode = fmRead; mappedSize = -1; offset = 0; newFileSize = -1; allowRemap = false; mapFlags = cint(-1)): MemFile
parsecfg: open(c: var CfgParser; input: Stream; filename: string; lineOffset = 0)
parsecsv: open(self: var CsvParser; input: Stream; filename: string; separator = ','; quote = '\"'; escape = '\x00'; skipInitialSpace = false)
parsecsv: open(self: var CsvParser; filename: string; separator = ','; quote = '\"'; escape = '\x00'; skipInitialSpace = false)
parsejson: open(my: var JsonParser; input: Stream; filename: string; rawStringLiterals = false)
parsexml: open(my: var XmlParser; input: Stream; filename: string; options: set[XmlParseOption] = {})
sexp_parse: open(parser: var SexpParser; input: Stream)
system: open[TMsg](c: var Channel[TMsg]; maxItems: int = 0)
OPEN_ALWAYS:
winlean: OPEN_ALWAYS
openArray:
system: openArray
openDefaultBrowser:
browsers: openDefaultBrowser()
browsers: openDefaultBrowser(url: string)
OPEN_EXISTING:
winlean: OPEN_EXISTING
openFileStream:
streams: openFileStream(filename: string; mode: FileMode = fmRead; bufSize: int = -1): owned FileStream
openProcess:
winlean: openProcess(dwDesiredAccess: DWORD; bInheritHandle: WINBOOL; dwProcessId: DWORD): Handle
opt:
dod_helpers: opt[T](t: typedesc[T]): untyped
Opt:
parseopt2: Opt
OptAcceptConn:
SOBool.OptAcceptConn
OptBroadcast:
SOBool.OptBroadcast
OptDebug:
SOBool.OptDebug
OptDontRoute:
SOBool.OptDontRoute
OptError:
parseopt2: OptError
optgroup:
htmlgen: optgroup(e: varargs[untyped]): untyped
option:
htmlgen: option(e: varargs[untyped]): untyped
Option:
options: Option
option:
options: option[T](val: sink T): Option[T]
OptionElement:
dom: OptionElement
OptKeepAlive:
SOBool.OptKeepAlive
OptKind:
parseopt2: OptKind
OptNoDelay:
SOBool.OptNoDelay
OptOOBInline:
SOBool.OptOOBInline
OptParser:
parseopt: OptParser
OptReuseAddr:
SOBool.OptReuseAddr
OptReusePort:
SOBool.OptReusePort
opts:
parseopt2: opts(argv: openArray[string]; shortDefault: OptValExpectation = optValNone; longDefault: OptValExpectation = optValOptional; shortVal: openArray[(char, OptValExpectation)] = []; longVal: openArray[(string, OptValExpectation)] = []; sep: set[char] = defaultOptSeparators): Opt
OptValExpectation:
parseopt2: OptValExpectation
optValNone:
OptValExpectation.optValNone
optValOptional:
OptValExpectation.optValOptional
optValRequired:
OptValExpectation.optValRequired
ord:
system: ord[T: Ordinal | enum](x: T): int
OrderedSet:
sets: OrderedSet
OrderedTable:
tables: OrderedTable
OrderedTableRef:
tables: OrderedTableRef
Ordinal:
system: Ordinal
OrdinalEnum:
typetraits: OrdinalEnum
OSError:
system: OSError
OSErrorCode:
os: OSErrorCode
osErrorMsg:
os: osErrorMsg(errorCode: OSErrorCode): string
osInvalidSocket:
nativesockets: osInvalidSocket
osLastError:
os: osLastError(): OSErrorCode
osOpenCmd:
browsers: osOpenCmd
osReleaseFile:
posix_utils: osReleaseFile(): Config
OSVERSIONINFO:
winlean: OSVERSIONINFO
out of memory:
Module system
OutConsole:
text_layouter: OutConsole
outDeg:
graph: outDeg[Id](graph: Graph[Id]; node: Id): int
outEdges:
graph: outEdges[Id](graph: Graph[Id]; source: Id): GraphEdge[Id]
outHtml:
OutputTarget.outHtml
outLatex:
OutputTarget.outLatex
OutOfMemDefect:
system: OutOfMemDefect
OutOfMemError:
system: OutOfMemError
outOfMemHook:
system: outOfMemHook
output:
htmlgen: output(e: varargs[untyped]): untyped
OutputFormatter:
unittest: OutputFormatter
outputHandle:
osproc: outputHandle(p: Process): FileHandle
OutputLevel:
unittest: OutputLevel
outputStream:
osproc: outputStream(p: Process): Stream
OutputTarget:
rstgen: OutputTarget
OverflowDefect:
system: OverflowDefect
OverflowError:
system: OverflowError
OVERLAPPED:
winlean: OVERLAPPED
owned:
system: owned(t: typedesc): typedesc
owner:
macros: owner(sym: NimNode): NimNode
p:
htmlgen: p(e: varargs[untyped]): untyped
PackedSet:
packedsets: PackedSet
PAGE_EXECUTE:
winlean: PAGE_EXECUTE
PAGE_EXECUTE_READ:
winlean: PAGE_EXECUTE_READ
PAGE_EXECUTE_READWRITE:
winlean: PAGE_EXECUTE_READWRITE
PAGE_NOACCESS:
winlean: PAGE_NOACCESS
PAGE_READONLY:
winlean: PAGE_READONLY
PAGE_READWRITE:
winlean: PAGE_READWRITE
pairs:
critbits: pairs[T](c: CritBitTree[T]): tuple[key: string, val: T]
deques: pairs[T](deq: Deque[T]): tuple[key: int, val: T]
dod_helpers: pairs(store: ValueStore): (ValueId, Value)
httpcore: pairs(headers: HttpHeaders): tuple[key, value: string]
iterators: pairs[IX, T](a: array[IX, T]): tuple[key: IX, val: T]
iterators: pairs(a: cstring): tuple[key: int, val: char]
iterators: pairs[T](a: openArray[T]): tuple[key: int, val: T]
iterators: pairs[T](a: seq[T]): tuple[key: int, val: T]
iterators: pairs(a: string): tuple[key: int, val: char]
jsffi: pairs[K: JsKey; V](assoc: JsAssoc[K, V]): (K, V)
jsffi: pairs(obj: JsObject): (cstring, JsObject)
jsformdata: pairs(self: FormData): seq[tuple[key, val: cstring]]
json: pairs(node: JsonNode): tuple[key: string, val: JsonNode]
macrocache: pairs(t: CacheTable): (string, NimNode)
macros: pairs(n: NimNode): (int, NimNode)
pegs: pairs(p: Peg): (int, Peg)
sets: pairs[A](s: OrderedSet[A]): tuple[a: int, b: A]
sexp: pairs(node: SexpNode): (int, SexpNode)
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)
text_layouter: pairs(blc: LytBlock): (int, LytBlock)
pairsWithPrefix:
critbits: pairsWithPrefix[T](c: CritBitTree[T]; prefix: string): tuple[key: string, val: T]
parallelReplace:
pegs: parallelReplace(s: string; subs: varargs[tuple[pattern: Peg, repl: string]]): string
param:
htmlgen: param(e: varargs[untyped]): untyped
paramCount:
nimscript: paramCount(): int
os: paramCount(): int
params:
macros: params(someProc: NimNode): NimNode
params=:
macros: params=(someProc: NimNode; params: NimNode)
paramStr:
nimscript: paramStr(i: int): string
os: paramStr(i: int): string
ParDir:
os: ParDir
parentDir:
os: parentDir(path: string): string
parentDirs:
os: parentDirs(path: string; fromRoot = false; inclusive = true): string
parityBits:
bitops: parityBits(x: SomeInteger): int
parse:
jscore: parse(d: DateLib; s: cstring): int
jscore: parse(l: JsonLib; s: cstring): JsRoot
times: parse(input: string; f: static[string]; zone: Timezone = local(); loc: DateTimeLocale = DefaultLocale): DateTime
times: parse(input, f: string; tz: Timezone = local(); loc: DateTimeLocale = DefaultLocale): DateTime
times: parse(input: string; f: TimeFormat; zone: Timezone = local(); loc: DateTimeLocale = DefaultLocale): DateTime
parseBiggestFloat:
parseutils: parseBiggestFloat(s: string; number: var BiggestFloat; start = 0): int
parseBiggestInt:
parseutils: parseBiggestInt(s: string; number: var BiggestInt; start = 0): int
strutils: parseBiggestInt(s: string): BiggestInt
parseBiggestUInt:
parseutils: parseBiggestUInt(s: string; number: var BiggestUInt; start = 0): int
strutils: parseBiggestUInt(s: string): BiggestUInt
parseBin:
parseutils: parseBin[T: SomeInteger](s: string; number: var T; start = 0; maxLen = 0): int
parseBinInt:
strutils: parseBinInt(s: string): int
parseBool:
strutils: parseBool(s: string): bool
parseChar:
parseutils: parseChar(s: string; c: var char; start = 0): int
parseCmdLine:
os: parseCmdLine(c: string): seq[string]
parseColor:
colors: parseColor(name: string): Color
parseCookies:
cookies: parseCookies(s: string): StringTableRef
parseEnum:
strutils: parseEnum[T: enum](s: string): T
strutils: parseEnum[T: enum](s: string; default: T): T
parseEscapedUTF16:
parsejson: parseEscapedUTF16(buf: cstring; pos: var int): int
parseExpr:
macros: parseExpr(s: string): NimNode
parseFile:
json: parseFile(filename: string): JsonNode
parseFloat:
parseutils: parseFloat(s: string; number: var float; start = 0): int
strutils: parseFloat(s: string): float
parseFromString:
dom: parseFromString(this: DomParser; str: cstring; mimeType: cstring): Document
parseHeader:
httpcore: parseHeader(line: string): tuple[key: string, value: seq[string]]
parseHex:
parseutils: parseHex[T: SomeInteger](s: string; number: var T; start = 0; maxLen = 0): int
parseHexInt:
strutils: parseHexInt(s: string): int
parseHexStr:
strutils: parseHexStr(s: string): string
parseHtml:
htmlparser: parseHtml(s: Stream): XmlNode
htmlparser: parseHtml(s: Stream; filename: string; errors: var seq[string]): XmlNode
htmlparser: parseHtml(html: string): XmlNode
parseIdent:
parseutils: parseIdent(s: string; start = 0): string
parseutils: parseIdent(s: string; ident: var string; start = 0): int
parseInt:
parseutils: parseInt(s: string; number: var int; start = 0): int
Module parseutils
strutils: parseInt(s: string): int
parseIpAddress:
net: parseIpAddress(addressStr: string): IpAddress
parseJson:
json: parseJson(s: Stream; filename: string = ""; rawIntegers = false; rawFloats = false): JsonNode
json: parseJson(buffer: string; rawIntegers = false; rawFloats = false): JsonNode
parseJsonFragments:
json: parseJsonFragments(s: Stream; filename: string = ""; rawIntegers = false; rawFloats = false): JsonNode
parseOct:
parseutils: parseOct[T: SomeInteger](s: string; number: var T; start = 0; maxLen = 0): int
parseOctInt:
strutils: parseOctInt(s: string): int
parseOid:
oids: parseOid(str: cstring): Oid
parsePeg:
pegs: parsePeg(pattern: string; filename = "pattern"; line = 1; col = 0): Peg
parseSaturatedNatural:
parseutils: parseSaturatedNatural(s: string; b: var int; start = 0): int
parseSecureHash:
sha1: parseSecureHash(hash: string): SecureHash
parseSexp:
sexp: parseSexp(s: Stream): SexpNode
sexp: parseSexp(buffer: string): SexpNode
parseSQL:
parsesql: parseSQL(input: Stream; filename: string): SqlNode
parsesql: parseSQL(input: string; filename = ""): SqlNode
parseStandardFormatSpecifier:
strformat: parseStandardFormatSpecifier(s: string; start = 0; ignoreUnknownSuffix = false): StandardFormatSpecifier
parseStmt:
macros: parseStmt(s: string): NimNode
parseTableCells:
asciitables: parseTableCells(s: string; delim = ' '): Cell
parseTime:
times: parseTime(input: string; f: static[string]; zone: Timezone): Time
times: parseTime(input, f: string; zone: Timezone): Time
parseUInt:
parseutils: parseUInt(s: string; number: var uint; start = 0): int
strutils: parseUInt(s: string): uint
parseUntil:
parseutils: parseUntil(s: string; token: var string; until: char; start = 0): int
parseutils: parseUntil(s: string; token: var string; until: set[char]; start = 0): int
parseutils: parseUntil(s: string; token: var string; until: string; start = 0): int
parseUri:
uri: parseUri(uri: string): Uri
uri: parseUri(uri: string; result: var Uri)
parseWhile:
parseutils: parseWhile(s: string; token: var string; validChars: set[char]; start = 0): int
parseXml:
xmlparser: parseXml(s: Stream; options: set[XmlParseOption] = {reportComments}): XmlNode
xmlparser: parseXml(s: Stream; filename: string; errors: var seq[string]; options: set[XmlParseOption] = {reportComments}): XmlNode
xmlparser: parseXml(str: string; options: set[XmlParseOption] = {reportComments}): XmlNode
partition:
strmisc: partition(s: string; sep: string; right: bool = false): (string, string, string)
patch:
httpclient: patch(client: HttpClient; url: Uri | string; body = ""; multipart: MultipartData = nil): Response
patchContent:
httpclient: patchContent(client: HttpClient; url: Uri | string; body = ""; multipart: MultipartData = nil): string
Path:
graph: Path
PathComponent:
os: PathComponent
PathEntry:
globs: PathEntry
PathIter:
pathnorm: PathIter
PathSep:
os: PathSep
patricia trie:
Module critbits
PBOOL:
winlean: PBOOL
pcDir:
PathComponent.pcDir
pcFile:
PathComponent.pcFile
pcLinkToDir:
PathComponent.pcLinkToDir
pcLinkToFile:
PathComponent.pcLinkToFile
PDWORD:
winlean: PDWORD
peek:
streams: peek[T](s: Stream; result: var T)
system: peek[TMsg](c: var Channel[TMsg]): int
peekableErrorStream:
osproc: peekableErrorStream(p: Process): Stream
peekableOutputStream:
osproc: peekableOutputStream(p: Process): Stream
peekBool:
streams: peekBool(s: Stream): bool
peekChar:
streams: peekChar(s: Stream): char
peekData:
streams: peekData(s: Stream; buffer: pointer; bufLen: int): int
peekExitCode:
osproc: peekExitCode(p: Process): int
peekFirst:
deques: peekFirst[T](deq: Deque[T]): lent T
deques: peekFirst[T](deq: var Deque[T]): var T
peekFloat32:
streams: peekFloat32(s: Stream): float32
peekFloat64:
streams: peekFloat64(s: Stream): float64
peekInt16:
streams: peekInt16(s: Stream): int16
peekInt32:
streams: peekInt32(s: Stream): int32
peekInt64:
streams: peekInt64(s: Stream): int64
peekInt8:
streams: peekInt8(s: Stream): int8
peekLast:
deques: peekLast[T](deq: Deque[T]): lent T
deques: peekLast[T](deq: var Deque[T]): var T
peekLine:
streams: peekLine(s: Stream): string
streams: peekLine(s: Stream; line: var string): bool
peekNamedPipe:
winlean: peekNamedPipe(hNamedPipe: Handle; lpBuffer: pointer = nil; nBufferSize: int32 = 0; lpBytesRead: ptr int32 = nil; lpTotalBytesAvail: ptr int32 = nil; lpBytesLeftThisMessage: ptr int32 = nil): bool
peekStr:
streams: peekStr(s: Stream; length: int): string
streams: peekStr(s: Stream; length: int; str: var string)
peekUint16:
streams: peekUint16(s: Stream): uint16
peekUint32:
streams: peekUint32(s: Stream): uint32
peekUint64:
streams: peekUint64(s: Stream): uint64
peekUint8:
streams: peekUint8(s: Stream): uint8
Peg:
pegs: Peg
peg:
pegs: peg(pattern: string): Peg
PegKind:
pegs: PegKind
Performance:
dom: Performance
PerformanceMemory:
dom: PerformanceMemory
PerformanceTiming:
dom: PerformanceTiming
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
PInt32:
system: PInt32
PInt64:
system: PInt64
pinToCpu:
system: pinToCpu[Arg](t: var Thread[Arg]; cpu: Natural)
PIPE_ACCESS_DUPLEX:
winlean: PIPE_ACCESS_DUPLEX
PIPE_ACCESS_INBOUND:
winlean: PIPE_ACCESS_INBOUND
PIPE_ACCESS_OUTBOUND:
winlean: PIPE_ACCESS_OUTBOUND
PIPE_NOWAIT:
winlean: PIPE_NOWAIT
PipeOutStream:
streamwrapper: PipeOutStream
piRest:
parsexml: piRest(my: XmlParser): string
pkAndPredicate:
PegKind.pkAndPredicate
pkAny:
PegKind.pkAny
pkAnyRune:
PegKind.pkAnyRune
pkBackRef:
PegKind.pkBackRef
pkBackRefIgnoreCase:
PegKind.pkBackRefIgnoreCase
pkBackRefIgnoreStyle:
PegKind.pkBackRefIgnoreStyle
pkCapture:
PegKind.pkCapture
pkCapturedSearch:
PegKind.pkCapturedSearch
pkChar:
PegKind.pkChar
pkCharChoice:
PegKind.pkCharChoice
pkEmpty:
PegKind.pkEmpty
pkGreedyAny:
PegKind.pkGreedyAny
pkGreedyRep:
PegKind.pkGreedyRep
pkGreedyRepChar:
PegKind.pkGreedyRepChar
pkGreedyRepSet:
PegKind.pkGreedyRepSet
pkLetter:
PegKind.pkLetter
pkList:
PegKind.pkList
pkLower:
PegKind.pkLower
pkNewLine:
PegKind.pkNewLine
pkNonTerminal:
PegKind.pkNonTerminal
pkNotPredicate:
PegKind.pkNotPredicate
pkOption:
PegKind.pkOption
pkOrderedChoice:
PegKind.pkOrderedChoice
pkRule:
PegKind.pkRule
pkSearch:
PegKind.pkSearch
pkSequence:
PegKind.pkSequence
pkStartAnchor:
PegKind.pkStartAnchor
pkTerminal:
PegKind.pkTerminal
pkTerminalIgnoreCase:
PegKind.pkTerminalIgnoreCase
pkTerminalIgnoreStyle:
PegKind.pkTerminalIgnoreStyle
pkTitle:
PegKind.pkTitle
pkUpper:
PegKind.pkUpper
pkWhitespace:
PegKind.pkWhitespace
play:
dom: play(e: EmbedElement)
Plugin:
dom: Plugin
poDaemon:
ProcessOption.poDaemon
poDemon:
osproc: poDemon
poEchoCmd:
ProcessOption.poEchoCmd
poEvalCommand:
ProcessOption.poEvalCommand
pointer:
system: pointer
poInteractive:
ProcessOption.poInteractive
pointerBase:
typetraits: pointerBase[T](_: typedesc[ptr T | ref T]): typedesc
polar:
complex: polar[T](z: Complex[T]): tuple[r, phi: T]
pop:
heapqueue: pop[T](heap: var HeapQueue[T]): T
reservedmem: pop[T](s: var ReservedMemSeq[T]): T
sets: pop[A](s: var HashSet[A]): A
system: pop[T](s: var seq[T]): T
tables: pop[A](t: var CountTable[A]; key: A; val: var int): bool
tables: pop[A](t: CountTableRef[A]; key: A; val: var int): bool
tables: pop[A, B](t: var OrderedTable[A, B]; key: A; val: var B): bool
tables: pop[A, B](t: OrderedTableRef[A, B]; key: A; val: var B): bool
tables: pop[A, B](t: var Table[A, B]; key: A; val: var B): bool
tables: pop[A, B](t: TableRef[A, B]; key: A; val: var B): bool
poParentStreams:
ProcessOption.poParentStreams
popcount:
bitops: popcount(x: SomeInteger): int
popFirst:
deques: popFirst[T](deq: var Deque[T]): T
popGcFrame:
system: popGcFrame()
popLast:
deques: popLast[T](deq: var Deque[T]): T
popMask:
dod_helpers: popMask(id`gensym14: ValueId): ValueId
text_layouter: popMask(id`gensym3: LytStrId): LytStrId
Port:
nativesockets: Port
portal:
htmlgen: portal(e: varargs[untyped]): untyped
Positive:
system: Positive
posixOptSeparators:
parseopt2: posixOptSeparators
post:
httpclient: post(client: HttpClient; url: Uri | string; body = ""; multipart: MultipartData = nil): Response
postContent:
httpclient: postContent(client: HttpClient; url: Uri | string; body = ""; multipart: MultipartData = nil): string
poStdErrToStdOut:
ProcessOption.poStdErrToStdOut
postfix:
macros: postfix(node: NimNode; op: string): NimNode
PostgreSQL:
Module db_postgres
postQueuedCompletionStatus:
winlean: postQueuedCompletionStatus(CompletionPort: Handle; dwNumberOfBytesTransferred: DWORD; dwCompletionKey: ULONG_PTR; lpOverlapped: pointer): bool
poUsePath:
ProcessOption.poUsePath
POVERLAPPED:
winlean: POVERLAPPED
POVERLAPPED_COMPLETION_ROUTINE:
winlean: POVERLAPPED_COMPLETION_ROUTINE
pow:
complex: pow[T](x, y: Complex[T]): Complex[T]
complex: pow[T](x: Complex[T]; y: T): Complex[T]
jscore: pow(m: MathLib; a, b: distinct SomeNumber): float
math: pow(x, y: float32): float32
math: pow(x, y: float64): float64
pragma:
macros: pragma(someProc: NimNode): NimNode
pragma=:
macros: pragma=(someProc: NimNode; val: NimNode)
pre:
htmlgen: pre(e: varargs[untyped]): untyped
pred:
system: pred[T: Ordinal](x: T; y = 1): T
preferSpawn:
threadpool: preferSpawn(): bool
prefix:
macros: prefix(node: NimNode; op: string): NimNode
prepare:
db_postgres: prepare(db: DbConn; stmtName: string; query: SqlQuery; nParams: int): SqlPrepared
db_sqlite: prepare(db: DbConn; q: string): SqlPrepared
prepareMutation:
system: prepareMutation(s: var string)
prepend:
lists: prepend[T](L: var DoublyLinkedList[T]; n: DoublyLinkedNode[T])
lists: prepend[T](L: var DoublyLinkedList[T]; value: T)
lists: prepend[T](L: var DoublyLinkedRing[T]; n: DoublyLinkedNode[T])
lists: prepend[T](L: var DoublyLinkedRing[T]; value: T)
lists: prepend[T](L: var SinglyLinkedList[T]; n: SinglyLinkedNode[T])
lists: prepend[T](L: var SinglyLinkedList[T]; value: T)
lists: prepend[T](L: var SinglyLinkedRing[T]; n: SinglyLinkedNode[T])
lists: prepend[T](L: var SinglyLinkedRing[T]; value: T)
lists: prepend[T: SomeLinkedList](a: var T; b: T)
prependMoved:
lists: prependMoved[T: SomeLinkedList](a, b: var T)
pretty:
json: pretty(node: JsonNode; indent = 2): string
sexp: pretty(node: SexpNode; indent = 2): string
prettyLink:
rstgen: prettyLink(file: string): string
preventDefault:
dom: preventDefault(ev: Event)
prevPermutation:
algorithm: prevPermutation[T](x: var openArray[T]): bool
PrimaryButton:
MouseButtons.PrimaryButton
print:
dom: print(w: Window)
PRINT_ALL:
OutputLevel.PRINT_ALL
PRINT_FAILURES:
OutputLevel.PRINT_FAILURES
printKeyCodes:
linenoise: printKeyCodes()
PRINT_NONE:
OutputLevel.PRINT_NONE
privateAccess:
importutils: privateAccess(t: typedesc)
procCall:
system: procCall(x: untyped)
Process:
osproc: Process
PROCESS_CREATE_PROCESS:
winlean: PROCESS_CREATE_PROCESS
PROCESS_CREATE_THREAD:
winlean: PROCESS_CREATE_THREAD
PROCESS_DUP_HANDLE:
winlean: PROCESS_DUP_HANDLE
processedRows:
parsecsv: processedRows(self: var CsvParser): int
processHandle:
osproc: processHandle(p: Process): int
processID:
osproc: processID(p: Process): int
PROCESS_INFORMATION:
winlean: PROCESS_INFORMATION
ProcessingInstructionNode:
NodeType.ProcessingInstructionNode
ProcessOption:
osproc: ProcessOption
PROCESS_QUERY_INFORMATION:
winlean: PROCESS_QUERY_INFORMATION
PROCESS_QUERY_LIMITED_INFORMATION:
winlean: PROCESS_QUERY_LIMITED_INFORMATION
PROCESS_SET_INFORMATION:
winlean: PROCESS_SET_INFORMATION
PROCESS_SET_LIMITED_INFORMATION:
winlean: PROCESS_SET_LIMITED_INFORMATION
PROCESS_SET_QUOTA:
winlean: PROCESS_SET_QUOTA
PROCESS_SET_SESSIONID:
winlean: PROCESS_SET_SESSIONID
PROCESS_SUSPEND_RESUME:
winlean: PROCESS_SUSPEND_RESUME
PROCESS_TERMINATE:
winlean: PROCESS_TERMINATE
PROCESS_VM_OPERATION:
winlean: PROCESS_VM_OPERATION
PROCESS_VM_READ:
winlean: PROCESS_VM_READ
PROCESS_VM_WRITE:
winlean: PROCESS_VM_WRITE
procName:
stackframes: procName(): string
prod:
math: prod[T](x: openArray[T]): T
product:
algorithm: product[T](x: openArray[seq[T]]): seq[seq[T]]
programResult:
system: programResult
progress:
htmlgen: progress(e: varargs[untyped]): untyped
ProgressChangedProc:
httpclient: ProgressChangedProc
PromiseJs:
asyncjs: PromiseJs
prompt:
dom: prompt(w: Window; text, default: cstring): cstring
Protocol:
nativesockets: Protocol
ProtocolError:
httpclient: ProtocolError
Protoent:
winlean: Protoent
protSSLv2:
SslProtVersion.protSSLv2
protSSLv23:
SslProtVersion.protSSLv23
protSSLv3:
SslProtVersion.protSSLv3
protTLSv1:
SslProtVersion.protTLSv1
Proxy:
httpclient: Proxy
PRstNode:
rstast: PRstNode
PSID:
winlean: PSID
pskIdentityHint=:
net: pskIdentityHint=(ctx: SslContext; hint: string)
PULONG:
winlean: PULONG
PULONG_PTR:
winlean: PULONG_PTR
PunyError:
punycode: PunyError
push:
heapqueue: push[T](heap: var HeapQueue[T]; item: sink T)
stats: push(r: var RunningRegress; x, y: float)
stats: push(r: var RunningRegress; x, y: int)
stats: push(r: var RunningRegress; x, y: openArray[float | int])
stats: push(s: var RunningStat; x: float)
stats: push(s: var RunningStat; x: int)
stats: push(s: var RunningStat; x: openArray[float | int])
pushGcFrame:
system: pushGcFrame(s: GcFrame)
pushpop:
heapqueue: pushpop[T](heap: var HeapQueue[T]; item: sink T): T
pushState:
dom: pushState[T](h: History; stateObject: T; title, url: cstring)
put:
httpclient: put(client: HttpClient; url: Uri | string; body = ""; multipart: MultipartData = nil): Response
jsformdata: put(self: FormData; name, value, filename: cstring)
putContent:
httpclient: putContent(client: HttpClient; url: Uri | string; body = ""; multipart: MultipartData = nil): string
putEnv:
nimscript: putEnv(key, val: string)
os: putEnv(key, val: string)
PWOHandleArray:
winlean: PWOHandleArray
q:
htmlgen: q(e: varargs[untyped]): untyped
querySelector:
dom: querySelector(d: Document; selectors: cstring): Element
dom: querySelector(n: Node; selectors: cstring): Element
querySelectorAll:
dom: querySelectorAll(d: Document; selectors: cstring): seq[Element]
dom: querySelectorAll(n: Node; selectors: cstring): seq[Element]
querySetting:
compilesettings: querySetting(setting: SingleValueSetting): string
querySettingSeq:
compilesettings: querySettingSeq(setting: MultipleValueSetting): seq[string]
quit:
system: quit(errorcode: int = QuitSuccess)
system: quit(errormsg: string; errorcode = QuitFailure)
QuitFailure:
system: QuitFailure
QuitSuccess:
system: QuitSuccess
quote:
macros: quote(bl: typed; op = "``"): NimNode
quoteShell:
os: quoteShell(s: string): string
quoteShellCommand:
os: quoteShellCommand(args: openArray[string]): string
quoteShellPosix:
os: quoteShellPosix(s: string): string
quoteShellWindows:
os: quoteShellWindows(s: string): string
radix tree:
Module critbits
radToDeg:
math: radToDeg[T: float32 | float64](d: T): T
raiseAssert:
assertions: raiseAssert(msg: string)
raiseInvalidLibrary:
dynlib: raiseInvalidLibrary(name: cstring)
raiseOSError:
os: raiseOSError(errorCode: OSErrorCode; additionalInfo = "")
raiseParseErr:
parsejson: raiseParseErr(p: JsonParser; msg: string)
sexp: raiseParseErr(p: SexpParser; msg: string)
raiseSSLError:
net: raiseSSLError(s = "")
Rand:
random: Rand
rand:
random: rand(max: float): float
random: rand[T: Ordinal or SomeFloat](x: HSlice[T, T]): T
random: rand(max: int): int
random: rand[T: Ordinal or SomeFloat](r: var Rand; x: HSlice[T, T]): T
random: rand(r: var Rand; max: Natural): int
random: rand(r: var Rand; max: range[0.0 .. high(float)]): float
random: rand[T: SomeInteger](t: typedesc[T]): T
random:
jscore: random(m: MathLib): float
randomize:
random: randomize()
random: randomize(seed: int64)
randState:
random: randState(): untyped
Range:
dom: Range
range:
system: range
rangeBase:
typetraits: rangeBase(t: typedesc): typedesc
rangeCheck:
system: rangeCheck(cond)
RangeDefect:
system: RangeDefect
RangeError:
system: RangeError
Rational:
rationals: Rational
rawData:
parsexml: rawData(my: var XmlParser): lent string
rawData2:
parsexml: rawData2(my: var XmlParser): lent string
rawEnv:
system: rawEnv[T: proc](x: T): pointer
rawMatch:
pegs: rawMatch(s: string; p: Peg; start: int; c: var Captures): int
rawProc:
system: rawProc[T: proc](x: T): pointer
rawTag:
xmltree: rawTag(n: XmlNode): string
rawText:
xmltree: rawText(n: XmlNode): string
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:
streams: read[T](s: Stream; result: var T)
readAll:
io: readAll(file: File): string
streams: readAll(s: Stream): string
readAllFromStdin:
nimscript: readAllFromStdin(): string
readAsBinaryString:
dom: readAsBinaryString(f: FileReader; b: Blob)
readAsDataURL:
dom: readAsDataURL(f: FileReader; b: Blob)
readAsText:
dom: readAsText(f: FileReader; b: Blob | File; encoding = cstring"UTF-8")
readBool:
streams: readBool(s: Stream): bool
readBuffer:
io: readBuffer(f: File; buffer: pointer; len: Natural): int
readBytes:
io: readBytes(f: File; a: var openArray[int8 | uint8]; start, len: Natural): int
readChar:
io: readChar(f: File): char
streams: readChar(s: Stream): char
readChars:
io: readChars(f: File; a: var openArray[char]): int
io: readChars(f: File; a: var openArray[char]; start, len: Natural): int
readConsoleInput:
winlean: readConsoleInput(hConsoleInput: Handle; lpBuffer: pointer; nLength: cint; lpNumberOfEventsRead: ptr cint): cint
readData:
cgi: readData(allowedMethods: set[RequestMethod] = {methodNone, methodPost, methodGet}): StringTableRef
cgi: readData(data: string): StringTableRef
streams: readData(s: Stream; buffer: pointer; bufLen: int): int
readDataStr:
streams: readDataStr(s: Stream; buffer: var string; slice: Slice[int]): int
ReadDbEffect:
db_common: ReadDbEffect
ReadDirEffect:
os: ReadDirEffect
ReadDisconnected:
ReadLineResult.ReadDisconnected
ReadEnvEffect:
os: ReadEnvEffect
readFile:
io: readFile(filename: string): string
winlean: readFile(hFile: Handle; buffer: pointer; nNumberOfBytesToRead: int32; lpNumberOfBytesRead: ptr int32; lpOverlapped: pointer): WINBOOL
readFloat32:
streams: readFloat32(s: Stream): float32
readFloat64:
streams: readFloat64(s: Stream): float64
ReadFullLine:
ReadLineResult.ReadFullLine
readHeaderRow:
parsecsv: readHeaderRow(self: var CsvParser)
readInt16:
streams: readInt16(s: Stream): int16
readInt32:
streams: readInt32(s: Stream): int32
readInt64:
streams: readInt64(s: Stream): int64
readInt8:
streams: readInt8(s: Stream): int8
ReadIOEffect:
system: ReadIOEffect
readLine:
io: readLine(f: File): string
io: readLine(f: File; line: var string): bool
linenoise: readLine(prompt: cstring): cstring
net: readLine(socket: Socket; line: var string; timeout = -1; flags = {SocketFlag.SafeDisconn}; maxLength = MaxLineLength)
streams: readLine(s: Stream): string
streams: readLine(s: Stream; line: var string): bool
readLineFromStdin:
nimscript: readLineFromStdin(): string
rdstdin: readLineFromStdin(prompt: string): string
rdstdin: readLineFromStdin(prompt: string; line: var string): bool
ReadLineResult:
linenoise: ReadLineResult
net: ReadLineResult
readLines:
io: readLines(filename: string; n: Natural): seq[string]
io: readLines(filename: string): seq[string]
osproc: readLines(p: Process): (seq[string], int)
readLineStatus:
linenoise: readLineStatus(prompt: string; result: var ReadLineResult)
ReadNone:
ReadLineResult.ReadNone
ReadPartialLine:
ReadLineResult.ReadPartialLine
readPasswordFromStdin:
terminal: readPasswordFromStdin(prompt = "password: "): string
terminal: readPasswordFromStdin(prompt: string; password: var string): bool
readRow:
parsecsv: readRow(self: var CsvParser; columns = 0): bool
ReadSocketStream:
socketstreams: ReadSocketStream
ReadSocketStreamObj:
socketstreams: ReadSocketStreamObj
readStr:
streams: readStr(s: Stream; length: int): string
streams: readStr(s: Stream; length: int; str: var string)
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:
system: ready[TMsg](c: var Channel[TMsg]): bool
ReadyKey:
selectors: ReadyKey
readyState:
dom: readyState(f: FileReader): FileReaderState
realloc:
system: realloc(p: pointer; newSize: Natural): pointer
realloc0:
system: realloc0(p: pointer; oldSize, newSize: Natural): pointer
realloc0Impl:
system: realloc0Impl(p: pointer; oldSize, newSize: Natural): pointer
reallocImpl:
system: reallocImpl(p: pointer; newSize: Natural): pointer
reallocShared:
system: reallocShared(p: pointer; newSize: Natural): pointer
reallocShared0:
system: reallocShared0(p: pointer; oldSize, newSize: Natural): pointer
reallocShared0Impl:
system: reallocShared0Impl(p: pointer; oldSize, newSize: Natural): pointer
reallocSharedImpl:
system: reallocSharedImpl(p: pointer; newSize: Natural): pointer
REALTIME_PRIORITY_CLASS:
winlean: REALTIME_PRIORITY_CLASS
reciprocal:
rationals: reciprocal[T](x: Rational[T]): Rational[T]
rect:
complex: rect[T](r, phi: T): Complex[T]
recursiveNodeVisiting:
ast_pattern_matching: recursiveNodeVisiting(arg: NimNode; callback: proc (arg: NimNode): bool)
recv:
net: recv(socket: Socket; size: int; timeout = -1; flags = {SocketFlag.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 = {SocketFlag.SafeDisconn}): int
system: recv[TMsg](c: var Channel[TMsg]): TMsg
winlean: recv(s: SocketHandle; buf: pointer; len, flags: cint): cint
recvFrom:
net: recvFrom[T: string | IpAddress](socket: Socket; data: var string; length: int; address: var T; port: var Port; flags = 0'i32): int
recvfrom:
winlean: recvfrom(s: SocketHandle; buf: cstring; len, flags: cint; fromm: ptr SockAddr; fromlen: ptr SockLen): cint
recvLine:
net: recvLine(socket: Socket; timeout = -1; flags = {SocketFlag.SafeDisconn}; maxLength = MaxLineLength): string
reDotAll:
RegexFlag.reDotAll
reduce:
rationals: reduce[T: SomeInteger](x: var Rational[T])
reExtended:
RegexFlag.reExtended
Regex:
nre: Regex
re: Regex
RegexError:
nre: RegexError
re: RegexError
RegexFlag:
re: RegexFlag
RegexInternalError:
nre: RegexInternalError
RegexMatch:
nre: RegexMatch
RegExp:
jsre: RegExp
register:
mimetypes: register(mimedb: var MimeDB; ext: string; mimetype: string)
registerEvent:
selectors: registerEvent[T](s: Selector[T]; ev: SelectEvent; data: T)
registerHandle:
selectors: registerHandle[T](s: Selector[T]; fd: int | SocketHandle; events: set[Event]; data: T)
registerProcess:
selectors: registerProcess[T](s: Selector[T]; pid: int; data: T): int
registerProtocolHandler:
dom: registerProtocolHandler(self: Navigator; scheme, url, title: cstring)
registerSignal:
selectors: registerSignal[T](s: Selector[T]; signal: int; data: T): int
registerTimer:
selectors: registerTimer[T](s: Selector[T]; timeout: int; oneshot: bool; data: T): int
registerVnode:
selectors: registerVnode[T](s: Selector[T]; fd: cint; events: set[Event]; data: T)
registerWaitForSingleObject:
winlean: registerWaitForSingleObject(phNewWaitObject: ptr Handle; hObject: Handle; Callback: WAITORTIMERCALLBACK; Context: pointer; dwMilliseconds: ULONG; dwFlags: ULONG): bool
reIgnoreCase:
RegexFlag.reIgnoreCase
relativePath:
os: relativePath(path, base: string; sep = DirSep): string
release:
locks: release(lock: var Lock)
rlocks: release(lock: var RLock)
reload:
dom: reload(loc: Location)
remainingArgs:
parseopt: remainingArgs(p: OptParser): seq[string]
remove:
dom: remove(c: ClassList; class: cstring)
dom: remove(child: Node)
lists: remove[T](L: var DoublyLinkedList[T]; n: DoublyLinkedNode[T])
lists: remove[T](L: var DoublyLinkedRing[T]; n: DoublyLinkedNode[T])
lists: remove[T](L: var SinglyLinkedList[T]; n: SinglyLinkedNode[T]): bool
removeAllRanges:
dom: removeAllRanges(s: Selection)
removeAttribute:
dom: removeAttribute(n: Node; attr: cstring)
removeAttributeNode:
dom: removeAttributeNode(n, attr: Node)
removeChild:
dom: removeChild(n, child: Node)
removeDir:
os: removeDir(dir: string; checkDir = false)
removeDirectoryW:
winlean: removeDirectoryW(lpPathName: WideCString): int32
removeEdge:
graph: removeEdge[Id](graph: var Graph[Id]; edge: GraphEdge[Id])
removeEventListener:
dom: removeEventListener(et: EventTarget; ev: cstring; cb: proc (ev: Event))
removeFile:
os: removeFile(file: string)
removeItem:
dom: removeItem(s: Storage; key: cstring)
removeNode:
graph: removeNode[Id](graph: var Graph[Id]; node: Id)
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 files:
Module os
renderCodeLang:
rstgen: renderCodeLang(result: var string; lang: SourceLanguage; code: string; target: OutputTarget)
renderIndexTerm:
rstgen: renderIndexTerm(d: PDoc; n: PRstNode; result: var string)
renderNimCode:
rstgen: renderNimCode(result: var string; code: string; target: OutputTarget)
renderRstToJson:
rstast: renderRstToJson(node: PRstNode): string
renderRstToOut:
rstgen: renderRstToOut(d: var RstGenerator; n: PRstNode; result: var string)
renderRstToRst:
rstast: renderRstToRst(n: PRstNode; result: var string)
renderRstToText:
rstast: renderRstToText(node: PRstNode): string
renderSQL:
parsesql: renderSQL(n: SqlNode; upperCase = false): string
renderTocEntries:
rstgen: renderTocEntries(d: var RstGenerator; j: var int; lvl: int; result: var string)
reopen:
io: reopen(f: File; filename: string; mode: FileMode = fmRead): bool
repeat:
sequtils: repeat[T](x: T; n: Natural): seq[T]
strutils: repeat(c: char; count: Natural): string
strutils: repeat(s: string; n: Natural): string
unicode: repeat(c: Rune; count: Natural): string
replace:
dom: replace(loc: Location; s: cstring)
heapqueue: replace[T](heap: var HeapQueue[T]; item: sink T): T
jsre: replace(pattern: cstring; self: RegExp; replacement: cstring): cstring
nre: replace(str: string; pattern: Regex; subproc: proc (match: RegexMatch): string): string
nre: replace(str: string; pattern: Regex; subproc: proc (match: string): string): string
nre: replace(str: string; pattern: Regex; sub: string): string
pegs: replace(s: string; sub: Peg; cb: proc (match: int; cnt: int; caps: openArray[string]): string): string
pegs: replace(s: string; sub: Peg; by = ""): string
re: replace(s: string; sub: Regex; by = ""): string
strutils: replace(s: string; sub, by: char): string
strutils: replace(s, sub: string; by = ""): string
replaceChild:
dom: replaceChild(n, newNode, oldNode: Node)
replaceData:
dom: replaceData(n: Node; start, len: int; text: cstring)
replacef:
pegs: replacef(s: string; sub: Peg; by: string): string
re: replacef(s: string; sub: Regex; by: string): string
replaceWord:
strutils: replaceWord(s, sub: string; by = ""): string
ReplyError:
smtp: ReplyError
reportComments:
XmlParseOption.reportComments
reportValidity:
dom: reportValidity(e: FormElement): bool
reportWhitespace:
XmlParseOption.reportWhitespace
request:
httpclient: request(client: HttpClient; url: Uri | string; httpMethod: HttpMethod = HttpGet; body = ""; headers: HttpHeaders = nil; multipart: MultipartData = nil): Response
Request:
jsfetch: Request
requestAnimationFrame:
dom: requestAnimationFrame(w: Window; function: proc (time: float)): int
RequestMethod:
cgi: RequestMethod
require:
jsffi: require(module: cstring): JsObject
unittest: require(conditions: untyped)
ReraiseDefect:
system: ReraiseDefect
ReraiseError:
system: ReraiseError
ReservedMem:
reservedmem: ReservedMem
ReservedMemSeq:
reservedmem: ReservedMemSeq
reset:
dom: reset(f: FormElement)
system: reset[T](obj: var T)
resetAttributes:
terminal: resetAttributes()
terminal: resetAttributes(f: File)
resetOutputFormatters:
unittest: resetOutputFormatters()
resetStream:
socketstreams: resetStream(s: ReadSocketStream)
socketstreams: resetStream(s: WriteSocketStream)
resetStyle:
TerminalCmd.resetStyle
resize:
memfiles: resize(f: var MemFile; newFileSize: int)
system: resize[T](p: ptr T; newSize: Natural): ptr T
resizeBy:
dom: resizeBy(w: Window; x, y: int)
resizeShared:
system: resizeShared[T](p: ptr T; newSize: Natural): ptr T
resizeTo:
dom: resizeTo(w: Window; x, y: int)
resource:
Module system
ResourceExhaustedError:
system: ResourceExhaustedError
Response:
httpclient: Response
jsfetch: Response
reStructuredText:
Module rstast
Module rstgen
reStudy:
RegexFlag.reStudy
Result:
results: Result
resultAsString:
dom: resultAsString(f: FileReader): cstring
ResultError:
results: ResultError
ResultErrorRef:
results: ResultErrorRef
resume:
osproc: resume(p: Process)
resumeThread:
winlean: resumeThread(hThread: Handle): int32
retryCall:
gitutils: retryCall(maxRetry = 3; backoffDuration = 1.0; call: untyped): bool
reverse:
algorithm: reverse[T](a: var openArray[T])
algorithm: reverse[T](a: var openArray[T]; first, last: Natural)
reverseBits:
bitops: reverseBits[T: SomeUnsignedInt](x: T): T
reversed:
algorithm: reversed[T](a: openArray[T]): seq[T]
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
ritems:
colortext: ritems(text: ColText): ColRune
graph: ritems[T](s: openArray[T]): T
RLock:
rlocks: RLock
rmDir:
nimscript: rmDir(dir: string; checkDir = false)
rmFile:
nimscript: rmFile(file: string)
rmpairs:
text_layouter: rmpairs[T](s: var seq[T]): (int, var T)
rnAdmonition:
RstNodeKind.rnAdmonition
rnBlockQuote:
RstNodeKind.rnBlockQuote
rnBulletItem:
RstNodeKind.rnBulletItem
rnBulletList:
RstNodeKind.rnBulletList
rnCitation:
RstNodeKind.rnCitation
rnCodeBlock:
RstNodeKind.rnCodeBlock
rnCodeFragment:
RstNodeKind.rnCodeFragment
rnContainer:
RstNodeKind.rnContainer
rnContents:
RstNodeKind.rnContents
rnDefaultRole:
RstNodeKind.rnDefaultRole
rnDefBody:
RstNodeKind.rnDefBody
rnDefItem:
RstNodeKind.rnDefItem
rnDefList:
RstNodeKind.rnDefList
rnDefName:
RstNodeKind.rnDefName
rnDescription:
RstNodeKind.rnDescription
rnDirArg:
RstNodeKind.rnDirArg
rnDirective:
RstNodeKind.rnDirective
rnEmphasis:
RstNodeKind.rnEmphasis
rnEnumItem:
RstNodeKind.rnEnumItem
rnEnumList:
RstNodeKind.rnEnumList
rnField:
RstNodeKind.rnField
rnFieldBody:
RstNodeKind.rnFieldBody
rnFieldList:
RstNodeKind.rnFieldList
rnFieldName:
RstNodeKind.rnFieldName
rnFigure:
RstNodeKind.rnFigure
rnFootnote:
RstNodeKind.rnFootnote
rnFootnoteGroup:
RstNodeKind.rnFootnoteGroup
rnFootnoteRef:
RstNodeKind.rnFootnoteRef
rnGridTable:
RstNodeKind.rnGridTable
rnHeadline:
RstNodeKind.rnHeadline
rnHyperlink:
RstNodeKind.rnHyperlink
rnIdx:
RstNodeKind.rnIdx
rnImage:
RstNodeKind.rnImage
rnIndex:
RstNodeKind.rnIndex
rnInlineCode:
RstNodeKind.rnInlineCode
rnInlineLiteral:
RstNodeKind.rnInlineLiteral
rnInlineTarget:
RstNodeKind.rnInlineTarget
rnInner:
RstNodeKind.rnInner
rnInternalRef:
RstNodeKind.rnInternalRef
rnInterpretedText:
RstNodeKind.rnInterpretedText
rnLeaf:
RstNodeKind.rnLeaf
rnLineBlock:
RstNodeKind.rnLineBlock
rnLineBlockItem:
RstNodeKind.rnLineBlockItem
rnLiteralBlock:
RstNodeKind.rnLiteralBlock
rnMarkdownHeadline:
RstNodeKind.rnMarkdownHeadline
rnMarkdownTable:
RstNodeKind.rnMarkdownTable
rnOption:
RstNodeKind.rnOption
rnOptionArgument:
RstNodeKind.rnOptionArgument
rnOptionGroup:
RstNodeKind.rnOptionGroup
rnOptionList:
RstNodeKind.rnOptionList
rnOptionListItem:
RstNodeKind.rnOptionListItem
rnOptionString:
RstNodeKind.rnOptionString
rnOverline:
RstNodeKind.rnOverline
rnParagraph:
RstNodeKind.rnParagraph
rnQuotedLiteralBlock:
RstNodeKind.rnQuotedLiteralBlock
rnRaw:
RstNodeKind.rnRaw
rnRawHtml:
RstNodeKind.rnRawHtml
rnRawLatex:
RstNodeKind.rnRawLatex
rnRef:
RstNodeKind.rnRef
rnSmiley:
RstNodeKind.rnSmiley
rnStandaloneHyperlink:
RstNodeKind.rnStandaloneHyperlink
rnStrongEmphasis:
RstNodeKind.rnStrongEmphasis
rnSub:
RstNodeKind.rnSub
rnSubstitutionDef:
RstNodeKind.rnSubstitutionDef
rnSubstitutionReferences:
RstNodeKind.rnSubstitutionReferences
rnSup:
RstNodeKind.rnSup
rnTable:
RstNodeKind.rnTable
rnTableDataCell:
RstNodeKind.rnTableDataCell
rnTableHeaderCell:
RstNodeKind.rnTableHeaderCell
rnTableRow:
RstNodeKind.rnTableRow
rnTitle:
RstNodeKind.rnTitle
rnTransition:
RstNodeKind.rnTransition
rnTripleEmphasis:
RstNodeKind.rnTripleEmphasis
rnUnknownRole:
RstNodeKind.rnUnknownRole
RollingFileLogger:
logging: RollingFileLogger
roof:
Module system
RootEffect:
system: RootEffect
RootNodeOptions:
dom: RootNodeOptions
RootObj:
system: RootObj
RootRef:
system: RootRef
Rope:
ropes: Rope
rope:
ropes: rope(f: BiggestFloat): Rope
ropes: rope(i: BiggestInt): Rope
ropes: rope(s: string = ""): Rope
Module ropes
rotatedLeft:
algorithm: rotatedLeft[T](arg: openArray[T]; slice: HSlice[int, int]; dist: int): seq[T]
algorithm: rotatedLeft[T](arg: openArray[T]; dist: int): seq[T]
rotateLeft:
algorithm: rotateLeft[T](arg: var openArray[T]; slice: HSlice[int, int]; dist: int): int
algorithm: rotateLeft[T](arg: var openArray[T]; dist: int): int
rotateLeftBits:
bitops: rotateLeftBits[T: SomeUnsignedInt](value: T; shift: range[0 .. (sizeof(T) * 8)]): T
rotateRightBits:
bitops: rotateRightBits[T: SomeUnsignedInt](value: T; shift: range[0 .. (sizeof(T) * 8)]): T
round:
jscore: round(m: MathLib; f: SomeFloat): int
math: round(x: float32): float32
math: round(x: float64): float64
math: round[T: float32 | float64](x: T; places: int): T
routeEvent:
dom: routeEvent(d: Document; event: Event)
dom: routeEvent(w: Window; event: Event)
RoutineNodes:
macros: RoutineNodes
Row:
db_mysql: Row
db_odbc: Row
db_postgres: Row
db_sqlite: Row
rowEntry:
parsecsv: rowEntry(self: var CsvParser; entry: string): var string
rows:
db_mysql: rows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
db_odbc: rows(db: var DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
db_postgres: rows(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): Row
db_postgres: rows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
db_sqlite: rows(db: DbConn; stmtName: SqlPrepared): Row
db_sqlite: rows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
rp:
htmlgen: rp(e: varargs[untyped]): untyped
rpartition:
strmisc: rpartition(s: string; sep: string): (string, string, string)
rsplit:
strutils: rsplit(s: string; sep: char; maxsplit: int = -1): seq[string]
strutils: rsplit(s: string; seps: set[char] = Whitespace; maxsplit: int = -1): seq[string]
strutils: rsplit(s: string; sep: string; maxsplit: int = -1): seq[string]
strutils: rsplit(s: string; sep: char; maxsplit: int = -1): string
strutils: rsplit(s: string; seps: set[char] = Whitespace; maxsplit: int = -1): string
strutils: rsplit(s: string; sep: string; maxsplit: int = -1; keepSeparators: bool = false): string
RstGenerator:
rstgen: RstGenerator
RstNode:
rstast: RstNode
RstNodeKind:
rstast: RstNodeKind
RstNodeSeq:
rstast: RstNodeSeq
rstToHtml:
rstgen: rstToHtml(s: string; options: RstParseOptions; config: StringTableRef; msgHandler: MsgHandler = rst.defaultMsgHandler): string
rstToLatex:
rstgen: rstToLatex(rstSource: string; options: RstParseOptions): string
rt:
htmlgen: rt(e: varargs[untyped]): untyped
RtArray:
rtarrays: RtArray
rtc:
htmlgen: rtc(e: varargs[untyped]): untyped
RTTI:
Module typeinfo
ruby:
htmlgen: ruby(e: varargs[untyped]): untyped
rule:
pegs: rule(nt: NonTerminal): Peg
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
runnable example:
Module system
runnableExamples:
system: runnableExamples(rdoccmd = ""; body: untyped)
running:
osproc: running(p: Process): bool
system: running[TArg](t: Thread[TArg]): bool
RunningRegress:
stats: RunningRegress
RunningStat:
stats: RunningStat
runtime type information:
Module typeinfo
s:
htmlgen: s(e: varargs[untyped]): untyped
sameFile:
os: sameFile(path1, path2: string): bool
sameFileContent:
os: sameFileContent(path1, path2: string): bool
SameSite:
cookies: SameSite
sameType:
macros: sameType(a, b: NimNode): bool
samp:
htmlgen: samp(e: varargs[untyped]): untyped
sample:
random: sample[T](a: openArray[T]): lent T
random: sample[T, U](a: openArray[T]; cdf: openArray[U]): T
random: sample[T](r: var Rand; a: openArray[T]): T
random: sample[T, U](r: var Rand; a: openArray[T]; cdf: openArray[U]): T
random: sample[T](r: var Rand; s: set[T]): T
random: sample[T](s: set[T]): T
scanf:
strscans: scanf(input: string; pattern: static[string]; results: varargs[typed]): bool
Module strscans
scanp:
strscans: scanp(input, idx: typed; pattern: varargs[untyped]): bool
scanSSLCertificates:
ssl_certs: scanSSLCertificates(useEnvVars = false): string
scanTuple:
strscans: scanTuple(input: untyped; pattern: static[string]; matcherTypes: varargs[untyped]): untyped
SCons:
SexpNodeKind.SCons
screen:
dom: screen
script:
htmlgen: script(e: varargs[untyped]): untyped
ScriptExt:
os: ScriptExt
ScriptMode:
nimscript: ScriptMode
ScrollBars:
dom: ScrollBars
scrollBy:
dom: scrollBy(w: Window; x, y: int)
scrollHeight:
dom: scrollHeight(e: Node): int
scrollIntoView:
dom: scrollIntoView(n: Node)
dom: scrollIntoView(n: Node; options: ScrollIntoViewOptions)
ScrollIntoViewOptions:
dom: ScrollIntoViewOptions
scrollLeft:
dom: scrollLeft(e: Node): int
scrollTo:
dom: scrollTo(w: Window; x, y: int)
scrollTop:
dom: scrollTop(e: Node): int
scrollTop=:
dom: scrollTop=(e: Node; value: int)
scrollWidth:
dom: scrollWidth(e: Node): int
sdiffPart:
sexp_diff: sdiffPart(index: int): SexpPathPart
sexp_diff: sdiffPart(key: string): SexpPathPart
searchExtPos:
os: searchExtPos(path: string): int
sec:
complex: sec[T](z: Complex[T]): Complex[T]
math: sec[T: float32 | float64](x: T): T
sech:
complex: sech[T](z: Complex[T]): Complex[T]
math: sech[T: float32 | float64](x: T): T
second:
times: second(dt: DateTime): SecondRange
SecondaryButton:
MouseButtons.SecondaryButton
SecondRange:
times: SecondRange
Seconds:
TimeUnit.Seconds
seconds:
times: seconds(s: int): TimeInterval
section:
htmlgen: section(e: varargs[untyped]): untyped
sections:
parsecfg: sections(dict: Config): lent string
SecureHash:
sha1: SecureHash
secureHash:
sha1: secureHash(str: openArray[char]): SecureHash
secureHashFile:
sha1: secureHashFile(filename: string): SecureHash
SECURITY_ATTRIBUTES:
winlean: SECURITY_ATTRIBUTES
SECURITY_BUILTIN_DOMAIN_RID:
winlean: SECURITY_BUILTIN_DOMAIN_RID
SECURITY_NT_AUTHORITY:
winlean: SECURITY_NT_AUTHORITY
sekDelete:
SeqEditKind.sekDelete
sekInsert:
SeqEditKind.sekInsert
sekKeep:
SeqEditKind.sekKeep
sekNone:
SeqEditKind.sekNone
sekReplace:
SeqEditKind.sekReplace
sekTranspose:
SeqEditKind.sekTranspose
select:
dom: select(e: Element)
htmlgen: select(e: varargs[untyped]): untyped
selectors: select[T](s: Selector[T]; timeout: int): seq[ReadyKey]
winlean: select(nfds: cint; readfds, writefds, exceptfds: ptr TFdSet; timeout: ptr Timeval): cint
SelectEvent:
selectors: SelectEvent
selectInto:
selectors: selectInto[T](s: Selector[T]; timeout: int; results: var openArray[ReadyKey]): int
Selection:
dom: Selection
Selector:
selectors: Selector
selectRead:
nativesockets: selectRead(readfds: var seq[SocketHandle]; timeout = 500): int
selectWrite:
nativesockets: selectWrite(writefds: var seq[SocketHandle]; timeout = 500): int
selfExe:
nimscript: selfExe(): string
selfExec:
nimscript: selfExec(command: string)
semantics:
htmlgen: semantics(e: varargs[untyped]): untyped
send:
net: send(socket: Socket; data: pointer; size: int): int
net: send(socket: Socket; data: string; flags = {SocketFlag.SafeDisconn})
system: send[TMsg](c: var Channel[TMsg]; msg: sink TMsg)
winlean: send(s: SocketHandle; buf: pointer; len, flags: cint): cint
sendBeacon:
dom: sendBeacon(self: Navigator; url, data: cstring): bool
sendMail:
smtp: sendMail(smtp: Smtp; fromAddr: string; toAddrs: seq[string]; msg: string)
sendSignal:
posix_utils: sendSignal(pid: Pid; signal: int)
sendTo:
net: sendTo(socket: Socket; address: IpAddress; port: Port; data: string; flags = 0'i32): int
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
SeqEdit:
diff: SeqEdit
SeqEditKind:
diff: SeqEditKind
sequence:
pegs: sequence(a: varargs[Peg]): Peg
serialization:
Module marshal
Servent:
nativesockets: Servent
winlean: Servent
serverGetPskFunc:
net: serverGetPskFunc(ctx: SslContext): SslServerGetPskFunc
serverGetPskFunc=:
net: serverGetPskFunc=(ctx: SslContext; fun: SslServerGetPskFunc)
sessionIdContext=:
net: sessionIdContext=(ctx: SslContext; sidCtx: string)
set:
system: set
setAttr:
dom: setAttr(n: Node; key, val: cstring)
setAttribute:
dom: setAttribute(n: Node; name, value: cstring)
setAttributeNode:
dom: setAttributeNode(n: Node; attr: Node)
setBackgroundColor:
terminal: setBackgroundColor(f: File; bg: BackgroundColor; bright = false)
terminal: setBackgroundColor(f: File; color: Color)
terminal: setBackgroundColor(bg: BackgroundColor; bright = false)
terminal: setBackgroundColor(color: Color)
setBiggestFloat:
typeinfo: setBiggestFloat(x: Any; y: BiggestFloat)
setBiggestInt:
typeinfo: setBiggestInt(x: Any; y: BiggestInt)
setBiggestUint:
typeinfo: setBiggestUint(x: Any; y: uint64)
setBit:
bitops: setBit[T: SomeInteger](v: var T; bit: BitsRange[T])
setBits:
bitops: setBits(v: typed; bits: varargs[typed]): untyped
setBlocking:
nativesockets: setBlocking(s: SocketHandle; blocking: bool)
setCompletionCallback:
linenoise: setCompletionCallback(a2: CompletionCallback)
setControlCHook:
system: setControlCHook(hook: proc () {.noconv.})
setCookie:
cgi: setCookie(name, value: string)
cookies: setCookie(key, value: string; expires: DateTime | Time; domain = ""; path = ""; noName = false; secure = false; httpOnly = false; maxAge = none(int); sameSite = SameSite.Default): string
cookies: setCookie(key, value: string; domain = ""; path = ""; expires = ""; noName = false; secure = false; httpOnly = false; maxAge = none(int); sameSite = SameSite.Default): string
setCurrentDir:
os: setCurrentDir(newDir: string)
setCurrentDirectoryW:
winlean: setCurrentDirectoryW(lpPathName: WideCString): int32
setCurrentException:
system: setCurrentException(exc: ref Exception)
setCursorPos:
terminal: setCursorPos(f: File; x, y: int)
terminal: setCursorPos(x, y: int)
setCursorXPos:
terminal: setCursorXPos(f: File; x: int)
terminal: setCursorXPos(x: int)
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:
winlean: setEvent(hEvent: Handle): cint
setExtraData:
net: setExtraData(ctx: SslContext; index: int; data: RootRef)
setFileAttributesW:
winlean: setFileAttributesW(lpFileName: WideCString; dwFileAttributes: int32): WINBOOL
setFilePermissions:
os: setFilePermissions(filename: string; permissions: set[FilePermission]; followSymlinks = true)
setFilePointer:
winlean: setFilePointer(hFile: Handle; lDistanceToMove: LONG; lpDistanceToMoveHigh: ptr LONG; dwMoveMethod: DWORD): DWORD
setFilePos:
io: setFilePos(f: File; pos: int64; relativeTo: FileSeekPos = fspSet)
setFileTime:
winlean: setFileTime(hFile: Handle; lpCreationTime: LPFILETIME; lpLastAccessTime: LPFILETIME; lpLastWriteTime: LPFILETIME): WINBOOL
setForegroundColor:
terminal: setForegroundColor(f: File; color: Color)
terminal: setForegroundColor(f: File; fg: ForegroundColor; bright = false)
terminal: setForegroundColor(color: Color)
terminal: setForegroundColor(fg: ForegroundColor; bright = false)
setFrame:
system: setFrame(s: PFrame)
setFrameMsg:
stackframes: setFrameMsg(msg: string; prefix = " ")
setFrameState:
system: setFrameState(state: FrameState)
setFullYear:
jscore: setFullYear(d: DateTime; year: int)
setGcFrame:
system: setGcFrame(s: GcFrame)
setHandleInformation:
winlean: setHandleInformation(hObject: Handle; dwMask: DWORD; dwFlags: DWORD): WINBOOL
setIndexTerm:
rstgen: setIndexTerm(d: var RstGenerator; htmlFile, id, term: string; linkTitle, linkDesc = "")
setInheritable:
io: setInheritable(f: FileHandle; inheritable: bool): bool
nativesockets: setInheritable(s: SocketHandle; inheritable: bool): bool
setInterval:
dom: setInterval(action: proc (); ms: int): Interval
dom: setInterval(w: Window; code: cstring; pause: int): Interval
dom: setInterval(w: Window; function: proc (); pause: int): Interval
setItem:
dom: setItem(s: Storage; key, value: cstring)
setLastError:
winlean: setLastError(error: int32)
setLastModificationTime:
os: setLastModificationTime(file: string; t: times.Time)
setLen:
reservedmem: setLen(m: var ReservedMem; newLen: int)
reservedmem: setLen[T](s: var ReservedMemSeq[T]; newLen: int)
system: setLen[T](s: var seq[T]; newlen: Natural)
system: setLen(s: var string; newlen: Natural)
setLogFilter:
logging: setLogFilter(lvl: Level)
setMask:
bitops: setMask[T: SomeInteger](v: var T; slice: Slice[int])
bitops: setMask[T: SomeInteger](v: var T; mask: T)
dod_helpers: setMask(id`gensym14: var ValueId; mask`gensym14: ValueIdMask)
text_layouter: setMask(id`gensym3: var LytStrId; mask`gensym3: LytStrIdMask)
setMasked:
bitops: setMasked[T: SomeInteger](v: T; slice: Slice[int]): T
bitops: setMasked[T: SomeInteger](v, mask: T): T
setMaxPoolSize:
threadpool: setMaxPoolSize(size: range[1 .. MaxThreadPoolSize])
setMinPoolSize:
threadpool: setMinPoolSize(size: range[1 .. MaxThreadPoolSize])
setMultiLine:
linenoise: setMultiLine(ml: cint)
setObjectRuntimeType:
typeinfo: setObjectRuntimeType(x: Any)
setPointer:
typeinfo: setPointer(x: Any; y: pointer)
setPosition:
streams: setPosition(s: Stream; pos: int)
setProgramResult:
exitprocs: setProgramResult(a: int)
setProperty:
dom: setProperty(s: Style; property, value: cstring; priority = "")
setRangeText:
dom: setRangeText(e: InputElement; replacement: cstring; startindex: int = 0; endindex: int = 0; selectionMode: cstring = "preserve")
setSamplingFrequency:
nimprof: setSamplingFrequency(intervalInUs: int)
setSectionKey:
parsecfg: setSectionKey(dict: var Config; section, key, value: string)
setSelectionRange:
dom: setSelectionRange(e: InputElement; selectionStart: int; selectionEnd: int; selectionDirection: cstring = "none")
setSlice:
strbasics: setSlice(s: var string; slice: Slice[int])
setSockOpt:
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:
colortext: setStyle(text: var ColText; new: ColStyle; override: bool = true)
terminal: setStyle(f: File; style: set[Style])
terminal: setStyle(style: set[Style])
setTestData:
cgi: setTestData(keysvalues: varargs[string])
setTimeout:
dom: setTimeout(action: proc (); ms: int): TimeOut
dom: setTimeout(w: Window; code: cstring; pause: int): TimeOut
dom: setTimeout(w: Window; function: proc (); pause: int): Interval
setUnicodeValue:
registry: setUnicodeValue(path, key, val: string; handle: HKEY)
setupForeignThreadGc:
system: setupForeignThreadGc()
sexp:
sexp: sexp(keyword: (string, SexpNode)): SexpNode
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_parse: SexpError
SexpEventKind:
sexp_parse: SexpEventKind
sexpFloat:
SexpEventKind.sexpFloat
sexpInt:
SexpEventKind.sexpInt
sexpKeyword:
SexpEventKind.sexpKeyword
sexpListEnd:
SexpEventKind.sexpListEnd
sexpListStart:
SexpEventKind.sexpListStart
SexpMismatch:
sexp_diff: SexpMismatch
SexpMismatchKind:
sexp_diff: SexpMismatchKind
sexpNil:
SexpEventKind.sexpNil
SexpNode:
sexp: SexpNode
SexpNodeKind:
sexp: SexpNodeKind
SexpNodeObj:
sexp: SexpNodeObj
SexpParser:
sexp_parse: SexpParser
SexpParsingError:
sexp: SexpParsingError
SexpPath:
sexp_diff: SexpPath
sexpString:
SexpEventKind.sexpString
sexpSymbol:
SexpEventKind.sexpSymbol
SFloat:
SexpNodeKind.SFloat
sgn:
math: sgn[T: SomeNumber](x: T): int
Sha1Digest:
sha1: Sha1Digest
Sha1State:
sha1: Sha1State
ShadowRoot:
dom: ShadowRoot
ShadowRootInit:
dom: ShadowRootInit
shallow copy:
Module system
shallowCopy:
system: shallowCopy[T](x: var T; y: T)
shared object:
Module os
SharedList:
sharedlist: SharedList
shArg:
shellrunner: shArg(arg: string): ShellArg
shell:
shellrunner: shell(bin: string; args: openArray[ShellArg]): ShellCmd
shellrunner: shell(bin: string; args: openArray[string] = @[]): ShellCmd
shell command:
Module os
ShellArg:
shellrunner: ShellArg
ShellArgKind:
shellrunner: ShellArgKind
ShellCmd:
shellrunner: ShellCmd
shellExecuteW:
winlean: shellExecuteW(hwnd: Handle; lpOperation, lpFile, lpParameters, lpDirectory: WideCString; nShowCmd: int32): Handle
ShellResult:
shellrunner: ShellResult
shift:
reservedmem: shift(p: pointer; distance: int): pointer
shiftDiffed:
diff: shiftDiffed[T](diff: seq[SeqEdit]; oldSeq, newSeq: openArray[T]): ShiftedDiff
ShiftedDiff:
diff: ShiftedDiff
ShInterpolate:
shellrunner: ShInterpolate
showCursor:
terminal: showCursor(f: File)
terminal: showCursor()
shrink:
deques: shrink[T](deq: var Deque[T]; fromFirst = 0; fromLast = 0)
system: shrink[T](x: var seq[T]; newLen: Natural)
shSub:
shellrunner: shSub(cmd: var ShellCmd; subs: openArray[string])
shellrunner: shSub(arg: string): ShellArg
shuffle:
random: shuffle[T](x: var openArray[T])
random: shuffle[T](r: var Rand; x: var openArray[T])
shutdown:
winlean: shutdown(s: SocketHandle; how: cint): cint
SID:
winlean: SID
SID_IDENTIFIER_AUTHORITY:
winlean: SID_IDENTIFIER_AUTHORITY
sign:
jscore: sign(m: MathLib; f: SomeNumber): int
signal:
locks: signal(cond: var Cond)
signalFence:
atomics: signalFence(order: MemoryOrder)
signatureHash:
macros: signatureHash(n: NimNode): string
signbit:
math: signbit(x: SomeFloat): bool
simple assertions:
Simple assertions
sin:
complex: sin[T](z: Complex[T]): Complex[T]
jscore: sin(m: MathLib; a: SomeNumber): float
math: sin(x: float32): float32
math: sin(x: float64): float64
since:
since: since(version: (int, int); body: untyped)
since: since(version: (int, int, int); body: untyped)
SingleTags:
htmlparser: SingleTags
SingleValueSetting:
compilesettings: SingleValueSetting
SinglyLinkedList:
lists: SinglyLinkedList
SinglyLinkedNode:
lists: SinglyLinkedNode
SinglyLinkedNodeObj:
lists: SinglyLinkedNodeObj
SinglyLinkedRing:
lists: SinglyLinkedRing
sinh:
complex: sinh[T](z: Complex[T]): Complex[T]
jscore: sinh(m: MathLib; a: SomeNumber): float
math: sinh(x: float32): float32
math: sinh(x: float64): float64
sink:
system: sink
Module system
SInt:
SexpNodeKind.SInt
SIO_GET_EXTENSION_FUNCTION_POINTER:
winlean: SIO_GET_EXTENSION_FUNCTION_POINTER
size:
typeinfo: size(x: Any): int
unicode: size(r: Rune): int
sizeof:
system: sizeof[T](x: T): int
system: sizeof(x: typedesc): int
skewness:
stats: skewness[T](x: openArray[T]): float
stats: skewness(s: RunningStat): float
skewnessS:
stats: skewnessS[T](x: openArray[T]): float
stats: skewnessS(s: RunningStat): float
SKeyword:
SexpNodeKind.SKeyword
skip:
net: skip(socket: Socket; size: int; timeout = -1)
parseutils: skip(s, token: string; start = 0): int
unittest: skip()
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)
slice:
dom: slice(e: Blob; startindex: int = 0; endindex: int = e.size; contentType: cstring = "")
Slice:
system: Slice
slice:
Module system
Module system
SList:
SexpNodeKind.SList
slope:
stats: slope(r: RunningRegress): float
slot:
htmlgen: slot(e: varargs[untyped]): untyped
SlotOptions:
dom: SlotOptions
slurp:
system: slurp(filename: string): string
small:
htmlgen: small(e: varargs[untyped]): untyped
smallest:
tables: smallest[A](t: CountTable[A]): tuple[key: A, val: int]
tables: smallest[A](t: CountTableRef[A]): tuple[key: A, val: int]
smArrayLen:
SexpMismatchKind.smArrayLen
smDifferentLiteral:
SexpMismatchKind.smDifferentLiteral
smDifferentSymbol:
SexpMismatchKind.smDifferentSymbol
smKindMismatch:
SexpMismatchKind.smKindMismatch
smMissingKey:
SexpMismatchKind.smMissingKey
Smtp:
smtp: Smtp
SNil:
SexpNodeKind.SNil
SO_ACCEPTCONN:
winlean: SO_ACCEPTCONN
SOBool:
net: SOBool
SO_BROADCAST:
winlean: SO_BROADCAST
SockAddr:
winlean: SockAddr
Sockaddr_in:
winlean: Sockaddr_in
Sockaddr_in6:
winlean: Sockaddr_in6
Sockaddr_storage:
winlean: Sockaddr_storage
SOCK_DGRAM:
SockType.SOCK_DGRAM
Socket:
net: Socket
socket:
winlean: socket(af, typ, protocol: cint): SocketHandle
socketError:
net: socketError(socket: Socket; err: int = -1; async = false; lastError = -1.OSErrorCode; flags: set[SocketFlag] = {})
SocketFlag:
net: SocketFlag
SocketHandle:
winlean: SocketHandle
SocketImpl:
net: SocketImpl
SockLen:
winlean: SockLen
SOCK_RAW:
SockType.SOCK_RAW
SOCK_SEQPACKET:
SockType.SOCK_SEQPACKET
SOCK_STREAM:
SockType.SOCK_STREAM
SockType:
nativesockets: SockType
SO_DEBUG:
winlean: SO_DEBUG
SO_DONTLINGER:
winlean: SO_DONTLINGER
SO_DONTROUTE:
winlean: SO_DONTROUTE
SO_ERROR:
winlean: SO_ERROR
SO_EXCLUSIVEADDRUSE:
winlean: SO_EXCLUSIVEADDRUSE
SO_KEEPALIVE:
winlean: SO_KEEPALIVE
SO_LINGER:
winlean: SO_LINGER
SOL_SOCKET:
winlean: SOL_SOCKET
SOMAXCONN:
winlean: SOMAXCONN
some:
options: some[T](val: sink T): Option[T]
SomeFloat:
system: SomeFloat
SomeInteger:
system: SomeInteger
SomeLinkedCollection:
lists: SomeLinkedCollection
SomeLinkedList:
lists: SomeLinkedList
SomeLinkedNode:
lists: SomeLinkedNode
SomeLinkedRing:
lists: SomeLinkedRing
SomeNumber:
system: SomeNumber
someOpt:
dod_helpers: someOpt[T](i: T): auto
SomeOrdinal:
system: SomeOrdinal
SomeSet:
sets: SomeSet
SomeSignedInt:
system: SomeSignedInt
SomeUnsignedInt:
system: SomeUnsignedInt
SO_OOBINLINE:
winlean: SO_OOBINLINE
SO_REUSEADDR:
winlean: SO_REUSEADDR
SO_REUSEPORT:
winlean: SO_REUSEPORT
sort:
algorithm: sort[T](a: var openArray[T]; order = SortOrder.Ascending)
algorithm: sort[T](a: var openArray[T]; cmp: proc (x, y: T): int {.closure.}; order = SortOrder.Ascending)
tables: sort[A](t: var CountTable[A]; order = SortOrder.Descending)
tables: sort[A](t: CountTableRef[A]; order = SortOrder.Descending)
tables: sort[A, B](t: var OrderedTable[A, B]; cmp: proc (x, y: (A, B)): int; order = SortOrder.Ascending)
tables: sort[A, B](t: OrderedTableRef[A, B]; cmp: proc (x, y: (A, B)): int; order = SortOrder.Ascending)
sorted:
algorithm: sorted[T](a: openArray[T]; order = SortOrder.Ascending): seq[T]
algorithm: sorted[T](a: openArray[T]; cmp: proc (x, y: T): int {.closure.}; order = SortOrder.Ascending): seq[T]
sortedByIt:
algorithm: sortedByIt(seq1, op: untyped): untyped
SortOrder:
algorithm: SortOrder
SO_UPDATE_ACCEPT_CONTEXT:
winlean: SO_UPDATE_ACCEPT_CONTEXT
source:
htmlgen: source(e: varargs[untyped]): untyped
SourceLanguage:
highlite: SourceLanguage
sourceLanguageToAlpha:
highlite: sourceLanguageToAlpha
sourceLanguageToStr:
highlite: sourceLanguageToStr
SO_USELOOPBACK:
winlean: SO_USELOOPBACK
space:
sexp_parse: space(p: var SexpParser)
spaces:
strutils: spaces(n: Natural): string
span:
htmlgen: span(e: varargs[untyped]): untyped
sparse bit set:
Module packedsets
spawnX:
threadpool: spawnX(call)
splice:
Module system
Module system
split:
jsre: split(pattern: cstring; self: RegExp): seq[cstring]
nre: split(str: string; pattern: Regex; maxSplit = -1; start = 0): seq[string]
pegs: split(s: string; sep: Peg): seq[string]
pegs: split(s: string; sep: Peg): string
re: split(s: string; sep: Regex; maxsplit = -1): seq[string]
re: split(s: string; sep: Regex; maxsplit = -1): string
strutils: split(s: string; sep: char; maxsplit: int = -1): seq[string]
strutils: split(s: string; seps: set[char] = Whitespace; maxsplit: int = -1): seq[string]
strutils: split(s: string; sep: string; maxsplit: int = -1): seq[string]
strutils: split(s: string; sep: char; maxsplit: int = -1): string
strutils: split(s: string; seps: set[char] = Whitespace; maxsplit: int = -1): string
strutils: split(s: string; sep: string; maxsplit: int = -1): string
unicode: split(s: string; seps: openArray[Rune] = unicodeSpaces; maxsplit: int = -1): seq[ string]
unicode: split(s: string; sep: Rune; maxsplit: int = -1): seq[string]
unicode: split(s: string; seps: openArray[Rune] = unicodeSpaces; maxsplit: int = -1): string
unicode: split(s: string; sep: Rune; maxsplit: int = -1): string
splitDecimal:
math: splitDecimal[T: float32 | float64](x: T): tuple[intpart: T, floatpart: T]
splitFile:
os: splitFile(path: string): tuple[dir, name, ext: string]
splitKeepSeparator:
colordiff: splitKeepSeparator(str: string; sep: set[char] = {' '}): seq[string]
splitLines:
strutils: splitLines(s: string; keepEol = false): seq[string]
strutils: splitLines(s: string; keepEol = false): string
splitPath:
os: splitPath(path: string): tuple[head, tail: string]
splitWhitespace:
strutils: splitWhitespace(s: string; maxsplit: int = -1): seq[string]
strutils: splitWhitespace(s: string; maxsplit: int = -1): string
unicode: splitWhitespace(s: string): seq[string]
unicode: splitWhitespace(s: string): string
sql:
db_common: sql(query: string): SqlQuery
SQLite:
Module db_sqlite
SqlLexer:
parsesql: SqlLexer
SqlNode:
parsesql: SqlNode
SqlNodeKind:
parsesql: SqlNodeKind
SqlNodeObj:
parsesql: SqlNodeObj
SqlParseError:
parsesql: SqlParseError
SqlParser:
parsesql: SqlParser
SqlPrepared:
db_postgres: SqlPrepared
db_sqlite: SqlPrepared
SqlQuery:
db_common: SqlQuery
sqrt:
complex: sqrt[T](z: Complex[T]): Complex[T]
jscore: sqrt(m: MathLib; f: SomeFloat): SomeFloat
math: sqrt(x: float32): float32
math: sqrt(x: float64): float64
SslAcceptResult:
net: SslAcceptResult
SslClientGetPskFunc:
net: SslClientGetPskFunc
SslContext:
net: SslContext
SslCVerifyMode:
net: SslCVerifyMode
SslError:
net: SslError
sslHandle:
net: sslHandle(self: Socket): SslPtr
SslHandshakeType:
net: SslHandshakeType
SslProtVersion:
net: SslProtVersion
SslServerGetPskFunc:
net: SslServerGetPskFunc
SString:
SexpNodeKind.SString
SSymbol:
SexpNodeKind.SSymbol
stableMatch:
sexp_diff: stableMatch(lhsLen, rhsLen: int; weight: proc (a, b: int): int; order: SortOrder = SortOrder.Ascending): tuple[ lhsIgnore, rhsIgnore: seq[int], map: seq[tuple[pair: (int, int), cost: int]]]
StackOverflowDefect:
system: StackOverflowDefect
StackOverflowError:
system: StackOverflowError
stackTraceAvailable:
system: stackTraceAvailable(): bool
StackTraceEntry:
system: StackTraceEntry
stamp:
macros: stamp(body: untyped): NimNode
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:
shellrunner: start(cmd: ShellCmd; dir: string = ""; options: set[ProcessOption] = {poUsePath}): Process
startAnchor:
pegs: startAnchor(): Peg
STARTF_USESHOWWINDOW:
winlean: STARTF_USESHOWWINDOW
STARTF_USESTDHANDLES:
winlean: STARTF_USESTDHANDLES
startProcess:
osproc: startProcess(command: string; workingDir: string = ""; args: openArray[string] = []; env: StringTableRef = nil; options: set[ProcessOption] = {poStdErrToStdOut}): owned(Process)
startsWith:
cstrutils: startsWith(s, prefix: cstring): bool
jsre: startsWith(pattern: cstring; self: RegExp): bool
pegs: startsWith(s: string; prefix: Peg; start = 0): bool
re: startsWith(s: string; prefix: Regex): bool
strutils: startsWith(s: string; prefix: char): bool
strutils: startsWith(s, prefix: string): bool
startsWithImpl:
strimpl: startsWithImpl[T: string | cstring](s, prefix: T)
startTls:
smtp: startTls(smtp: Smtp; sslContext: SslContext = nil)
STARTUPINFO:
winlean: STARTUPINFO
stat:
posix_utils: stat(path: string): Stat
staticExec:
system: staticExec(command: string; input = ""; cache = ""): string
StaticParam:
typetraits: StaticParam
staticRead:
system: staticRead(filename: string): string
Status:
linenoise: Status
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
StdlibMajor:
system: StdlibMajor
StdlibMinor:
system: StdlibMinor
StdlibPatch:
system: StdlibPatch
StdlibVersion:
system: StdlibVersion
stdmsg:
io: stdmsg(): File
stdout:
io: stdout
STD_OUTPUT_HANDLE:
winlean: STD_OUTPUT_HANDLE
STILL_ACTIVE:
winlean: STILL_ACTIVE
stop:
dom: stop(e: EmbedElement)
dom: stop(w: Window)
stopImmediatePropagation:
dom: stopImmediatePropagation(ev: Event)
stopPropagation:
dom: stopPropagation(ev: Event)
Storage:
dom: Storage
StorageEvent:
dom: StorageEvent
store:
atomics: store[T: Trivial](location: var Atomic[T]; desired: T; order: MemoryOrder = moSequentiallyConsistent)
atomics: store[T: not Trivial](location: var Atomic[T]; desired: T; order: MemoryOrder = moSequentiallyConsistent)
marshal: store[T](s: Stream; data: T)
str:
parsejson: str(my: JsonParser): string
sexp_parse: str(parser: SexpParser): string
Stream:
streams: Stream
StreamObj:
streams: StreamObj
string:
system: string
string interpolation:
Module strutils
stringify:
jscore: stringify(l: JsonLib; s: JsRoot): cstring
StringStream:
streams: StringStream
StringStreamObj:
streams: StringStreamObj
StringTableMode:
strtabs: StringTableMode
StringTableObj:
strtabs: StringTableObj
StringTableRef:
strtabs: StringTableRef
strip:
strbasics: strip(a: var string; leading = true; trailing = true; chars: set[char] = whitespaces)
strutils: strip(s: string; leading = true; trailing = true; chars: set[char] = Whitespace): string
unicode: strip(s: string; leading = true; trailing = true; runes: openArray[Rune] = unicodeSpaces): string
stripGenericParams:
typetraits: stripGenericParams(t: typedesc): typedesc
stripLineEnd:
strutils: stripLineEnd(s: var string)
stripLines:
colortext: stripLines(text: ColText; leading: bool = false; trails: bool = true; chars: set[char] = {' '}): ColText
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: string; body: untyped): untyped
suiteEnded:
unittest: suiteEnded(formatter: ConsoleOutputFormatter)
unittest: suiteEnded(formatter: JUnitOutputFormatter)
unittest: suiteEnded(formatter: OutputFormatter)
suiteStarted:
unittest: suiteStarted(formatter: ConsoleOutputFormatter; suiteName: string)
unittest: suiteStarted(formatter: JUnitOutputFormatter; suiteName: string)
unittest: suiteStarted(formatter: OutputFormatter; suiteName: string)
sum:
math: sum[T](x: openArray[T]): T
sumKbn:
sums: sumKbn[T](x: openArray[T]): T
summary:
htmlgen: summary(e: varargs[untyped]): untyped
sumPairs:
sums: sumPairs[T](x: openArray[T]): T
sup:
htmlgen: sup(e: varargs[untyped]): untyped
super:
Module system
supportsCopyMem:
typetraits: supportsCopyMem(t: typedesc): bool
supportsZeroMem:
typetraits: supportsZeroMem(t: typedesc): bool
suspend:
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)
SwitchToFiber:
winlean: SwitchToFiber(fiber: pointer)
SW_SHOWNORMAL:
winlean: SW_SHOWNORMAL
symAddr:
dynlib: symAddr(lib: LibHandle; name: cstring): pointer
symBodyHash:
macros: symBodyHash(s: NimNode): string
symbolName:
enumutils: symbolName[T: enum](a: T): string
symbolRank:
enumutils: symbolRank[T: enum](a: T): int
symKind:
macros: symKind(symbol: NimNode): NimSymKind
symlinkExists:
os: symlinkExists(link: string): bool
symmetricDifference:
packedsets: symmetricDifference[A](s1, s2: PackedSet[A]): PackedSet[A]
sets: symmetricDifference[A](s1, s2: HashSet[A]): HashSet[A]
sync:
threadpool: sync()
SYNCHRONIZE:
winlean: SYNCHRONIZE
SyntaxError:
nre: SyntaxError
system:
Module osproc
SystemInfo:
win_getsysteminfo: SystemInfo
SysThread:
system: SysThread
table:
htmlgen: table(e: varargs[untyped]): untyped
jsconsole: table(console: Console)
Table:
tables: Table
TableRef:
tables: TableRef
tag:
xmltree: tag(n: XmlNode): lent string
tag=:
xmltree: tag=(n: XmlNode; tag: sink string)
tagA:
HtmlTag.tagA
tagAbbr:
HtmlTag.tagAbbr
tagAcronym:
HtmlTag.tagAcronym
tagAddress:
HtmlTag.tagAddress
tagApplet:
HtmlTag.tagApplet
tagArea:
HtmlTag.tagArea
tagArticle:
HtmlTag.tagArticle
tagAside:
HtmlTag.tagAside
tagAudio:
HtmlTag.tagAudio
tagB:
HtmlTag.tagB
tagBase:
HtmlTag.tagBase
tagBasefont:
HtmlTag.tagBasefont
tagBdi:
HtmlTag.tagBdi
tagBdo:
HtmlTag.tagBdo
tagBig:
HtmlTag.tagBig
tagBlockquote:
HtmlTag.tagBlockquote
tagBody:
HtmlTag.tagBody
tagBr:
HtmlTag.tagBr
tagButton:
HtmlTag.tagButton
tagCanvas:
HtmlTag.tagCanvas
tagCaption:
HtmlTag.tagCaption
tagCenter:
HtmlTag.tagCenter
tagCite:
HtmlTag.tagCite
tagCode:
HtmlTag.tagCode
tagCol:
HtmlTag.tagCol
tagColgroup:
HtmlTag.tagColgroup
tagCommand:
HtmlTag.tagCommand
tagDatalist:
HtmlTag.tagDatalist
tagDd:
HtmlTag.tagDd
tagDel:
HtmlTag.tagDel
tagDetails:
HtmlTag.tagDetails
tagDfn:
HtmlTag.tagDfn
tagDialog:
HtmlTag.tagDialog
tagDir:
HtmlTag.tagDir
tagDiv:
HtmlTag.tagDiv
tagDl:
HtmlTag.tagDl
tagDt:
HtmlTag.tagDt
tagEm:
HtmlTag.tagEm
tagEmbed:
HtmlTag.tagEmbed
tagFieldset:
HtmlTag.tagFieldset
tagFigcaption:
HtmlTag.tagFigcaption
tagFigure:
HtmlTag.tagFigure
tagFont:
HtmlTag.tagFont
tagFooter:
HtmlTag.tagFooter
tagForm:
HtmlTag.tagForm
tagFrame:
HtmlTag.tagFrame
tagFrameset:
HtmlTag.tagFrameset
tagH1:
HtmlTag.tagH1
tagH2:
HtmlTag.tagH2
tagH3:
HtmlTag.tagH3
tagH4:
HtmlTag.tagH4
tagH5:
HtmlTag.tagH5
tagH6:
HtmlTag.tagH6
tagHead:
HtmlTag.tagHead
tagHeader:
HtmlTag.tagHeader
tagHgroup:
HtmlTag.tagHgroup
tagHr:
HtmlTag.tagHr
tagHtml:
HtmlTag.tagHtml
tagI:
HtmlTag.tagI
tagIframe:
HtmlTag.tagIframe
tagImg:
HtmlTag.tagImg
tagInput:
HtmlTag.tagInput
tagIns:
HtmlTag.tagIns
tagIsindex:
HtmlTag.tagIsindex
tagKbd:
HtmlTag.tagKbd
tagKeygen:
HtmlTag.tagKeygen
tagLabel:
HtmlTag.tagLabel
tagLegend:
HtmlTag.tagLegend
tagLi:
HtmlTag.tagLi
tagLink:
HtmlTag.tagLink
tagMap:
HtmlTag.tagMap
tagMark:
HtmlTag.tagMark
tagMenu:
HtmlTag.tagMenu
tagMeta:
HtmlTag.tagMeta
tagMeter:
HtmlTag.tagMeter
tagNav:
HtmlTag.tagNav
tagNobr:
HtmlTag.tagNobr
tagNoframes:
HtmlTag.tagNoframes
tagNoscript:
HtmlTag.tagNoscript
tagObject:
HtmlTag.tagObject
tagOl:
HtmlTag.tagOl
tagOptgroup:
HtmlTag.tagOptgroup
tagOption:
HtmlTag.tagOption
tagOutput:
HtmlTag.tagOutput
tagP:
HtmlTag.tagP
tagParam:
HtmlTag.tagParam
tagPre:
HtmlTag.tagPre
tagProgress:
HtmlTag.tagProgress
tagQ:
HtmlTag.tagQ
tagRp:
HtmlTag.tagRp
tagRt:
HtmlTag.tagRt
tagRuby:
HtmlTag.tagRuby
tagS:
HtmlTag.tagS
tagSamp:
HtmlTag.tagSamp
tagScript:
HtmlTag.tagScript
tagSection:
HtmlTag.tagSection
tagSelect:
HtmlTag.tagSelect
tagSmall:
HtmlTag.tagSmall
tagSource:
HtmlTag.tagSource
tagSpan:
HtmlTag.tagSpan
tagStrike:
HtmlTag.tagStrike
tagStrong:
HtmlTag.tagStrong
tagStyle:
HtmlTag.tagStyle
tagSub:
HtmlTag.tagSub
tagSummary:
HtmlTag.tagSummary
tagSup:
HtmlTag.tagSup
tagTable:
HtmlTag.tagTable
tagTbody:
HtmlTag.tagTbody
tagTd:
HtmlTag.tagTd
tagTextarea:
HtmlTag.tagTextarea
tagTfoot:
HtmlTag.tagTfoot
tagTh:
HtmlTag.tagTh
tagThead:
HtmlTag.tagThead
tagTime:
HtmlTag.tagTime
tagTitle:
HtmlTag.tagTitle
tagToStr:
htmlparser: tagToStr
tagTr:
HtmlTag.tagTr
tagTrack:
HtmlTag.tagTrack
tagTt:
HtmlTag.tagTt
tagU:
HtmlTag.tagU
tagUl:
HtmlTag.tagUl
tagUnknown:
HtmlTag.tagUnknown
tagVar:
HtmlTag.tagVar
tagVideo:
HtmlTag.tagVideo
tagWbr:
HtmlTag.tagWbr
tailDir:
os: tailDir(path: string): string
TaintedString:
system: TaintedString
take:
results: take[T: not void; E](r: sink Result[T, E]): T
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
takeErr:
results: takeErr[T, E](r: sink Result[T, E]): E
tan:
complex: tan[T](z: Complex[T]): Complex[T]
jscore: tan(m: MathLib; a: SomeNumber): float
math: tan(x: float32): float32
math: tan(x: float64): float64
tanh:
complex: tanh[T](z: Complex[T]): Complex[T]
jscore: tanh(m: MathLib; a: SomeNumber): float
math: tanh(x: float32): float32
math: tanh(x: float64): float64
Task:
tasks: Task
TAU:
math: TAU
tbody:
htmlgen: tbody(e: varargs[untyped]): untyped
TCP_NODELAY:
winlean: TCP_NODELAY
td:
htmlgen: td(e: varargs[untyped]): untyped
tearDownForeignThreadGc:
system: tearDownForeignThreadGc()
term:
pegs: term(t: char): Peg
pegs: term(p: Peg): string
pegs: term(t: string): Peg
termBg:
colortext: termBg(gray: range[0 .. 23]): TermColorBg
colortext: termBg(r, g, b: range[0 .. 5]): TermColorBg
termColor:
colortext: termColor(bg: BackgroundColor): TermColorBg
colortext: termColor(bg: ForegroundColor): TermColorFg
TermColorBg:
colortext: TermColorBg
TermColorFg:
colortext: TermColorFg
termFg:
colortext: termFg(gray: range[0 .. 23]): TermColorFg
colortext: termFg(r, g, b: range[0 .. 5]): TermColorFg
termIgnoreCase:
pegs: termIgnoreCase(t: string): Peg
termIgnoreStyle:
pegs: termIgnoreStyle(t: string): Peg
TerminalCmd:
terminal: TerminalCmd
terminalHeight:
terminal: terminalHeight(): int
terminalHeightIoctl:
terminal: terminalHeightIoctl(fds: openArray[int]): int
terminalSize:
terminal: terminalSize(): tuple[w, h: int]
terminalWidth:
terminal: terminalWidth(): int
terminalWidthIoctl:
terminal: terminalWidthIoctl(fds: openArray[int]): int
terminate:
osproc: terminate(p: Process)
terminateProcess:
winlean: terminateProcess(hProcess: Handle; uExitCode: int): WINBOOL
test:
jsre: test(self: RegExp; pattern: cstring): bool
unittest: test(name: string; body: untyped)
testAndSet:
atomics: testAndSet(location: var AtomicFlag; order: MemoryOrder = moSequentiallyConsistent): bool
testBit:
bitops: testBit[T: SomeInteger](v: T; bit: BitsRange[T]): bool
testEnded:
unittest: testEnded(formatter: ConsoleOutputFormatter; testResult: TestResult)
unittest: testEnded(formatter: JUnitOutputFormatter; testResult: TestResult)
unittest: testEnded(formatter: OutputFormatter; testResult: TestResult)
TestResult:
unittest: TestResult
testStarted:
unittest: testStarted(formatter: ConsoleOutputFormatter; testName: string)
unittest: testStarted(formatter: JUnitOutputFormatter; testName: string)
unittest: testStarted(formatter: OutputFormatter; testName: string)
TestStatus:
unittest: TestStatus
text:
jsfetch: text(self: Response): Future[cstring]
xmltree: text(n: XmlNode): lent string
text=:
xmltree: text=(n: XmlNode; text: sink string)
textarea:
htmlgen: textarea(e: varargs[untyped]): untyped
TextAreaElement:
dom: TextAreaElement
TextNode:
NodeType.TextNode
TFdSet:
winlean: TFdSet
Tfenv:
fenv: Tfenv
Tfexcept:
fenv: Tfexcept
tfoot:
htmlgen: tfoot(e: varargs[untyped]): untyped
TFrame:
system: TFrame
th:
htmlgen: th(e: varargs[untyped]): untyped
thead:
htmlgen: thead(e: varargs[untyped]): untyped
then:
asyncjs: then[T](future: Future[T]; onSuccess: proc; onReject: OnReject = nil): auto
thisDir:
nimscript: thisDir(): string
Thread:
system: Thread
ThreadId:
threadpool: ThreadId
ThreadPoolAdvice:
cpuload: ThreadPoolAdvice
ThreadPoolState:
cpuload: ThreadPoolState
ticks:
monotimes: ticks(t: MonoTime): int64
time:
htmlgen: time(e: varargs[untyped]): untyped
jsconsole: time(console: Console; label = "".cstring)
Time:
times: Time
time_t: Time
TimeEffect:
system: TimeEffect
timeEnd:
jsconsole: timeEnd(console: Console; label = "".cstring)
TimeFormat:
times: TimeFormat
TimeFormatParseError:
times: TimeFormatParseError
TimeInterval:
times: TimeInterval
TimeIntervalParts:
times: TimeIntervalParts
timeLog:
jsconsole: timeLog(console: Console; label = "".cstring)
TimeOut:
dom: TimeOut
TimeoutError:
net: TimeoutError
TimeParseError:
times: TimeParseError
timeStamp:
jsconsole: timeStamp(console: Console; label: cstring)
TimeUnit:
times: TimeUnit
Timeval:
winlean: Timeval
Timezone:
times: Timezone
timezone:
times: timezone(dt: DateTime): Timezone
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
tkDot:
TTokKind.tkDot
tkEof:
TokKind.tkEof
TTokKind.tkEof
tkError:
TokKind.tkError
TTokKind.tkError
tkFalse:
TokKind.tkFalse
tkFloat:
TokKind.tkFloat
TTokKind.tkFloat
tkInt:
TokKind.tkInt
TTokKind.tkInt
tkKeyword:
TTokKind.tkKeyword
tkNil:
TTokKind.tkNil
tkNull:
TokKind.tkNull
tkParensLe:
TTokKind.tkParensLe
tkParensRi:
TTokKind.tkParensRi
tkSpace:
TTokKind.tkSpace
tkString:
TokKind.tkString
TTokKind.tkString
tkSymbol:
TTokKind.tkSymbol
tkTrue:
TokKind.tkTrue
TLineInfo:
rstast: TLineInfo
to:
jsffi: to(x: JsObject; T: typedesc): T:type
json: to[T](node: JsonNode; t: typedesc[T]): T
marshal: to[T](data: string): T
toAny:
typeinfo: toAny[T](x: var T): Any
toBiggestFloat:
system: toBiggestFloat(i: BiggestInt): BiggestFloat
toBiggestInt:
system: toBiggestInt(f: BiggestFloat): BiggestInt
toBin:
strutils: toBin(x: BiggestInt; len: Positive): string
toCInt:
net: toCInt(opt: SOBool): cint
toColRune:
colortext: toColRune(rune: Rune; style: ColStyle): ColRune
toColText:
colortext: toColText(rune: ColRune): ColText
colortext: toColText(text: ColText): ColText
colortext: toColText(text: string; style: ColStyle = default(ColStyle)): ColText
toCountTable:
tables: toCountTable[A](keys: openArray[A]): CountTable[A]
toCritBitTree:
critbits: toCritBitTree[T](pairs: openArray[(string, T)]): CritBitTree[T]
critbits: toCritBitTree(items: openArray[string]): CritBitTree[void]
toCstring:
jsbigints: toCstring(this: JsBigInt): cstring
jsbigints: toCstring(this: JsBigInt; radix: 2 .. 36): cstring
jsfetch: toCstring(self: Request | Response | FetchOptions): cstring
jsformdata: toCstring(self: FormData): cstring
jsheaders: toCstring(self: Headers): cstring
jsre: toCstring(self: RegExp): cstring
toDeque:
deques: toDeque[T](x: openArray[T]): Deque[T]
toDll:
nimscript: toDll(filename: string): string
toDoublyLinkedList:
lists: toDoublyLinkedList[T](elems: openArray[T]): DoublyLinkedList[T]
toException:
results: toException[E](err: E): ResultErrorRef[E]
toExe:
nimscript: toExe(filename: string): string
toFILETIME:
winlean: toFILETIME(t: int64): FILETIME
toFloat:
rationals: toFloat[T](x: Rational[T]): float
system: toFloat(i: int): float
toggle:
dom: toggle(c: ClassList; class: cstring)
toHashSet:
sets: toHashSet[A](keys: openArray[A]): HashSet[A]
toHeapQueue:
heapqueue: toHeapQueue[T](x: openArray[T]): HeapQueue[T]
toHex:
strutils: toHex(s: string): string
strutils: toHex[T: SomeInteger](x: T): string
strutils: toHex[T: SomeInteger](x: T; len: Positive): string
toIndex:
dod_helpers: toIndex(id: ValueId): int
text_layouter: toIndex(id: LytStrId): int
toInt:
nativesockets: toInt(domain: Domain): cint
nativesockets: toInt(p: Protocol): cint
nativesockets: toInt(typ: SockType): cint
rationals: toInt[T](x: Rational[T]): int
system: toInt(f: float): int
toIntSet:
intsets: toIntSet(x: openArray[int]): IntSet
toJs:
jsffi: toJs[T](val: T): JsObject
jsffi: toJs(s: string): JsObject
toJsKey:
jsffi: toJsKey(text: cstring; t: type cstring): cstring
jsffi: toJsKey[T: SomeInteger](text: cstring; t: type T): T
jsffi: toJsKey[T: enum](text: cstring; t: type T): T
jsffi: toJsKey[T: SomeFloat](text: cstring; t: type T): T
toJson:
jsonutils: toJson[T](a: T; opt = initToJsonOptions()): JsonNode
toJsonHook:
jsonutils: toJsonHook[K: string | cstring; V](t: (Table[K, V] | OrderedTable[K, V])): JsonNode
jsonutils: toJsonHook[T](self: Option[T]): JsonNode
jsonutils: toJsonHook[A](s: SomeSet[A]): JsonNode
jsonutils: toJsonHook(a: StringTableRef): JsonNode
ToJsonOptions:
jsonutils: ToJsonOptions
TokenClass:
highlite: TokenClass
tokenClassToStr:
highlite: tokenClassToStr
tokenize:
highlite: tokenize(text: string; lang: SourceLanguage): seq[(string, TokenClass)]
strutils: tokenize(s: string; seps: set[char] = Whitespace): tuple[token: string, isSep: bool]
TokKind:
parsejson: TokKind
toKnownDomain:
nativesockets: toKnownDomain(family: cint): Option[Domain]
toLayout:
text_layouter: toLayout(bl: LytBlock; opts: LytOptions): Layout
toLayouts:
text_layouter: toLayouts(bl: LytBlock; opts: LytOptions): seq[Layout]
toLine:
sexp_diff: toLine(s: SexpNode; sortfield: bool = false): ColText
toLocation:
miscdollars: toLocation(result: var string; file: string | cstring; line: int; col: int)
toLower:
colortext: toLower(text: sink ColText): ColText
unicode: toLower(c: Rune): Rune
unicode: toLower(s: string): string
toLowerAscii:
strimpl: toLowerAscii(c: char): char
strutils: toLowerAscii(c: char): char
strutils: toLowerAscii(s: string): string
toLytStrId:
text_layouter: toLytStrId(idx: int): LytStrId
toMask:
bitops: toMask[T: SomeInteger](slice: Slice[int]): T
toMD5:
md5: toMD5(s: string): MD5Digest
toNumber:
jsbigints: toNumber(this: JsBigInt): BiggestInt
toOct:
strutils: toOct(x: BiggestInt; len: Positive): string
toOctal:
strutils: toOctal(c: char): string
ToolBar:
dom: ToolBar
toOpenArray:
system: toOpenArray[I, T](x: array[I, T]; first, last: I): openArray[T]
system: toOpenArray(x: cstring; first, last: int): openArray[char]
system: toOpenArray[T](x: openArray[T]; first, last: int): openArray[T]
system: toOpenArray[T](x: ptr UncheckedArray[T]; first, last: int): openArray[T]
system: toOpenArray[T](x: seq[T]; first, last: int): openArray[T]
system: toOpenArray(x: string; first, last: int): openArray[char]
toOpenArrayByte:
system: toOpenArrayByte(x: cstring; first, last: int): openArray[byte]
system: toOpenArrayByte(x: openArray[char]; first, last: int): openArray[byte]
system: toOpenArrayByte(x: seq[char]; first, last: int): openArray[byte]
system: toOpenArrayByte(x: string; first, last: int): openArray[byte]
toOrderedSet:
sets: toOrderedSet[A](keys: openArray[A]): OrderedSet[A]
toOrderedTable:
tables: toOrderedTable[A, B](pairs: openArray[(A, B)]): OrderedTable[A, B]
toOSFlags:
net: toOSFlags(socketFlags: set[SocketFlag]): cint
toPackedSet:
packedsets: toPackedSet[A](x: openArray[A]): PackedSet[A]
toParts:
times: toParts(dur: Duration): DurationParts
times: toParts(ti: TimeInterval): TimeIntervalParts
topologicalOrdering:
graph: topologicalOrdering[Id](graph: Graph[Id]; start: openArray[Id] = []): seq[Id]
toRational:
rationals: toRational(x: float; n: int = high(int) shr 32): Rational[int]
rationals: toRational[T: SomeInteger](x: T): Rational[T]
toRunes:
unicode: toRunes(s: string): seq[Rune]
toSeq:
nre: toSeq(pattern: CaptureBounds; default = none(HSlice[int, int])): seq[ Option[HSlice[int, int]]]
nre: toSeq(pattern: Captures; default: Option[string] = none(string)): seq[ Option[string]]
sequtils: toSeq(arg: untyped): untyped
toSet:
sets: toSet[A](keys: openArray[A]): HashSet[A]
setutils: toSet(iter: untyped): untyped
toSinglyLinkedList:
lists: toSinglyLinkedList[T](elems: openArray[T]): SinglyLinkedList[T]
toSockAddr:
net: toSockAddr(address: IpAddress; port: Port; sa: var Sockaddr_storage; sl: var SockLen)
toSockType:
nativesockets: toSockType(protocol: Protocol): SockType
toStr:
shellrunner: toStr(part: ShellArg): string
shellrunner: toStr(cmd: ShellCmd): seq[string]
toString:
colortext: toString(rune: ColRune; color: bool = true): string
colortext: toString(text: ColText; color: bool = true): string
colortext: toString(runes: seq[ColRune]; color: bool = true): string
Module dollars
dom: toString(s: Selection): cstring
httpcore: toString(values: HttpHeaderValues): string
jscore: toString(d: DateTime): cstring
jsre: toString(self: RegExp): cstring
toStrLit:
macros: toStrLit(n: NimNode): NimNode
toTable:
nre: toTable(pattern: CaptureBounds): Table[string, HSlice[int, int]]
nre: toTable(pattern: Captures): Table[string, string]
tables: toTable[A, B](pairs: openArray[(A, B)]): Table[A, B]
toTask:
tasks: toTask(e: typed{nkCall | nkInfix | nkPrefix | nkPostfix | nkCommand | nkCallStrLit}): Task
toTime:
times: toTime(dt: DateTime): Time
toTitle:
unicode: toTitle(c: Rune): Rune
toU16:
system: toU16(x: int): int16
toU32:
system: toU32(x: int64): int32
toU8:
system: toU8(x: int): int8
Touch:
dom: Touch
TouchEvent:
dom: TouchEvent
TouchList:
dom: TouchList
toUgly:
json: toUgly(result: var string; node: JsonNode)
toUnix:
times: toUnix(t: Time): int64
toUnixFloat:
times: toUnixFloat(t: Time): float
toUnsigned:
bitops_utils: toUnsigned(x: int): uint
bitops_utils: toUnsigned(x: int16): uint16
bitops_utils: toUnsigned(x: int32): uint32
bitops_utils: toUnsigned(x: int64): uint64
bitops_utils: toUnsigned(x: int8): uint8
toUpper:
colortext: toUpper(text: sink ColText): ColText
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
toValueId:
dod_helpers: toValueId(idx: int): ValueId
toWideCString:
widestrs: toWideCString(x: WideCStringObj): WideCString
toWinTime:
times: toWinTime(t: Time): int64
toXmlAttributes:
xmltree: toXmlAttributes(keyValuePairs: varargs[tuple[key, val: string]]): XmlAttributes
tr:
htmlgen: tr(e: varargs[untyped]): untyped
trace:
jsconsole: trace(console: Console)
Module system
track:
htmlgen: track(e: varargs[untyped]): untyped
trailingZeros2Digits:
digitsutils: trailingZeros2Digits(digits: uint32): int32
transformFile:
pegs: transformFile(infile, outfile: string; subs: varargs[tuple[pattern: Peg, repl: string]])
re: transformFile(infile, outfile: string; subs: openArray[tuple[pattern: Regex, repl: string]])
translate:
unicode: translate(s: string; replacements: proc (key: string): string): string
treeRepr:
macros: treeRepr(n: NimNode): string
parsesql: treeRepr(s: SqlNode): string
rstast: treeRepr(node: PRstNode; indent = 0): string
sexp: treeRepr(node: SexpNode): string
text_layouter: treeRepr(self: Layout; getStr: proc (s: LytStr): string = nil; level: int = 0): string
text_layouter: treeRepr(inBl: LytBlock; getStr: proc (str: LytStr): string = nil): string
text_layouter: treeRepr(self: LytSolution; getStr: proc (s: LytStr): string = nil; level: int = 0): string
trigger:
selectors: trigger(ev: SelectEvent)
trimZeros:
strutils: trimZeros(x: var string; decimalSep = '.')
trunc:
jscore: trunc(m: MathLib; f: SomeFloat): int
math: trunc(x: float32): float32
math: trunc(x: float64): float64
tryAcquire:
locks: tryAcquire(lock: var Lock): bool
rlocks: tryAcquire(lock: var RLock): bool
tryExec:
db_mysql: tryExec(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): bool
db_odbc: tryExec(db: var DbConn; query: SqlQuery; args: varargs[string, `$`]): bool
db_postgres: tryExec(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): bool
db_postgres: tryExec(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): bool
db_sqlite: tryExec(db: DbConn; stmtName: SqlPrepared): bool
db_sqlite: tryExec(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): bool
tryInsert:
db_mysql: tryInsert(db: DbConn; query: SqlQuery; pkName: string; args: varargs[string, `$`]): int64
db_odbc: tryInsert(db: var DbConn; query: SqlQuery; pkName: string; args: varargs[string, `$`]): int64
db_postgres: tryInsert(db: DbConn; query: SqlQuery; pkName: string; args: varargs[string, `$`]): int64
db_sqlite: tryInsert(db: DbConn; query: SqlQuery; pkName: string; args: varargs[string, `$`]): int64
tryInsertId:
db_mysql: tryInsertId(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
db_odbc: tryInsertId(db: var DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
tryInsertID:
db_postgres: tryInsertID(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
db_sqlite: tryInsertID(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
tryRecv:
system: tryRecv[TMsg](c: var Channel[TMsg]): tuple[dataAvailable: bool, msg: TMsg]
tryRemoveFile:
os: tryRemoveFile(file: string): bool
trySend:
net: trySend(socket: Socket; data: string): bool
system: trySend[TMsg](c: var Channel[TMsg]; msg: sink TMsg): bool
tt:
htmlgen: tt(e: varargs[untyped]): untyped
TTokKind:
sexp_parse: TTokKind
tupleLen:
typetraits: tupleLen(T: typedesc[tuple]): int
typetraits: tupleLen(t: tuple): int
TWSABuf:
winlean: TWSABuf
type:
Module macros
Module macros
Module macros
typed:
system: typed
typedesc:
system: typedesc
typeKind:
macros: typeKind(n: NimNode): NimTypeKind
typeof:
system: typeof(x: untyped; mode = typeOfIter): typedesc
typeOfIter:
TypeOfMode.typeOfIter
TypeOfMode:
system: TypeOfMode
typeOfProc:
TypeOfMode.typeOfProc
u:
htmlgen: u(e: varargs[untyped]): untyped
uc:
colortext: uc(s: static[string]): Rune
UIEvent:
dom: UIEvent
uint:
system: uint
uint16:
system: uint16
uint32:
system: uint32
Uint32Array:
jsutils: Uint32Array
uint64:
system: uint64
uint8:
system: uint8
Uint8Array:
jsutils: Uint8Array
ul:
htmlgen: ul(e: varargs[untyped]): untyped
ULONG:
winlean: ULONG
ULONG_PTR:
winlean: ULONG_PTR
Uname:
posix_utils: Uname
uname:
posix_utils: uname(): Uname
UncheckedArray:
system: UncheckedArray
underscoredCalls:
underscored_calls: underscoredCalls(result, calls, arg0: NimNode)
unescape:
dom: unescape(uri: cstring): cstring
strutils: unescape(s: string; prefix = "\""; suffix = "\""): string
unhandledExceptionHook:
system: unhandledExceptionHook
unicodeLetter:
pegs: unicodeLetter(): Peg
unicodeLower:
pegs: unicodeLower(): Peg
unicodeTitle:
pegs: unicodeTitle(): Peg
unicodeUpper:
pegs: unicodeUpper(): Peg
unicodeWhitespace:
pegs: unicodeWhitespace(): Peg
unidecode:
unidecode: unidecode(s: string): string
unified:
colordiff: unified(conf: DiffFormatConf): bool
unindent:
strutils: unindent(s: string; count: Natural = int.high; padding: string = " "): string
union:
packedsets: union[A](s1, s2: PackedSet[A]): PackedSet[A]
sets: union[A](s1, s2: HashSet[A]): HashSet[A]
unixToNativePath:
os: unixToNativePath(path: string; drive = ""): string
unlikely:
system: unlikely(val: bool): bool
unloadLib:
dynlib: unloadLib(lib: LibHandle)
unmapMem:
memfiles: unmapMem(f: var MemFile; p: pointer; size: int)
unmapViewOfFile:
winlean: unmapViewOfFile(lpBaseAddress: pointer): WINBOOL
Unmarshals:
Module json
unown:
system: unown(x: typed): untyped
UnpackDefect:
options: UnpackDefect
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:
selectors: unregister[T](s: Selector[T]; fd: int | SocketHandle | cint)
selectors: unregister[T](s: Selector[T]; ev: SelectEvent)
unregisterWait:
winlean: unregisterWait(WaitHandle: Handle): DWORD
unsafeAddr:
system: unsafeAddr[T](x: T): ptr T
unsafeColumnAt:
db_mysql: unsafeColumnAt(row: InstantRow; index: int): cstring
db_odbc: unsafeColumnAt(row: InstantRow; index: int): cstring
db_postgres: unsafeColumnAt(row: InstantRow; index: int): cstring
db_sqlite: unsafeColumnAt(row: InstantRow; index: int32): cstring
unsafeGet:
options: unsafeGet[T](self: Option[T]): lent T
results: unsafeGet[T, E](self: var Result[T, E]): var T
results: unsafeGet[T, E](self: Result[T, E]): lent T
results: unsafeGet[E](self: Result[void, E])
unsafeIsolate:
isolation: unsafeIsolate[T](value: sink T): Isolated[T]
unsafeNew:
system: unsafeNew[T: ref](a: var T; size: Natural)
unsafeNewFetchOptions:
jsfetch: unsafeNewFetchOptions(metod, body, mode, credentials, cache, referrerPolicy: cstring; keepalive: bool; redirect = "follow".cstring; referrer = "client".cstring; integrity = "".cstring; headers: Headers = newHeaders()): FetchOptions
unsafeRead:
threadpool: unsafeRead[T](fv: FlowVar[ref T]): ptr T
unsetControlCHook:
system: unsetControlCHook()
untyped:
system: untyped
unzip:
sequtils: unzip[S, T](s: openArray[(S, T)]): (seq[S], seq[T])
update:
sha1: update(ctx: var Sha1State; data: openArray[char])
updateHandle:
selectors: updateHandle[T](s: Selector[T]; fd: int | SocketHandle; events: set[Event])
upperBound:
algorithm: upperBound[T, K](a: openArray[T]; key: K; cmp: proc (x: T; k: K): int {.closure.}): int
algorithm: upperBound[T](a: openArray[T]; key: T): int
urandom:
sysrand: urandom(size: Natural): seq[byte]
sysrand: urandom(dest: var openArray[byte]): bool
Uri:
uri: Uri
UriParseError:
uri: UriParseError
uriParseError:
uri: uriParseError(msg: string)
Url:
uri: Url
useEmpty:
FormatFlag.useEmpty
useEnvironment:
FormatFlag.useEnvironment
useKey:
FormatFlag.useKey
useWinUnicode:
winlean: useWinUnicode
UTC:
jscore: UTC(d: DateLib): int
utc:
times: utc(): Timezone
times: utc(dt: DateTime): DateTime
times: utc(t: Time): DateTime
utcOffset:
times: utcOffset(dt: DateTime): int
Utf16Char:
widestrs: Utf16Char
utf8:
unicode: utf8(s: string): string
utoa2Digits:
digitsutils: utoa2Digits(buf: var openArray[char]; pos: int; digits: uint32)
validateData:
cgi: validateData(data: StringTableRef; validKeys: varargs[string])
validateUtf8:
unicode: validateUtf8(s: string): int
validIdentifier:
strutils: validIdentifier(s: string): bool
ValidityState:
dom: ValidityState
value:
dom: value(n: Node): cstring
macrocache: value(c: CacheCounter): int
results: value[T, E](self: Result[T, E]): T
results: value[T, E](self: var Result[T, E]): var T
results: value[E](self: Result[void, E])
results: value[E](self: var Result[void, E])
value=:
dom: value=(n: Node; v: cstring)
ValueError:
system: ValueError
ValueId:
dod_helpers: ValueId
ValueIdMask:
dod_helpers: ValueIdMask
valueOr:
results: valueOr[T, E](self: Result[T, E]; def: T): T
values:
critbits: values[T](c: CritBitTree[T]): T
jsformdata: values(self: FormData): seq[cstring]
jsheaders: values(self: Headers): seq[cstring]
strtabs: values(t: StringTableRef): string
tables: values[A](t: CountTable[A]): int
tables: values[A](t: CountTableRef[A]): int
tables: values[A, B](t: OrderedTable[A, B]): lent B
tables: values[A, B](t: OrderedTableRef[A, B]): lent B
tables: values[A, B](t: Table[A, B]): lent B
tables: values[A, B](t: TableRef[A, B]): lent B
ValueStore:
dod_helpers: ValueStore
valuesWithPrefix:
critbits: valuesWithPrefix[T](c: CritBitTree[T]; prefix: string): T
varargs:
system: varargs
varargsLen:
macros: varargsLen(x: varargs[untyped]): int
variance:
stats: variance[T](x: openArray[T]): float
stats: variance(s: RunningStat): float
varianceS:
stats: varianceS[T](x: openArray[T]): float
stats: varianceS(s: RunningStat): float
verboseFmtStr:
logging: verboseFmtStr
vibrate:
dom: vibrate(self: Navigator; pattern: cint): bool
dom: vibrate(self: Navigator; pattern: openArray[cint]): bool
video:
htmlgen: video(e: varargs[untyped]): untyped
vmTrace:
vmutils: vmTrace(on: bool)
void:
system: void
volatileLoad:
volatile: volatileLoad[T](src: ptr T): T
volatileStore:
volatile: volatileStore[T](dest: ptr T; val: T)
wait:
locks: wait(cond: var Cond; lock: var Lock)
WAIT_FAILED:
winlean: WAIT_FAILED
waitForExit:
osproc: waitForExit(p: Process; timeout: int = -1): int
waitForMultipleObjects:
winlean: waitForMultipleObjects(nCount: DWORD; lpHandles: PWOHandleArray; bWaitAll: WINBOOL; dwMilliseconds: DWORD): DWORD
waitForSingleObject:
winlean: waitForSingleObject(hHandle: Handle; dwMilliseconds: int32): int32
WAIT_OBJECT_0:
winlean: WAIT_OBJECT_0
WAITORTIMERCALLBACK:
winlean: WAITORTIMERCALLBACK
WAIT_TIMEOUT:
winlean: WAIT_TIMEOUT
walkDir:
os: walkDir(dir: string; relative = false; checkDir = false): tuple[ kind: PathComponent, path: string]
walkDirRec:
os: walkDirRec(dir: string; yieldFilter = {pcFile}; followFilter = {pcDir}; relative = false; checkDir = false): string
walkDirRecFilter:
globs: walkDirRecFilter(dir: string; follow: proc (entry: PathEntry): bool = nil; relative = false; checkDir = true): PathEntry
walkDirs:
os: walkDirs(pattern: string): string
walkFiles:
os: walkFiles(pattern: string): string
walkPattern:
os: walkPattern(pattern: string): string
warn:
jsconsole: warn(console: Console)
logging: warn(args: varargs[string, `$`])
warning:
macros: warning(msg: string; n: NimNode = nil)
warningStr:
parsecfg: warningStr(c: CfgParser; msg: string): string
wasMoved:
system: wasMoved[T](obj: var T)
wbr:
htmlgen: wbr(e: varargs[untyped]): untyped
WeekDay:
times: WeekDay
weekday:
times: weekday(dt: DateTime): WeekDay
Weeks:
TimeUnit.Weeks
weeks:
times: weeks(w: int): TimeInterval
whitespace:
pegs: whitespace(): Peg
Whitespace:
strutils: Whitespace
WideCString:
widestrs: WideCString
WideCStringObj:
widestrs: WideCStringObj
width:
colortext: width(text: ColText): int
WIN32_FIND_DATA:
winlean: WIN32_FIND_DATA
WINBOOL:
winlean: WINBOOL
WinChar:
winlean: WinChar
Window:
dom: Window
window:
dom: window
WinSizeT:
winlean: WinSizeT
with:
with: with(arg: typed; calls: varargs[untyped]): untyped
withData:
selectors: withData[T](s: Selector[T]; fd: SocketHandle | int; value, body: untyped)
selectors: withData[T](s: Selector[T]; fd: SocketHandle | int; value, body1, body2: untyped)
withDir:
nimscript: withDir(dir: string; body: untyped): untyped
withLock:
locks: withLock(a: Lock; body: untyped)
withRLock:
rlocks: withRLock(lock: RLock; code: untyped)
withValue:
tables: withValue[A, B](t: var Table[A, B]; key: A; value, body: untyped)
tables: withValue[A, B](t: var Table[A, B]; key: A; value, body1, body2: untyped)
WOHandleArray:
winlean: WOHandleArray
wrapConnectedSocket:
net: wrapConnectedSocket(ctx: SslContext; socket: Socket; handshake: SslHandshakeType; hostname: string = "")
wrapSocket:
net: wrapSocket(ctx: SslContext; socket: Socket)
wrapToInt:
jsbigints: wrapToInt(this: JsBigInt; bits: Natural): JsBigInt
wrapToUint:
jsbigints: wrapToUint(this: JsBigInt; bits: Natural): JsBigInt
wrapWords:
wordwrap: wrapWords(s: string; maxLineWidth = 80; splitLongWords = true; seps: set[char] = Whitespace; newLine = " "): string
write:
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:
io: writeBuffer(f: File; buffer: pointer; len: Natural): int
writeBytes:
io: writeBytes(f: File; a: openArray[int8 | uint8]; start, len: Natural): int
writeChars:
io: writeChars(f: File; a: openArray[char]; start, len: Natural): int
writeConfig:
parsecfg: writeConfig(dict: Config; stream: Stream)
parsecfg: writeConfig(dict: Config; filename: string)
writeContentType:
cgi: writeContentType()
writeData:
streams: writeData(s: Stream; buffer: pointer; bufLen: int)
WriteDbEffect:
db_common: WriteDbEffect
WriteDirEffect:
os: WriteDirEffect
WriteEnvEffect:
os: WriteEnvEffect
writeErrorMessage:
cgi: writeErrorMessage(data: string)
writeFile:
io: writeFile(filename: string; content: openArray[byte])
io: writeFile(filename, content: string)
winlean: writeFile(hFile: Handle; buffer: pointer; nNumberOfBytesToWrite: int32; lpNumberOfBytesWritten: ptr int32; lpOverlapped: pointer): WINBOOL
writeIndexFile:
rstgen: writeIndexFile(g: var RstGenerator; outfile: string)
WriteIOEffect:
system: WriteIOEffect
writeLine:
io: writeLine[Ty](f: File; x: varargs[Ty, `$`])
streams: writeLine(s: Stream; args: varargs[string, `$`])
writeln:
dom: writeln(d: Document; text: cstring)
WriteSocketStream:
socketstreams: WriteSocketStream
WriteSocketStreamObj:
socketstreams: WriteSocketStreamObj
writeStackTrace:
system: writeStackTrace()
writeStyled:
terminal: writeStyled(txt: string; style: set[Style] = {styleBright})
writeVu64:
varints: writeVu64(z: var openArray[byte]; x: uint64): int
WrongCustomCondition:
MatchingErrorKind.WrongCustomCondition
WrongIdent:
MatchingErrorKind.WrongIdent
WrongKindLength:
MatchingErrorKind.WrongKindLength
WrongKindValue:
MatchingErrorKind.WrongKindValue
wsaCloseEvent:
winlean: wsaCloseEvent(hEvent: Handle): bool
wsaCreateEvent:
winlean: wsaCreateEvent(): Handle
WSAData:
winlean: WSAData
WSADESCRIPTION_LEN:
winlean: WSADESCRIPTION_LEN
WSAEADDRINUSE:
winlean: WSAEADDRINUSE
WSAECONNABORTED:
winlean: WSAECONNABORTED
WSAECONNRESET:
winlean: WSAECONNRESET
WSAEDISCON:
winlean: WSAEDISCON
WSAEINPROGRESS:
winlean: WSAEINPROGRESS
WSAEINTR:
winlean: WSAEINTR
WSAENETRESET:
winlean: WSAENETRESET
WSAENOTSOCK:
winlean: WSAENOTSOCK
WSAESHUTDOWN:
winlean: WSAESHUTDOWN
WSAETIMEDOUT:
winlean: WSAETIMEDOUT
wsaEventSelect:
winlean: wsaEventSelect(s: SocketHandle; hEventObject: Handle; lNetworkEvents: clong): cint
WSAEWOULDBLOCK:
winlean: WSAEWOULDBLOCK
wsaGetLastError:
winlean: wsaGetLastError(): cint
WSAID_ACCEPTEX:
winlean: WSAID_ACCEPTEX
WSAID_CONNECTEX:
winlean: WSAID_CONNECTEX
WSAID_GETACCEPTEXSOCKADDRS:
winlean: WSAID_GETACCEPTEXSOCKADDRS
WSAIoctl:
winlean: WSAIoctl(s: SocketHandle; dwIoControlCode: DWORD; lpvInBuffer: pointer; cbInBuffer: DWORD; lpvOutBuffer: pointer; cbOutBuffer: DWORD; lpcbBytesReturned: PDWORD; lpOverlapped: POVERLAPPED; lpCompletionRoutine: POVERLAPPED_COMPLETION_ROUTINE): cint
WSAIORW:
winlean: WSAIORW(x, y): untyped
WSANOTINITIALISED:
winlean: WSANOTINITIALISED
WSAPROC_ACCEPTEX:
winlean: WSAPROC_ACCEPTEX
WSAPROC_CONNECTEX:
winlean: WSAPROC_CONNECTEX
WSAPROC_GETACCEPTEXSOCKADDRS:
winlean: WSAPROC_GETACCEPTEXSOCKADDRS
WSARecv:
winlean: WSARecv(s: SocketHandle; buf: ptr TWSABuf; bufCount: DWORD; bytesReceived, flags: PDWORD; lpOverlapped: POVERLAPPED; completionProc: POVERLAPPED_COMPLETION_ROUTINE): cint
WSARecvFrom:
winlean: WSARecvFrom(s: SocketHandle; buf: ptr TWSABuf; bufCount: DWORD; bytesReceived: PDWORD; flags: PDWORD; name: ptr SockAddr; namelen: ptr cint; lpOverlapped: POVERLAPPED; completionProc: POVERLAPPED_COMPLETION_ROUTINE): cint
wsaResetEvent:
winlean: wsaResetEvent(hEvent: Handle): bool
WSASend:
winlean: WSASend(s: SocketHandle; buf: ptr TWSABuf; bufCount: DWORD; bytesSent: PDWORD; flags: DWORD; lpOverlapped: POVERLAPPED; completionProc: POVERLAPPED_COMPLETION_ROUTINE): cint
WSASendTo:
winlean: WSASendTo(s: SocketHandle; buf: ptr TWSABuf; bufCount: DWORD; bytesSent: PDWORD; flags: DWORD; name: ptr SockAddr; namelen: cint; lpOverlapped: POVERLAPPED; completionProc: POVERLAPPED_COMPLETION_ROUTINE): cint
wsaStartup:
winlean: wsaStartup(wVersionRequired: int16; WSData: ptr WSAData): cint
WSASYS_STATUS_LEN:
winlean: WSASYS_STATUS_LEN
WT_EXECUTEDEFAULT:
winlean: WT_EXECUTEDEFAULT
WT_EXECUTEINIOTHREAD:
winlean: WT_EXECUTEINIOTHREAD
WT_EXECUTEINPERSISTENTIOTHREAD:
winlean: WT_EXECUTEINPERSISTENTIOTHREAD
WT_EXECUTEINPERSISTENTTHREAD:
winlean: WT_EXECUTEINPERSISTENTTHREAD
WT_EXECUTEINTIMERTHREAD:
winlean: WT_EXECUTEINTIMERTHREAD
WT_EXECUTEINUITHREAD:
winlean: WT_EXECUTEINUITHREAD
WT_EXECUTEINWAITTHREAD:
winlean: WT_EXECUTEINWAITTHREAD
WT_EXECUTELONGFUNCTION:
winlean: WT_EXECUTELONGFUNCTION
WT_EXECUTEONLYONCE:
winlean: WT_EXECUTEONLYONCE
WT_TRANSFER_IMPERSONATION:
winlean: WT_TRANSFER_IMPERSONATION
XML:
Module htmlgen
Module parsexml
xmlAttribute:
XmlEventKind.xmlAttribute
XmlAttributes:
xmltree: XmlAttributes
xmlCData:
XmlEventKind.xmlCData
xmlCharData:
XmlEventKind.xmlCharData
xmlCheckedTag:
htmlgen: xmlCheckedTag(argsList: NimNode; tag: string; optAttr = ""; reqAttr = ""; isLeaf = false): NimNode
xmlComment:
XmlEventKind.xmlComment
xmlElementClose:
XmlEventKind.xmlElementClose
xmlElementEnd:
XmlEventKind.xmlElementEnd
xmlElementOpen:
XmlEventKind.xmlElementOpen
xmlElementStart:
XmlEventKind.xmlElementStart
xmlEncode:
cgi: xmlEncode(s: string): string
xmlEntity:
XmlEventKind.xmlEntity
xmlEof:
XmlEventKind.xmlEof
xmlError:
XmlEventKind.xmlError
XmlError:
xmlparser: XmlError
XmlErrorKind:
parsexml: XmlErrorKind
XmlEventKind:
parsexml: XmlEventKind
xmlHeader:
xmltree: xmlHeader
XmlNode:
xmltree: XmlNode
XmlNodeKind:
xmltree: XmlNodeKind
XmlParseOption:
parsexml: XmlParseOption
XmlParser:
parsexml: XmlParser
xmlPI:
XmlEventKind.xmlPI
xmlSpecial:
XmlEventKind.xmlSpecial
xmlWhitespace:
XmlEventKind.xmlWhitespace
xnCData:
XmlNodeKind.xnCData
xnComment:
XmlNodeKind.xnComment
xnElement:
XmlNodeKind.xnElement
xnEntity:
XmlNodeKind.xnEntity
xnText:
XmlNodeKind.xnText
xnVerbatimText:
XmlNodeKind.xnVerbatimText
year:
times: year(dt: DateTime): int
yearday:
times: yearday(dt: DateTime): YeardayRange
YeardayRange:
times: YeardayRange
Years:
TimeUnit.Years
years:
times: years(y: int): TimeInterval
ze:
system: ze(x: int16): int
system: ze(x: int8): int
ze64:
system: ze64(x: int): int64
system: ze64(x: int16): int64
system: ze64(x: int32): int64
system: ze64(x: int8): int64
zeroMem:
system: zeroMem(p: pointer; size: Natural)
Module typetraits
Module typetraits
zip:
sequtils: zip[S, T](s1: openArray[S]; s2: openArray[T]): seq[(S, T)]
text_layouter: zip[T1, T2, T3, T4, T5](s1: seq[T1]; s2: seq[T2]; s3: seq[T3]; s4: seq[T4]; s5: seq[T5]): tuple[v1: T1, v2: T2, v3: T3, v4: T4, v5: T5]
zipToMax:
diff: zipToMax[T](lhs, rhs: seq[T]; fill: T = default(T)): tuple[lhs, rhs: T, rhsDefault, lhsDefault: bool, idx: int]
ZonedTime:
times: ZonedTime
zonedTimeFromAdjTime:
times: zonedTimeFromAdjTime(zone: Timezone; adjTime: Time): ZonedTime
zonedTimeFromTime:
times: zonedTimeFromTime(zone: Timezone; time: Time): ZonedTime