Index
Documents:
Embedded Nim Debugger (ENDB) User Guide
,
Embedded Stack Trace Profiler (ESTP) User Guide
,
Nim Compiler User Guide
,
Nim DocGen Tools Guide
,
Nim Documentation Overview
,
Nim Enhancement Proposal #1 - Standard Library Style Guide
,
Nim IDE Integration Guide
,
Nim IDE Integration Guide
,
Nim maintenance script
,
Nim Manual
,
Nim Standard Library
,
Nim Tutorial (Part I)
,
Nim Tutorial (Part II)
,
Nim's Garbage Collector
,
Nimfix User Guide
,
nimgrep User's manual
,
niminst User's manual
,
NimScript
,
Source Code Filters
.
Modules:
actors
,
algorithm
,
asyncdispatch
,
asyncfile
,
asyncftpclient
,
asynchttpserver
,
asyncio
,
asyncnet
,
base64
,
basic2d
,
basic3d
,
browsers
,
cgi
,
channels
,
colors
,
complex
,
contributing
,
cookies
,
coro
,
cpuinfo
,
critbits
,
db_common
,
db_mysql
,
db_postgres
,
db_sqlite
,
deques
,
dom
,
dynlib
,
encodings
,
endians
,
events
,
fenv
,
fsmonitor
,
ftpclient
,
future
,
hashes
,
highlite
,
htmlgen
,
htmlparser
,
httpclient
,
httpcore
,
httpserver
,
intsets
,
json
,
lexbase
,
lists
,
locks
,
logging
,
macros
,
marshal
,
matchers
,
math
,
md5
,
memfiles
,
mersenne
,
mimetypes
,
nativesockets
,
net
,
nimprof
,
nimscript
,
nre
,
oids
,
options
,
os
,
ospaths
,
osproc
,
parsecfg
,
parsecsv
,
parseopt
,
parseopt2
,
parsesql
,
parseutils
,
parsexml
,
pegs
,
posix
,
queues
,
random
,
rationals
,
rdstdin
,
re
,
rlocks
,
ropes
,
rst
,
rstast
,
rstgen
,
scgi
,
securehash
,
selectors
,
sequtils
,
sets
,
smtp
,
ssl
,
stats
,
streams
,
strmisc
,
strscans
,
strtabs
,
strutils
,
subexes
,
system
,
tables
,
terminal
,
threadpool
,
threads
,
times
,
typeinfo
,
typetraits
,
unicode
,
unidecode
,
unittest
,
uri
,
util
,
winlean
,
xmldom
,
xmldomparser
,
xmlparser
,
xmltree
.
Documentation files
Embedded Nim Debugger (ENDB) User Guide
General Commands
Executing Commands
Breakpoint Commands
The
breakpoint
pragma
The
watchpoint
pragma
Data Display Commands
Embedded Stack Trace Profiler (ESTP) User Guide
Memory profiler
Example results file
Nim Compiler User Guide
Introduction
Compiler Usage
Command line switches
List of warnings
Verbosity levels
Compile time symbols
Configuration files
debug build
release build
Search path handling
Generated C code directory
Compilation cache
rod
symbol files
incremental compilation
Cross compilation
DLL generation
Additional compilation switches
malloc
Additional Features
LineDir option
StackTrace option
LineTrace option
Debugger option
Breakpoint pragma
DynlibOverride
Backend language options
Nim documentation tools
doc
doc2
Nim idetools integration
Nim for embedded systems
standalone
AVR
Nim for realtime systems
Debugging with Nim
Optimizing for Nim
Optimizing string handling
shallow
freeze
Nim DocGen Tools Guide
Introduction
documentation generation tools
Documentation Comments
Nim file input
Document Types
HTML
JSON
Related Options
Project switch
Index switch
See source switch
Other Input Formats
HTML anchor generation
Index (idx) file format
Additional resources
Nim Documentation Overview
Nim Enhancement Proposal #1 - Standard Library Style Guide
Introduction
Spacing and Whitespace Conventions
Naming Conventions
Coding Conventions
Conventions for multi-line statements and expressions
Nim IDE Integration Guide
Idetools invocation
Specifying the location of the query
Definitions
Suggestions
Invocation context
Symbol usages
Expression evaluation
Compiler as a service (CAAS)
Parsing idetools output
skConst
skEnumField
skForVar
skIterator, skClosureIterator
skLabel
skLet
skMacro
skMethod
skParam
skProc
skResult
skTemplate
skType
skVar
Test suite
Running the test suite
Test case file format
Nim IDE Integration Guide
Installation
Nimsuggest invocation
Specifying the location of the query
Definitions
Suggestions
Invocation context
Symbol usages
Parsing nimsuggest output
Nim maintenance script
Introduction
koch
Commands
boot command
boot
clean command
clean
csource command
csource
inno command
inno
install command
install
temp command
test command
test
update command
update
web command
web
zip command
zip
Nim Manual
About this document
Definitions
locations
type
static type
dynamic type
identifier
scope
l-values
constant expressions
static error
checked runtime error
unchecked runtime error
safe
Lexical Analysis
Encoding
Indentation
indentation sensitive
Comments
comment pieces
Documentation comments
Multiline comments
Identifiers & Keywords
Identifier equality
partial case insensitivity
style-insensitive
String literals
escape sequences
newline
carriage return
line feed
form feed
tabulator
vertical tabulator
backslash
quotation mark
apostrophe
character with decimal value d
alert
backspace
escape
[ESC]
character with hex value HH
Triple quoted string literals
Raw string literals
Generalized raw string literals
Character literals
newline
escape sequences
carriage return
line feed
form feed
tabulator
vertical tabulator
backslash
quotation mark
apostrophe
character with decimal value d
alert
backspace
escape
[ESC]
character with hex value HH
Numerical constants
type suffix
Operators
Other tokens
slice
Syntax
Associativity
Precedence
sigil-like
arrow like
Grammar
Types
Ordinal types
Pre-defined integer types
unsigned integer
Automatic type conversion
narrowing type conversion
widening type conversion
Subrange types
interval arithmetic
Pre-defined floating point types
FloatInvalidOpError
FloatDivByZeroError
FloatOverflowError
FloatUnderflowError
FloatInexactError
FloatingPointError
NaNChecks
InfChecks
floatChecks
Boolean type
bool
Character type
Enumeration types
String type
cstring type
Structured types
Array and sequence types
Open arrays
openarray
Varargs
Tuples and object types
Object construction
object construction expression
Object variants
discriminator
Set type
Reference and pointer types
aliasing
traced
untraced
Not nil annotation
Memory regions
Procedural type
functional
calling conventions
nimcall
closure
stdcall
cdecl
safecall
inline
fastcall
syscall
noconv
Distinct type
base type
Modelling currencies
units
borrow
Avoiding SQL injection attacks
SQL injection attack
Void type
Auto type
Type relations
Type equality
Type equality modulo type distinction
Subtype relation
Convertible relation
converter
Assignment compatibility
Overloading resolution
Overloading based on 'var T'
l-value
Automatic dereferencing
Automatic self insertions
this
Lazy type resolution for untyped
unresolved
Varargs matching
Statements and expressions
simple statements
complex statements
dangling else problem
Statement list expression
Discard statement
discardable
Void context
Var statement
noinit
requiresInit
control flow analysis
let statement
single assignment
Tuple unpacking
Const section
Constants
Static statement/expression
If statement
Case statement
When statement
When nimvm statement
Return statement
result
Yield statement
Block statement
Break statement
While statement
Continue statement
Assembler statement
Using statement
experimental
If expression
When expression
Case expression
Table constructor
Type conversions
Type casts
The addr operator
Procedures
methods
functions
procedures
forward
result
Operators
Export marker
asterisk
Method call syntax
Properties
Command invocation syntax
Closures
Creating closures in loops
Anonymous Procs
Do notation
Nonoverloadable builtins
shadow
Var parameters
tuple unpacking
Var return type
Overloading of the subscript operator
Multi-methods
base
Iterators and the for statement
for
iterator
implicit block
Implict items/pairs invocations
First class iterators
inline iterator
closure iterator
collaborative tasking
Converters
Type sections
Exception handling
Try statement
exception handlers
except
finally
Try expression
Except clauses
Defer statement
Raise statement
re-raised
ReraiseError
Exception hierarchy
Effect system
Exception tracking
raises
Tag tracking
effect system
Read/Write tracking
Effects pragma
Generics
type parameters
Is operator
Type operator
typeof
Type Classes
implicitly generic
type constraints
Concepts
Symbol lookup in generics
mixin
Bind statement
Templates
Typed vs untyped parameters
immediate
Passing a code block to a template
Varargs of untyped
Symbol binding in templates
hygienic
Identifier construction
Lookup rules for template parameters
Hygiene in templates
hygienic
inject
gensym
dirty
Limitations of the method call syntax
Macros
domain specific languages
Expression Macros
BindSym
symbols
Statement Macros
Macros as pragmas
Special Types
static[T]
typedesc
Special Operators
dot operators
operator
.
operator
.()
operator
.=
Type bound operations
operator
=
destructors
finalizer
deepCopy
Term rewriting macros
Parameter constraints
parameter constraint
Pattern operators
The
|
operator
The
{}
operator
The
~
operator
The
*
operator
The
**
operator
Parameters
Example: Partial evaluation
Example: Hoisting
AST based overloading
Move optimization
Modules
namespace
information hiding
separate compilation
import
Recursive module dependencies
Import statement
Include statement
Module names in imports
From import statement
Export statement
Note on paths
Scope rules
Block scope
Tuple or object scope
Module scope
system
Compiler Messages
hint
warning
error
Pragmas
deprecated pragma
noSideEffect pragma
destructor pragma
override pragma
procvar pragma
compileTime pragma
noReturn pragma
acyclic pragma
final pragma
shallow pragma
pure pragma
asmNoStackFrame pragma
error pragma
fatal pragma
warning pragma
hint pragma
line pragma
linearScanEnd pragma
case
computedGoto pragma
case
unroll pragma
for
while
immediate pragma
compilation option pragmas
push and pop pragmas
push/pop
register pragma
global pragma
deadCodeElim pragma
pragma pragma
Disabling certain messages
experimental pragma
Implementation Specific Pragmas
Bitsize pragma
Volatile pragma
NoDecl pragma
Header pragma
IncompleteStruct pragma
Compile pragma
Link pragma
PassC pragma
PassL pragma
Emit pragma
C++
Objective C
ImportCpp pragma
C++
Namespaces
Importcpp for enums
Importcpp for procs
Wrapping constructors
constructor
Wrapping destructors
Importcpp for objects
ImportObjC pragma
Objective C
CodegenDecl pragma
InjectStmt pragma
compile time define pragmas
Foreign function interface
FFI
Importc pragma
Exportc pragma
Extern pragma
Bycopy pragma
Byref pragma
Varargs pragma
Union pragma
Packed pragma
Unchecked pragma
Dynlib pragma for import
Dynlib pragma for export
Threads
Thread pragma
no heap sharing restriction
GC safety
GC safe
gcsafe
Threadvar pragma
thread-local
Threads and exceptions
Parallel & Spawn
Structured
Unstructured
Spawn statement
spawn
data flow variable
Parallel statement
disjoint checker
Guards and locks
guard
locks
lock levels
Guards and the locks section
Protecting global variables
Protecting general locations
path analysis
Lock levels
Taint mode
TaintedString
Nim Standard Library
Pure libraries
Core
Collections and algorithms
String handling
Generic Operating System Services
Math libraries
Internet Protocols and Support
Parsers
XML Processing
Cryptography and Hashing
Multimedia support
Miscellaneous
Modules for JS backend
Deprecated modules
Impure libraries
Regular expressions
Database support
Other
Wrappers
Windows specific
UNIX specific
Regular expressions
GUI libraries
Database support
Network Programming and Internet Protocols
Scientific computing
Nimble
Official packages
Unofficial packages
Nim Tutorial (Part I)
Introduction
The first program
local type inference
Lexical elements
String and character literals
Comments
Numbers
The var statement
The assignment statement
Constants
The let statement
Control flow statements
If statement
Case statement
While statement
For statement
Scopes and the block statement
Break statement
Continue statement
When statement
Statements and indentation
Procedures
Result variable
Parameters
Discard statement
Named arguments
Default values
Overloaded procedures
Operators
Forward declarations
Iterators
Basic types
Booleans
Characters
Strings
Integers
arithmetic bit shifts
Automatic type conversion
EOutOfRange
Floats
Type Conversion
Internal type representation
Advanced types
Enumerations
Ordinal types
Subranges
Sets
Arrays
Sequences
Open arrays
openarray
Varargs
Slices
Tuples
Reference and pointer types
traced
untraced
Procedural type
functional
Distinct type
Modules
information hiding
separate compilation
import
Excluding symbols
From statement
Include statement
Part 2
Nim Tutorial (Part II)
Introduction
Pragmas
Object Oriented Programming
Objects
Mutually recursive types
Type conversions
type casts
type conversions
Object variants
Methods
Method call syntax
Properties
array properties
Dynamic dispatch
Exceptions
Raise statement
Try statement
Annotating procs with raised exceptions
Generics
type parameters
Templates
Macros
Expression Macros
Statement Macros
Building your first macro
Generating source code
Generating AST by hand
Example Templates and Macros
Lifting Procs
Identifier Mangling
Compilation to JavaScript
Nim's Garbage Collector
Introduction
realtime systems
Cycle collector
Realtime support
useRealtimeGC
Time measurement
Tweaking the GC
Keeping track of memory
Nimfix User Guide
Installation
Usage
nimgrep User's manual
Installation
Command line switches
niminst User's manual
Introduction
Configuration file
Project section
files
key
Config section
Documentation section
Other section
Lib section
Windows section
UnixBin section
Unix section
InnoSetup section
C_Compiler section
Real world example
NimScript
NimScript as a configuration file
NimScript as a build tool
Nimble integration
Standalone NimScript
Source Code Filters
Pipe operator
Available filters
Replace filter
Strip filter
StdTmpl filter
API symbols
`!$`:
hashes : `!$`(h: Hash): Hash
`!&`:
hashes : `!&`(h: Hash; val: int): Hash
`!*\`:
pegs : `!*\`(a: Peg): Peg
`!*`:
pegs : `!*`(a: Peg): Peg
`!=`:
system : `!=`(x, y: untyped): untyped
`!`:
macros : `!`(s: string): NimIdent
pegs : `!`(a: Peg): Peg
`$$`:
marshal : `$$`[T](x: T): string
`$`:
basic2d : `$`(t: Matrix2d): string
basic2d : `$`(p: Point2d): string
basic2d : `$`(v: Vector2d): string
basic3d : `$`(m: Matrix3d): string
basic3d : `$`(p: Point3d): string
basic3d : `$`(v: Vector3d): string
colors : `$`(c: Color): string
complex : `$`(z: Complex): string
critbits : `$`[T](c: CritBitTree[T]): string
deques : `$`[T](deq: Deque[T]): string
httpcore : `$`(code: HttpCode): string
httpcore : `$`(httpMethod: HttpMethod): string
intsets : `$`(s: IntSet): string
json : `$`(node: JsonNode): string
lists : `$`[T](L: DoublyLinkedList[T]): string
lists : `$`[T](L: DoublyLinkedRing[T]): string
lists : `$`[T](L: SinglyLinkedList[T]): string
lists : `$`[T](L: SinglyLinkedRing[T]): string
macros : `$`(i: NimIdent): string
macros : `$`(node: NimNode): string
macros : `$`(s: NimSym): string
md5 : `$`(d: MD5Digest): string
memfiles : `$`(ms: MemSlice): 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
pegs : `$`(r: Peg): string
queues : `$`[T](q: Queue[T]): string
rationals : `$`[T](x: Rational[T]): string
ropes : `$`(r: Rope): string
securehash : `$`(self: SecureHash): string
selectors : `$`(x: SocketHandle): string
sets : `$`[A](s: HashSet[A]): string
sets : `$`[A](s: OrderedSet[A]): string
smtp : `$`(msg: Message): string
strtabs : `$`(t: StringTableRef): string
system : `$`(x: bool): string
system : `$`(x: char): string
system : `$`(x: cstring): string
system : `$`[Enum: enum](x: Enum): string
system : `$`(x: float): string
system : `$`(x: int): string
system : `$`(x: int64): string
system : `$`[T](x: seq[T]): string
system : `$`[T](x: set[T]): string
system : `$`(x: string): string
system : `$`[T: tuple | object](x: T): string
system : `$`(x: uint64): string
system : `$`(s: WideCString): string
system : `$`(w: WideCString; estimate: int; replacement: int = 0x0000FFFD): string
tables : `$`[A](t: CountTable[A]): string
tables : `$`[A](t: CountTableRef[A]): string
tables : `$`[A, B](t: OrderedTable[A, B]): string
tables : `$`[A, B](t: OrderedTableRef[A, B]): string
tables : `$`[A, B](t: Table[A, B]): string
tables : `$`[A, B](t: TableRef[A, B]): string
times : `$`(m: Month): string
times : `$`(time: Time): string
times : `$`(timeInfo: TimeInfo): string
times : `$`(day: WeekDay): string
unicode : `$`(rune: Rune): string
unicode : `$`(runes: seq[Rune]): string
uri : `$`(u: Uri): string
uri : `$`(url: Url): string
xmldom : `$`(doc: PDocument): string
xmltree : `$`(n: XmlNode): string
`%%`:
system : `%%`(x, y: int64): int64
system : `%%`[IntMax32](x, y: IntMax32): IntMax32
`%*`:
json : `%*`(x: untyped): untyped
`%`:
json : `%`[](o: object): JsonNode
json : `%`(n: BiggestInt): JsonNode
json : `%`(b: bool): JsonNode
json : `%`(n: float): JsonNode
json : `%`[T](elements: openArray[T]): JsonNode
json : `%`(keyVals: openArray[tuple[key: string, val: JsonNode]]): JsonNode
json : `%`[](o: ref object): JsonNode
json : `%`(s: string): JsonNode
json : `%`(j: JsonNode): 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
subexes : `%`(formatstr: Subex; a: openArray[string]): string
subexes : `%`(formatstr: Subex; a: string): string
`&=`:
basic2d : `&=`(p: var Point2d; t: Matrix2d)
basic2d : `&=`(v: var Vector2d; m: Matrix2d)
basic3d : `&=`(p: var Point3d; m: Matrix3d)
basic3d : `&=`(v: var Vector3d; m: Matrix3d)
net : `&=`(socket: Socket; data: typed)
system : `&=`(x: var string; y: string)
system : `&=`(f: File; x: typed)
system : `&=`(x, y: typed)
`&`:
basic2d : `&`(a, b: Matrix2d): Matrix2d
basic2d : `&`(p: Point2d; t: Matrix2d): Point2d
basic2d : `&`(v: Vector2d; m: Matrix2d): Vector2d
basic3d : `&`(a, b: Matrix3d): Matrix3d
basic3d : `&`(p: Point3d; m: Matrix3d): Point3d
basic3d : `&`(v: Vector3d; m: Matrix3d): Vector3d
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
system : `&`(x, y: char): string
system : `&`(x: char; y: string): string
system : `&`[T](x, y: seq[T]): seq[T]
system : `&`[T](x: seq[T]; y: T): seq[T]
system : `&`(x: string; y: char): string
system : `&`(x, y: string): string
system : `&`[T](x: T; y: seq[T]): seq[T]
`>%`:
system : `>%`(x, y: untyped): untyped
`>=%`:
system : `>=%`(x, y: untyped): untyped
`>=`:
system : `>=`(x, y: untyped): untyped
`>`:
system : `>`(x, y: untyped): untyped
`<%`:
system : `<%`(x, y: int64): bool
system : `<%`[IntMax32](x, y: IntMax32): bool
unicode : `<%`(a, b: Rune): bool
`<>`:
xmltree : `<>`(x: expr): expr
`<=%`:
system : `<=%`(x, y: int64): bool
system : `<=%`[IntMax32](x, y: IntMax32): bool
unicode : `<=%`(a, b: Rune): bool
`<=`:
rationals : `<=`[Rational](x, y: Rational): bool
sets : `<=`[A](s, t: HashSet[A]): bool
system : `<=`(x, y: bool): bool
system : `<=`(x, y: char): bool
system : `<=`[Enum: enum](x, y: Enum): bool
system : `<=`(x, y: float): bool
system : `<=`(x, y: float32): bool
system : `<=`(x, y: int): bool
system : `<=`(x, y: int16): bool
system : `<=`(x, y: int32): bool
system : `<=`(x, y: int64): bool
system : `<=`(x, y: int8): bool
system : `<=`(x, y: pointer): bool
system : `<=`[T](x, y: ref T): bool
system : `<=`[T](x, y: set[T]): bool
system : `<=`(x, y: string): bool
system : `<=`[T: SomeUnsignedInt](x, y: T): bool
system : `<=`[T: tuple](x, y: T): bool
times : `<=`(a, b: Time): bool
`<`:
rationals : `<`[Rational](x, y: Rational): bool
sets : `<`[A](s, t: HashSet[A]): bool
system : `<`(x, y: bool): bool
system : `<`(x, y: char): bool
system : `<`[Enum: enum](x, y: Enum): bool
system : `<`(x, y: float): bool
system : `<`(x, y: float32): bool
system : `<`(x, y: int): bool
system : `<`(x, y: int16): bool
system : `<`(x, y: int32): bool
system : `<`(x, y: int64): bool
system : `<`(x, y: int8): bool
system : `<`[T](x: Ordinal[T]): T
system : `<`(x, y: pointer): bool
system : `<`[T](x, y: ptr T): bool
system : `<`[T](x, y: ref T): bool
system : `<`[T](x, y: set[T]): bool
system : `<`(x, y: string): bool
system : `<`[T: SomeUnsignedInt](x, y: T): bool
system : `<`[T: tuple](x, y: T): bool
times : `<`(a, b: Time): bool
`*%`:
system : `*%`(x, y: int64): int64
system : `*%`[IntMax32](x, y: IntMax32): IntMax32
`*=`:
basic2d : `*=`(a115775: var Vector2d; b115777: float)
basic2d : `*=`(a115771: var Vector2d; b115773: Vector2d)
basic3d : `*=`(a122159: var Vector3d; b122161: float)
basic3d : `*=`(a122155: var Vector3d; b122157: Vector3d)
complex : `*=`(x: var Complex; y: Complex)
complex : `*=`(x: var Complex; y: float)
rationals : `*=`[T](x: var Rational[T]; y: Rational[T])
rationals : `*=`[T](x: var Rational[T]; y: T)
system : `*=`[T: SomeOrdinal | uint | uint64](x: var T; y: T)
system : `*=`[T: float | float32 | float64](x: var T; y: T)
`*`:
algorithm : `*`(x: int; order: SortOrder): int
basic2d : `*`(a115629: float; b115631: Vector2d): Vector2d
basic2d : `*`(a115625: Vector2d; b115627: float): Vector2d
basic2d : `*`(a115621, b115623: Vector2d): Vector2d
basic3d : `*`(a121973: float; b121975: Vector3d): Vector3d
basic3d : `*`(a121969: Vector3d; b121971: float): Vector3d
basic3d : `*`(a121965, b121967: Vector3d): Vector3d
complex : `*`(x, y: Complex): Complex
complex : `*`(x: Complex; y: float): Complex
complex : `*`(x: float; y: Complex): Complex
pegs : `*`(a: Peg): Peg
rationals : `*`[T](x, y: Rational[T]): Rational[T]
rationals : `*`[T](x: Rational[T]; y: T): Rational[T]
rationals : `*`[T](x: T; y: Rational[T]): Rational[T]
sets : `*`[A](s1, s2: HashSet[A]): HashSet[A]
system : `*`(x, y: float): float
system : `*`(x, y: float32): float32
system : `*`(x, y: int): int
system : `*`(x, y: int16): int16
system : `*`(x, y: int32): int32
system : `*`(x, y: int64): int64
system : `*`(x, y: int8): int8
system : `*`[T](x, y: set[T]): set[T]
system : `*`[T: SomeUnsignedInt](x, y: T): T
`+%`:
system : `+%`(x, y: int64): int64
system : `+%`[IntMax32](x, y: IntMax32): IntMax32
`+=`:
basic2d : `+=`(p: var Point2d; v: Vector2d)
basic2d : `+=`(a115667: var Vector2d; b115669: float)
basic2d : `+=`(a115663: var Vector2d; b115665: Vector2d)
basic3d : `+=`(p: var Point3d; v: Vector3d)
basic3d : `+=`(a122011: var Vector3d; b122013: float)
basic3d : `+=`(a122007: var Vector3d; b122009: Vector3d)
complex : `+=`(x: var Complex; y: Complex)
complex : `+=`(x: var Complex; y: float)
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: SomeOrdinal | uint | uint64](x: var T; y: T)
system : `+=`[T: float | float32 | float64](x: var T; y: T)
times : `+=`(t: var Time; ti: TimeInterval)
`+`:
basic2d : `+`(a115587: float; b115589: Vector2d): Vector2d
basic2d : `+`(p: Point2d; v: Vector2d): Point2d
basic2d : `+`(a115583: Vector2d; b115585: float): Vector2d
basic2d : `+`(a115579, b115581: Vector2d): Vector2d
basic3d : `+`(a121931: float; b121933: Vector3d): Vector3d
basic3d : `+`(p: Point3d; v: Vector3d): Point3d
basic3d : `+`(a121927: Vector3d; b121929: float): Vector3d
basic3d : `+`(a121923, b121925: Vector3d): Vector3d
colors : `+`(a, b: Color): Color
complex : `+`(x, y: Complex): Complex
complex : `+`(x: Complex; y: float): Complex
complex : `+`(x: float; y: Complex): Complex
pegs : `+`(a: Peg): Peg
rationals : `+`[T](x, y: Rational[T]): Rational[T]
rationals : `+`[T](x: Rational[T]; y: T): Rational[T]
rationals : `+`[T](x: T; y: Rational[T]): Rational[T]
sets : `+`[A](s1, s2: HashSet[A]): HashSet[A]
stats : `+`(a, b: RunningRegress): RunningRegress
stats : `+`(a, b: RunningStat): RunningStat
system : `+`(x: float): float
system : `+`(x, y: float): float
system : `+`(x: float32): float32
system : `+`(x, y: float32): float32
system : `+`(x: int): int
system : `+`(x, y: int): int
system : `+`(x: int16): int16
system : `+`(x, y: int16): int16
system : `+`(x: int32): int32
system : `+`(x, y: int32): int32
system : `+`(x: int64): int64
system : `+`(x, y: int64): int64
system : `+`(x: int8): int8
system : `+`(x, y: int8): int8
system : `+`[T](x, y: set[T]): set[T]
system : `+`[T: SomeUnsignedInt](x, y: T): T
times : `+`(t: Time; ti: TimeInterval): Time
times : `+`(a: TimeInfo; interval: TimeInterval): TimeInfo
times : `+`(ti1, ti2: TimeInterval): TimeInterval
`-%`:
system : `-%`(x, y: int64): int64
system : `-%`[IntMax32](x, y: IntMax32): IntMax32
`->`:
future : `->`(p, b: untyped): untyped
`-+-`:
sets : `-+-`[A](s1, s2: HashSet[A]): HashSet[A]
`--`:
nimscript : `--`(key: untyped)
nimscript : `--`(key, val: untyped)
`-=`:
basic2d : `-=`(p: var Point2d; v: Vector2d)
basic2d : `-=`(a115721: var Vector2d; b115723: float)
basic2d : `-=`(a115717: var Vector2d; b115719: Vector2d)
basic3d : `-=`(p: var Point3d; v: Vector3d)
basic3d : `-=`(a122085: var Vector3d; b122087: float)
basic3d : `-=`(a122081: var Vector3d; b122083: Vector3d)
complex : `-=`(x: var Complex; y: Complex)
complex : `-=`(x: var Complex; y: float)
rationals : `-=`[T](x: var Rational[T]; y: Rational[T])
rationals : `-=`[T](x: var Rational[T]; y: T)
system : `-=`[T: SomeOrdinal | uint | uint64](x: var T; y: T)
system : `-=`[T: float | float32 | float64](x: var T; y: T)
times : `-=`(t: var Time; ti: TimeInterval)
`-`:
basic2d : `-`(a115608: float; b115610: Vector2d): Vector2d
basic2d : `-`(p1, p2: Point2d): Vector2d
basic2d : `-`(p: Point2d; v: Vector2d): Point2d
basic2d : `-`(v: Vector2d): Vector2d
basic2d : `-`(a115604: Vector2d; b115606: float): Vector2d
basic2d : `-`(a115600, b115602: Vector2d): Vector2d
basic3d : `-`(a121952: float; b121954: Vector3d): Vector3d
basic3d : `-`(p1, p2: Point3d): Vector3d
basic3d : `-`(p: Point3d; v: Vector3d): Point3d
basic3d : `-`(v: Vector3d): Vector3d
basic3d : `-`(a121948: Vector3d; b121950: float): Vector3d
basic3d : `-`(a121944, b121946: Vector3d): Vector3d
colors : `-`(a, b: Color): Color
complex : `-`(z: Complex): Complex
complex : `-`(x, y: Complex): Complex
complex : `-`(x: Complex; y: float): Complex
complex : `-`(x: float; y: Complex): Complex
rationals : `-`[T](x: Rational[T]): Rational[T]
rationals : `-`[T](x, y: Rational[T]): Rational[T]
rationals : `-`[T](x: Rational[T]; y: T): Rational[T]
rationals : `-`[T](x: T; y: Rational[T]): Rational[T]
sets : `-`[A](s1, s2: HashSet[A]): HashSet[A]
system : `-`(x: float): float
system : `-`(x, y: float): float
system : `-`(x: float32): float32
system : `-`(x, y: float32): float32
system : `-`(x: int): int
system : `-`(x, y: int): int
system : `-`(x: int16): int16
system : `-`(x, y: int16): int16
system : `-`(x: int32): int32
system : `-`(x, y: int32): int32
system : `-`(x: int64): int64
system : `-`(x, y: int64): int64
system : `-`(x: int8): int8
system : `-`(x, y: int8): int8
system : `-`[T](x, y: set[T]): set[T]
system : `-`[T: SomeUnsignedInt](x, y: T): T
times : `-`(a, b: Time): int64
times : `-`(t: Time; ti: TimeInterval): Time
times : `-`(a: TimeInfo; interval: TimeInterval): TimeInfo
times : `-`(ti: TimeInterval): TimeInterval
times : `-`(ti1, ti2: TimeInterval): TimeInterval
`..<`:
system : `..<`[S, T](a: S; b: T): T
system : `..<`(a, b: untyped): untyped
`..^`:
system : `..^`(a, b: untyped): untyped
`..`:
system : `..`[T](b: T): Slice[T]
system : `..`[T](a, b: T): Slice[T]
system : `..`[S, T](a: S; b: T): T
`/%`:
system : `/%`(x, y: int64): int64
system : `/%`[IntMax32](x, y: IntMax32): IntMax32
`/../`:
os : `/../`(head, tail: string): string
ospaths : `/../`(head, tail: string): string
`//`:
rationals : `//`[T](num, den: T): Rational[T]
`/=`:
basic2d : `/=`(a115829: var Vector2d; b115831: float)
basic2d : `/=`(a115825: var Vector2d; b115827: Vector2d)
basic3d : `/=`(a122233: var Vector3d; b122235: float)
basic3d : `/=`(a122229: var Vector3d; b122231: Vector3d)
complex : `/=`(x: var Complex; y: Complex)
complex : `/=`(x: var Complex; y: float)
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)
`/`:
basic2d : `/`(a115650: float; b115652: Vector2d): Vector2d
basic2d : `/`(a115646: Vector2d; b115648: float): Vector2d
basic2d : `/`(a115642, b115644: Vector2d): Vector2d
basic3d : `/`(a121994: float; b121996: Vector3d): Vector3d
basic3d : `/`(a121990: Vector3d; b121992: float): Vector3d
basic3d : `/`(a121986, b121988: Vector3d): Vector3d
complex : `/`(x, y: Complex): Complex
complex : `/`(x: Complex; y: float): Complex
complex : `/`(x: float; y: Complex): Complex
os : `/`(head, tail: string): string
ospaths : `/`(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
uri : `/`(a, b: Url): Url
`=>`:
future : `=>`(p, b: untyped): untyped
`==`:
asyncdispatch : `==`(x: AsyncFD; y: AsyncFD): bool
colors : `==`(a, b: Color): bool
complex : `==`(x, y: Complex): bool
httpcore : `==`(a, b: HttpCode): bool
httpcore : `==`(rawCode: string; code: HttpCode): bool
httpcore : `==`(protocol: tuple[orig: string, major, minor: int]; ver: HttpVersion): bool
json : `==`(a, b: JsonNode): bool
macros : `==`(a, b: NimIdent): bool
macros : `==`(a, b: NimNode): bool
md5 : `==`(D1, D2: MD5Digest): bool
memfiles : `==`(x, y: MemSlice): 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 : `==`[Option](a, b: Option): bool
os : `==`(err1, err2: OSErrorCode): bool
posix : `==`(x, y: SocketHandle): bool
rationals : `==`[Rational](x, y: Rational): bool
securehash : `==`(a, b: SecureHash): bool
sets : `==`[A](s, t: HashSet[A]): bool
sets : `==`[A](s, t: OrderedSet[A]): 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 : `==`(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, y: string): bool
system : `==`[T: proc](x, y: T): bool
system : `==`[T: SomeUnsignedInt](x, y: T): bool
system : `==`[T: tuple | object](x, y: T): bool
tables : `==`[A](s, t: CountTable[A]): bool
tables : `==`[A](s, t: CountTableRef[A]): bool
tables : `==`[A, B](s, t: OrderedTable[A, B]): bool
tables : `==`[A, B](s, t: OrderedTableRef[A, B]): bool
tables : `==`[A, B](s, t: Table[A, B]): bool
tables : `==`[A, B](s, t: TableRef[A, B]): bool
times : `==`(a, b: Time): bool
unicode : `==`(a, b: Rune): bool
winlean : `==`(x, y: SocketHandle): bool
`=`:
system : `=`[T](dest: var T; src: T)
`=~`:
basic2d : `=~`(m1, m2: Matrix2d): bool
basic2d : `=~`(p1, p2: Point2d): bool
basic2d : `=~`(v1, v2: Vector2d): bool
basic3d : `=~`(m1, m2: Matrix3d): bool
basic3d : `=~`(p1, p2: Point3d): bool
basic3d : `=~`(v1, v2: Vector3d): bool
complex : `=~`(x, y: Complex): bool
pegs : `=~`(s: string; pattern: Peg): bool
re : `=~`(s: string; pattern: Regex): expr
`?`:
pegs : `?`(a: Peg): Peg
`@`:
system : `@`[IDX, T](a: array[IDX, T]): seq[T]
system : `@`[T](a: openArray[T]): seq[T]
`[]=`:
critbits : `[]=`[T](c: var CritBitTree[T]; key: string; val: T)
deques : `[]=`[T](deq: var Deque[T]; i: Natural; val: T)
httpclient : `[]=`(p: var MultipartData; name, content: string)
httpclient : `[]=`(p: var MultipartData; name: string; file: tuple[name, contentType, content: string])
httpcore : `[]=`(headers: HttpHeaders; key: string; value: seq[string])
httpcore : `[]=`(headers: HttpHeaders; key, value: string)
json : `[]=`(obj: JsonNode; key: string; val: JsonNode)
macros : `[]=`(n: NimNode; i: int; child: NimNode)
queues : `[]=`[T](q: var Queue[T]; i: Natural; val: T)
strtabs : `[]=`(t: StringTableRef; key, val: string)
system : `[]=`[Idx, T](a: var array[Idx, T]; x: Slice[Idx]; b: openArray[T])
system : `[]=`[Idx, T](a: var array[Idx, T]; x: Slice[int]; b: openArray[T])
system : `[]=`[T](s: var seq[T]; x: Slice[int]; b: openArray[T])
system : `[]=`(s: var string; x: Slice[int]; b: string)
system : `[]=`[I: Ordinal, T, S](a: T; i: I; x: S)
tables : `[]=`[A](t: var CountTable[A]; key: A; val: int)
tables : `[]=`[A](t: CountTableRef[A]; key: A; val: int)
tables : `[]=`[A, B](t: var OrderedTable[A, B]; key: A; val: B)
tables : `[]=`[A, B](t: OrderedTableRef[A, B]; key: A; val: B)
tables : `[]=`[A, B](t: var Table[A, B]; key: A; val: B)
tables : `[]=`[A, B](t: TableRef[A, B]; key: A; val: B)
typeinfo : `[]=`(x, y: Any)
typeinfo : `[]=`(x: Any; i: int; y: Any)
typeinfo : `[]=`(x: Any; fieldName: string; value: Any)
`[]`:
critbits : `[]`[T](c: CritBitTree[T]; key: string): T
critbits : `[]`[T](c: var CritBitTree[T]; key: string): var T
db_mysql : `[]`(row: InstantRow; col: int): string
db_postgres : `[]`(row: InstantRow; col: int32): string
db_sqlite : `[]`(row: InstantRow; col: int32): string
deques : `[]`[T](deq: Deque[T]; i: Natural): T
deques : `[]`[T](deq: var Deque[T]; i: Natural): var T
future : `[]`(lc: ListComprehension; comp, typ: untyped): untyped
httpcore : `[]`(headers: HttpHeaders; key: string): HttpHeaderValues
httpcore : `[]`(headers: HttpHeaders; key: string; i: int): string
json : `[]`(node: JsonNode; index: int): JsonNode
json : `[]`(node: JsonNode; name: string): JsonNode
macros : `[]`(n: NimNode; i: int): NimNode
nre : `[]`(pattern: CaptureBounds; i: int): Option[Slice[int]]
nre : `[]`(pattern: CaptureBounds; name: string): Option[Slice[int]]
nre : `[]`(pattern: Captures; i: int): string
nre : `[]`(pattern: Captures; name: string): string
queues : `[]`[T](q: Queue[T]; i: Natural): T
queues : `[]`[T](q: var Queue[T]; i: Natural): var T
ropes : `[]`(r: Rope; i: int): char
selectors : `[]`(s: Selector; fd: SocketHandle): SelectorKey
sets : `[]`[A](s: var HashSet[A]; key: A): var A
strtabs : `[]`(t: StringTableRef; key: string): var string
system : `[]`[Idx, T](a: array[Idx, T]; x: Slice[Idx]): seq[T]
system : `[]`[Idx, T](a: array[Idx, T]; x: Slice[int]): seq[T]
system : `[]`[T](s: seq[T]; x: Slice[int]): seq[T]
system : `[]`(s: string; x: Slice[int]): string
system : `[]`[I: Ordinal, T](a: T; i: I): T
tables : `[]`[A](t: CountTable[A]; key: A): int
tables : `[]`[A](t: var CountTable[A]; key: A): var int
tables : `[]`[A](t: CountTableRef[A]; key: A): var int
tables : `[]`[A, B](t: OrderedTable[A, B]; key: A): B
tables : `[]`[A, B](t: var OrderedTable[A, B]; key: A): var B
tables : `[]`[A, B](t: OrderedTableRef[A, B]; key: A): var B
tables : `[]`[A, B](t: Table[A, B]; key: A): B
tables : `[]`[A, B](t: var Table[A, B]; key: A): var B
tables : `[]`[A, B](t: TableRef[A, B]; key: A): var B
typeinfo : `[]`(x: Any): Any
typeinfo : `[]`(x: Any; i: int): Any
typeinfo : `[]`(x: Any; fieldName: string): Any
xmltree : `[]`(n: XmlNode; i: int): XmlNode
xmltree : `[]`(n: var XmlNode; i: int): var XmlNode
`^`:
actors : `^`[T](f: ptr Channel[T]): T
math : `^`[T](x, y: T): T
system : `^`(x: int): int
system : `^`[T](x: int; y: openArray[T]): int
threadpool : `^`[T](fv: FlowVar[ref T]): ref T
threadpool : `^`[T](fv: FlowVar[T]): T
`addr`:
system : `addr`[T](x: var T): ptr T
`and`:
asyncdispatch : `and`[T, Y](fut1: Future[T]; fut2: Future[Y]): Future[void]
system : `and`(x, y: bool): bool
system : `and`(x, y: int): int
system : `and`(x, y: int16): int16
system : `and`(x, y: int32): int32
system : `and`(x, y: int64): int64
system : `and`(x, y: int8): int8
system : `and`[T: SomeUnsignedInt](x, y: T): T
`div`:
htmlgen : `div`(e: varargs[untyped]): untyped
system : `div`(x, y: int): int
system : `div`(x, y: int16): int16
system : `div`(x, y: int32): int32
system : `div`(x, y: int64): int64
system : `div`(x, y: int8): int8
system : `div`[T: SomeUnsignedInt](x, y: T): T
`in`:
system : `in`(x, y: untyped): untyped
`is`:
system : `is`[T, S](x: T; y: S): bool
`isnot`:
system : `isnot`(x, y: untyped): untyped
`mod`:
math : `mod`[T: float32 | float64](x, y: T): T
system : `mod`(x, y: int): int
system : `mod`(x, y: int16): int16
system : `mod`(x, y: int32): int32
system : `mod`(x, y: int64): int64
system : `mod`(x, y: int8): int8
system : `mod`[T: SomeUnsignedInt](x, y: T): T
`not`:
system : `not`(x: bool): bool
system : `not`(x: int): int
system : `not`(x: int16): int16
system : `not`(x: int32): int32
system : `not`(x: int64): int64
system : `not`(x: int8): int8
system : `not`[T: SomeUnsignedInt](x: T): T
`notin`:
system : `notin`(x, y: untyped): untyped
`object`:
htmlgen : `object`(e: varargs[untyped]): untyped
`of`:
system : `of`[T, S](x: T; y: S): bool
`or`:
asyncdispatch : `or`[T, Y](fut1: Future[T]; fut2: Future[Y]): Future[void]
system : `or`(x, y: bool): bool
system : `or`(x, y: int): int
system : `or`(x, y: int16): int16
system : `or`(x, y: int32): int32
system : `or`(x, y: int64): int64
system : `or`(x, y: int8): int8
system : `or`[T: SomeUnsignedInt](x, y: T): T
`ptr`:
system : ptr
`raise`:
posix : `raise`(a1: cint): cint
`ref`:
system : ref
`shl`:
system : `shl`[SomeInteger](x: int; y: SomeInteger): int
system : `shl`[SomeInteger](x: int16; y: SomeInteger): int16
system : `shl`[SomeInteger](x: int32; y: SomeInteger): int32
system : `shl`[SomeInteger](x: int64; y: SomeInteger): int64
system : `shl`[SomeInteger](x: int8; y: SomeInteger): int8
system : `shl`[T: SomeUnsignedInt](x: T; y: SomeInteger): T
`shr`:
system : `shr`[SomeInteger](x: int; y: SomeInteger): int
system : `shr`[SomeInteger](x: int16; y: SomeInteger): int16
system : `shr`[SomeInteger](x: int32; y: SomeInteger): int32
system : `shr`[SomeInteger](x: int64; y: SomeInteger): int64
system : `shr`[SomeInteger](x: int8; y: SomeInteger): int8
system : `shr`[T: SomeUnsignedInt](x: T; y: SomeInteger): T
`type`:
system : `type`[](x: expr): typedesc
`var`:
htmlgen : `var`(e: varargs[untyped]): untyped
`xor`:
system : `xor`(x, y: bool): bool
system : `xor`(x, y: int): int
system : `xor`(x, y: int16): int16
system : `xor`(x, y: int32): int32
system : `xor`(x, y: int64): int64
system : `xor`(x, y: int8): int8
system : `xor`[T: SomeUnsignedInt](x, y: T): T
`{}=`:
json : `{}=`(node: JsonNode; keys: varargs[string]; value: JsonNode)
`{}`:
json : `{}`(node: JsonNode; keys: varargs[string]): JsonNode
`||`:
system : `||`[S, T](a: S; b: T; annotation = ""): T
a:
htmlgen : a(e: varargs[untyped]): untyped
abbrev:
strutils : abbrev(s: string; possibilities: openArray[string]): int
ABDAY_1:
posix : ABDAY_1
ABDAY_2:
posix : ABDAY_2
ABDAY_3:
posix : ABDAY_3
ABDAY_4:
posix : ABDAY_4
ABDAY_5:
posix : ABDAY_5
ABDAY_6:
posix : ABDAY_6
ABDAY_7:
posix : ABDAY_7
ABMON_1:
posix : ABMON_1
ABMON_10:
posix : ABMON_10
ABMON_11:
posix : ABMON_11
ABMON_12:
posix : ABMON_12
ABMON_2:
posix : ABMON_2
ABMON_3:
posix : ABMON_3
ABMON_4:
posix : ABMON_4
ABMON_5:
posix : ABMON_5
ABMON_6:
posix : ABMON_6
ABMON_7:
posix : ABMON_7
ABMON_8:
posix : ABMON_8
ABMON_9:
posix : ABMON_9
abortOnError:
unittest : abortOnError
abs:
complex : abs(z: Complex): float
rationals : abs[T](x: Rational[T]): Rational[T]
system : abs(x: float): float
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
absolute:
Module os
accept:
asyncdispatch : accept(socket: AsyncFD; flags = {SafeDisconn}): Future[AsyncFD]
asyncio : accept(server: AsyncSocket): AsyncSocket
asyncio : accept(server: AsyncSocket; client: var AsyncSocket)
asyncnet : accept(socket: AsyncSocket; flags = {SafeDisconn}): Future[AsyncSocket]
net : accept(server: Socket; client: var Socket; flags = {SafeDisconn})
posix : accept(a1: SocketHandle; a2: ptr SockAddr; a3: ptr Socklen): SocketHandle
winlean : accept(s: SocketHandle; a: ptr SockAddr; addrlen: ptr SockLen): SocketHandle
acceptAddr:
asyncdispatch : acceptAddr(socket: AsyncFD; flags = {SafeDisconn}): Future[ tuple[address: string, client: AsyncFD]]
asyncio : acceptAddr(server: AsyncSocket): tuple[sock: AsyncSocket, address: string]
asyncio : acceptAddr(server: AsyncSocket; client: var AsyncSocket; address: var string)
asyncnet : acceptAddr(socket: AsyncSocket; flags = {SafeDisconn}): Future[ tuple[address: string, client: AsyncSocket]]
net : acceptAddr(server: Socket; client: var Socket; address: var string; flags = {SafeDisconn})
access:
posix : access(a1: cstring; a2: cint): cint
AccessViolationError:
system : AccessViolationError
accumulateResult:
system : accumulateResult(iter: expr)
acquire:
locks : acquire(lock: var Lock)
rlocks : acquire(lock: var RLock)
acronym:
htmlgen : acronym(e: varargs[untyped]): untyped
Actor:
Module actors
ActorPool:
actors : ActorPool
add:
dom : add*(c: ClassList; class: cstring)
fsmonitor : add(monitor: FSMonitor; target: string; filters = {MonitorAll}): cint
httpclient : add(p: var MultipartData; xs: MultipartEntries): MultipartData
httpclient : add(p: var MultipartData; name, content: string; filename: string = nil; contentType: string = nil)
httpcore : add(headers: HttpHeaders; key, value: string)
json : add(father, child: JsonNode)
json : add(obj: JsonNode; key: string; val: JsonNode)
macros : add(father, child: NimNode): NimNode
macros : add(father: NimNode; children: varargs[NimNode]): NimNode
parsesql : add(father, n: SqlNode)
queues : add[T](q: var Queue[T]; item: T)
ropes : add(a: var Rope; b: Rope)
ropes : add(a: var Rope; b: string)
rstast : add(father, son: PRstNode)
system : add[T](x: var seq[T]; y: openArray[T])
system : add[T](x: var seq[T]; y: T)
system : add(x: var string; y: char)
system : add(x: var string; y: cstring)
system : add(result: var string; x: float)
system : add(result: var string; x: int64)
system : add(x: var string; y: string)
tables : add[A, B](t: var OrderedTable[A, B]; key: A; val: B)
tables : add[A, B](t: OrderedTableRef[A, B]; key: A; val: B)
tables : add[A, B](t: var Table[A, B]; key: A; val: B)
tables : add[A, B](t: TableRef[A, B]; key: A; val: B)
uri : add(url: var Url; a: Url)
xmltree : add(result: var string; n: XmlNode; indent = 0; indWidth = 2)
xmltree : add(father, son: XmlNode)
addAndFetch:
system : addAndFetch(p: ptr int; val: int): int
addEscaped:
xmltree : addEscaped(result: var string; s: string)
addEventListener:
dom : addEventListener*(et: EventTarget; ev: cstring; cb: proc (ev: Event); useCapture: bool = false)
addf:
ropes : addf(c: var Rope; frmt: string; args: openArray[Rope])
strutils : addf(s: var string; formatstr: string; a: varargs[string, `$`])
subexes : addf(s: var string; formatstr: Subex; a: varargs[string, `$`])
addFileExt:
os : addFileExt(filename, ext: string): string
ospaths : addFileExt(filename, ext: string): string
addFiles:
httpclient : addFiles(p: var MultipartData; xs: openArray[tuple[name, file: string]]): MultipartData
addFirst:
deques : addFirst[T](deq: var Deque[T]; item: T)
addHandler:
events : addHandler(handler: var EventHandler; fn: proc (e: EventArgs))
logging : addHandler(handler: Logger)
addIdentIfAbsent:
macros : addIdentIfAbsent(dest: NimNode; ident: string)
addIfNotNil:
rstast : addIfNotNil(father, son: PRstNode)
addLast:
deques : addLast[T](deq: var Deque[T]; item: T)
addNodes:
rst : addNodes(n: PRstNode): string
addPragma:
macros : addPragma(someProc, pragma: NimNode)
addQuitProc:
system : addQuitProc(QuitProc: proc ())
addRead:
asyncdispatch : addRead(fd: AsyncFD; cb: Callback)
address:
htmlgen : address(e: varargs[untyped]): untyped
AddrInfo:
posix : AddrInfo
winlean : AddrInfo
addSep:
strutils : addSep(dest: var string; sep = ", "; startLen: Natural = 0)
addWrite:
asyncdispatch : addWrite(fd: AsyncFD; cb: Callback)
affinity:
Module threads
AF_INET:
posix : AF_INET
winlean : AF_INET
AF_INET6:
posix : AF_INET6
winlean : AF_INET6
AF_UNIX:
posix : AF_UNIX
AF_UNSPEC:
posix : AF_UNSPEC
AI_ADDRCONFIG:
posix : AI_ADDRCONFIG
AI_ALL:
posix : AI_ALL
AI_CANONNAME:
posix : AI_CANONNAME
AI_NUMERICHOST:
posix : AI_NUMERICHOST
AI_NUMERICSERV:
posix : AI_NUMERICSERV
AIO_ALLDONE:
posix : AIO_ALLDONE
aio_cancel:
posix : aio_cancel(a1: cint; a2: ptr Taiocb): cint
AIO_CANCELED:
posix : AIO_CANCELED
aio_error:
posix : aio_error(a1: ptr Taiocb): cint
aio_fsync:
posix : aio_fsync(a1: cint; a2: ptr Taiocb): cint
AIO_NOTCANCELED:
posix : AIO_NOTCANCELED
aio_read:
posix : aio_read(a1: ptr Taiocb): cint
aio_return:
posix : aio_return(a1: ptr Taiocb): int
aio_suspend:
posix : aio_suspend(a1: ptr ptr Taiocb; a2: cint; a3: ptr Timespec): cint
aio_write:
posix : aio_write(a1: ptr Taiocb): cint
AI_PASSIVE:
posix : AI_PASSIVE
AI_V4MAPPED:
posix : AI_V4MAPPED
winlean : AI_V4MAPPED
alarm:
posix : alarm(a1: cint): cint
alert:
dom : alert*(w: Window; msg: cstring)
align:
strutils : align(s: string; count: Natural; padding = ' '): string
AlignType:
system : AlignType
alive:
coro : alive(c: proc ()): bool
all:
asyncdispatch : all[T](futs: varargs[Future[T]]): auto
sequtils : all[T](seq1: seq[T]; pred: proc (item: T): bool): bool
AllChars:
strutils : AllChars
allCharsInSet:
strutils : allCharsInSet(s: string; theSet: set[char]): bool
allIt:
sequtils : allIt(seq1, pred: untyped): bool
alloc:
system : alloc(size: Natural): pointer
alloc0:
system : alloc0(size: Natural): pointer
allocCStringArray:
system : allocCStringArray(a: openArray[string]): cstringArray
allocShared:
system : allocShared(size: Natural): pointer
allocShared0:
system : allocShared0(size: Natural): pointer
allValues:
tables : allValues[A, B](t: Table[A, B]; key: A): B
ALT_DIGITS:
posix : ALT_DIGITS
AltSep:
os : AltSep
ospaths : AltSep
AM_STR:
posix : AM_STR
AnchorElement:
dom : AnchorElement
angle:
basic2d : angle(a, b: Point2d): float
basic2d : angle(v: Vector2d): float
angleCCW:
basic2d : angleCCW(v1, v2: Vector2d): float
angleCW:
basic2d : angleCW(v1, v2: Vector2d): float
angleTo:
basic2d : angleTo(v1, v2: Vector2d): float
basic3d : angleTo(v1, v2: Vector3d): float
any:
pegs : any(): Peg
sequtils : any[T](seq1: seq[T]; pred: proc (item: T): bool): bool
system : any
Any:
typeinfo : Any
any character:
PEG construction
any rune:
PEG construction
anyIt:
sequtils : anyIt(seq1, pred: untyped): bool
AnyKind:
typeinfo : AnyKind
anyRune:
pegs : anyRune(): Peg
append:
lists : append[T](L: var DoublyLinkedList[T]; n: DoublyLinkedNode[T])
lists : append[T](L: var DoublyLinkedList[T]; value: T)
lists : append[T](L: var DoublyLinkedRing[T]; n: DoublyLinkedNode[T])
lists : append[T](L: var DoublyLinkedRing[T]; value: T)
lists : append[T](L: var SinglyLinkedRing[T]; n: SinglyLinkedNode[T])
lists : append[T](L: var SinglyLinkedRing[T]; value: T)
appendChild:
dom : appendChild*(n, child: Node)
xmldom : appendChild(n: PNode; newChild: PNode)
appendData:
dom : appendData*(n: Node; data: cstring)
apply:
basic2d : apply(m: Matrix2d; x, y: var float; translate = false)
basic3d : apply(m: Matrix3d; x, y, z: var float; translate = false)
sequtils : apply[T](data: var seq[T]; op: proc (x: var T))
sequtils : apply[T](data: var seq[T]; op: proc (x: T): T)
applyIt:
sequtils : applyIt(varSeq, op: untyped)
appType:
system : appType
arbitraryAxis:
basic3d : arbitraryAxis(norm: Vector3d): Matrix3d
arccos:
complex : arccos(z: Complex): Complex
math : arccos(x: float32): float32
math : arccos(x: float64): float64
arccosh:
complex : arccosh(z: Complex): Complex
arccot:
complex : arccot(z: Complex): Complex
arccoth:
complex : arccoth(z: Complex): Complex
arccsc:
complex : arccsc(z: Complex): Complex
arccsch:
complex : arccsch(z: Complex): Complex
arcsec:
complex : arcsec(z: Complex): Complex
arcsech:
complex : arcsech(z: Complex): Complex
arcsin:
complex : arcsin(z: Complex): Complex
math : arcsin(x: float32): float32
math : arcsin(x: float64): float64
arcsinh:
complex : arcsinh(z: Complex): Complex
arctan:
complex : arctan(z: Complex): Complex
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(z: Complex): Complex
area:
basic2d : area(a, b, c: Point2d): float
basic3d : area(a, b, c: Point3d): float
htmlgen : area(e: varargs[untyped]): untyped
ArithmeticError:
system : ArithmeticError
arity:
typetraits : arity[](t: typedesc): int
array:
system : array
asctime:
posix : asctime(a1: var Tm): cstring
asctime_r:
posix : asctime_r(a1: var Tm; a2: cstring): cstring
assert:
system : assert(cond: bool; msg = "")
AssertionError:
system : AssertionError
assign:
intsets : assign(dest: var IntSet; src: IntSet)
typeinfo : assign(x, y: Any)
AST:
Module macros
astToStr:
system : astToStr[T](x: T): string
async:
asyncdispatch : async(prc: untyped): untyped
asyncCheck:
asyncdispatch : asyncCheck[T](future: Future[T])
AsyncFD:
asyncdispatch : AsyncFD
AsyncFile:
asyncfile : AsyncFile
AsyncFtpClient:
asyncftpclient : AsyncFtpClient
ftpclient : AsyncFtpClient
asyncFTPClient:
ftpclient : asyncFTPClient(address: string; port = Port(21); user, pass = ""; handleEvent: proc ( ftp: AsyncFtpClient; ev: FTPEvent) = (proc (ftp: AsyncFtpClient; ev: FTPEvent) = discard )): AsyncFtpClient
AsyncFtpClientObj:
asyncftpclient : AsyncFtpClientObj
ftpclient : AsyncFtpClientObj
AsyncHttpClient:
httpclient : AsyncHttpClient
AsyncHttpServer:
asynchttpserver : AsyncHttpServer
asyncHTTPServer:
httpserver : asyncHTTPServer(handleRequest: proc (server: PAsyncHTTPServer; client: Socket; path, query: string): bool; port = Port(80); address = ""; reuseAddr = false): PAsyncHTTPServer
AsyncScgiState:
scgi : AsyncScgiState
AsyncSmtp:
smtp : AsyncSmtp
AsyncSocket:
asyncio : AsyncSocket
asyncSocket:
asyncio : asyncSocket(domain: Domain = AF_INET; typ: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP; buffered = true): AsyncSocket
AsyncSocket:
asyncnet : AsyncSocket
AsyncSocketObj:
asyncio : AsyncSocketObj
atEnd:
streams : atEnd(s: Stream): bool
streams : atEnd(s, unused: Stream): bool
atom:
strscans : atom(input: string; idx: int; c: char): bool
strscans : atom(input: string; idx: int; s: set[char]): bool
atomicDec:
system : atomicDec(memLoc: var int; x: int = 1): int
system : atomicDec(memLoc: var int; x: int = 1): int
atomicInc:
system : atomicInc(memLoc: var int; x: int = 1): int
system : atomicInc(memLoc: var int; x: int = 1): int
AtomicNodes:
macros : AtomicNodes
attr:
xmltree : attr(n: XmlNode; name: string): string
AttributeNode:
xmldom : 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
auth:
smtp : auth(smtp: AsyncSmtp; username, password: string): Future[void]
smtp : auth(smtp: var Smtp; username, password: string)
author:
nimscript : author
auto:
system : auto
await:
threadpool : await(fv: FlowVarBase)
awaitAndThen:
threadpool : awaitAndThen[T](fv: FlowVar[T]; action: proc (x: T))
awaitAny:
threadpool : awaitAny(flowVars: openArray[FlowVarBase]): int
b:
htmlgen : b(e: varargs[untyped]): untyped
back:
dom : back*(h: History)
dom : back*(w: Window)
queues : back[T](q: Queue[T]): T
backend:
nimscript : backend
BackgroundColor:
terminal : BackgroundColor
backref:
pegs : backref(index: range[1 .. MaxSubpatterns]): Peg
backrefIgnoreCase:
pegs : backrefIgnoreCase(index: range[1 .. MaxSubpatterns]): Peg
backrefIgnoreStyle:
pegs : backrefIgnoreStyle(index: range[1 .. MaxSubpatterns]): Peg
backslash:
Backslash
base:
htmlgen : base(e: varargs[untyped]): untyped
typeinfo : base(x: Any): Any
BaseLexer:
lexbase : BaseLexer
basename:
macros : basename(a: NimNode): NimNode
posix : basename(a1: cstring): cstring
basename=:
macros : basename=(a: NimNode; val: string)
baseTypeKind:
typeinfo : baseTypeKind(x: Any): AnyKind
baseTypeSize:
typeinfo : baseTypeSize(x: Any): int
big:
htmlgen : big(e: varargs[untyped]): untyped
bigEndian16:
endians : bigEndian16(outp, inp: pointer)
bigEndian32:
endians : bigEndian32(outp, inp: pointer)
bigEndian64:
endians : bigEndian64(outp, inp: pointer)
BiggestFloat:
system : BiggestFloat
BiggestInt:
system : BiggestInt
bin:
nimscript : bin
BinaryPrefixMode:
strutils : BinaryPrefixMode
binarySearch:
algorithm : binarySearch[T](a: openArray[T]; key: T): int
bindAddr:
asyncio : bindAddr(sock: AsyncSocket; port = Port(0); address = "")
asyncnet : bindAddr(socket: AsyncSocket; port = Port(0); address = "")
nativesockets : bindAddr(socket: SocketHandle; name: ptr SockAddr; namelen: SockLen): cint
net : bindAddr(socket: Socket; port = Port(0); address = "")
binDir:
nimscript : binDir
bindSocket:
posix : bindSocket(a1: SocketHandle; a2: ptr SockAddr; a3: Socklen): cint
winlean : bindSocket(s: SocketHandle; name: ptr SockAddr; namelen: SockLen): cint
bindSym:
macros : bindSym(ident: string; rule: BindSymRule = brClosed): NimNode
BindSymRule:
macros : BindSymRule
bindUnix:
net : bindUnix(socket: Socket; path: string)
binom:
math : binom(n, k: int): int
bisect:
basic2d : bisect(v1, v2: Vector2d): Vector2d
basic3d : bisect(v1, v2: Vector3d): Vector3d
BitScalar:
intsets : BitScalar
Blkcnt:
posix : Blkcnt
Blksize:
posix : Blksize
blockquote:
htmlgen : blockquote(e: varargs[untyped]): untyped
BlockTags:
htmlparser : BlockTags
blur:
dom : blur*(e: Element)
dom : blur*(w: Window)
body:
htmlgen : body(e: varargs[untyped]): untyped
macros : body(someProc: NimNode): NimNode
body=:
macros : body=(someProc: NimNode; val: NimNode)
bool:
system : bool
boolVal:
macros : boolVal(n: NimNode): bool
bounds:
pegs : bounds(c: Captures; i: range[0 .. 20 - 1]): tuple[first, last: int]
br:
htmlgen : br(e: varargs[untyped]): untyped
bsd_signal:
posix : bsd_signal(a1: cint; a2: proc (x: pointer))
BufferSize:
net : BufferSize
button:
htmlgen : button(e: varargs[untyped]): untyped
BY_HANDLE_FILE_INFORMATION:
winlean : BY_HANDLE_FILE_INFORMATION
byte:
system : byte
ByteAddress:
system : ByteAddress
callback=:
asyncdispatch : callback=[T](future: Future[T]; cb: proc (future: Future[T]))
asyncdispatch : callback=(future: FutureBase; cb: proc ())
caller info:
Module system
CallNodes:
macros : CallNodes
callsite:
macros : callsite(): NimNode
callSoon:
asyncdispatch : callSoon(cbproc: proc ())
capitalize:
strutils : capitalize(s: string): string
unicode : capitalize(s: string): string
capitalizeAscii:
strutils : capitalizeAscii(s: string): string
caption:
htmlgen : caption(e: varargs[untyped]): untyped
capture:
pegs : capture(a: Peg): Peg
captureBetween:
parseutils : captureBetween(s: string; first: char; second = '\0'; start = 0): string
CaptureBounds:
nre : CaptureBounds
captureBounds:
nre : captureBounds(pattern: RegexMatch): CaptureBounds
captureCount:
nre : captureCount(pattern: Regex): int
captureEvents:
dom : captureEvents*(d: Document; eventMask: int)
dom : captureEvents*(w: Window; eventMask: int)
captureNameId:
nre : captureNameId(pattern: Regex): Table[string, int]
Captures:
nre : Captures
captures:
nre : captures(pattern: RegexMatch): Captures
Captures:
pegs : Captures
card:
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
catclose:
posix : catclose(a1: Nl_catd): cint
catgets:
posix : catgets(a1: Nl_catd; a2, a3: cint; a4: cstring): cstring
catopen:
posix : catopen(a1: cstring; a2: cint): Nl_catd
cbrt:
math : cbrt(x: float32): float32
math : cbrt(x: float64): float64
cchar:
system : cchar
cd:
asyncftpclient : cd(ftp: AsyncFtpClient; dir: string): Future[void]
ftpclient : cd[T](ftp: FtpBase[T]; dir: string)
nimscript : cd(dir: string)
CDataSectionNode:
xmldom : CDataSectionNode
cdouble:
system : cdouble
cdup:
asyncftpclient : cdup(ftp: AsyncFtpClient): Future[void]
ftpclient : cdup[T](ftp: FtpBase[T])
ceil:
math : ceil(x: float32): float32
math : ceil(x: float64): float64
center:
strutils : center(s: string; width: int; fillChar: char = ' '): string
CfgEvent:
parsecfg : CfgEvent
CfgEventKind:
parsecfg : CfgEventKind
CfgParser:
parsecfg : CfgParser
cfloat:
system : cfloat
CgiError:
cgi : CgiError
cgiError:
cgi : cgiError(msg: string)
changeFileExt:
os : changeFileExt(filename, ext: string): string
ospaths : changeFileExt(filename, ext: string): string
Channel:
channels : Channel
char:
system : char
charData:
parsexml : charData(my: XmlParser): string
charSet:
pegs : charSet(s: set[char]): Peg
CharSet:
strutils : CharSet
chdir:
posix : chdir(a1: cstring): cint
check:
unittest : check(conditions: untyped): untyped
checkedSymAddr:
dynlib : checkedSymAddr(lib: LibHandle; name: cstring): pointer
checkpoint:
unittest : checkpoint(msg: string)
child:
xmltree : child(n: XmlNode; name: string): XmlNode
children:
macros : children(n: NimNode): NimNode
chmod:
asyncftpclient : chmod(ftp: AsyncFtpClient; path: string; permissions: set[FilePermission]): Future[ void]
ftpclient : chmod[T](ftp: FtpBase[T]; path: string; permissions: set[FilePermission])
posix : chmod(a1: cstring; a2: Mode): cint
chown:
posix : chown(a1: cstring; a2: Uid; a3: Gid): cint
chr:
system : chr(u: range[0 .. 255]): char
cint:
system : cint
cite:
htmlgen : cite(e: varargs[untyped]): untyped
clamp:
system : clamp[T](x, a, b: T): T
classify:
math : classify(x: float): FloatClass
ClassList:
dom : ClassList
clean:
asyncdispatch : clean[T](future: FutureVar[T])
clear:
httpcore : clear(headers: HttpHeaders)
intsets : clear(result: var IntSet)
stats : clear(r: var RunningRegress)
stats : clear(s: var RunningStat)
strtabs : clear(s: StringTableRef; mode: StringTableMode)
tables : clear[A](t: var CountTable[A] | CountTableRef[A])
tables : clear[A, B](t: var OrderedTable[A, B])
tables : clear[A, B](t: var OrderedTableRef[A, B])
tables : clear[A, B](t: var Table[A, B])
tables : clear[A, B](t: TableRef[A, B])
clearHandlers:
events : clearHandlers(handler: var EventHandler)
clearInterval:
dom : clearInterval*(w: Window; interval: ref TInterval)
clearTimeout:
dom : clearTimeout*(w: Window; timeout: ref TTimeOut)
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)
Clock:
posix : Clock
clock:
posix : clock(): Clock
clock_getcpuclockid:
posix : clock_getcpuclockid(a1: Pid; a2: var ClockId): cint
clock_getres:
posix : clock_getres(a1: ClockId; a2: var Timespec): cint
clock_gettime:
posix : clock_gettime(a1: ClockId; a2: var Timespec): cint
ClockId:
posix : ClockId
CLOCK_MONOTONIC:
posix : CLOCK_MONOTONIC
clock_nanosleep:
posix : clock_nanosleep(a1: ClockId; a2: cint; a3: var Timespec; a4: var Timespec): cint
CLOCK_PROCESS_CPUTIME_ID:
posix : CLOCK_PROCESS_CPUTIME_ID
CLOCK_REALTIME:
posix : CLOCK_REALTIME
clock_settime:
posix : clock_settime(a1: ClockId; a2: var Timespec): cint
CLOCKS_PER_SEC:
posix : CLOCKS_PER_SEC
CLOCK_THREAD_CPUTIME_ID:
posix : CLOCK_THREAD_CPUTIME_ID
cloneNode:
dom : cloneNode*(n: Node; copyContent: bool): Node
xmldom : cloneNode(n: PNode; deep: bool): PNode
clong:
system : clong
clongdouble:
system : clongdouble
clonglong:
system : clonglong
close:
asyncfile : close(f: AsyncFile)
asynchttpserver : close(server: AsyncHttpServer)
asyncio : close(sock: AsyncSocket)
asyncnet : close(socket: AsyncSocket)
channels : close*[TMsg](c: var Channel[TMsg])
db_mysql : close(db: DbConn)
db_postgres : close(db: DbConn)
db_sqlite : close(db: DbConn)
dom : close*(w: Window)
encodings : close(c: EncodingConverter)
ftpclient : close[T](ftp: FtpBase[T])
httpclient : close[](client: HttpClient | AsyncHttpClient)
httpserver : close(h: PAsyncHTTPServer)
httpserver : close(s: Server)
json : close(my: var JsonParser)
lexbase : close(L: var BaseLexer)
memfiles : close(f: var MemFile)
nativesockets : close(socket: SocketHandle)
net : close(socket: Socket)
osproc : close(p: Process)
parsecfg : close(c: var CfgParser)
parsecsv : close(my: var CsvParser)
parsexml : close(my: var XmlParser)
posix : close[](a1: cint | SocketHandle): cint
scgi : close(s: AsyncScgiState)
scgi : close(s: var ScgiState)
selectors : close(s: Selector)
smtp : close(smtp: AsyncSmtp): Future[void]
smtp : close(smtp: Smtp)
ssl : close(sock: SecureSocket)
streams : close(s: Stream)
streams : close(s, unused: Stream)
system : close(f: File)
system : close(f: File)
closedir:
posix : closedir(a1: ptr DIR): cint
closeHandle:
winlean : closeHandle(hObject: Handle): WINBOOL
closeSocket:
asyncdispatch : closeSocket(socket: AsyncFD)
closesocket:
winlean : closesocket(s: SocketHandle): cint
closestPoint:
basic2d : closestPoint(p: Point2d; pts: varargs[Point2d]): Point2d
closureScope:
system : closureScope(body: untyped): untyped
CmdLineKind:
parseopt : CmdLineKind
parseopt2 : CmdLineKind
cmdLineRest:
parseopt : cmdLineRest(p: OptParser): TaintedString
parseopt2 : cmdLineRest(p: OptParser): TaintedString
cmp:
rationals : cmp[Rational](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:
strutils : cmpIgnoreCase(a, b: string): int
cmpIgnoreStyle:
strutils : cmpIgnoreStyle(a, b: string): int
cmpPaths:
os : cmpPaths(pathA, pathB: string): int
ospaths : cmpPaths(pathA, pathB: string): int
cmpRunesIgnoreCase:
unicode : cmpRunesIgnoreCase(a, b: string): int
CMSG_DATA:
posix : CMSG_DATA(cmsg: ptr Tcmsghdr): cstring
CMSG_FIRSTHDR:
posix : CMSG_FIRSTHDR(mhdr: ptr Tmsghdr): ptr Tcmsghdr
CMSG_NXTHDR:
posix : CMSG_NXTHDR(mhdr: ptr Tmsghdr; cmsg: ptr Tcmsghdr): ptr Tcmsghdr
code:
htmlgen : code(e: varargs[untyped]): untyped
httpclient : code(response: Response): HttpCode
CODESET:
posix : CODESET
col:
htmlgen : col(e: varargs[untyped]): untyped
colAliceBlue:
colors : colAliceBlue
colAntiqueWhite:
colors : colAntiqueWhite
colAqua:
colors : colAqua
colAquamarine:
colors : colAquamarine
colAzure:
colors : colAzure
colBeige:
colors : colBeige
colBisque:
colors : colBisque
colBlack:
colors : colBlack
colBlanchedAlmond:
colors : colBlanchedAlmond
colBlue:
colors : colBlue
colBlueViolet:
colors : colBlueViolet
colBrown:
colors : colBrown
colBurlyWood:
colors : colBurlyWood
colCadetBlue:
colors : colCadetBlue
colChartreuse:
colors : colChartreuse
colChocolate:
colors : colChocolate
colCoral:
colors : colCoral
colCornflowerBlue:
colors : colCornflowerBlue
colCornsilk:
colors : colCornsilk
colCrimson:
colors : colCrimson
colCyan:
colors : colCyan
colDarkBlue:
colors : colDarkBlue
colDarkCyan:
colors : colDarkCyan
colDarkGoldenRod:
colors : colDarkGoldenRod
colDarkGray:
colors : colDarkGray
colDarkGreen:
colors : colDarkGreen
colDarkKhaki:
colors : colDarkKhaki
colDarkMagenta:
colors : colDarkMagenta
colDarkOliveGreen:
colors : colDarkOliveGreen
colDarkorange:
colors : colDarkorange
colDarkOrchid:
colors : colDarkOrchid
colDarkRed:
colors : colDarkRed
colDarkSalmon:
colors : colDarkSalmon
colDarkSeaGreen:
colors : colDarkSeaGreen
colDarkSlateBlue:
colors : colDarkSlateBlue
colDarkSlateGray:
colors : colDarkSlateGray
colDarkTurquoise:
colors : colDarkTurquoise
colDarkViolet:
colors : colDarkViolet
colDeepPink:
colors : colDeepPink
colDeepSkyBlue:
colors : colDeepSkyBlue
colDimGray:
colors : colDimGray
colDodgerBlue:
colors : colDodgerBlue
colFireBrick:
colors : colFireBrick
colFloralWhite:
colors : colFloralWhite
colForestGreen:
colors : colForestGreen
colFuchsia:
colors : colFuchsia
colGainsboro:
colors : colGainsboro
colGhostWhite:
colors : colGhostWhite
colGold:
colors : colGold
colGoldenRod:
colors : colGoldenRod
colGray:
colors : colGray
colGreen:
colors : colGreen
colGreenYellow:
colors : colGreenYellow
colgroup:
htmlgen : colgroup(e: varargs[untyped]): untyped
colHoneyDew:
colors : colHoneyDew
colHotPink:
colors : colHotPink
colIndianRed:
colors : colIndianRed
colIndigo:
colors : colIndigo
colIvory:
colors : colIvory
colKhaki:
colors : colKhaki
colLavender:
colors : colLavender
colLavenderBlush:
colors : colLavenderBlush
colLawnGreen:
colors : colLawnGreen
colLemonChiffon:
colors : colLemonChiffon
colLightBlue:
colors : colLightBlue
colLightCoral:
colors : colLightCoral
colLightCyan:
colors : colLightCyan
colLightGoldenRodYellow:
colors : colLightGoldenRodYellow
colLightGreen:
colors : colLightGreen
colLightGrey:
colors : colLightGrey
colLightPink:
colors : colLightPink
colLightSalmon:
colors : colLightSalmon
colLightSeaGreen:
colors : colLightSeaGreen
colLightSkyBlue:
colors : colLightSkyBlue
colLightSlateGray:
colors : colLightSlateGray
colLightSteelBlue:
colors : colLightSteelBlue
colLightYellow:
colors : colLightYellow
colLime:
colors : colLime
colLimeGreen:
colors : colLimeGreen
colLinen:
colors : colLinen
colMagenta:
colors : colMagenta
colMaroon:
colors : colMaroon
colMediumAquaMarine:
colors : colMediumAquaMarine
colMediumBlue:
colors : colMediumBlue
colMediumOrchid:
colors : colMediumOrchid
colMediumPurple:
colors : colMediumPurple
colMediumSeaGreen:
colors : colMediumSeaGreen
colMediumSlateBlue:
colors : colMediumSlateBlue
colMediumSpringGreen:
colors : colMediumSpringGreen
colMediumTurquoise:
colors : colMediumTurquoise
colMediumVioletRed:
colors : colMediumVioletRed
colMidnightBlue:
colors : colMidnightBlue
colMintCream:
colors : colMintCream
colMistyRose:
colors : colMistyRose
colMoccasin:
colors : colMoccasin
colNavajoWhite:
colors : colNavajoWhite
colNavy:
colors : colNavy
colOldLace:
colors : colOldLace
colOlive:
colors : colOlive
colOliveDrab:
colors : colOliveDrab
Color:
colors : Color
colOrange:
colors : colOrange
colOrangeRed:
colors : colOrangeRed
colOrchid:
colors : colOrchid
colorOutput:
unittest : colorOutput
colPaleGoldenRod:
colors : colPaleGoldenRod
colPaleGreen:
colors : colPaleGreen
colPaleTurquoise:
colors : colPaleTurquoise
colPaleVioletRed:
colors : colPaleVioletRed
colPapayaWhip:
colors : colPapayaWhip
colPeachPuff:
colors : colPeachPuff
colPeru:
colors : colPeru
colPink:
colors : colPink
colPlum:
colors : colPlum
colPowderBlue:
colors : colPowderBlue
colPurple:
colors : colPurple
colRed:
colors : colRed
colRosyBrown:
colors : colRosyBrown
colRoyalBlue:
colors : colRoyalBlue
colSaddleBrown:
colors : colSaddleBrown
colSalmon:
colors : colSalmon
colSandyBrown:
colors : colSandyBrown
colSeaGreen:
colors : colSeaGreen
colSeaShell:
colors : colSeaShell
colSienna:
colors : colSienna
colSilver:
colors : colSilver
colSkyBlue:
colors : colSkyBlue
colSlateBlue:
colors : colSlateBlue
colSlateGray:
colors : colSlateGray
colSnow:
colors : colSnow
colSpringGreen:
colors : colSpringGreen
colSteelBlue:
colors : colSteelBlue
colTan:
colors : colTan
colTeal:
colors : colTeal
colThistle:
colors : colThistle
colTomato:
colors : colTomato
colTurquoise:
colors : colTurquoise
colViolet:
colors : colViolet
colWheat:
colors : colWheat
colWhite:
colors : colWhite
colWhiteSmoke:
colors : colWhiteSmoke
colYellow:
colors : colYellow
colYellowGreen:
colors : colYellowGreen
combine:
uri : combine(base: Uri; reference: Uri): Uri
uri : combine(uris: varargs[Uri]): Uri
comma separated value:
Module parsecsv
command line argument:
Module os
command line arguments:
Module os
commandLineParams:
os : commandLineParams(): seq[TaintedString]
CommentNode:
xmldom : CommentNode
commonAttr:
htmlgen : commonAttr
CompileDate:
system : CompileDate
compileOption:
system : compileOption(option: string): bool
system : compileOption(option, arg: string): bool
compiles:
system : compiles(x: expr): bool
CompileTime:
system : CompileTime
complete:
asyncdispatch : complete[T](future: Future[T]; val: T)
asyncdispatch : complete(future: Future[void])
asyncdispatch : complete[T](future: FutureVar[T])
asyncdispatch : complete[T](future: FutureVar[T]; val: T)
CompletionData:
asyncdispatch : CompletionData
CompletionKey:
asyncdispatch : CompletionKey
Complex:
complex : Complex
concat:
sequtils : concat[T](seqs: varargs[seq[T]]): seq[T]
Cond:
locks : Cond
condition system:
Module system
Config:
parsecfg : Config
confirm:
dom : confirm*(w: Window; msg: cstring): bool
confstr:
posix : confstr(a1: cint; a2: cstring; a3: int): int
conjugate:
complex : conjugate(z: Complex): Complex
connect:
asyncdispatch : connect(socket: AsyncFD; address: string; port: Port; domain = nativesockets.AF_INET): Future[ void]
asyncftpclient : connect(ftp: AsyncFtpClient): Future[void]
asyncio : connect(sock: AsyncSocket; name: string; port = Port(0); af: Domain = AF_INET)
asyncnet : connect(socket: AsyncSocket; address: string; port: Port): Future[void]
ftpclient : connect[T](ftp: FtpBase[T])
net : connect(socket: Socket; address: string; port = Port(0))
net : connect(socket: Socket; address: string; port = Port(0); timeout: int)
posix : connect(a1: SocketHandle; a2: ptr SockAddr; a3: Socklen): cint
smtp : connect(smtp: AsyncSmtp): Future[void]
smtp : connect(address: string; port = Port(25); ssl = false; debug = false; sslContext = defaultSSLContext): Smtp
ssl : connect(sock: var SecureSocket; address: string; port: int): int
winlean : connect(s: SocketHandle; name: ptr SockAddr; namelen: SockLen): cint
connectUnix:
net : connectUnix(socket: Socket; path: string)
ConsoleLogger:
logging : ConsoleLogger
contains:
critbits : contains[T](c: CritBitTree[T]; key: string): bool
deques : contains[T](deq: Deque[T]; item: T): bool
dom : contains*(c: ClassList; class: cstring): bool
httpcore : contains(values: HttpHeaderValues; value: string): bool
httpcore : contains(methods: set[HttpMethod]; x: string): bool
intsets : contains(s: IntSet; key: int): bool
json : contains(node: JsonNode; val: JsonNode): bool
json : contains(node: JsonNode; key: string): bool
lists : contains[T](L: DoublyLinkedList[T]; value: T): bool
lists : contains[T](L: DoublyLinkedRing[T]; value: T): bool
lists : contains[T](L: SinglyLinkedList[T]; value: T): bool
lists : contains[T](L: SinglyLinkedRing[T]; value: T): bool
nre : contains(str: string; pattern: Regex; start = 0; endpos = int.high): bool
pegs : contains(s: string; pattern: Peg; start = 0): bool
pegs : contains(s: string; pattern: Peg; matches: var openArray[string]; start = 0): bool
queues : contains[T](q: Queue[T]; item: T): 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(s: Selector; key: SelectorKey): bool
selectors : contains(s: Selector; fd: SocketHandle): bool
sets : contains[A](s: HashSet[A]; key: A): bool
sets : contains[A](s: OrderedSet[A]; key: A): bool
strutils : contains(s: string; c: char): bool
strutils : contains(s: string; chars: set[char]): bool
strutils : contains(s, sub: string): bool
system : contains[T](a: openArray[T]; item: T): bool
system : contains[T](x: set[T]; y: T): bool
system : contains[T](s: Slice[T]; value: 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
containsHandler:
events : containsHandler(handler: var EventHandler; fn: proc (e: EventArgs)): bool
containsOrIncl:
critbits : containsOrIncl[T](c: var CritBitTree[T]; key: string; val: T): bool
critbits : containsOrIncl(c: var CritBitTree[void]; key: string): bool
intsets : containsOrIncl(s: var IntSet; key: int): bool
sets : containsOrIncl[A](s: var HashSet[A]; key: A): bool
sets : containsOrIncl[A](s: var OrderedSet[A]; key: A): bool
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
copy:
json : copy(p: JsonNode): JsonNode
macros : copy(node: NimNode): NimNode
system : copy(s: string; first = 0): string
system : copy(s: string; first, last: int): string
copyChildrenTo:
macros : copyChildrenTo(src, dest: NimNode)
copyDir:
os : copyDir(source, dest: string)
copyDirWithPermissions:
os : copyDirWithPermissions(source, dest: string; ignorePermissionErrors = true)
copyFile:
os : copyFile(source, dest: string)
copyFileW:
winlean : copyFileW(lpExistingFileName, lpNewFileName: WideCString; bFailIfExists: WINBOOL): WINBOOL
copyFileWithPermissions:
os : copyFileWithPermissions(source, dest: string; ignorePermissionErrors = true)
copyMem:
system : copyMem(dest, source: pointer; size: Natural)
copyNimNode:
macros : copyNimNode(n: NimNode): NimNode
copyNimTree:
macros : copyNimTree(n: NimNode): NimNode
coreAttr:
htmlgen : coreAttr
correlation:
stats : correlation(r: RunningRegress): float
cos:
complex : cos(z: Complex): Complex
math : cos(x: float32): float32
math : cos(x: float64): float64
cosh:
complex : cosh(z: Complex): Complex
math : cosh(x: float32): float32
math : cosh(x: float64): float64
cot:
complex : cot(z: Complex): Complex
coth:
complex : coth(z: Complex): Complex
count:
strutils : count(s: string; sub: char): int
strutils : count(s: string; subs: set[char]): int
strutils : count(s: string; sub: string; overlapping: bool = false): int
countBits32:
math : countBits32(n: int32): int
countDays:
times : countDays(yearSpan: int): int
countdown:
system : countdown[T](a, b: T; step = 1): T
countLeapYears:
times : countLeapYears(yearSpan: int): int
countLines:
strutils : countLines(s: string): int
countProcessors:
cpuinfo : countProcessors(): int
osproc : countProcessors(): int
CountTable:
tables : CountTable
CountTableRef:
tables : CountTableRef
countup:
system : countup[S, T](a: S; b: T; step = 1): T
countYears:
times : countYears(daySpan: int): int
countYearsAndDays:
times : countYearsAndDays(daySpan: int): tuple[years: int, days: int]
cpFile:
nimscript : cpFile(`from`, to: string)
CPU:
Module threads
cpuEndian:
system : cpuEndian
cpuRelax:
system : cpuRelax()
cpuTime:
times : cpuTime(): float
creat:
posix : creat(a1: cstring; a2: Mode): cint
create:
system : create[](T: typedesc; size = 1.Positive): ptr T:type
createActorPool:
actors : createActorPool[In, Out](a: var ActorPool[In, Out]; poolSize = 4)
CREATE_ALWAYS:
winlean : CREATE_ALWAYS
createAttribute:
dom : createAttribute*(d: Document; identifier: cstring): Node
xmldom : createAttribute(doc: PDocument; name: string): PAttr
createAttributeNS:
xmldom : createAttributeNS(doc: PDocument; namespaceURI: string; qualifiedName: string): PAttr
createCDATASection:
xmldom : createCDATASection(doc: PDocument; data: string): PCDataSection
createComment:
xmldom : createComment(doc: PDocument; data: string): PComment
createDir:
asyncftpclient : createDir(ftp: AsyncFtpClient; dir: string; recursive = false): Future[void]
ftpclient : createDir[T](ftp: FtpBase[T]; dir: string; recursive: bool = false)
os : createDir(dir: string)
createDirectoryW:
winlean : createDirectoryW(pathName: WideCString; security: pointer = nil): int32
createDocument:
xmldom : createDocument(dom: PDOMImplementation; n: PElement): PDocument
xmldom : createDocument(dom: PDOMImplementation; namespaceURI: string; qualifiedName: string): PDocument
createDocumentFragment:
xmldom : createDocumentFragment(doc: PDocument): PDocumentFragment
createElement:
dom : createElement*(d: Document; identifier: cstring): Element
xmldom : createElement(doc: PDocument; tagName: string): PElement
createElementNS:
xmldom : createElementNS(doc: PDocument; namespaceURI: string; qualifiedName: string): PElement
createEvent:
winlean : createEvent(lpEventAttributes: ptr SECURITY_ATTRIBUTES; bManualReset: DWORD; bInitialState: DWORD; lpName: ptr Utf16Char): 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
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
createProcessingInstruction:
xmldom : createProcessingInstruction(doc: PDocument; target: string; data: string): PProcessingInstruction
createProcessW:
winlean : createProcessW(lpApplicationName, lpCommandLine: WideCString; lpProcessAttributes: ptr SECURITY_ATTRIBUTES; lpThreadAttributes: ptr SECURITY_ATTRIBUTES; bInheritHandles: WINBOOL; dwCreationFlags: int32; lpEnvironment, lpCurrentDirectory: WideCString; lpStartupInfo: var STARTUPINFO; lpProcessInformation: var PROCESS_INFORMATION): WINBOOL
createShared:
system : createShared[](T: typedesc; size = 1.Positive): ptr T:type
createSharedU:
system : createSharedU[](T: typedesc; size = 1.Positive): ptr T:type
createSymbolicLinkW:
winlean : createSymbolicLinkW(lpSymlinkFileName, lpTargetFileName: WideCString; flags: DWORD): int32
createSymlink:
os : createSymlink(src, dest: string)
createTextNode:
dom : createTextNode*(d: Document; identifier: cstring): Node
xmldom : createTextNode(doc: PDocument; data: string): PText
createThread:
threads : createThread*[TArg](t: var Thread[TArg]; tp: proc (arg: TArg); param: TArg)
threads : createThread*(t: var Thread[void]; tp: proc ())
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
CRNCYSTR:
posix : CRNCYSTR
cross:
basic2d : cross(v1, v2: Vector2d): float
basic3d : cross(v1, v2: Vector3d): Vector3d
crypt:
posix : crypt(a1, a2: cstring): cstring
csc:
complex : csc(z: Complex): Complex
csch:
complex : csch(z: Complex): Complex
cschar:
system : cschar
cshort:
system : cshort
cSIG_HOLD:
posix : cSIG_HOLD
csize:
system : csize
CS_PATH:
posix : CS_PATH
CS_POSIX_V6_ILP32_OFF32_CFLAGS:
posix : CS_POSIX_V6_ILP32_OFF32_CFLAGS
CS_POSIX_V6_ILP32_OFF32_LDFLAGS:
posix : CS_POSIX_V6_ILP32_OFF32_LDFLAGS
CS_POSIX_V6_ILP32_OFF32_LIBS:
posix : CS_POSIX_V6_ILP32_OFF32_LIBS
CS_POSIX_V6_ILP32_OFFBIG_CFLAGS:
posix : CS_POSIX_V6_ILP32_OFFBIG_CFLAGS
CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS:
posix : CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS
CS_POSIX_V6_ILP32_OFFBIG_LIBS:
posix : CS_POSIX_V6_ILP32_OFFBIG_LIBS
CS_POSIX_V6_LP64_OFF64_CFLAGS:
posix : CS_POSIX_V6_LP64_OFF64_CFLAGS
CS_POSIX_V6_LP64_OFF64_LDFLAGS:
posix : CS_POSIX_V6_LP64_OFF64_LDFLAGS
CS_POSIX_V6_LP64_OFF64_LIBS:
posix : CS_POSIX_V6_LP64_OFF64_LIBS
CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS:
posix : CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS
CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS:
posix : CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS
CS_POSIX_V6_LPBIG_OFFBIG_LIBS:
posix : CS_POSIX_V6_LPBIG_OFFBIG_LIBS
CS_POSIX_V6_WIDTH_RESTRICTED_ENVS:
posix : CS_POSIX_V6_WIDTH_RESTRICTED_ENVS
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
ctermid:
posix : ctermid(a1: cstring): cstring
ctime:
posix : ctime(a1: var Time): cstring
ctime_r:
posix : ctime_r(a1: var Time; a2: cstring): cstring
cuchar:
system : cuchar
cuint:
system : cuint
culong:
system : culong
culonglong:
system : culonglong
CurDir:
os : CurDir
ospaths : CurDir
current working directory:
Module os
Module os
currentSourcePath:
system : currentSourcePath(): string
cursorBackward:
terminal : cursorBackward(f: File; count = 1)
terminal : cursorBackward(count = 1)
cursorDown:
terminal : cursorDown(f: File; count = 1)
terminal : cursorDown(count = 1)
cursorForward:
terminal : cursorForward(f: File; count = 1)
terminal : cursorForward(count = 1)
cursorUp:
terminal : cursorUp(f: File; count = 1)
terminal : cursorUp(count = 1)
cushort:
system : cushort
cut:
Module system
cycle:
sequtils : cycle[T](s: seq[T]; n: Natural): seq[T]
DAY_1:
posix : DAY_1
DAY_2:
posix : DAY_2
DAY_3:
posix : DAY_3
DAY_4:
posix : DAY_4
DAY_5:
posix : DAY_5
DAY_6:
posix : DAY_6
DAY_7:
posix : DAY_7
daylight:
posix : daylight
days:
times : days(d: int): TimeInterval
DbColumn:
db_common : DbColumn
DbColumns:
db_common : DbColumns
DbConn:
db_mysql : DbConn
db_postgres : DbConn
db_sqlite : DbConn
DbEffect:
db_common : DbEffect
DbError:
db_common : DbError
dbError:
db_common : dbError(msg: string)
db_mysql : dbError(db: DbConn)
db_postgres : dbError(db: DbConn)
db_sqlite : dbError(db: DbConn)
dbQuote:
db_mysql : dbQuote(s: string): string
db_postgres : dbQuote(s: string): string
db_sqlite : dbQuote(s: string): string
DbType:
db_common : DbType
DbTypeKind:
db_common : DbTypeKind
dd:
htmlgen : dd(e: varargs[untyped]): untyped
DeadThreadError:
system : DeadThreadError
dealloc:
nativesockets : dealloc(ai: ptr AddrInfo)
system : dealloc(p: pointer)
deallocCStringArray:
system : deallocCStringArray(a: cstringArray)
deallocShared:
system : deallocShared(p: pointer)
debug:
logging : debug(args: varargs[string, `$`])
debugEcho:
system : debugEcho(x: varargs[typed, `$`])
dec:
system : dec[T: Ordinal | uint | uint64](x: var T; y = 1)
declared:
system : declared(x: expr): bool
declaredInScope:
system : declaredInScope(x: expr): bool
decode:
base64 : decode(s: string): string
decodeData:
cgi : decodeData(allowedMethods: set[RequestMethod] = {methodNone, methodPost, methodGet}): tuple[ key, value: TaintedString]
cgi : decodeData(data: string): tuple[key, value: TaintedString]
decodeURI:
dom : decodeURI*(uri: cstring): cstring
decodeURIComponent:
dom : decodeURIComponent*(uri: cstring): cstring
decodeUrl:
cgi : decodeUrl(s: string): string
deduplicate:
sequtils : deduplicate[T](seq1: seq[T]): seq[T]
deepCopy:
system : deepCopy[T](x: var T; y: T)
defaultConfig:
rstgen : defaultConfig(): StringTableRef
defaultFilename:
logging : defaultFilename(): string
defaultFindFile:
rst : defaultFindFile(filename: string): string
defaultFmtStr:
logging : defaultFmtStr
defaultMsgHandler:
rst : defaultMsgHandler(filename: string; line, col: int; msgkind: MsgKind; arg: string)
defaultOnProgressChanged:
asyncftpclient : defaultOnProgressChanged(total, progress: BiggestInt; speed: float): Future[void]
defined:
system : defined(x: expr): bool
definedInScope:
system : definedInScope(x: expr): bool
defUserAgent:
httpclient : defUserAgent
DEG15:
basic2d : DEG15
DEG180:
basic2d : DEG180
DEG270:
basic2d : DEG270
DEG30:
basic2d : DEG30
DEG360:
basic2d : DEG360
DEG45:
basic2d : DEG45
DEG60:
basic2d : DEG60
DEG90:
basic2d : DEG90
degToRad:
basic2d : degToRad(deg: float): float
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)
del:
fsmonitor : del(monitor: FSMonitor; wd: cint)
htmlgen : del(e: varargs[untyped]): untyped
httpcore : del(headers: HttpHeaders; key: string)
macros : del(father: NimNode; idx = 0; n = 1)
system : del[T](x: var seq[T]; i: Natural)
tables : del[A, B](t: var OrderedTable[A, B]; key: A)
tables : del[A, B](t: var OrderedTableRef[A, B]; key: A)
tables : del[A, B](t: var Table[A, B]; key: A)
tables : del[A, B](t: TableRef[A, B]; key: A)
Delegate:
asyncio : Delegate
DelegateObj:
asyncio : DelegateObj
delete:
json : delete(obj: JsonNode; key: string)
sequtils : delete[T](s: var seq[T]; first, last: Natural)
strutils : delete(s: var string; first, last: int)
system : delete[T](x: var seq[T]; i: Natural)
xmltree : delete(n: XmlNode; i: Natural)
deleteData:
dom : deleteData*(n: Node; start, len: int)
deleteFileW:
winlean : deleteFileW(pathName: WideCString): int32
delHandleWrite:
asyncio : delHandleWrite(s: AsyncSocket)
delSection:
parsecfg : delSection(dict: var Config; section: string)
delSectionKey:
parsecfg : delSectionKey(dict: var Config; section, key: string)
Deque:
deques : Deque
deque:
Module deques
dequeue:
queues : dequeue[T](q: var Queue[T]): T
description:
nimscript : description
deseralization:
Module marshal
destroyContext:
net : destroyContext(ctx: SslContext)
DETACHED_PROCESS:
winlean : DETACHED_PROCESS
determinant:
basic2d : determinant(t: Matrix2d): float
basic3d : determinant(m: Matrix3d): float
Dev:
posix : Dev
DeviceId:
os : DeviceId
D_FMT:
posix : D_FMT
dfn:
htmlgen : dfn(e: varargs[untyped]): untyped
dictionary:
Module tables
difference:
sets : difference[A](s1, s2: HashSet[A]): HashSet[A]
difftime:
posix : difftime(a1, a2: Time): cdouble
digits:
fenv : digits[](T: typedesc[float32]): int
fenv : digits[](T: typedesc[float64]): int
pegs : digits(): expr
Digits:
strutils : Digits
DIR:
posix : DIR
directory:
Module os
Module os
Dirent:
posix : Dirent
dirExists:
nimscript : dirExists(dir: string): bool
os : dirExists(dir: string): bool
dirname:
posix : dirname(a1: cstring): cstring
DirSep:
os : DirSep
ospaths : DirSep
disableCache:
ropes : disableCache()
disableExternalCapture:
dom : disableExternalCapture*(w: Window)
disableProfiling:
nimprof : disableProfiling()
disjoint:
sets : disjoint[A](s1, s2: HashSet[A]): bool
Dispatcher:
asyncio : Dispatcher
dispose:
system : dispose(x: ForeignCell)
dist:
basic2d : dist(a, b: Point2d): float
basic3d : dist(a, b: Point3d): float
distribute:
sequtils : distribute[T](s: seq[T]; num: Positive; spread = true): seq[seq[T]]
DivByZeroError:
system : DivByZeroError
dl:
htmlgen : dl(e: varargs[untyped]): untyped
dlclose:
posix : dlclose(a1: pointer): cint
dlerror:
posix : dlerror(): cstring
DLL:
Module os
Module ospaths
dlopen:
posix : dlopen(a1: cstring; a2: cint): pointer
dlsym:
posix : dlsym(a1: pointer; a2: cstring): pointer
doAssert:
system : doAssert(cond: bool; msg = "")
Document:
dom : Document
document:
dom : document
documentElement:
xmldom : documentElement(doc: PDocument): PElement
DocumentFragmentNode:
xmldom : DocumentFragmentNode
DocumentNode:
xmldom : DocumentNode
Domain:
nativesockets : Domain
dot:
basic2d : dot(v1, v2: Vector2d): float
basic3d : dot(v1, v2: Vector3d): float
DoublyLinkedList:
lists : DoublyLinkedList
DoublyLinkedNode:
lists : DoublyLinkedNode
DoublyLinkedNodeObj:
lists : DoublyLinkedNodeObj
DoublyLinkedRing:
lists : DoublyLinkedRing
downloadFile:
httpclient : downloadFile(url: string; outputFilename: string; sslContext: SSLContext = defaultSSLContext; timeout = - 1; userAgent = defUserAgent; proxy: Proxy = nil)
dt:
htmlgen : dt(e: varargs[untyped]): untyped
DT_BLK:
posix : DT_BLK
DT_CHR:
posix : DT_CHR
DT_DIR:
posix : DT_DIR
DT_FIFO:
posix : DT_FIFO
D_T_FMT:
posix : D_T_FMT
DT_LNK:
posix : DT_LNK
DT_REG:
posix : DT_REG
DT_SOCK:
posix : DT_SOCK
DT_UNKNOWN:
posix : DT_UNKNOWN
DT_WHT:
posix : DT_WHT
dump:
future : dump(x: typed): untyped
dumpLisp:
macros : dumpLisp(s: untyped): untyped
dumpLispImm:
macros : dumpLispImm(s: untyped): untyped
dumpTree:
macros : dumpTree(s: untyped): untyped
dumpTreeImm:
macros : dumpTreeImm(s: untyped): untyped
dup:
posix : dup(a1: cint): cint
dup2:
posix : dup2(a1, a2: cint): cint
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
DWORD:
winlean : DWORD
DynlibFormat:
os : DynlibFormat
ospaths : DynlibFormat
E:
math : E
E2BIG:
posix : E2BIG
EACCES:
posix : EACCES
EADDRINUSE:
posix : EADDRINUSE
EADDRNOTAVAIL:
posix : EADDRNOTAVAIL
EAFNOSUPPORT:
posix : EAFNOSUPPORT
EAGAIN:
posix : EAGAIN
EAI_AGAIN:
posix : EAI_AGAIN
EAI_BADFLAGS:
posix : EAI_BADFLAGS
EAI_FAIL:
posix : EAI_FAIL
EAI_FAMILY:
posix : EAI_FAMILY
EAI_MEMORY:
posix : EAI_MEMORY
EAI_NONAME:
posix : EAI_NONAME
EAI_OVERFLOW:
posix : EAI_OVERFLOW
EAI_SERVICE:
posix : EAI_SERVICE
EAI_SOCKTYPE:
posix : EAI_SOCKTYPE
EAI_SYSTEM:
posix : EAI_SYSTEM
EALREADY:
posix : EALREADY
EBADF:
posix : EBADF
EBADMSG:
posix : EBADMSG
EBUSY:
posix : EBUSY
ECANCELED:
posix : ECANCELED
ECHILD:
posix : ECHILD
echo:
system : echo(x: varargs[typed, `$`])
ECONNABORTED:
posix : ECONNABORTED
ECONNREFUSED:
posix : ECONNREFUSED
ECONNRESET:
posix : ECONNRESET
EDEADLK:
posix : EDEADLK
EDESTADDRREQ:
posix : EDESTADDRREQ
editDistance:
strutils : editDistance(a, b: string): int
EDOM:
posix : EDOM
EDOMException:
xmldom : EDOMException
EDOMStringSizeErr:
xmldom : EDOMStringSizeErr
EDQUOT:
posix : EDQUOT
EEXIST:
posix : EEXIST
EFAULT:
posix : EFAULT
EFBIG:
posix : EFBIG
EHierarchyRequestErr:
xmldom : EHierarchyRequestErr
EHOSTUNREACH:
posix : EHOSTUNREACH
EIDRM:
posix : EIDRM
EILSEQ:
posix : EILSEQ
EIndexSizeErr:
xmldom : EIndexSizeErr
EINPROGRESS:
posix : EINPROGRESS
EINTR:
posix : EINTR
EInuseAttributeErr:
xmldom : EInuseAttributeErr
EINVAL:
posix : EINVAL
EInvalidAccessErr:
xmldom : EInvalidAccessErr
EInvalidCharacterErr:
xmldom : EInvalidCharacterErr
EInvalidModificationErr:
xmldom : EInvalidModificationErr
EInvalidPeg:
pegs : EInvalidPeg
EInvalidStateErr:
xmldom : EInvalidStateErr
EIO:
posix : EIO
EISCONN:
posix : EISCONN
EISDIR:
posix : EISDIR
Element:
dom : Element
elementName:
parsexml : elementName(my: XmlParser): string
ElementNode:
xmldom : ElementNode
elements:
typeinfo : elements(x: Any): int
ELOOP:
posix : ELOOP
em:
htmlgen : em(e: varargs[untyped]): untyped
EmbedElement:
dom : EmbedElement
EMFILE:
posix : EMFILE
EMismatchedTag:
xmldomparser : EMismatchedTag
emit:
events : emit(emitter: var EventEmitter; eventhandler: var EventHandler; args: EventArgs)
events : emit(emitter: var EventEmitter; event: string; args: EventArgs)
macros : emit[](e: static[string]): untyped
EMLINK:
posix : EMLINK
empty:
intsets : empty(s: IntSet): bool
EMSGSIZE:
posix : EMSGSIZE
EMULTIHOP:
posix : EMULTIHOP
enableCache:
ropes : enableCache()
enableExternalCapture:
dom : enableExternalCapture*(w: Window)
enableProfiling:
nimprof : enableProfiling()
ENamespaceErr:
xmldom : ENamespaceErr
ENAMETOOLONG:
posix : ENAMETOOLONG
encode:
base64 : encode[T: SomeInteger | char](s: openArray[T]; lineLen = 75; newLine = "\x0D\x0A"): string
base64 : encode(s: string; lineLen = 75; newLine = "\x0D\x0A"): string
encodeURI:
dom : encodeURI*(uri: cstring): cstring
encodeURIComponent:
dom : encodeURIComponent*(uri: cstring): cstring
encodeUrl:
cgi : encodeUrl(s: string): string
EncodingConverter:
encodings : EncodingConverter
EncodingError:
encodings : EncodingError
encrypt:
posix : encrypt(a1: array[0 .. 63, char]; a2: cint)
endAnchor:
pegs : endAnchor(): Peg
endgrent:
posix : endgrent()
endhostent:
posix : endhostent()
endian:
Module endians
Endianness:
system : Endianness
endnetent:
posix : endnetent()
EndOfFile:
lexbase : EndOfFile
endOfFile:
system : endOfFile(f: File): bool
system : endOfFile(f: File): bool
endprotoent:
posix : endprotoent()
endpwent:
posix : endpwent()
endservent:
posix : endservent()
endsWith:
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
ENETDOWN:
posix : ENETDOWN
ENETRESET:
posix : ENETRESET
ENETUNREACH:
posix : ENETUNREACH
ENFILE:
posix : ENFILE
ENOBUFS:
posix : ENOBUFS
ENODATA:
posix : ENODATA
ENoDataAllowedErr:
xmldom : ENoDataAllowedErr
ENODEV:
posix : ENODEV
ENOENT:
posix : ENOENT
ENOEXEC:
posix : ENOEXEC
ENOLCK:
posix : ENOLCK
ENOLINK:
posix : ENOLINK
ENOMEM:
posix : ENOMEM
ENoModificationAllowedErr:
xmldom : ENoModificationAllowedErr
ENOMSG:
posix : ENOMSG
ENOPROTOOPT:
posix : ENOPROTOOPT
ENOSPC:
posix : ENOSPC
ENOSR:
posix : ENOSR
ENOSTR:
posix : ENOSTR
ENOSYS:
posix : ENOSYS
ENOTCONN:
posix : ENOTCONN
ENOTDIR:
posix : ENOTDIR
ENOTEMPTY:
posix : ENOTEMPTY
ENotFoundErr:
xmldom : ENotFoundErr
ENOTSOCK:
posix : ENOTSOCK
ENOTSUP:
posix : ENOTSUP
ENotSupportedErr:
xmldom : ENotSupportedErr
ENOTTY:
posix : ENOTTY
enqueue:
queues : enqueue[T](q: var Queue[T]; item: T)
entityName:
parsexml : entityName(my: XmlParser): string
entityToUtf8:
htmlparser : entityToUtf8(entity: string): string
environment variable:
Module os
Module os
environments variables:
Module os
envPairs:
os : envPairs(): tuple[key, value: TaintedString]
ENXIO:
posix : ENXIO
EOPNOTSUPP:
posix : EOPNOTSUPP
EOVERFLOW:
posix : EOVERFLOW
EParseError:
rst : EParseError
EParserError:
xmldomparser : EParserError
EPERM:
posix : EPERM
EPIPE:
posix : EPIPE
epochTime:
times : epochTime(): float
EPROTO:
posix : EPROTO
EPROTONOSUPPORT:
posix : EPROTONOSUPPORT
EPROTOTYPE:
posix : EPROTOTYPE
epsilon:
fenv : epsilon[](T: typedesc[float32]): float32
fenv : epsilon[](T: typedesc[float64]): float64
eqIdent:
macros : eqIdent(node: NimNode; s: string): bool
macros : eqIdent(a, b: string): bool
equalMem:
system : equalMem(a, b: pointer; size: Natural): bool
equals:
basic2d : equals(m1: Matrix2d; m2: Matrix2d; tol = 1e-06'f64): bool
basic2d : equals(v1, v2: Vector2d; tol = 1e-06'f64): bool
basic3d : equals(m1: Matrix3d; m2: Matrix3d; tol = 1e-06'f64): bool
basic3d : equals(v1, v2: Vector3d; tol = 1e-06'f64): bool
equalsFile:
ropes : equalsFile(r: Rope; f: File): bool
ropes : equalsFile(r: Rope; filename: string): bool
ERA:
posix : ERA
ERA_D_FMT:
posix : ERA_D_FMT
ERA_D_T_FMT:
posix : ERA_D_T_FMT
ERANGE:
posix : ERANGE
eraseLine:
terminal : eraseLine(f: File)
terminal : eraseLine()
eraseScreen:
terminal : eraseScreen(f: File)
terminal : eraseScreen()
ERA_T_FMT:
posix : ERA_T_FMT
erf:
math : erf(x: float32): float32
math : erf(x: float64): float64
erfc:
math : erfc(x: float32): float32
math : erfc(x: float64): float64
EROFS:
posix : EROFS
errno:
posix : errno
error:
logging : error(args: varargs[string, `$`])
macros : error(msg: string; n: NimNode = nil)
ERROR_ACCESS_DENIED:
winlean : ERROR_ACCESS_DENIED
ERROR_BAD_ARGUMENTS:
winlean : ERROR_BAD_ARGUMENTS
errorHandle:
osproc : errorHandle(p: Process): FileHandle
ERROR_HANDLE_EOF:
winlean : ERROR_HANDLE_EOF
ERROR_IO_PENDING:
winlean : ERROR_IO_PENDING
errorMessageWriter:
system : errorMessageWriter
errorMsg:
json : errorMsg(my: JsonParser): string
parsexml : errorMsg(my: XmlParser): string
parsexml : errorMsg(my: XmlParser; msg: string): string
errorMsgExpected:
json : errorMsgExpected(my: JsonParser; e: string): string
parsexml : errorMsgExpected(my: XmlParser; tag: string): string
ERROR_NETNAME_DELETED:
winlean : ERROR_NETNAME_DELETED
errorStr:
parsecfg : errorStr(c: CfgParser; msg: string): string
errorStream:
osproc : errorStream(p: Process): Stream
esc:
rstgen : esc(target: OutputTarget; s: string; splitAfter = - 1): string
escape:
dom : escape*(uri: cstring): cstring
strutils : escape(s: string; prefix = "\""; suffix = "\""): string
xmltree : escape(s: string): string
escapeJson:
json : escapeJson(s: string): string
json : escapeJson(s: string; result: var string)
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)
ESPIPE:
posix : ESPIPE
ESRCH:
posix : ESRCH
ESTALE:
posix : ESTALE
ESyntaxErr:
xmldom : ESyntaxErr
ETIME:
posix : ETIME
ETIMEDOUT:
posix : ETIMEDOUT
ETXTBSY:
posix : ETXTBSY
Event:
dom : Event
selectors : Event
EventArgs:
events : EventArgs
eventAttr:
htmlgen : eventAttr
EventEmitter:
events : EventEmitter
EventError:
events : EventError
EventHandler:
events : EventHandler
EventTarget:
dom : EventTarget
EWOULDBLOCK:
posix : EWOULDBLOCK
EWrongDocumentErr:
xmldom : EWrongDocumentErr
Exception:
system : Exception
excl:
critbits : excl[T](c: var CritBitTree[T]; key: string)
intsets : excl(s: var IntSet; key: int)
sets : excl[A](s: var HashSet[A]; key: A)
sets : excl[A](s: var HashSet[A]; other: HashSet[A])
system : excl[T](x: var set[T]; y: T)
system : excl[T](s: var set[T]; flags: set[T])
exclFilePermissions:
os : exclFilePermissions(filename: string; permissions: set[FilePermission])
EXDEV:
posix : EXDEV
exec:
db_mysql : exec(db: DbConn; query: SqlQuery; args: varargs[string, `$`])
db_postgres : exec(db: DbConn; stmtName: SqlPrepared; args: varargs[string])
db_postgres : exec(db: DbConn; query: SqlQuery; args: varargs[string, `$`])
db_sqlite : exec(db: DbConn; query: SqlQuery; args: varargs[string, `$`])
nimscript : exec(command: string)
nimscript : exec(command: string; input: string; cache = "")
execAffectedRows:
db_mysql : execAffectedRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
db_postgres : execAffectedRows(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): int64
db_postgres : execAffectedRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
db_sqlite : execAffectedRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
execCmd:
osproc : execCmd(command: string): int
execCmdEx:
osproc : execCmdEx(command: string; options: set[ProcessOption] = {poStdErrToStdOut, poUsePath}): tuple[ output: TaintedString, exitCode: int]
ExecIOEffect:
system : ExecIOEffect
execl:
posix : execl(a1, a2: cstring): cint
execle:
posix : execle(a1, a2: cstring): cint
execlp:
posix : execlp(a1, a2: cstring): cint
execProcess:
osproc : execProcess(command: string; args: openArray[string] = []; env: StringTableRef = nil; options: set[ProcessOption] = {poStdErrToStdOut, poUsePath, poEvalCommand}): TaintedString
execProcesses:
osproc : execProcesses(cmds: openArray[string]; options = {poStdErrToStdOut, poParentStreams}; n = countProcessors(); beforeRunEvent: proc (idx: int) = nil; afterRunEvent: proc (idx: int; p: Process) = nil): int
execShellCmd:
os : execShellCmd(command: string): int
execv:
posix : execv(a1: cstring; a2: cstringArray): cint
execve:
posix : execve(a1: cstring; a2, a3: cstringArray): cint
execvp:
posix : execvp(a1: cstring; a2: cstringArray): cint
execvpe:
posix : execvpe(a1: cstring; a2: cstringArray; a3: cstringArray): cint
ExeExt:
os : ExeExt
ospaths : ExeExt
ExeExts:
os : ExeExts
ospaths : ExeExts
exists:
nimscript : exists(key: string): bool
existsCookie:
cgi : existsCookie(name: string): bool
existsDir:
nimscript : existsDir(dir: string): bool
os : existsDir(dir: string): bool
existsEnv:
nimscript : existsEnv(key: string): bool
os : existsEnv(key: string): bool
existsFile:
asyncftpclient : existsFile(ftp: AsyncFtpClient; file: string): Future[bool]
ftpclient : existsFile(ftp: FtpClient; file: string): bool
nimscript : existsFile(filename: string): bool
os : existsFile(filename: string): bool
existsKey:
json : existsKey(node: JsonNode; key: string): bool
existsOrCreateDir:
os : existsOrCreateDir(dir: string): bool
exitnow:
posix : exitnow(code: int): void
exp:
complex : exp(z: Complex): Complex
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
ospaths : expandTilde(path: string): string
expect:
unittest : expect(exceptions: varargs[typed]; body: untyped): untyped
expectKind:
macros : expectKind(n: NimNode; k: NimNodeKind)
macros : expectKind(n: NimNode; k: set[NimNodeKind])
expectLen:
macros : expectLen(n: NimNode; len: int)
expectMinLen:
macros : expectMinLen(n: NimNode; min: int)
expr:
system : expr
extendSeq:
typeinfo : extendSeq(x: Any)
extractFilename:
os : extractFilename(path: string): string
ospaths : extractFilename(path: string): string
extractRGB:
colors : extractRGB(a: Color): tuple[r, g, b: range[0 .. 255]]
ExtSep:
os : ExtSep
ospaths : ExtSep
fac:
math : fac(n: int): int
fail:
asyncdispatch : fail[T](future: Future[T]; error: ref Exception)
unittest : fail()
failed:
asyncdispatch : failed(future: FutureBase): bool
failedAssertImpl:
system : failedAssertImpl(msg: string)
fastRows:
db_mysql : fastRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
db_postgres : fastRows(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): Row
db_postgres : fastRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
db_sqlite : fastRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
fastRuneAt:
unicode : fastRuneAt(s: string; i: int; result: untyped; doInc = true)
fastToUTF8Copy:
unicode : fastToUTF8Copy(c: Rune; s: var string; pos: int; doInc = true)
fatal:
logging : fatal(args: varargs[string, `$`])
fchdir:
posix : fchdir(a1: cint): cint
fchmod:
posix : fchmod(a1: cint; a2: Mode): cint
fchown:
posix : fchown(a1: cint; a2: Uid; a3: Gid): cint
fcntl:
posix : fcntl[](a1: cint | SocketHandle; a2: cint): cint
FD_ACCEPT:
winlean : FD_ACCEPT
FD_ADDRESS_LIST_CHANGE:
winlean : FD_ADDRESS_LIST_CHANGE
FD_ALL_EVENTS:
winlean : FD_ALL_EVENTS
fdatasync:
posix : fdatasync(a1: cint): cint
FD_CLOEXEC:
posix : FD_CLOEXEC
FD_CLOSE:
winlean : FD_CLOSE
FD_CLR:
posix : FD_CLR(a1: cint; a2: var TFdSet)
FD_CONNECT:
winlean : FD_CONNECT
FD_GROUP_QQS:
winlean : FD_GROUP_QQS
FD_ISSET:
posix : FD_ISSET[](a1: cint | SocketHandle; a2: var TFdSet): cint
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:
posix : FD_SET[](a1: cint | SocketHandle; a2: var TFdSet)
winlean : FD_SET(socket: SocketHandle; s: var TFdSet)
FD_SETSIZE:
posix : FD_SETSIZE
winlean : FD_SETSIZE
F_DUPFD:
posix : F_DUPFD
FD_WRITE:
winlean : FD_WRITE
FD_ZERO:
posix : FD_ZERO(a1: var TFdSet)
winlean : FD_ZERO(s: var TFdSet)
FE_ALL_EXCEPT:
fenv : FE_ALL_EXCEPT
feclearexcept:
fenv : feclearexcept(excepts: cint): cint
FE_DFL_ENV:
fenv : FE_DFL_ENV
FE_DIVBYZERO:
fenv : FE_DIVBYZERO
FE_DOWNWARD:
fenv : FE_DOWNWARD
fegetenv:
fenv : fegetenv(envp: ptr Tfenv): cint
fegetexceptflag:
fenv : fegetexceptflag(flagp: ptr Tfexcept; excepts: cint): cint
fegetround:
fenv : fegetround(): cint
feholdexcept:
fenv : feholdexcept(envp: ptr Tfenv): cint
FE_INEXACT:
fenv : FE_INEXACT
FE_INVALID:
fenv : FE_INVALID
FE_OVERFLOW:
fenv : FE_OVERFLOW
feraiseexcept:
fenv : feraiseexcept(excepts: cint): cint
fesetenv:
fenv : fesetenv(a1: ptr Tfenv): cint
fesetexceptflag:
fenv : fesetexceptflag(flagp: ptr Tfexcept; excepts: cint): cint
fesetround:
fenv : fesetround(roundingDirection: cint): cint
fetestexcept:
fenv : fetestexcept(excepts: cint): cint
FE_TONEAREST:
fenv : FE_TONEAREST
FE_TOWARDZERO:
fenv : FE_TOWARDZERO
FE_UNDERFLOW:
fenv : FE_UNDERFLOW
feupdateenv:
fenv : feupdateenv(envp: ptr Tfenv): cint
FE_UPWARD:
fenv : FE_UPWARD
fget:
util : fget[K, V](self: Table[K, V]; key: K): V
F_GETFD:
posix : F_GETFD
F_GETFL:
posix : F_GETFL
F_GETLK:
posix : F_GETLK
F_GETOWN:
posix : F_GETOWN
FieldError:
system : FieldError
fieldPairs:
system : fieldPairs[S: tuple | object, T: tuple | object](x: S; y: T): tuple[a, b: expr]
system : fieldPairs[T: tuple | object](x: T): RootObj
fields:
system : fields[S: tuple | object, T: tuple | object](x: S; y: T): tuple[a, b: expr]
system : fields[T: tuple | object](x: T): RootObj
typeinfo : fields(x: Any): tuple[name: string, any: Any]
fieldset:
htmlgen : fieldset(e: varargs[untyped]): untyped
File:
system : File
FILE_ATTRIBUTE_ARCHIVE:
winlean : FILE_ATTRIBUTE_ARCHIVE
FILE_ATTRIBUTE_COMPRESSED:
winlean : FILE_ATTRIBUTE_COMPRESSED
FILE_ATTRIBUTE_DIRECTORY:
winlean : FILE_ATTRIBUTE_DIRECTORY
FILE_ATTRIBUTE_HIDDEN:
winlean : FILE_ATTRIBUTE_HIDDEN
FILE_ATTRIBUTE_NORMAL:
winlean : FILE_ATTRIBUTE_NORMAL
FILE_ATTRIBUTE_READONLY:
winlean : FILE_ATTRIBUTE_READONLY
FILE_ATTRIBUTE_REPARSE_POINT:
winlean : FILE_ATTRIBUTE_REPARSE_POINT
FILE_ATTRIBUTE_SYSTEM:
winlean : FILE_ATTRIBUTE_SYSTEM
FILE_ATTRIBUTE_TEMPORARY:
winlean : FILE_ATTRIBUTE_TEMPORARY
FILE_BEGIN:
winlean : FILE_BEGIN
fileExists:
ftpclient : fileExists(ftp: FtpClient; file: string): bool
nimscript : fileExists(filename: string): bool
os : fileExists(filename: string): bool
FILE_FLAG_BACKUP_SEMANTICS:
winlean : FILE_FLAG_BACKUP_SEMANTICS
FILE_FLAG_OPEN_REPARSE_POINT:
winlean : FILE_FLAG_OPEN_REPARSE_POINT
FILE_FLAG_OVERLAPPED:
winlean : FILE_FLAG_OVERLAPPED
FILE_FLAG_WRITE_THROUGH:
winlean : FILE_FLAG_WRITE_THROUGH
FileHandle:
system : FileHandle
FileId:
os : FileId
FileInfo:
os : FileInfo
FileLogger:
logging : FileLogger
FILE_MAP_READ:
winlean : FILE_MAP_READ
FILE_MAP_WRITE:
winlean : FILE_MAP_WRITE
FileMode:
system : FileMode
fileNewer:
os : fileNewer(a, b: string): bool
FilePermission:
os : FilePermission
FILE_READ_DATA:
winlean : FILE_READ_DATA
FileSeekPos:
system : FileSeekPos
FILE_SHARE_DELETE:
winlean : FILE_SHARE_DELETE
FILE_SHARE_READ:
winlean : FILE_SHARE_READ
FILE_SHARE_WRITE:
winlean : FILE_SHARE_WRITE
FileStream:
streams : FileStream
FileStreamObj:
streams : FileStreamObj
FileSystemCaseSensitive:
os : FileSystemCaseSensitive
ospaths : FileSystemCaseSensitive
FILETIME:
winlean : FILETIME
FILE_WRITE_DATA:
winlean : FILE_WRITE_DATA
fill:
algorithm : fill[T](a: var openArray[T]; first, last: Natural; value: T)
algorithm : fill[T](a: var openArray[T]; value: T)
filter:
options : filter[T](self: Option[T]; callback: proc (input: T): bool): Option[T]
sequtils : filter[T](seq1: seq[T]; pred: proc (item: T): bool): seq[T]
sequtils : filter[T](seq1: seq[T]; pred: proc (item: T): bool): T
filterIt:
sequtils : filterIt(seq1, pred: untyped): untyped
find:
dom : find*(w: Window; text: cstring; caseSensitive = false; backwards = false)
lists : find[T](L: DoublyLinkedList[T]; value: T): DoublyLinkedNode[T]
lists : find[T](L: DoublyLinkedRing[T]; value: T): DoublyLinkedNode[T]
lists : find[T](L: SinglyLinkedList[T]; value: T): SinglyLinkedNode[T]
lists : find[T](L: SinglyLinkedRing[T]; value: T): SinglyLinkedNode[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(s: string; pattern: Regex; start = 0): int
re : find(s: string; pattern: Regex; matches: var openArray[string]; start = 0): int
strutils : find(s: string; sub: char; start: Natural = 0): int
strutils : find(s: string; chars: set[char]; start: Natural = 0): int
strutils : find(s, sub: string; start: Natural = 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(s: string; pattern: Regex; start = 0): string
xmltree : findAll(n: XmlNode; tag: string): seq[XmlNode]
xmltree : findAll(n: XmlNode; tag: string; result: var seq[XmlNode])
findBounds:
pegs : findBounds(s: string; pattern: Peg; matches: var openArray[string]; start = 0): tuple[ first, last: int]
re : findBounds(s: string; pattern: Regex; start = 0): tuple[first, last: int]
re : findBounds(s: string; pattern: Regex; matches: var openArray[string]; start = 0): tuple[ first, last: int]
re : findBounds(s: string; pattern: Regex; matches: var openArray[tuple[first, last: int]]; start = 0): tuple[ first, last: int]
findChild:
macros : findChild(n: NimNode; cond: untyped): NimNode
findClose:
winlean : findClose(hFindFile: Handle)
findExe:
os : findExe(exe: string; followSymlinks: bool = true; extensions = ExeExts): string
ospaths : findExe(exe: string; followSymlinks: bool = true; extensions = ExeExts): string
FindFileHandler:
rst : FindFileHandler
findFirstFileW:
winlean : findFirstFileW(lpFileName: WideCString; lpFindFileData: var WIN32_FIND_DATA): Handle
findIter:
nre : findIter(str: string; pattern: Regex; start = 0; endpos = int.high): RegexMatch
findNextFileW:
winlean : findNextFileW(hFindFile: Handle; lpFindFileData: var WIN32_FIND_DATA): int32
finished:
asyncdispatch : finished[T](future: Future[T] | FutureVar[T]): bool
system : finished[T: proc](x: T): bool
FIONBIO:
nativesockets : FIONBIO
firstChild:
xmldom : firstChild(n: PNode): PNode
float:
system : float
float32:
system : float32
float64:
system : float64
FloatClass:
math : FloatClass
FloatDivByZeroError:
system : FloatDivByZeroError
FloatFormatMode:
strutils : FloatFormatMode
FloatInexactError:
system : FloatInexactError
FloatingPointError:
system : FloatingPointError
FloatInvalidOpError:
system : FloatInvalidOpError
FloatOverflowError:
system : FloatOverflowError
FloatUnderflowError:
system : FloatUnderflowError
floatVal:
macros : floatVal(n: NimNode): BiggestFloat
floatVal=:
macros : floatVal=(n: NimNode; val: BiggestFloat)
F_LOCK:
posix : F_LOCK
floor:
math : floor(x: float32): float32
math : floor(x: float64): float64
FlowVar:
threadpool : FlowVar
FlowVarBase:
threadpool : FlowVarBase
flush:
streams : flush(s: Stream)
flushFile:
system : flushFile(f: File)
system : flushFile(f: File)
flushFileBuffers:
winlean : flushFileBuffers(hFile: Handle): WINBOOL
fmod:
math : fmod(x, y: float32): float32
math : fmod(x, y: float64): float64
fmtmsg:
posix : fmtmsg(a1: int; a2: cstring; a3: cint; a4, a5, a6: cstring): cint
fnmatch:
posix : fnmatch(a1, a2: cstring; a3: cint): cint
FNM_NOESCAPE:
posix : FNM_NOESCAPE
FNM_NOMATCH:
posix : FNM_NOMATCH
FNM_NOSYS:
posix : FNM_NOSYS
FNM_PATHNAME:
posix : FNM_PATHNAME
FNM_PERIOD:
posix : FNM_PERIOD
focus:
dom : focus*(e: Element)
dom : focus*(w: Window)
F_OK:
posix : F_OK
foldl:
sequtils : foldl(sequence, operation, first): untyped
sequtils : foldl(sequence, operation: untyped): untyped
foldr:
sequtils : foldr(sequence, operation: untyped): untyped
ForegroundColor:
terminal : ForegroundColor
foreign:
threadpool : foreign
ForeignCell:
system : ForeignCell
fork:
posix : fork(): Pid
form:
htmlgen : form(e: varargs[untyped]): untyped
format:
strutils : format(formatstr: string; a: varargs[string, `$`]): string
subexes : format(formatstr: Subex; a: varargs[string, `$`]): string
times : format(info: TimeInfo; f: string): string
formatBiggestFloat:
strutils : formatBiggestFloat(f: BiggestFloat; format: FloatFormatMode = ffDefault; precision: range[0 .. 32] = 16; decimalSep = '.'): string
formatEng:
strutils : formatEng(f: BiggestFloat; precision: range[0 .. 32] = 10; trim: bool = true; siPrefix: bool = false; unit: string = nil; decimalSep = '.'): string
FormatFlag:
strtabs : FormatFlag
formatFloat:
strutils : formatFloat(f: float; format: FloatFormatMode = ffDefault; precision: range[0 .. 32] = 16; decimalSep = '.'): string
formatMessageW:
winlean : formatMessageW(dwFlags: int32; lpSource: pointer; dwMessageId, dwLanguageId: int32; lpBuffer: pointer; nSize: int32; Arguments: pointer): int32
formatNamedVars:
rstgen : formatNamedVars(frmt: string; varnames: openArray[string]; varvalues: openArray[string]): string
formatSize:
strutils : formatSize(bytes: int64; decimalSep = '.'; prefix = bpIEC; includeSpace = false): string
formatStr:
util : formatStr(howExpr, namegetter, idgetter: expr): expr
FormElement:
dom : FormElement
forward:
dom : forward*(h: History)
dom : forward*(w: Window)
fpathconf:
posix : fpathconf(a1, a2: cint): int
fpRadix:
fenv : fpRadix(): int
Frame:
dom : Frame
F_RDLCK:
posix : F_RDLCK
freeaddrinfo:
posix : freeaddrinfo(a1: ptr AddrInfo)
winlean : freeaddrinfo(ai: ptr AddrInfo)
freeEnvironmentStringsW:
winlean : freeEnvironmentStringsW(para1: WideCString): int32
freeShared:
system : freeShared[T](p: ptr T)
frexp:
math : frexp(x: float32; exponent: var int): float32
math : frexp(x: float64; exponent: var int): float64
fromSeconds:
times : fromSeconds(since1970: float): Time
times : fromSeconds(since1970: int64): Time
front:
queues : front[T](q: Queue[T]): T
Fsblkcnt:
posix : Fsblkcnt
F_SETFD:
posix : F_SETFD
F_SETFL:
posix : F_SETFL
F_SETLK:
posix : F_SETLK
F_SETLKW:
posix : F_SETLKW
F_SETOWN:
posix : F_SETOWN
Fsfilcnt:
posix : Fsfilcnt
FSMonitor:
fsmonitor : FSMonitor
fstat:
posix : fstat(a1: cint; a2: var Stat): cint
fstatvfs:
posix : fstatvfs(a1: cint; a2: var Statvfs): cint
fsync:
posix : fsync(a1: cint): cint
F_TEST:
posix : F_TEST
F_TLOCK:
posix : F_TLOCK
ftok:
posix : ftok(a1: cstring; a2: cint): Key
FtpBase:
ftpclient : FtpBase
FtpBaseObj:
ftpclient : FtpBaseObj
FtpClient:
ftpclient : FtpClient
ftpClient:
ftpclient : ftpClient(address: string; port = Port(21); user, pass = ""): FtpClient
FtpClientObj:
ftpclient : FtpClientObj
FTPError:
ftpclient : FTPError
FTPEvent:
ftpclient : FTPEvent
FTPEventType:
ftpclient : FTPEventType
FTPJobType:
ftpclient : FTPJobType
ftruncate:
posix : ftruncate(a1: cint; a2: Off): cint
FTW:
posix : FTW
ftw:
posix : ftw(a1: cstring; a2: proc (x1: cstring; x2: ptr Stat; x3: cint): cint; a3: cint): cint
FTW_CHDIR:
posix : FTW_CHDIR
FTW_D:
posix : FTW_D
FTW_DEPTH:
posix : FTW_DEPTH
FTW_DNR:
posix : FTW_DNR
FTW_DP:
posix : FTW_DP
FTW_F:
posix : FTW_F
FTW_MOUNT:
posix : FTW_MOUNT
FTW_NS:
posix : FTW_NS
FTW_PHYS:
posix : FTW_PHYS
FTW_SL:
posix : FTW_SL
FTW_SLN:
posix : FTW_SLN
F_ULOCK:
posix : F_ULOCK
F_UNLCK:
posix : F_UNLCK
Future:
asyncdispatch : Future
FutureBase:
asyncdispatch : FutureBase
FutureError:
asyncdispatch : FutureError
FutureVar:
asyncdispatch : FutureVar
F_WRLCK:
posix : F_WRLCK
gai_strerror:
posix : gai_strerror(a1: cint): cstring
GC_addCycleRoot:
system : GC_addCycleRoot[T](p: ref T)
gcd:
math : gcd[T](x, y: T): T
GC_disable:
system : GC_disable()
GC_disableMarkAndSweep:
system : GC_disableMarkAndSweep()
GC_enable:
system : GC_enable()
GC_enableMarkAndSweep:
system : GC_enableMarkAndSweep()
GC_fullCollect:
system : GC_fullCollect()
GC_getStatistics:
system : GC_getStatistics(): string
gcInvariant:
system : gcInvariant()
GC_ref:
system : GC_ref[T](x: ref T)
system : GC_ref[T](x: seq[T])
system : GC_ref(x: string)
GC_setStrategy:
system : GC_setStrategy(strategy: GC_Strategy)
GC_Strategy:
system : GC_Strategy
GC_unref:
system : GC_unref[T](x: ref T)
system : GC_unref[T](x: seq[T])
system : GC_unref(x: string)
GeneralTokenizer:
highlite : GeneralTokenizer
generatedTime:
oids : generatedTime(oid: Oid): Time
generic character types:
Generic character types
GENERIC_ALL:
winlean : GENERIC_ALL
GENERIC_READ:
winlean : GENERIC_READ
GENERIC_WRITE:
winlean : GENERIC_WRITE
genOid:
oids : genOid(): Oid
genSym:
macros : genSym(kind: NimSymKind = nskLet; ident = ""): NimNode
get:
httpclient : get(client: AsyncHttpClient; url: string): Future[Response]
httpclient : get(client: HttpClient; url: string): Response
httpclient : get(url: string; extraHeaders = ""; maxRedirects = 5; sslContext: SSLContext = defaultSSLContext; timeout = - 1; userAgent = defUserAgent; proxy: Proxy = nil): Response
nimscript : get(key: string): string
options : get[T](self: Option[T]): T
options : get[T](self: Option[T]; otherwise: T): T
getAddrInfo:
nativesockets : getAddrInfo(address: string; port: Port; domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP): ptr AddrInfo
getaddrinfo:
posix : getaddrinfo(a1, a2: cstring; a3: ptr AddrInfo; a4: var ptr AddrInfo): cint
winlean : getaddrinfo(nodename, servname: cstring; hints: ptr AddrInfo; res: var ptr AddrInfo): cint
getAddrString:
nativesockets : getAddrString(sockAddr: ptr SockAddr): string
getAllRows:
db_mysql : getAllRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): seq[Row]
db_postgres : getAllRows(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): seq[Row]
db_postgres : getAllRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): seq[Row]
db_sqlite : getAllRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): seq[Row]
getAppDir:
os : getAppDir(): string
getAppFilename:
os : getAppFilename(): string
getApplicationDir:
os : getApplicationDir(): string
getApplicationFilename:
os : getApplicationFilename(): string
getArgument:
rst : getArgument(n: PRstNode): string
getAst:
macros : getAst(macroOrTemplate: untyped): NimNode
getAttribute:
dom : getAttribute*(n: Node; attr: cstring): cstring
dom : getAttribute*(s: Style; attr: cstring; caseSensitive = false): cstring
xmldom : getAttribute(el: PNode; name: string): string
getAttributeNode:
dom : getAttributeNode*(n: Node; attr: cstring): Node
xmldom : getAttributeNode(el: PElement; name: string): PAttr
getAttributeNodeNS:
xmldom : getAttributeNodeNS(el: PElement; namespaceURI: string; localName: string): PAttr
getAttributeNS:
xmldom : getAttributeNS(el: PNode; namespaceURI: string; localName: string): string
getBiggestFloat:
typeinfo : getBiggestFloat(x: Any): BiggestFloat
getBiggestInt:
typeinfo : getBiggestInt(x: Any): BiggestInt
getBiggestUint:
typeinfo : getBiggestUint(x: Any): uint64
getBool:
typeinfo : getBool(x: Any): bool
getBVal:
json : getBVal(n: JsonNode; default: bool = false): bool
getch:
terminal : getch(): char
getChar:
typeinfo : getChar(x: Any): char
getClockStr:
times : getClockStr(): string
getColNumber:
lexbase : getColNumber(L: BaseLexer; pos: int): int
getColumn:
json : getColumn(my: JsonParser): int
parsecfg : getColumn(c: CfgParser): int
parsexml : getColumn(my: XmlParser): int
getCommand:
nimscript : getCommand(): string
getCommandLineW:
winlean : getCommandLineW(): WideCString
getConfigDir:
os : getConfigDir(): string
ospaths : getConfigDir(): string
getContent:
httpclient : getContent(client: AsyncHttpClient; url: string): Future[string]
httpclient : getContent(client: HttpClient; url: string): string
httpclient : getContent(url: string; extraHeaders = ""; maxRedirects = 5; sslContext: SSLContext = defaultSSLContext; timeout = - 1; userAgent = defUserAgent; proxy: Proxy = nil): string
getContentLength:
cgi : getContentLength(): string
getContentType:
cgi : getContentType(): string
getcontext:
posix : getcontext(a1: var Ucontext): cint
getCookie:
cgi : getCookie(name: string): TaintedString
getCreationTime:
os : getCreationTime(file: string): Time
getCString:
typeinfo : getCString(x: Any): cstring
getCurrentDir:
os : getCurrentDir(): string
getCurrentDirectoryW:
winlean : getCurrentDirectoryW(nBufferLength: int32; lpBuffer: WideCString): int32
getCurrentEncoding:
encodings : getCurrentEncoding(): string
getCurrentException:
system : getCurrentException(): ref Exception
getCurrentExceptionMsg:
system : getCurrentExceptionMsg(): string
getCurrentLine:
lexbase : getCurrentLine(L: BaseLexer; marker: bool = true): string
getCurrentProcess:
winlean : getCurrentProcess(): Handle
getcwd:
posix : getcwd(a1: cstring; a2: int): cstring
getdate:
posix : getdate(a1: cstring): ptr Tm
getDateStr:
times : getDateStr(): string
getDayOfWeek:
times : getDayOfWeek(day, month, year: int): WeekDay
getDayOfWeekJulian:
times : getDayOfWeekJulian(day, month, year: int): WeekDay
getDaysInMonth:
times : getDaysInMonth(month: Month; year: int): int
getDaysInYear:
times : getDaysInYear(year: int): int
getDocumentRoot:
cgi : getDocumentRoot(): string
getDOM:
xmldom : getDOM(): PDOMImplementation
getegid:
posix : getegid(): Gid
getElementById:
dom : getElementById*(d: Document; id: cstring): Element
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]
xmldom : getElementsByTagName(doc: PDocument; tagName: string): seq[PNode]
xmldom : getElementsByTagName(el: PElement; name: string): seq[PNode]
getElementsByTagNameNS:
xmldom : getElementsByTagNameNS(doc: PDocument; namespaceURI: string; localName: string): seq[ PNode]
xmldom : getElementsByTagNameNS(el: PElement; namespaceURI: string; localName: string): seq[ PNode]
getElems:
json : getElems(n: JsonNode; default: seq[JsonNode] = @ []): seq[JsonNode]
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): string
os : getEnv(key: string): TaintedString
getEnvironmentStringsW:
winlean : getEnvironmentStringsW(): WideCString
geteuid:
posix : geteuid(): Uid
getExitCodeProcess:
winlean : getExitCodeProcess(hProcess: Handle; lpExitCode: var int32): WINBOOL
getExt:
mimetypes : getExt(mimedb: MimeDB; mimetype: string; default = "txt"): string
getExtraData:
net : getExtraData(ctx: SslContext; index: int): RootRef
getFd:
asyncnet : getFd(socket: AsyncSocket): SocketHandle
net : getFd(socket: Socket): SocketHandle
getFields:
json : getFields(n: JsonNode; default = initOrderedTable(4)): OrderedTable[string, JsonNode]
getFieldValue:
rst : getFieldValue(n: PRstNode): string
rst : getFieldValue(n: PRstNode; fieldname: string): string
getFileAttributesW:
winlean : getFileAttributesW(lpFileName: WideCString): int32
getFileHandle:
system : getFileHandle(f: File): FileHandle
system : 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:
json : getFilename(my: JsonParser): string
parsecfg : getFilename(c: CfgParser): string
parsexml : getFilename(my: XmlParser): string
getFilePermissions:
os : getFilePermissions(filename: string): set[FilePermission]
getFilePos:
asyncfile : getFilePos(f: AsyncFile): int64
system : getFilePos(f: File): int64
system : getFilePos(f: File): int64
getFileSize:
os : getFileSize(file: string): BiggestInt
system : getFileSize(f: File): int64
system : getFileSize(f: File): int64
winlean : getFileSize(hFile: Handle; lpFileSizeHigh: ptr DWORD): DWORD
getFloat:
json : getFloat(my: JsonParser): float
typeinfo : getFloat(x: Any): float
getFloat32:
typeinfo : getFloat32(x: Any): float32
getFloat64:
typeinfo : getFloat64(x: Any): float64
getFNum:
json : getFNum(n: JsonNode; default: float = 0.0'f64): float
getFrame:
system : getFrame(): PFrame
getFreeMem:
system : getFreeMem(): int
getFullPathNameW:
winlean : getFullPathNameW(lpFileName: WideCString; nBufferLength: int32; lpBuffer: WideCString; lpFilePart: var WideCString): int32
getGatewayInterface:
cgi : getGatewayInterface(): string
getgid:
posix : getgid(): Gid
getGlobalDispatcher:
asyncdispatch : getGlobalDispatcher(): PDispatcher
getGMTime:
times : getGMTime(t: Time): TimeInfo
getgrent:
posix : getgrent(): ptr Group
getgrgid:
posix : getgrgid(a1: Gid): ptr Group
getgrgid_r:
posix : getgrgid_r(a1: Gid; a2: ptr Group; a3: cstring; a4: int; a5: ptr ptr Group): cint
getgrnam:
posix : getgrnam(a1: cstring): ptr Group
getgrnam_r:
posix : getgrnam_r(a1: cstring; a2: ptr Group; a3: cstring; a4: int; a5: ptr ptr Group): cint
getgroups:
posix : getgroups(a1: cint; a2: ptr array[0 .. 255, Gid]): cint
getHandlers:
logging : getHandlers(): seq[Logger]
getHomeDir:
os : getHomeDir(): string
ospaths : getHomeDir(): string
getHostByAddr:
nativesockets : getHostByAddr(ip: string): Hostent
gethostbyaddr:
posix : gethostbyaddr(a1: pointer; a2: Socklen; a3: cint): ptr Hostent
winlean : gethostbyaddr(ip: ptr InAddr; len: cuint; theType: cint): ptr Hostent
getHostByName:
nativesockets : getHostByName(name: string): Hostent
gethostbyname:
posix : gethostbyname(a1: cstring): ptr Hostent
winlean : gethostbyname(name: cstring): ptr Hostent
gethostent:
posix : gethostent(): ptr Hostent
gethostid:
posix : gethostid(): int
gethostname:
posix : gethostname(a1: cstring; a2: int): cint
getHttpAccept:
cgi : getHttpAccept(): string
getHttpAcceptCharset:
cgi : getHttpAcceptCharset(): string
getHttpAcceptEncoding:
cgi : getHttpAcceptEncoding(): string
getHttpAcceptLanguage:
cgi : getHttpAcceptLanguage(): string
getHttpConnection:
cgi : getHttpConnection(): string
getHttpCookie:
cgi : getHttpCookie(): string
getHttpHost:
cgi : getHttpHost(): string
getHttpReferer:
cgi : getHttpReferer(): string
getHttpUserAgent:
cgi : getHttpUserAgent(): string
getImpl:
macros : getImpl(s: NimSym): NimNode
getInt:
json : getInt(my: JsonParser): 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
getLastAccessTime:
os : getLastAccessTime(file: string): Time
getLastError:
winlean : getLastError(): int32
getLastModificationTime:
os : getLastModificationTime(file: string): Time
getLine:
json : getLine(my: JsonParser): int
parsecfg : getLine(c: CfgParser): int
parsexml : getLine(my: XmlParser): int
getLocalAddr:
nativesockets : getLocalAddr(socket: SocketHandle; domain: Domain): (string, Port)
net : getLocalAddr(socket: Socket): (string, Port)
getLocalTime:
times : getLocalTime(t: Time): TimeInfo
getLogFilter:
logging : getLogFilter(): Level
getlogin:
posix : getlogin(): cstring
getlogin_r:
posix : getlogin_r(a1: cstring; a2: int): cint
getMD5:
md5 : getMD5(s: string): string
getMimetype:
mimetypes : getMimetype(mimedb: MimeDB; ext: string; default = "text/plain"): string
getModuleFileNameW:
winlean : getModuleFileNameW(handle: Handle; buf: WideCString; size: int32): int32
getNamedItem:
xmldom : getNamedItem(nList: seq[PAttr]; name: string): PAttr
xmldom : getNamedItem(nList: seq[PNode]; name: string): PNode
getNamedItemNS:
xmldom : getNamedItemNS(nList: seq[PAttr]; namespaceURI: string; localName: string): PAttr
xmldom : getNamedItemNS(nList: seq[PNode]; namespaceURI: string; localName: string): PNode
getnameinfo:
posix : getnameinfo(a1: ptr SockAddr; a2: Socklen; a3: cstring; a4: Socklen; a5: cstring; a6: Socklen; a7: cint): cint
winlean : getnameinfo(a1: ptr SockAddr; a2: SockLen; a3: cstring; a4: SockLen; a5: cstring; a6: SockLen; a7: cint): cint
getnetbyaddr:
posix : getnetbyaddr(a1: int32; a2: cint): ptr Tnetent
getnetbyname:
posix : getnetbyname(a1: cstring): ptr Tnetent
getnetent:
posix : getnetent(): ptr Tnetent
getNextToken:
highlite : getNextToken(g: var GeneralTokenizer; lang: SourceLanguage)
getNum:
json : getNum(n: JsonNode; default: BiggestInt = 0): BiggestInt
mersenne : getNum(m: var MersenneTwister): uint32
getOccupiedMem:
system : getOccupiedMem(): int
getopt:
parseopt : getopt(): tuple[kind: CmdLineKind, key, val: TaintedString]
parseopt2 : getopt(): GetoptResult
posix : getopt(a1: cint; a2: cstringArray; a3: cstring): cint
GetoptResult:
parseopt2 : GetoptResult
getOrDefault:
httpcore : getOrDefault(headers: HttpHeaders; key: string; default = @ [""].HttpHeaderValues): HttpHeaderValues
json : getOrDefault(node: JsonNode; key: string): JsonNode
strtabs : getOrDefault(t: StringTableRef; key: string): string
tables : getOrDefault[A](t: CountTable[A]; key: A): int
tables : getOrDefault[A](t: CountTableRef[A]; key: A): int
tables : getOrDefault[A, B](t: OrderedTable[A, B]; key: A): B
tables : getOrDefault[A, B](t: OrderedTableRef[A, B]; key: A): B
tables : getOrDefault[A, B](t: Table[A, B]; key: A): B
tables : getOrDefault[A, B](t: TableRef[A, B]; key: A): B
get_osfhandle:
winlean : get_osfhandle(fd: FileHandle): Handle
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)
getpeername:
Module nativesockets
Creating a server
posix : getpeername(a1: SocketHandle; a2: ptr SockAddr; a3: ptr Socklen): cint
winlean : getpeername(s: SocketHandle; name: ptr SockAddr; namelen: ptr SockLen): cint
getpgid:
posix : getpgid(a1: Pid): Pid
getpgrp:
posix : getpgrp(): Pid
getpid:
posix : getpid(): Pid
getPointer:
typeinfo : getPointer(x: Any): pointer
getPosition:
streams : getPosition(s: Stream): int
streams : getPosition(s, unused: Stream): int
getppid:
posix : getppid(): Pid
getProcessTimes:
winlean : getProcessTimes(hProcess: Handle; lpCreationTime, lpExitTime, lpKernelTime, lpUserTime: var FILETIME): WINBOOL
getprotobyname:
posix : getprotobyname(a1: cstring): ptr Protoent
getprotobynumber:
posix : getprotobynumber(a1: cint): ptr Protoent
getprotoent:
posix : getprotoent(): ptr Protoent
getPskIdentity:
net : getPskIdentity(socket: Socket): string
getpwent:
posix : getpwent(): ptr Passwd
getpwnam:
posix : getpwnam(a1: cstring): ptr Passwd
getpwnam_r:
posix : getpwnam_r(a1: cstring; a2: ptr Passwd; a3: cstring; a4: int; a5: ptr ptr Passwd): cint
getpwuid:
posix : getpwuid(a1: Uid): ptr Passwd
getpwuid_r:
posix : getpwuid_r(a1: Uid; a2: ptr Passwd; a3: cstring; a4: int; a5: ptr ptr Passwd): cint
getQueryString:
cgi : getQueryString(): string
getQueuedCompletionStatus:
winlean : getQueuedCompletionStatus(CompletionPort: Handle; lpNumberOfBytesTransferred: PDWORD; lpCompletionKey: PULONG_PTR; lpOverlapped: ptr POVERLAPPED; dwMilliseconds: DWORD): WINBOOL
getRefcount:
system : getRefcount[T](x: ref T): int
system : getRefcount[T](x: seq[T]): int
system : getRefcount(x: string): int
getRemoteAddr:
cgi : getRemoteAddr(): string
getRemoteHost:
cgi : getRemoteHost(): string
getRemoteIdent:
cgi : getRemoteIdent(): string
getRemotePort:
cgi : getRemotePort(): string
getRemoteUser:
cgi : getRemoteUser(): string
getRequestMethod:
cgi : getRequestMethod(): string
getRequestURI:
cgi : getRequestURI(): string
getRow:
db_mysql : getRow(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
db_postgres : getRow(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): Row
db_postgres : getRow(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
db_sqlite : getRow(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
getScriptFilename:
cgi : getScriptFilename(): string
getScriptName:
cgi : getScriptName(): string
getSectionValue:
parsecfg : getSectionValue(dict: Config; section, key: string): string
getSelection:
dom : getSelection*(d: Document): cstring
getServByName:
nativesockets : getServByName(name, proto: string): Servent
getservbyname:
posix : getservbyname(a1, a2: cstring): ptr Servent
winlean : getservbyname(name, proto: cstring): ptr Servent
getServByPort:
nativesockets : getServByPort(port: Port; proto: string): Servent
getservbyport:
posix : getservbyport(a1: cint; a2: cstring): ptr Servent
winlean : getservbyport(port: cint; proto: cstring): ptr Servent
getservent:
posix : getservent(): 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
getsid:
posix : getsid(a1: Pid): Pid
getSockDomain:
nativesockets : getSockDomain(socket: SocketHandle): Domain
getSocket:
asyncio : getSocket(s: AsyncSocket): Socket
getSocketError:
net : getSocketError(socket: Socket): OSErrorCode
getSockName:
nativesockets : getSockName(socket: SocketHandle): Port
getsockname:
Module nativesockets
Creating a server
posix : getsockname(a1: SocketHandle; a2: ptr SockAddr; a3: ptr Socklen): cint
winlean : getsockname(s: SocketHandle; name: ptr SockAddr; namelen: ptr SockLen): cint
getSockOpt:
asyncnet : getSockOpt(socket: AsyncSocket; opt: SOBool; level = SOL_SOCKET): bool
net : getSockOpt(socket: Socket; opt: SOBool; level = SOL_SOCKET): bool
getsockopt:
posix : getsockopt(a1: SocketHandle; a2, a3: cint; a4: pointer; a5: ptr Socklen): cint
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(): string
system : getStackTrace(e: ref Exception): string
system : getStackTrace(e: ref Exception): string
getStartMilsecs:
times : getStartMilsecs(): int
getStdHandle:
winlean : getStdHandle(nStdHandle: int32): Handle
getStr:
json : getStr(n: JsonNode; default: string = ""): string
getString:
typeinfo : getString(x: Any): string
getSystemTimeAsFileTime:
winlean : getSystemTimeAsFileTime(lpSystemTimeAsFileTime: var FILETIME)
getSystemTimes:
winlean : getSystemTimes(lpIdleTime, lpKernelTime, lpUserTime: var FILETIME): WINBOOL
getTempDir:
os : getTempDir(): string
ospaths : getTempDir(): string
getTime:
times : getTime(): Time
getTimezone:
times : getTimezone(): int
getTotalMem:
system : getTotalMem(): int
getType:
macros : getType(n: NimNode): NimNode
macros : getType[](n: typedesc): NimNode
getTypeImpl:
macros : getTypeImpl(n: NimNode): NimNode
macros : getTypeImpl[](n: typedesc): NimNode
getTypeInfo:
system : getTypeInfo[T](x: T): pointer
getTypeInst:
macros : getTypeInst(n: NimNode): NimNode
macros : getTypeInst[](n: typedesc): NimNode
getuid:
posix : getuid(): Uid
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
getValue:
db_mysql : getValue(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): string
db_postgres : getValue(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): string
db_postgres : getValue(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): string
db_sqlite : getValue(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): string
getVersion:
winlean : getVersion(): DWORD
getVersionExW:
winlean : getVersionExW(lpVersionInfo: ptr OSVERSIONINFO): WINBOOL
getwd:
posix : getwd(a1: cstring): cstring
getXAxis:
basic3d : getXAxis(m: Matrix3d): Vector3d
getYAxis:
basic3d : getYAxis(m: Matrix3d): Vector3d
getZAxis:
basic3d : getZAxis(m: Matrix3d): Vector3d
Gid:
posix : Gid
glob:
Module os
Module os
Module os
Glob:
posix : Glob
glob:
posix : glob(a1: cstring; a2: cint; a3: proc (x1: cstring; x2: cint): cint; a4: ptr Glob): cint
GLOB_ABORTED:
posix : GLOB_ABORTED
globalRaiseHook:
system : globalRaiseHook
GLOB_APPEND:
posix : GLOB_APPEND
GLOB_DOOFFS:
posix : GLOB_DOOFFS
GLOB_ERR:
posix : GLOB_ERR
globfree:
posix : globfree(a1: ptr Glob)
GLOB_MARK:
posix : GLOB_MARK
GLOB_NOCHECK:
posix : GLOB_NOCHECK
GLOB_NOESCAPE:
posix : GLOB_NOESCAPE
GLOB_NOMATCH:
posix : GLOB_NOMATCH
GLOB_NOSORT:
posix : GLOB_NOSORT
GLOB_NOSPACE:
posix : GLOB_NOSPACE
GLOB_NOSYS:
posix : GLOB_NOSYS
gmtime:
posix : gmtime(a1: var Time): ptr Tm
gmtime_r:
posix : gmtime_r(a1: var Time; a2: var Tm): ptr Tm
go:
dom : go*(h: History; pagesToJump: int)
gorge:
system : gorge(command: string; input = ""; cache = ""): string
gorgeEx:
system : gorgeEx(command: string; input = ""; cache = ""): tuple[output: string, exitCode: int]
graphemeLen:
unicode : graphemeLen(s: string; i: Natural): Natural
Group:
posix : Group
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
handle:
threads : handle*[TArg](t: Thread[TArg]): SysThread
Handle:
winlean : Handle
handleCR:
lexbase : handleCR(L: var BaseLexer; pos: int): int
handleEvent:
dom : handleEvent*(d: Document; event: Event)
dom : handleEvent*(e: Element; event: Event)
dom : handleEvent*(w: Window; e: Event)
handleLF:
lexbase : handleLF(L: var BaseLexer; pos: int): int
handleMatches:
pegs : handleMatches(m: int; n: int; c: openArray[string]): string
handleRefillChar:
lexbase : handleRefillChar(L: var BaseLexer; pos: int): int
hasArgOfName:
macros : hasArgOfName(params: NimNode; name: string): bool
hasAttribute:
xmldom : hasAttribute(el: PElement; name: string): bool
hasAttributeNS:
xmldom : hasAttributeNS(el: PElement; namespaceURI: string; localName: string): bool
hasAttributes:
xmldom : hasAttributes(n: PNode): bool
hasChildNodes:
dom : hasChildNodes*(n: Node): bool
xmldom : hasChildNodes(n: PNode): bool
hasData:
osproc : hasData(p: Process): bool
hasDataBuffered:
net : hasDataBuffered(s: Socket): bool
hasFeature:
xmldom : hasFeature(dom: PDOMImplementation; feature: string; version: string = ""): bool
Hash:
hashes : Hash
hash:
hashes : hash(x: char): Hash
hashes : hash(x: float): Hash
hashes : hash(x: int): Hash
hashes : hash(x: int64): Hash
hashes : hash[A](x: openArray[A]): Hash
hashes : hash[A](aBuf: openArray[A]; sPos, ePos: int): Hash
hashes : hash(x: pointer): Hash
hashes : hash[A](x: set[A]): Hash
hashes : hash(x: string): Hash
hashes : hash(sBuf: string; sPos, ePos: int): Hash
hashes : hash[T: proc](x: T): Hash
hashes : hash[T: Ordinal](x: T): Hash
hashes : hash[T: tuple](x: T): Hash
json : hash(n: JsonNode): Hash
json : hash(n: OrderedTable[string, JsonNode]): Hash
rationals : hash[T](x: Rational[T]): Hash
selectors : hash(x: SocketHandle): Hash
hash set:
Module sets
hash table:
Module tables
hashData:
hashes : hashData(data: pointer; size: int): Hash
hashIgnoreCase:
hashes : hashIgnoreCase(x: string): Hash
hashes : hashIgnoreCase(sBuf: string; sPos, ePos: int): Hash
hashIgnoreStyle:
hashes : hashIgnoreStyle(x: string): Hash
hashes : hashIgnoreStyle(sBuf: string; sPos, ePos: int): Hash
HashSet:
sets : HashSet
hasKey:
critbits : hasKey[T](c: CritBitTree[T]; key: string): bool
httpcore : hasKey(headers: HttpHeaders; key: string): bool
json : hasKey(node: JsonNode; key: string): bool
strtabs : hasKey(t: StringTableRef; key: string): bool
tables : hasKey[A](t: CountTable[A]; key: A): bool
tables : hasKey[A](t: CountTableRef[A]; key: A): bool
tables : hasKey[A, B](t: OrderedTable[A, B]; key: A): bool
tables : hasKey[A, B](t: OrderedTableRef[A, B]; key: A): bool
tables : hasKey[A, B](t: Table[A, B]; key: A): bool
tables : hasKey[A, B](t: TableRef[A, B]; key: A): bool
hasKeyOrPut:
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
hasOverlappedIoCompleted:
winlean : hasOverlappedIoCompleted(lpOverlapped): bool
hasPendingOperations:
asyncdispatch : hasPendingOperations(): bool
HDC:
winlean : HDC
head:
htmlgen : head(e: varargs[untyped]): untyped
headerLimit:
httpcore : headerLimit
h_errno:
posix : h_errno
hexbyte:
oids : hexbyte(hex: char): int
HexDigits:
strutils : HexDigits
HGLRC:
winlean : HGLRC
hideCursor:
terminal : hideCursor(f: File)
terminal : hideCursor()
high:
system : high[T](x: T): T
HIGH_PRIORITY_CLASS:
winlean : HIGH_PRIORITY_CLASS
hint:
macros : hint(msg: string)
nimscript : hint(name: string; val: bool)
History:
dom : History
home:
dom : home*(w: Window)
hostCPU:
system : hostCPU
Hostent:
nativesockets : Hostent
posix : Hostent
winlean : Hostent
HOST_NOT_FOUND:
posix : HOST_NOT_FOUND
hostOS:
system : hostOS
hours:
times : hours(h: int): TimeInterval
hr:
htmlgen : hr(): untyped
hstrerror:
posix : hstrerror(herrnum: cint): cstring
html:
htmlgen : html(e: varargs[untyped]): untyped
HTML:
Module htmlgen
Module parsexml
HtmlTag:
htmlparser : HtmlTag
htmlTag:
htmlparser : htmlTag(s: string): HtmlTag
htmlparser : htmlTag(n: XmlNode): HtmlTag
htonl:
nativesockets : htonl(x: int32): expr
nativesockets : htonl(x: uint32): expr
posix : htonl(a1: int32): int32
htons:
nativesockets : htons(x: int16): expr
nativesockets : htons(x: uint16): expr
posix : htons(a1: int16): int16
Http100:
httpcore : Http100
Http101:
httpcore : Http101
Http200:
httpcore : Http200
Http201:
httpcore : Http201
Http202:
httpcore : Http202
Http203:
httpcore : Http203
Http204:
httpcore : Http204
Http205:
httpcore : Http205
Http206:
httpcore : Http206
Http300:
httpcore : Http300
Http301:
httpcore : Http301
Http302:
httpcore : Http302
Http303:
httpcore : Http303
Http304:
httpcore : Http304
Http305:
httpcore : Http305
Http307:
httpcore : Http307
Http400:
httpcore : Http400
Http401:
httpcore : Http401
Http403:
httpcore : Http403
Http404:
httpcore : Http404
Http405:
httpcore : Http405
Http406:
httpcore : Http406
Http407:
httpcore : Http407
Http408:
httpcore : Http408
Http409:
httpcore : Http409
Http410:
httpcore : Http410
Http411:
httpcore : Http411
Http412:
httpcore : Http412
Http413:
httpcore : Http413
Http414:
httpcore : Http414
Http415:
httpcore : Http415
Http416:
httpcore : Http416
Http417:
httpcore : Http417
Http418:
httpcore : Http418
Http421:
httpcore : Http421
Http422:
httpcore : Http422
Http426:
httpcore : Http426
Http428:
httpcore : Http428
Http429:
httpcore : Http429
Http431:
httpcore : Http431
Http451:
httpcore : Http451
Http500:
httpcore : Http500
Http501:
httpcore : Http501
Http502:
httpcore : Http502
Http503:
httpcore : Http503
Http504:
httpcore : Http504
Http505:
httpcore : Http505
HttpClient:
httpclient : HttpClient
HttpClientBase:
httpclient : HttpClientBase
HttpCode:
httpcore : HttpCode
HttpHeaders:
httpcore : HttpHeaders
HttpHeaderValues:
httpcore : HttpHeaderValues
HttpMethod:
httpcore : HttpMethod
HttpRequestError:
httpclient : HttpRequestError
HttpVersion:
httpcore : HttpVersion
hypot:
math : hypot(x, y: float32): float32
math : hypot(x, y: float64): float64
i:
htmlgen : i(e: varargs[untyped]): untyped
iconv:
Module encodings
Iconv:
posix : Iconv
iconv:
posix : iconv(a1: Iconv; a2: var cstring; a3: var int; a4: var cstring; a5: var int): int
iconv_close:
posix : iconv_close(a1: Iconv): cint
iconv_open:
posix : iconv_open(a1, a2: cstring): Iconv
Id:
posix : Id
ident:
macros : ident(n: NimNode): NimIdent
macros : ident(name: string): NimNode
pegs : ident(): expr
ident=:
macros : ident=(n: NimNode; val: NimIdent)
identChars:
pegs : identChars(): expr
IdentChars:
strutils : IdentChars
identStartChars:
pegs : identStartChars(): expr
IdentStartChars:
strutils : IdentStartChars
IDLE_PRIORITY_CLASS:
winlean : IDLE_PRIORITY_CLASS
IDMATRIX:
basic2d : IDMATRIX
basic3d : IDMATRIX
if_freenameindex:
posix : if_freenameindex(a1: ptr Tif_nameindex)
if_indextoname:
posix : if_indextoname(a1: cint; a2: cstring): cstring
if_nameindex:
posix : if_nameindex(): ptr Tif_nameindex
IF_NAMESIZE:
posix : IF_NAMESIZE
if_nametoindex:
posix : if_nametoindex(a1: cstring): cint
ignoreMsg:
parsecfg : ignoreMsg(c: CfgParser; e: CfgEvent): string
ImageElement:
dom : ImageElement
img:
htmlgen : img(e: varargs[untyped]): untyped
implementation:
xmldom : implementation(doc: PDocument): PDOMImplementation
importNode:
xmldom : importNode(doc: PDocument; importedNode: PNode; deep: bool): PNode
In6Addr:
posix : In6Addr
In6_addr:
winlean : In6_addr
in6addr_any:
posix : in6addr_any
IN6ADDR_ANY_INIT:
posix : IN6ADDR_ANY_INIT(): In6Addr
in6addr_loopback:
posix : in6addr_loopback
IN6ADDR_LOOPBACK_INIT:
posix : IN6ADDR_LOOPBACK_INIT(): In6Addr
IN6_IS_ADDR_LINKLOCAL:
posix : IN6_IS_ADDR_LINKLOCAL(a1: ptr In6Addr): cint
IN6_IS_ADDR_LOOPBACK:
posix : IN6_IS_ADDR_LOOPBACK(a1: ptr In6Addr): cint
IN6_IS_ADDR_MC_GLOBAL:
posix : IN6_IS_ADDR_MC_GLOBAL(a1: ptr In6Addr): cint
IN6_IS_ADDR_MC_LINKLOCAL:
posix : IN6_IS_ADDR_MC_LINKLOCAL(a1: ptr In6Addr): cint
IN6_IS_ADDR_MC_NODELOCAL:
posix : IN6_IS_ADDR_MC_NODELOCAL(a1: ptr In6Addr): cint
IN6_IS_ADDR_MC_ORGLOCAL:
posix : IN6_IS_ADDR_MC_ORGLOCAL(a1: ptr In6Addr): cint
IN6_IS_ADDR_MC_SITELOCAL:
posix : IN6_IS_ADDR_MC_SITELOCAL(a1: ptr In6Addr): cint
IN6_IS_ADDR_MULTICAST:
posix : IN6_IS_ADDR_MULTICAST(a1: ptr In6Addr): cint
IN6_IS_ADDR_SITELOCAL:
posix : IN6_IS_ADDR_SITELOCAL(a1: ptr In6Addr): cint
IN6_IS_ADDR_UNSPECIFIED:
posix : IN6_IS_ADDR_UNSPECIFIED(a1: ptr In6Addr): cint
IN6_IS_ADDR_V4COMPAT:
posix : IN6_IS_ADDR_V4COMPAT(a1: ptr In6Addr): cint
IN6_IS_ADDR_V4MAPPED:
posix : IN6_IS_ADDR_V4MAPPED(a1: ptr In6Addr): cint
InAddr:
posix : InAddr
winlean : InAddr
INADDR_ANY:
posix : INADDR_ANY
winlean : INADDR_ANY
INADDR_BROADCAST:
posix : INADDR_BROADCAST
winlean : INADDR_BROADCAST
INADDR_LOOPBACK:
posix : INADDR_LOOPBACK
winlean : INADDR_LOOPBACK
INADDR_NONE:
winlean : INADDR_NONE
InAddrScalar:
posix : InAddrScalar
InAddrT:
posix : InAddrT
inbox:
actors : inbox[In, Out](self: PActor[In, Out]): ptr Channel[In]
inc:
critbits : inc(c: var CritBitTree[int]; key: string)
system : inc[T: Ordinal | uint | uint64](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(c: var CritBitTree[void]; key: string)
intsets : incl(s: var IntSet; key: int)
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](s: var set[T]; flags: set[T])
inclFilePermissions:
os : inclFilePermissions(filename: string; permissions: set[FilePermission])
inclSetElement:
typeinfo : inclSetElement(x: Any; elem: int)
indent:
strutils : indent(s: string; count: Natural; padding: string = " "): string
indexBy:
tables : indexBy[A, B, C](collection: A; index: proc (x: B): C): Table[C, B]
IndexError:
system : IndexError
IndexExt:
rstgen : IndexExt
INET6_ADDRSTRLEN:
posix : INET6_ADDRSTRLEN
inet_addr:
posix : inet_addr(a1: cstring): InAddrT
winlean : inet_addr(cp: cstring): uint32
INET_ADDRSTRLEN:
posix : INET_ADDRSTRLEN
inet_ntoa:
posix : inet_ntoa(a1: InAddr): cstring
winlean : inet_ntoa(i: InAddr): cstring
inet_ntop:
posix : inet_ntop(a1: cint; a2: pointer; a3: cstring; a4: int32): cstring
winlean : inet_ntop(family: cint; paddr: pointer; pStringBuffer: cstring; stringBufSize: int32): cstring
inet_pton:
posix : inet_pton(a1: cint; a2: cstring; a3: pointer): cint
Inf:
system : Inf
INFINITE:
winlean : INFINITE
infix:
macros : infix(a: NimNode; op: string; b: NimNode): NimNode
info:
logging : info(args: varargs[string, `$`])
init:
securehash : init(result: var Sha1State)
sets : init[A](s: var HashSet[A]; initialSize = 64)
sets : init[A](s: var OrderedSet[A]; initialSize = 64)
initCond:
locks : initCond(cond: var Cond)
initCountTable:
tables : initCountTable[A](initialSize = 64): CountTable[A]
initDeque:
deques : initDeque[T](initialSize: int = 4): Deque[T]
initDoublyLinkedList:
lists : initDoublyLinkedList[T](): DoublyLinkedList[T]
initDoublyLinkedRing:
lists : initDoublyLinkedRing[T](): DoublyLinkedRing[T]
initEventEmitter:
events : initEventEmitter(): EventEmitter
initEventHandler:
events : initEventHandler(name: string): EventHandler
initGeneralTokenizer:
highlite : initGeneralTokenizer(g: var GeneralTokenizer; buf: cstring)
highlite : initGeneralTokenizer(g: var GeneralTokenizer; buf: string)
initInterval:
times : initInterval(milliseconds, seconds, minutes, hours, days, months, years: int = 0): TimeInterval
initIntSet:
intsets : initIntSet(): IntSet
initLock:
locks : initLock(lock: var Lock)
initOptParser:
parseopt : initOptParser(cmdline = ""): OptParser
parseopt2 : initOptParser(): OptParser
parseopt2 : initOptParser(cmdline: seq[string]): OptParser
parseopt2 : initOptParser(cmdline: string): OptParser
initOrderedSet:
sets : initOrderedSet[A](initialSize = 64): OrderedSet[A]
initOrderedTable:
tables : initOrderedTable[A, B](initialSize = 64): OrderedTable[A, B]
initQueue:
queues : initQueue[T](initialSize: int = 4): Queue[T]
initRational:
rationals : initRational[T: SomeInteger](num, den: T): Rational[T]
initRLock:
rlocks : initRLock(lock: var RLock)
initRstGenerator:
rstgen : initRstGenerator(g: var RstGenerator; target: OutputTarget; config: StringTableRef; filename: string; options: RstParseOptions; findFile: FindFileHandler = nil; msgHandler: MsgHandler = nil)
initSet:
sets : initSet[A](initialSize = 64): HashSet[A]
initSinglyLinkedList:
lists : initSinglyLinkedList[T](): SinglyLinkedList[T]
initSinglyLinkedRing:
lists : initSinglyLinkedRing[T](): SinglyLinkedRing[T]
initTable:
tables : initTable[A, B](initialSize = 64): Table[A, B]
initUri:
uri : initUri(): Uri
InlineTags:
htmlparser : InlineTags
innerText:
xmltree : innerText(n: XmlNode): string
Ino:
posix : Ino
InPort:
posix : InPort
input:
htmlgen : input(e: varargs[untyped]): untyped
inputHandle:
osproc : inputHandle(p: Process): FileHandle
inputStream:
osproc : inputStream(p: Process): Stream
ins:
htmlgen : ins(e: varargs[untyped]): untyped
insert:
macros : insert(a: NimNode; pos: int; b: NimNode)
sequtils : insert[T](dest: var seq[T]; src: openArray[T]; pos = 0)
system : insert[T](x: var seq[T]; item: T; i = 0.Natural)
system : insert(x: var string; item: string; i = 0.Natural)
xmltree : insert(father, son: XmlNode; index: int)
insertBefore:
dom : insertBefore*(n, newNode, before: Node)
xmldom : insertBefore(n: PNode; newChild: PNode; refChild: PNode): PNode
insertData:
dom : insertData*(n: Node; position: int; data: cstring)
insertId:
db_mysql : insertId(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
insertID:
db_postgres : insertID(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
db_sqlite : insertID(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
insertSep:
strutils : insertSep(s: string; sep = '_'; digits = 3): string
installDirs:
nimscript : installDirs
installExt:
nimscript : installExt
installFiles:
nimscript : installFiles
instantiationInfo:
system : instantiationInfo(index = - 1; fullPaths = false): tuple[filename: string, line: int]
InstantRow:
db_mysql : 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_postgres : instantRows(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): InstantRow
db_postgres : instantRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): InstantRow
db_sqlite : instantRows(db: DbConn; columns: var DbColumns; query: SqlQuery; args: varargs[string, `$`]): InstantRow
db_sqlite : instantRows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): InstantRow
int:
system : int
int16:
system : int16
int32:
system : int32
int64:
system : int64
int8:
system : int8
intensity:
colors : intensity(a: Color; f: float): Color
intercept:
stats : intercept(r: RunningRegress): float
internalErrorFlag:
macros : internalErrorFlag(): string
internalNew:
system : internalNew[T](a: var ref T)
internationalization:
Substitution Expressions (subex)
interpolatedFragments:
parseutils : interpolatedFragments(s: string): tuple[kind: InterpolatedKind, value: string]
InterpolatedKind:
parseutils : InterpolatedKind
intersection:
sets : intersection[A](s1, s2: HashSet[A]): HashSet[A]
INT_MAX:
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)
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:
posix : INVALID_SOCKET
winlean : INVALID_SOCKET
InvalidUnicodeError:
nre : InvalidUnicodeError
inverse:
basic2d : inverse(m: Matrix2d): Matrix2d
basic3d : inverse(m: Matrix3d): Matrix3d
invokeNew:
typeinfo : invokeNew(x: Any)
invokeNewSeq:
typeinfo : invokeNewSeq(x: Any; len: int)
IOC_IN:
nativesockets : IOC_IN
winlean : IOC_IN
IOC_INOUT:
winlean : IOC_INOUT
IOC_OUT:
winlean : IOC_OUT
IOCPARM_MASK:
nativesockets : IOCPARM_MASK
ioctl:
posix : ioctl(f: FileHandle; device: uint): int
ioctlsocket:
nativesockets : ioctlsocket(s: SocketHandle; cmd: clong; argptr: ptr clong): cint
IOC_WS2:
winlean : IOC_WS2
IOEffect:
system : IOEffect
IOError:
system : IOError
IOVec:
posix : IOVec
IpAddress:
net : IpAddress
IpAddressFamily:
net : IpAddressFamily
IPC_CREAT:
posix : IPC_CREAT
IPC_EXCL:
posix : IPC_EXCL
IPC_NOWAIT:
posix : IPC_NOWAIT
Ipc_perm:
posix : Ipc_perm
IPC_PRIVATE:
posix : IPC_PRIVATE
IPC_RMID:
posix : IPC_RMID
IPC_SET:
posix : IPC_SET
IPC_STAT:
posix : IPC_STAT
IPPORT_RESERVED:
posix : IPPORT_RESERVED
IPPROTO_ICMP:
posix : IPPROTO_ICMP
IPPROTO_IP:
posix : IPPROTO_IP
IPPROTO_IPV6:
posix : IPPROTO_IPV6
IPPROTO_RAW:
posix : IPPROTO_RAW
IPPROTO_TCP:
posix : IPPROTO_TCP
IPPROTO_UDP:
posix : 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_JOIN_GROUP:
posix : IPV6_JOIN_GROUP
IPV6_LEAVE_GROUP:
posix : IPV6_LEAVE_GROUP
IPv6_loopback:
net : IPv6_loopback(): IpAddress
IPV6_MULTICAST_HOPS:
posix : IPV6_MULTICAST_HOPS
IPV6_MULTICAST_IF:
posix : IPV6_MULTICAST_IF
IPV6_MULTICAST_LOOP:
posix : IPV6_MULTICAST_LOOP
IPV6_UNICAST_HOPS:
posix : IPV6_UNICAST_HOPS
IPV6_V6ONLY:
posix : IPV6_V6ONLY
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
ospaths : isAbsolute(path: string): bool
isAlpha:
strutils : isAlpha(c: char): bool
strutils : isAlpha(s: string): bool
unicode : isAlpha(c: Rune): bool
unicode : isAlpha(s: string): bool
isAlphaAscii:
strutils : isAlphaAscii(c: char): bool
strutils : isAlphaAscii(s: string): bool
isAlphaNumeric:
strutils : isAlphaNumeric(c: char): bool
strutils : isAlphaNumeric(s: string): bool
isatty:
posix : isatty(a1: cint): cint
terminal : isatty(f: File): bool
isClosed:
asyncio : isClosed(s: AsyncSocket): bool
asyncnet : isClosed(socket: AsyncSocket): bool
isColor:
colors : isColor(name: string): bool
isCombining:
unicode : isCombining(c: Rune): bool
isConnected:
asyncio : isConnected(s: AsyncSocket): bool
isConnecting:
asyncio : isConnecting(s: AsyncSocket): bool
isDigit:
strutils : isDigit(c: char): bool
strutils : isDigit(s: string): bool
isDisconnectionError:
net : isDisconnectionError(flags: set[SocketFlag]; lastError: OSErrorCode): bool
isFinite:
dom : isFinite*(x: BiggestFloat): bool
isHidden:
os : isHidden(path: string): bool
isIdentity:
basic2d : isIdentity(m: Matrix2d; tol = 1e-06'f64): bool
isIpAddress:
net : isIpAddress(address_str: string): bool
isLeapYear:
times : isLeapYear(year: int): bool
isListening:
asyncio : isListening(s: AsyncSocket): bool
isLower:
strutils : isLower(c: char): bool
strutils : isLower(s: string): bool
unicode : isLower(c: Rune): bool
unicode : isLower(s: string): bool
isLowerAscii:
strutils : isLowerAscii(c: char): bool
strutils : isLowerAscii(s: string): bool
isMainModule:
system : isMainModule
isMirroring:
basic2d : isMirroring(m: Matrix2d): bool
isNaN:
dom : isNaN*(x: BiggestFloat): bool
isNil:
intsets : isNil(x: IntSet): bool
system : isNil(x: cstring): bool
system : isNil(x: pointer): bool
system : isNil[T](x: ptr T): bool
system : isNil[T](x: ref T): bool
system : isNil[T](x: seq[T]): bool
system : isNil(x: string): bool
system : isNil[T: proc](x: T): bool
typeinfo : isNil(x: Any): bool
isNilOrEmpty:
strutils : isNilOrEmpty(s: string): bool
isNilOrWhitespace:
strutils : isNilOrWhitespace(s: string): bool
isNone:
options : isNone[T](self: Option[T]): bool
isNotForeign:
system : isNotForeign(x: ForeignCell): bool
isPowerOfTwo:
math : isPowerOfTwo(x: int): bool
isReady:
threadpool : isReady(fv: FlowVarBase): bool
isRootDir:
os : isRootDir(path: string): bool
ospaths : isRootDir(path: string): bool
isSendDataBuffered:
asyncio : isSendDataBuffered(s: AsyncSocket): bool
isSome:
options : isSome[T](self: Option[T]): bool
isSorted:
algorithm : isSorted[T](a: openArray[T]; cmp: proc (x, y: T): int; order = SortOrder.Ascending): bool
isSpace:
strutils : isSpace(c: char): bool
strutils : isSpace(s: string): bool
unicode : isSpace(s: string): bool
isSpaceAscii:
strutils : isSpaceAscii(c: char): bool
strutils : isSpaceAscii(s: string): bool
isSsl:
asyncnet : isSsl(socket: AsyncSocket): bool
net : isSsl(socket: Socket): bool
isSupported:
xmldom : isSupported(n: PNode; feature: string; version: string): bool
isTitle:
unicode : isTitle(c: Rune): bool
unicode : isTitle(s: string): bool
isUniform:
basic2d : isUniform(t: Matrix2d; tol = 1e-06'f64): bool
basic3d : isUniform(m: Matrix3d; tol = 1e-06'f64): bool
isUpper:
strutils : isUpper(c: char): bool
strutils : isUpper(s: string): bool
unicode : isUpper(c: Rune): bool
unicode : isUpper(s: string): bool
isUpperAscii:
strutils : isUpperAscii(c: char): bool
strutils : isUpperAscii(s: string): bool
isValid:
sets : isValid[A](s: HashSet[A]): bool
sets : isValid[A](s: OrderedSet[A]): bool
isWhiteSpace:
unicode : isWhiteSpace(c: Rune): bool
isWriteable:
asyncio : isWriteable(s: AsyncSocket): bool
item:
xmldom : item(nList: seq[PNode]; index: int): PNode
items:
critbits : items[T](c: CritBitTree[T]): string
deques : items[T](deq: Deque[T]): T
intsets : items(s: IntSet): int
json : items(node: JsonNode): JsonNode
lists : items[T](L: DoublyLinkedList[T]): T
lists : items[T](L: DoublyLinkedRing[T]): T
lists : items[T](L: SinglyLinkedList[T]): T
lists : items[T](L: SinglyLinkedRing[T]): T
macros : items(n: NimNode): NimNode
nre : items(pattern: CaptureBounds; default = none(Slice[int])): Option[Slice[int]]
nre : items(pattern: Captures; default: string = nil): string
queues : items[T](q: Queue[T]): T
ropes : items(r: Rope): char
sets : items[A](s: HashSet[A]): A
sets : items[A](s: OrderedSet[A]): A
system : items[IX, T](a: array[IX, T]): T
system : items(a: cstring): char
system : items[T](a: openArray[T]): T
system : items[T](a: seq[T]): T
system : items[T](a: set[T]): T
system : items[T](s: Slice[T]): T
system : items(a: string): char
system : items[](E: typedesc[enum]): E:type
xmltree : items(n: XmlNode): XmlNode
itemsWithPrefix:
critbits : itemsWithPrefix[T](c: CritBitTree[T]; prefix: string; longestMatch = false): string
iterToProc:
system : iterToProc[](iter: typed; envType: typedesc; procName: untyped)
Itimerspec:
posix : Itimerspec
javaEnabled:
dom : javaEnabled*(h: Navigator): bool
join:
actors : join[In, Out](a: var ActorPool[In, Out])
actors : join[In, Out](a: PActor[In, Out])
strutils : join(a: openArray[string]; sep: string = ""): string
strutils : join[T: not string](a: openArray[T]; sep: string = ""): string
joinPath:
os : joinPath(head, tail: string): string
os : joinPath(parts: varargs[string]): string
ospaths : joinPath(head, tail: string): string
ospaths : joinPath(parts: varargs[string]): string
joinThread:
threads : joinThread*[TArg](t: Thread[TArg])
joinThreads:
threads : joinThreads*[TArg](t: varargs[Thread[TArg]])
JSON:
Module json
Module marshal
JsonError:
json : JsonError
JsonEventKind:
json : JsonEventKind
JsonNode:
json : JsonNode
JsonNodeKind:
json : JsonNodeKind
JsonNodeObj:
json : JsonNodeObj
JsonParser:
json : JsonParser
JsonParsingError:
json : JsonParsingError
kbd:
htmlgen : kbd(e: varargs[untyped]): untyped
keepIf:
sequtils : keepIf[T](seq1: var seq[T]; pred: proc (item: T): bool)
keepItIf:
sequtils : keepItIf[seq](varSeq: seq; pred: untyped)
Key:
posix : Key
KeyError:
system : KeyError
KEY_EVENT_RECORD:
winlean : KEY_EVENT_RECORD
keys:
critbits : keys[T](c: CritBitTree[T]): string
strtabs : keys(t: StringTableRef): string
tables : keys[A](t: CountTable[A]): A
tables : keys[A](t: CountTableRef[A]): A
tables : keys[A, B](t: OrderedTable[A, B]): A
tables : keys[A, B](t: OrderedTableRef[A, B]): A
tables : keys[A, B](t: Table[A, B]): A
tables : keys[A, B](t: TableRef[A, B]): A
keysWithPrefix:
critbits : keysWithPrefix[T](c: CritBitTree[T]; prefix: string; longestMatch = false): string
kill:
osproc : kill(p: Process)
posix : kill(a1: Pid; a2: cint): cint
killpg:
posix : killpg(a1: Pid; a2: cint): cint
kind:
json : kind(my: JsonParser): JsonEventKind
macros : kind(n: NimNode): NimNodeKind
parsexml : kind(my: XmlParser): XmlEventKind
typeinfo : kind(x: Any): AnyKind
xmltree : kind(n: XmlNode): XmlNodeKind
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
largest:
tables : largest[A](t: CountTable[A]): tuple[key: A, val: int]
tables : largest[A](t: CountTableRef[A]): (A, int)
last:
macros : last(node: NimNode): NimNode
lastChild:
xmldom : lastChild(n: PNode): PNode
lastRune:
unicode : lastRune(s: string; last: int): (Rune, int)
lastSon:
rstast : lastSon(n: PRstNode): PRstNode
lc:
future : lc
LC_ALL:
posix : LC_ALL
LC_COLLATE:
posix : LC_COLLATE
LC_CTYPE:
posix : LC_CTYPE
lchown:
posix : lchown(a1: cstring; a2: Uid; a3: Gid): cint
lcm:
math : lcm[T](x, y: T): T
LC_MESSAGES:
posix : LC_MESSAGES
LC_MONETARY:
posix : LC_MONETARY
LC_NUMERIC:
posix : LC_NUMERIC
Lconv:
posix : Lconv
LC_TIME:
posix : LC_TIME
leaves:
ropes : leaves(r: Rope): string
legend:
htmlgen : legend(e: varargs[untyped]): untyped
len:
asyncio : len(disp: Dispatcher): int
basic2d : len(v: Vector2d): float
basic3d : len(v: Vector3d): float
critbits : len[T](c: CritBitTree[T]): int
db_mysql : len(row: InstantRow): int
db_postgres : len(row: InstantRow): int32
db_sqlite : len(row: InstantRow): int32
deques : len[T](deq: Deque[T]): int
httpcore : len(headers: HttpHeaders): int
json : len(n: JsonNode): int
macros : len(n: NimNode): int
parsesql : len(n: SqlNode): int
queues : len[T](q: Queue[T]): int
ropes : len(a: Rope): int
rstast : len(n: PRstNode): int
selectors : len(s: Selector): int
sets : len[A](s: HashSet[A]): int
sets : len[A](s: OrderedSet[A]): int
strtabs : len(t: StringTableRef): int
system : len[I, T](x: array[I, T]): int
system : len(x: cstring): int
system : len[T](x: seq[T]): int
system : len(x: string): int
system : len[TOpenArray: openArray | varargs](x: TOpenArray): int
system : len(w: WideCString): int
tables : len[A](t: CountTable[A]): int
tables : len[A](t: CountTableRef[A]): int
tables : len[A, B](t: OrderedTable[A, B]): int
tables : len[A, B](t: OrderedTableRef[A, B]): int
tables : len[A, B](t: Table[A, B]): int
tables : len[A, B](t: TableRef[A, B]): int
typeinfo : len(x: Any): int
xmltree : len(n: XmlNode): int
len=:
basic2d : len=(v: var Vector2d; newlen: float)
basic3d : len=(v: var Vector3d; newlen: float)
letters:
pegs : letters(): expr
Letters:
strutils : Letters
Level:
logging : Level
LevelNames:
logging : LevelNames
Levenshtein:
Module strutils
lgamma:
math : lgamma(x: float32): float32
math : lgamma(x: float64): float64
li:
htmlgen : li(e: varargs[untyped]): untyped
libCandidates:
dynlib : libCandidates(s: string; dest: var seq[string])
LibHandle:
dynlib : LibHandle
system : LibHandle
LibraryError:
system : LibraryError
license:
nimscript : license
likely:
system : likely(val: bool): bool
limit:
Module system
lineinfo:
macros : lineinfo(n: NimNode): string
lines:
memfiles : lines(mfile: MemFile; delim = '\x0A'; eat = '\x0D'): TaintedString
memfiles : lines(mfile: MemFile; buf: var TaintedString; delim = '\x0A'; eat = '\x0D'): TaintedString
system : lines(f: File): TaintedString
system : lines(filename: string): TaintedString
link:
htmlgen : link(e: varargs[untyped]): untyped
posix : link(a1, a2: cstring): cint
LinkElement:
dom : LinkElement
lio_listio:
posix : lio_listio(a1: cint; a2: ptr ptr Taiocb; a3: cint; a4: ptr SigEvent): cint
LIO_NOP:
posix : LIO_NOP
LIO_NOWAIT:
posix : LIO_NOWAIT
LIO_READ:
posix : LIO_READ
LIO_WAIT:
posix : LIO_WAIT
LIO_WRITE:
posix : LIO_WRITE
lispRepr:
macros : lispRepr(n: NimNode): string
list:
asyncftpclient : list(ftp: AsyncFtpClient; dir = ""): Future[string]
ftpclient : list[T](ftp: FtpBase[T]; dir: string = ""; async = false): string
listDirs:
asyncftpclient : listDirs(ftp: AsyncFtpClient; dir = ""): Future[seq[string]]
ftpclient : listDirs[T](ftp: FtpBase[T]; dir: string = ""; async = false): seq[string]
nimscript : listDirs(dir: string): seq[string]
listen:
asyncio : listen(sock: AsyncSocket)
asyncnet : listen(socket: AsyncSocket; backlog = SOMAXCONN)
nativesockets : listen(socket: SocketHandle; backlog = SOMAXCONN): cint
net : listen(socket: Socket; backlog = SOMAXCONN)
posix : listen(a1: SocketHandle; a2: cint): cint
winlean : listen(s: SocketHandle; backlog: cint): cint
listFiles:
nimscript : listFiles(dir: string): seq[string]
littleEndian16:
endians : littleEndian16(outp, inp: pointer)
littleEndian32:
endians : littleEndian32(outp, inp: pointer)
littleEndian64:
endians : littleEndian64(outp, inp: pointer)
ln:
complex : ln(z: Complex): Complex
math : ln(x: float32): float32
math : ln(x: float64): float64
load:
marshal : load[T](s: Stream; data: var T)
loadConfig:
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; global_symbols = false): LibHandle
loadLibPattern:
dynlib : loadLibPattern(pattern: string; global_symbols = false): LibHandle
loadUnidecodeTable:
unidecode : loadUnidecodeTable(datafile = "unidecode.dat")
loadXML:
xmldomparser : loadXML(xml: string): PDocument
loadXml:
xmlparser : loadXml(path: string): XmlNode
xmlparser : loadXml(path: string; errors: var seq[string]): XmlNode
loadXMLFile:
xmldomparser : loadXMLFile(path: string): PDocument
loadXMLStream:
xmldomparser : loadXMLStream(stream: Stream): PDocument
localeconv:
posix : localeconv(): ptr Lconv
localFree:
winlean : localFree(p: pointer)
localName:
xmldom : localName(n: PNode): string
localRaiseHook:
system : localRaiseHook
locals:
system : locals(): RootObj
localtime:
posix : localtime(a1: var Time): ptr Tm
localtime_r:
posix : localtime_r(a1: var Time; a2: var Tm): ptr Tm
Location:
dom : Location
Lock:
locks : Lock
lockf:
posix : lockf(a1, a2: cint; a3: Off): cint
log:
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, `$`])
log10:
complex : log10(z: Complex): Complex
math : log10(x: float32): float32
math : log10(x: float64): float64
log2:
complex : log2(z: Complex): Complex
math : log2[T: float32 | float64](x: T): T
Logger:
logging : Logger
LONG:
winlean : LONG
low:
system : low[T](x: T): T
lowerBound:
algorithm : lowerBound[T](a: openArray[T]; key: T): int
algorithm : lowerBound[T](a: openArray[T]; key: T; cmp: proc (x, y: T): int): int
LPINT:
winlean : LPINT
lseek:
posix : lseek(a1: cint; a2: Off; a3: cint): Off
lstat:
posix : lstat(a1: cstring; a2: var Stat): cint
makecontext:
posix : makecontext(a1: var Ucontext; a4: proc (); a3: cint)
mantissaDigits:
fenv : mantissaDigits[](T: typedesc[float32]): int
fenv : mantissaDigits[](T: typedesc[float64]): int
map:
htmlgen : map(e: varargs[untyped]): untyped
options : map[T](self: Option[T]; callback: proc (input: T))
options : map[T, R](self: Option[T]; callback: proc (input: T): R): Option[R]
sequtils : map[T, S](data: openArray[T]; op: proc (x: T): S): seq[S]
sequtils : map[T](data: var openArray[T]; op: proc (x: var T))
sets : map[A, B](data: HashSet[A]; op: proc (x: A): B): HashSet[B]
MAP_FAILED:
posix : MAP_FAILED
MAP_FIXED:
posix : MAP_FIXED
mapIt:
sequtils : mapIt(seq1, op: untyped): untyped
sequtils : mapIt(seq1, typ, op: untyped): untyped
mapMem:
memfiles : mapMem(m: var MemFile; mode: FileMode = fmRead; mappedSize = - 1; offset = 0): pointer
MAP_POPULATE:
posix : MAP_POPULATE
MAP_PRIVATE:
posix : MAP_PRIVATE
MAP_SHARED:
posix : MAP_SHARED
mapViewOfFileEx:
winlean : mapViewOfFileEx(hFileMappingObject: Handle; dwDesiredAccess: DWORD; dwFileOffsetHigh, dwFileOffsetLow: DWORD; dwNumberOfBytesToMap: DWORD; lpBaseAddress: pointer): pointer
markdown:
Module rst
match:
nre : match(pattern: RegexMatch): string
nre : match(str: string; pattern: Regex; start = 0; endpos = int.high): Option[RegexMatch]
pegs : match(s: string; pattern: Peg; start = 0): bool
pegs : match(s: string; pattern: Peg; matches: var openArray[string]; start = 0): bool
re : match(s: string; pattern: Regex; start = 0): bool
re : match(s: string; pattern: Regex; matches: var openArray[string]; start = 0): bool
matchBounds:
nre : matchBounds(pattern: RegexMatch): Slice[int]
matchLen:
pegs : matchLen(s: string; pattern: Peg; start = 0): int
pegs : matchLen(s: string; pattern: Peg; matches: var openArray[string]; start = 0): int
re : matchLen(s: string; pattern: Regex; start = 0): int
re : matchLen(s: string; pattern: Regex; matches: var openArray[string]; start = 0): int
Matrix2d:
basic2d : Matrix2d
matrix2d:
basic2d : matrix2d(ax, ay, bx, by, tx, ty: float): Matrix2d
Matrix3d:
basic3d : Matrix3d
matrix3d:
basic3d : matrix3d(ax, ay, az, aw, bx, by, bz, bw, cx, cy, cz, cw, tx, ty, tz, tw: float): Matrix3d
max:
system : max(x, y: float): float
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: varargs[T]): T
max10Exponent:
fenv : max10Exponent[](T: typedesc[float32]): int
fenv : max10Exponent[](T: typedesc[float64]): int
MaxDistinguishedThread:
threadpool : MaxDistinguishedThread
maxExponent:
fenv : maxExponent[](T: typedesc[float32]): int
fenv : maxExponent[](T: typedesc[float64]): int
MaxFloat32Precision:
math : MaxFloat32Precision
MaxFloat64Precision:
math : MaxFloat64Precision
MaxFloatPrecision:
math : MaxFloatPrecision
maximumPositiveValue:
fenv : maximumPositiveValue[](T: typedesc[float32]): float32
fenv : maximumPositiveValue[](T: typedesc[float64]): float64
MAXIMUM_WAIT_OBJECTS:
winlean : MAXIMUM_WAIT_OBJECTS
MAX_INT:
Module system
MaxLineLength:
net : MaxLineLength
MAX_PATH:
winlean : MAX_PATH
MaxSubpatterns:
pegs : MaxSubpatterns
re : MaxSubpatterns
MaxThreadPoolSize:
threadpool : MaxThreadPoolSize
MCL_CURRENT:
posix : MCL_CURRENT
MCL_FUTURE:
posix : MCL_FUTURE
Mcontext:
posix : Mcontext
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)
mean:
stats : mean[T](x: openArray[T]): float
stats : mean(s: RunningStat): float
MemFile:
memfiles : MemFile
memory mapped files:
Module memfiles
MemSlice:
memfiles : MemSlice
memSlices:
memfiles : memSlices(mfile: MemFile; delim = '\x0A'; eat = '\x0D'): MemSlice
merge:
tables : merge[A](s: var CountTable[A]; t: CountTable[A])
tables : merge[A](s, t: CountTable[A]): CountTable[A]
tables : merge[A](s, t: CountTableRef[A])
mergeIndexes:
rstgen : mergeIndexes(dir: string): string
MersenneTwister:
mersenne : MersenneTwister
Message:
smtp : Message
meta:
htmlgen : meta(e: varargs[untyped]): untyped
MetaEnum:
rstgen : MetaEnum
method:
Module system
mget:
asyncdispatch : mget[T](future: FutureVar[T]): var T
critbits : mget[T](c: var CritBitTree[T]; key: string): var T
sets : mget[A](s: var HashSet[A]; key: A): var A
strtabs : mget(t: StringTableRef; key: string): var string
tables : mget[A](t: var CountTable[A]; key: A): var int
tables : mget[A](t: CountTableRef[A]; key: A): var int
tables : mget[A, B](t: var OrderedTable[A, B]; key: A): var B
tables : mget[A, B](t: OrderedTableRef[A, B]; key: A): var B
tables : mget[A, B](t: var Table[A, B]; key: A): var B
tables : mget[A, B](t: TableRef[A, B]; key: A): var B
xmltree : mget(n: var XmlNode; i: int): var XmlNode
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
miliseconds:
times : miliseconds(t: TimeInterval): int
miliseconds=:
times : miliseconds=(t: var TimeInterval; milliseconds: int)
milliseconds:
times : milliseconds(ms: int): TimeInterval
MimeDB:
mimetypes : MimeDB
mimes:
mimetypes : mimes
min:
system : min(x, y: float): float
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: varargs[T]): T
min10Exponent:
fenv : min10Exponent[](T: typedesc[float32]): int
fenv : min10Exponent[](T: typedesc[float64]): int
minExponent:
fenv : minExponent[](T: typedesc[float32]): int
fenv : minExponent[](T: typedesc[float64]): int
minimumPositiveValue:
fenv : minimumPositiveValue[](T: typedesc[float32]): float32
fenv : minimumPositiveValue[](T: typedesc[float64]): float64
MINSIGSTKSZ:
posix : MINSIGSTKSZ
minutes:
times : minutes(m: int): TimeInterval
mirror:
basic2d : mirror(org: Point2d; v: Vector2d): Matrix2d
basic2d : mirror(v: Vector2d): Matrix2d
basic2d : mirror(v: var Vector2d; mirrvec: Vector2d)
basic3d : mirror(org: Point3d; planeperp: Vector3d): Matrix3d
basic3d : mirror(planeperp: Vector3d): Matrix3d
basic3d : mirror(v: var Vector3d; planeperp: Vector3d)
mitems:
deques : mitems[T](deq: var Deque[T]): var T
json : mitems(node: var JsonNode): var JsonNode
lists : mitems[T](L: var DoublyLinkedList[T]): var T
lists : mitems[T](L: var DoublyLinkedRing[T]): var T
lists : mitems[T](L: var SinglyLinkedList[T]): var T
lists : mitems[T](L: var SinglyLinkedRing[T]): var T
queues : mitems[T](q: var Queue[T]): var T
system : mitems[IX, T](a: var array[IX, T]): var T
system : mitems(a: var cstring): var char
system : mitems[T](a: var openArray[T]): var T
system : mitems[T](a: var seq[T]): var T
system : mitems(a: var string): var char
xmltree : mitems(n: var XmlNode): var XmlNode
mix:
colors : mix(a, b: Color; fn: expr): expr
mkDir:
nimscript : mkDir(dir: string)
mkdir:
posix : mkdir(a1: cstring; a2: Mode): cint
mkfifo:
posix : mkfifo(a1: cstring; a2: Mode): cint
mknod:
posix : mknod(a1: cstring; a2: Mode; a3: Dev): cint
mkstemp:
posix : mkstemp(tmpl: cstring): cint
mktime:
posix : mktime(a1: var Tm): Time
mlock:
posix : mlock(a1: pointer; a2: int): cint
mlockall:
posix : mlockall(a1: cint): cint
mmap:
Module memfiles
posix : mmap(a1: pointer; a2: int; a3, a4, a5: cint; a6: Off): pointer
MM_APPL:
posix : MM_APPL
MM_CONSOLE:
posix : MM_CONSOLE
MM_ERROR:
posix : MM_ERROR
MM_FIRM:
posix : MM_FIRM
MM_HALT:
posix : MM_HALT
MM_HARD:
posix : MM_HARD
MM_INFO:
posix : MM_INFO
MM_NOCON:
posix : MM_NOCON
MM_NOMSG:
posix : MM_NOMSG
MM_NOSEV:
posix : MM_NOSEV
MM_NOTOK:
posix : MM_NOTOK
MM_NRECOV:
posix : MM_NRECOV
MM_NULLACT:
posix : MM_NULLACT
MM_NULLLBL:
posix : MM_NULLLBL
MM_NULLMC:
posix : MM_NULLMC
MM_NULLSEV:
posix : MM_NULLSEV
MM_NULLTAG:
posix : MM_NULLTAG
MM_NULLTXT:
posix : MM_NULLTXT
MM_OK:
posix : MM_OK
MM_OPSYS:
posix : MM_OPSYS
MM_PRINT:
posix : MM_PRINT
MM_RECOVER:
posix : MM_RECOVER
MM_SOFT:
posix : MM_SOFT
MM_UTIL:
posix : MM_UTIL
MM_WARNING:
posix : MM_WARNING
mode:
nimscript : mode
Mode:
posix : Mode
system : Mode
MON_1:
posix : MON_1
MON_10:
posix : MON_10
MON_11:
posix : MON_11
MON_12:
posix : MON_12
MON_2:
posix : MON_2
MON_3:
posix : MON_3
MON_4:
posix : MON_4
MON_5:
posix : MON_5
MON_6:
posix : MON_6
MON_7:
posix : MON_7
MON_8:
posix : MON_8
MON_9:
posix : MON_9
MonitorEvent:
fsmonitor : MonitorEvent
MonitorEventType:
fsmonitor : MonitorEventType
Month:
times : Month
months:
times : months(m: int): TimeInterval
move:
basic2d : move(dx, dy: float): Matrix2d
basic2d : move(p: var Point2d; dx, dy: float)
basic2d : move(p: var Point2d; v: Vector2d)
basic2d : move(v: Vector2d): Matrix2d
basic3d : move(dx, dy, dz: float): Matrix3d
basic3d : move(p: var Point3d; dx, dy, dz: float)
basic3d : move(p: var Point3d; v: Vector3d)
basic3d : move(v: Vector3d): Matrix3d
moveBy:
dom : moveBy*(w: Window; x, y: int)
moveFile:
os : moveFile(source, dest: string)
moveFileW:
winlean : moveFileW(lpExistingFileName, lpNewFileName: WideCString): WINBOOL
moveMem:
system : moveMem(dest, source: pointer; size: Natural)
moveTo:
dom : moveTo*(w: Window; x, y: int)
mpairs:
critbits : mpairs[T](c: var CritBitTree[T]): tuple[key: string, val: var T]
json : mpairs(node: var JsonNode): tuple[key: string, val: var JsonNode]
system : mpairs[IX, T](a: var array[IX, T]): tuple[key: IX, val: var T]
system : mpairs(a: var cstring): tuple[key: int, val: var char]
system : mpairs[T](a: var openArray[T]): tuple[key: int, val: var T]
system : mpairs[T](a: var seq[T]): tuple[key: int, val: var T]
system : mpairs(a: var string): tuple[key: int, val: var char]
tables : mpairs[A](t: var CountTable[A]): (A, var int)
tables : mpairs[A](t: CountTableRef[A]): (A, var int)
tables : mpairs[A, B](t: var OrderedTable[A, B]): (A, var B)
tables : mpairs[A, B](t: OrderedTableRef[A, B]): (A, var B)
tables : mpairs[A, B](t: var Table[A, B]): (A, var B)
tables : mpairs[A, B](t: TableRef[A, B]): (A, var B)
mpairsWithPrefix:
critbits : mpairsWithPrefix[T](c: var CritBitTree[T]; prefix: string; longestMatch = false): tuple[ key: string, val: var T]
mprotect:
posix : mprotect(a1: pointer; a2: int; a3: cint): cint
MqAttr:
posix : MqAttr
mq_close:
posix : mq_close(a1: Mqd): cint
Mqd:
posix : Mqd
mq_getattr:
posix : mq_getattr(a1: Mqd; a2: ptr MqAttr): cint
mq_notify:
posix : mq_notify(a1: Mqd; a2: ptr SigEvent): cint
mq_open:
posix : mq_open(a1: cstring; a2: cint): Mqd
mq_receive:
posix : mq_receive(a1: Mqd; a2: cstring; a3: int; a4: var int): int
mq_send:
posix : mq_send(a1: Mqd; a2: cstring; a3: int; a4: int): cint
mq_setattr:
posix : mq_setattr(a1: Mqd; a2, a3: ptr MqAttr): cint
mq_timedreceive:
posix : mq_timedreceive(a1: Mqd; a2: cstring; a3: int; a4: int; a5: ptr Timespec): int
mq_timedsend:
posix : mq_timedsend(a1: Mqd; a2: cstring; a3: int; a4: int; a5: ptr Timespec): cint
mq_unlink:
posix : mq_unlink(a1: cstring): cint
MS_ASYNC:
posix : MS_ASYNC
MsgClass:
rst : MsgClass
MSG_CTRUNC:
posix : MSG_CTRUNC
MSG_DONTROUTE:
posix : MSG_DONTROUTE
MSG_EOR:
posix : MSG_EOR
MsgHandler:
rst : MsgHandler
MsgKind:
rst : MsgKind
MSG_NOSIGNAL:
posix : MSG_NOSIGNAL
MSG_OOB:
posix : MSG_OOB
MSG_PEEK:
posix : MSG_PEEK
winlean : MSG_PEEK
MSG_TRUNC:
posix : MSG_TRUNC
MSG_WAITALL:
posix : MSG_WAITALL
MS_INVALIDATE:
posix : MS_INVALIDATE
MS_SYNC:
posix : MS_SYNC
msync:
posix : msync(a1: pointer; a2: int; a3: cint): cint
MultipartData:
httpclient : MultipartData
MultipartEntries:
httpclient : MultipartEntries
multisync:
asyncdispatch : multisync(prc: untyped): untyped
munlock:
posix : munlock(a1: pointer; a2: int): cint
munlockall:
posix : munlockall(): cint
munmap:
posix : munmap(a1: pointer; a2: int): cint
mvalues:
critbits : mvalues[T](c: var CritBitTree[T]): var T
tables : mvalues[A](t: CountTable[A]): var int
tables : mvalues[A](t: CountTableRef[A]): var int
tables : mvalues[A, B](t: var OrderedTable[A, B]): var B
tables : mvalues[A, B](t: OrderedTableRef[A, B]): var B
tables : mvalues[A, B](t: var Table[A, B]): var B
tables : mvalues[A, B](t: TableRef[A, B]): var B
mvaluesWithPrefix:
critbits : mvaluesWithPrefix[T](c: var CritBitTree[T]; prefix: string; longestMatch = false): var T
mvFile:
nimscript : mvFile(`from`, to: string)
mySQL:
Module db_mysql
name:
macros : name(someProc: NimNode): NimNode
typetraits : name[](t: typedesc): string
xmldom : name(a: PAttr): string
name=:
macros : name=(someProc: NimNode; val: NimNode)
namespaceURI:
xmldom : namespaceURI(n: PNode): string
namespaceURI=:
xmldom : namespaceURI=(n: PNode; value: string)
NaN:
system : NaN
Nanos:
nimprof : Nanos
nanosleep:
posix : nanosleep(a1, a2: var Timespec): cint
nativeStackTraceSupported:
system : nativeStackTraceSupported
natural:
pegs : natural(): expr
Natural:
system : Natural
Navigator:
dom : Navigator
navigator:
dom : navigator
NegInf:
system : NegInf
nestList:
macros : nestList(theProc: NimIdent; x: NimNode): NimNode
new:
system : new[T](a: var ref T)
system : new[T](a: var ref T; finalizer: proc (x: ref T))
system : new[](T: typedesc): auto
newAssignment:
macros : newAssignment(lhs, rhs: NimNode): NimNode
newAsyncFtpClient:
asyncftpclient : newAsyncFtpClient(address: string; port = Port(21); user, pass = ""): AsyncFtpClient
newAsyncHttpClient:
httpclient : newAsyncHttpClient(userAgent = defUserAgent; maxRedirects = 5; sslContext = defaultSslContext; proxy: Proxy = nil): AsyncHttpClient
newAsyncHttpServer:
asynchttpserver : newAsyncHttpServer(reuseAddr = true; reusePort = false): AsyncHttpServer
newAsyncNativeSocket:
asyncdispatch : newAsyncNativeSocket(domain, sockType, protocol: cint): AsyncFD
asyncdispatch : newAsyncNativeSocket(domain: Domain = nativesockets.AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP): AsyncFD
newAsyncSmtp:
smtp : newAsyncSmtp(address: string; port: Port; useSsl = false; sslContext = defaultSslContext): AsyncSmtp
newAsyncSocket:
asyncnet : newAsyncSocket(fd: AsyncFD; domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP; buffered = true): AsyncSocket
asyncnet : newAsyncSocket(domain, sockType, protocol: cint; buffered = true): AsyncSocket
asyncnet : newAsyncSocket(domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP; buffered = true): AsyncSocket
newBlockStmt:
macros : newBlockStmt(body: NimNode): NimNode
macros : newBlockStmt(label, body: NimNode): NimNode
newCall:
macros : newCall(theProc: NimIdent; args: varargs[NimNode]): NimNode
macros : newCall(theProc: NimNode; args: varargs[NimNode]): NimNode
macros : newCall(theProc: string; args: varargs[NimNode]): NimNode
newCData:
xmltree : newCData(cdata: string): XmlNode
newColonExpr:
macros : newColonExpr(a, b: NimNode): NimNode
newComment:
xmltree : newComment(comment: string): XmlNode
newConfig:
parsecfg : newConfig(): Config
newConsoleLogger:
logging : newConsoleLogger(levelThreshold = lvlAll; fmtStr = defaultFmtStr): ConsoleLogger
newConstStmt:
macros : newConstStmt(name, value: NimNode): NimNode
newContext:
net : newContext(protVersion = protSSLv23; verifyMode = CVerifyPeer; certFile = ""; keyFile = ""; cipherList = "ALL"): SslContext
newCountTable:
tables : newCountTable[A](initialSize = 64): CountTableRef[A]
tables : newCountTable[A](keys: openArray[A]): CountTableRef[A]
newDelegate:
asyncio : newDelegate(): Delegate
newDispatcher:
asyncdispatch : newDispatcher(): PDispatcher
asyncio : newDispatcher(): Dispatcher
newDotExpr:
macros : newDotExpr(a, b: NimNode): NimNode
newDoublyLinkedNode:
lists : newDoublyLinkedNode[T](value: T): DoublyLinkedNode[T]
newElement:
xmltree : newElement(tag: string): XmlNode
newEmptyNode:
macros : newEmptyNode(): NimNode
newEntity:
xmltree : newEntity(entity: string): XmlNode
newException:
system : newException[](exceptn: typedesc; message: string): expr
newFileLogger:
logging : newFileLogger(file: File; levelThreshold = lvlAll; fmtStr = defaultFmtStr): FileLogger
logging : newFileLogger(filename = defaultFilename(); mode: FileMode = fmAppend; levelThreshold = lvlAll; fmtStr = defaultFmtStr; bufSize: int = - 1): FileLogger
newFileStream:
streams : newFileStream(f: File): FileStream
streams : newFileStream(filename: string; mode: FileMode = fmRead): FileStream
newFloatLitNode:
macros : newFloatLitNode(f: BiggestFloat): NimNode
newFuture:
asyncdispatch : newFuture[T](fromProc: string = "unspecified"): Future[T]
newFutureVar:
asyncdispatch : newFutureVar[T](fromProc = "unspecified"): FutureVar[T]
newHttpClient:
httpclient : newHttpClient(userAgent = defUserAgent; maxRedirects = 5; sslContext = defaultSslContext; proxy: Proxy = nil; timeout = - 1): HttpClient
newHttpHeaders:
httpcore : newHttpHeaders(): HttpHeaders
httpcore : newHttpHeaders(keyValuePairs: openArray[tuple[key: string, val: string]]): HttpHeaders
newIdentDefs:
macros : newIdentDefs(name, kind: NimNode; default = newEmptyNode()): NimNode
newIdentNode:
macros : newIdentNode(i: NimIdent): NimNode
macros : newIdentNode(i: string): NimNode
newIfStmt:
macros : newIfStmt(branches: varargs[tuple[cond, body: NimNode]]): NimNode
newIntLitNode:
macros : newIntLitNode(i: BiggestInt): NimNode
newJArray:
json : newJArray(): JsonNode
newJBool:
json : newJBool(b: bool): JsonNode
newJFloat:
json : newJFloat(n: float): JsonNode
newJInt:
json : newJInt(n: BiggestInt): JsonNode
newJNull:
json : newJNull(): JsonNode
newJObject:
json : newJObject(): JsonNode
newJString:
json : newJString(s: string): JsonNode
newLetStmt:
macros : newLetStmt(name, value: NimNode): NimNode
newLine:
pegs : newLine(): Peg
newline:
PEG construction
NewLines:
lexbase : NewLines
strutils : NewLines
newLit:
macros : newLit(f: BiggestFloat): NimNode
macros : newLit(i: BiggestInt): NimNode
macros : newLit(b: bool): NimNode
macros : newLit(c: char): NimNode
macros : newLit(s: string): NimNode
newMersenneTwister:
mersenne : newMersenneTwister(seed: uint32): MersenneTwister
newMimetypes:
mimetypes : newMimetypes(): MimeDB
newMonitor:
fsmonitor : newMonitor(): FSMonitor
newMultipartData:
httpclient : newMultipartData(): MultipartData
httpclient : newMultipartData(xs: MultipartEntries): MultipartData
newNativeSocket:
nativesockets : newNativeSocket(domain: cint; sockType: cint; protocol: cint): SocketHandle
nativesockets : newNativeSocket(domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP): SocketHandle
newNilLit:
macros : newNilLit(): NimNode
newNimNode:
macros : newNimNode(kind: NimNodeKind; n: NimNode = nil): NimNode
newNonTerminal:
pegs : newNonTerminal(name: string; line, column: int): NonTerminal
newOrderedTable:
tables : newOrderedTable[A, B](initialSize = 64): OrderedTableRef[A, B]
tables : newOrderedTable[A, B](pairs: openArray[(A, B)]): OrderedTableRef[A, B]
newPar:
macros : newPar(exprs: varargs[NimNode]): NimNode
newProc:
macros : newProc(name = newEmptyNode(); params: openArray[NimNode] = [newEmptyNode()]; body: NimNode = newStmtList(); procType = nnkProcDef): NimNode
newProxy:
httpclient : newProxy(url: string; auth = ""): Proxy
newRollingFileLogger:
logging : newRollingFileLogger(filename = defaultFilename(); mode: FileMode = fmReadWrite; levelThreshold = lvlAll; fmtStr = defaultFmtStr; maxLines = 1000; bufSize: int = - 1): RollingFileLogger
newRstNode:
rstast : newRstNode(kind: RstNodeKind): PRstNode
rstast : newRstNode(kind: RstNodeKind; s: string): PRstNode
newSelector:
selectors : newSelector(): Selector
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]
newSeqWith:
sequtils : newSeqWith(len: int; init: untyped): untyped
newSinglyLinkedNode:
lists : newSinglyLinkedNode[T](value: T): SinglyLinkedNode[T]
newSocket:
net : newSocket(domain, sockType, protocol: cint; buffered = true): Socket
net : newSocket(domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP; buffered = true): Socket
net : newSocket(fd: SocketHandle; domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP; buffered = true): Socket
newStmtList:
macros : newStmtList(stmts: varargs[NimNode]): NimNode
newString:
system : newString(len: Natural): string
newStringOfCap:
system : newStringOfCap(cap: Natural): string
newStringStream:
streams : newStringStream(s: string = ""): StringStream
newStringTable:
strtabs : newStringTable(mode: StringTableMode): StringTableRef
strtabs : newStringTable(keyValuePairs: varargs[string]; mode: StringTableMode): StringTableRef
strtabs : newStringTable(keyValuePairs: varargs[tuple[key, val: string]]; mode: StringTableMode = modeCaseSensitive): StringTableRef
newStrLitNode:
macros : newStrLitNode(s: string): NimNode
newTable:
tables : newTable[A, B](initialSize = 64): TableRef[A, B]
tables : newTable[A, B](pairs: openArray[(A, B)]): TableRef[A, B]
newTableFrom:
tables : newTableFrom[A, B, C](collection: A; index: proc (x: B): C): TableRef[C, B]
newText:
xmltree : newText(text: string): XmlNode
newTree:
macros : newTree(kind: NimNodeKind; children: varargs[NimNode]): NimNode
newVarStmt:
macros : newVarStmt(name, value: NimNode): NimNode
newWideCString:
system : newWideCString(s: cstring): WideCString
system : newWideCString(source: cstring; L: int): WideCString
system : newWideCString(s: string): WideCString
newXmlTree:
xmltree : newXmlTree(tag: string; children: openArray[XmlNode]; attributes: XmlAttributes = nil): XmlNode
next:
httpserver : next(s: var Server)
json : next(my: var JsonParser)
parsecfg : next(c: var CfgParser): CfgEvent
parseopt : next(p: var OptParser)
parseopt2 : next(p: var OptParser)
parsexml : next(my: var XmlParser)
scgi : next(s: var ScgiState; timeout: int = - 1): bool
nextPermutation:
algorithm : nextPermutation[T](x: var openArray[T]): bool
nextPowerOfTwo:
math : nextPowerOfTwo(x: int): int
nextSibling:
xmldom : nextSibling(n: PNode): PNode
nextSplitPoint:
rstgen : nextSplitPoint(s: string; start: int): int
nftw:
posix : nftw(a1: cstring; a2: proc (x1: cstring; x2: ptr Stat; x3: cint; x4: ptr FTW): cint; a3: cint; a4: cint): cint
nice:
posix : nice(a1: cint): cint
NI_DGRAM:
posix : NI_DGRAM
nimcacheDir:
nimscript : nimcacheDir(): string
NimIdent:
macros : NimIdent
NimMajor:
system : NimMajor
NimMinor:
system : NimMinor
NimNode:
system : NimNode
NimNodeKind:
macros : NimNodeKind
NimNodeKinds:
macros : NimNodeKinds
NimPatch:
system : NimPatch
NimSym:
macros : NimSym
NimSymKind:
macros : NimSymKind
NimTypeKind:
macros : NimTypeKind
NimVersion:
system : NimVersion
nimvm:
system : nimvm
NI_NAMEREQD:
posix : NI_NAMEREQD
NI_NOFQDN:
posix : NI_NOFQDN
NI_NUMERICHOST:
posix : NI_NUMERICHOST
NI_NUMERICSCOPE:
posix : NI_NUMERICSCOPE
NI_NUMERICSERV:
posix : NI_NUMERICSERV
Nl_catd:
posix : Nl_catd
NL_CAT_LOCALE:
posix : NL_CAT_LOCALE
Nlink:
posix : Nlink
Nl_item:
posix : Nl_item
nl_langinfo:
posix : nl_langinfo(a1: Nl_item): cstring
NL_SETD:
posix : NL_SETD
nnkCallKinds:
macros : nnkCallKinds
nnkLiterals:
macros : nnkLiterals
NO_DATA:
posix : NO_DATA
Node:
dom : Node
nodeName:
xmldom : nodeName(n: PNode): string
nodes:
lists : nodes[T](L: DoublyLinkedList[T]): DoublyLinkedNode[T]
lists : nodes[T](L: DoublyLinkedRing[T]): DoublyLinkedNode[T]
lists : nodes[T](L: SinglyLinkedList[T]): SinglyLinkedNode[T]
lists : nodes[T](L: SinglyLinkedRing[T]): SinglyLinkedNode[T]
NodeType:
dom : NodeType
nodeType:
xmldom : nodeType(n: PNode): int
NO_ERROR:
winlean : NO_ERROR
NOEXPR:
posix : NOEXPR
NoFakeVars:
system : NoFakeVars
none:
options : none[](T: typedesc): Option[T]
NonTerminal:
pegs : NonTerminal
nonterminal:
pegs : nonterminal(n: NonTerminal): Peg
NO_RECOVERY:
posix : NO_RECOVERY
normalize:
basic2d : normalize(v: var Vector2d)
basic3d : normalize(v: var Vector3d)
strutils : normalize(s: string): string
xmldom : normalize(n: PNode)
NORMAL_PRIORITY_CLASS:
winlean : NORMAL_PRIORITY_CLASS
normAngle:
basic2d : normAngle(ang: float): float
noscript:
htmlgen : noscript(e: varargs[untyped]): untyped
notice:
logging : notice(args: varargs[string, `$`])
ntohl:
nativesockets : ntohl(x: uint32): uint32
nativesockets : ntohl(x: int32): expr
posix : ntohl(a1: int32): int32
ntohs:
nativesockets : ntohs(x: uint16): uint16
nativesockets : ntohs(x: int16): expr
posix : ntohs(a1: int16): int16
nxt:
strscans : nxt(input: string; idx, step: int = 1)
O_ACCMODE:
posix : O_ACCMODE
O_APPEND:
posix : O_APPEND
object branch transition:
Module system
ObjectAssignmentError:
system : ObjectAssignmentError
ObjectConversionError:
system : ObjectConversionError
O_CREAT:
posix : O_CREAT
O_DSYNC:
posix : O_DSYNC
O_EXCL:
posix : O_EXCL
Off:
posix : Off
off:
system : off
Oid:
oids : Oid
oidToString:
oids : oidToString(oid: Oid; str: cstring)
ol:
htmlgen : ol(e: varargs[untyped]): untyped
on:
events : on(emitter: var EventEmitter; event: string; fn: proc (e: EventArgs))
system : on
onFailedAssert:
system : onFailedAssert(msg, code: untyped): untyped
O_NOCTTY:
posix : O_NOCTTY
O_NONBLOCK:
posix : O_NONBLOCK
onRaise:
system : onRaise(action: proc (e: ref Exception): bool)
onSignal:
posix : onSignal(signals: varargs[cint]; body: untyped)
open:
channels : open*[TMsg](c: var Channel[TMsg])
db_mysql : 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
httpserver : open(s: var Server; port = Port(80); reuseAddr = false)
json : open(my: var JsonParser; input: Stream; filename: string)
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): MemFile
parsecfg : open(c: var CfgParser; input: Stream; filename: string; lineOffset = 0)
parsecsv : open(my: var CsvParser; input: Stream; filename: string; separator = ','; quote = '\"'; escape = '\0'; skipInitialSpace = false)
parsecsv : open(my: var CsvParser; filename: string; separator = ','; quote = '\"'; escape = '\0'; skipInitialSpace = false)
parsexml : open(my: var XmlParser; input: Stream; filename: string; options: set[XmlParseOption] = {})
posix : open(a1: cstring; a2: cint): cint
scgi : open(handleRequest: proc (client: AsyncSocket; input: string; headers: StringTableRef); port = Port(4000); address = "127.0.0.1"; reuseAddr = false): AsyncScgiState
scgi : open(s: var ScgiState; port = Port(4000); address = "127.0.0.1"; reuseAddr = false)
system : open(f: var File; filehandle: FileHandle; mode: FileMode = fmRead): bool
system : open(f: var File; filehandle: FileHandle; mode: FileMode = fmRead): bool
system : open(f: var File; filename: string; mode: FileMode = fmRead; bufSize: int = - 1): bool
system : open(f: var File; filename: string; mode: FileMode = fmRead; bufSize: int = - 1): bool
system : open(filename: string; mode: FileMode = fmRead; bufSize: int = - 1): File
openArray:
system : openArray
openAsync:
asyncfile : openAsync(filename: string; mode = fmRead): AsyncFile
openDefaultBrowser:
browsers : openDefaultBrowser(url: string)
opendir:
posix : opendir(a1: cstring): ptr DIR
OPEN_EXISTING:
winlean : OPEN_EXISTING
OpenMP:
Module system
openProcess:
winlean : openProcess(dwDesiredAccess: DWORD; bInheritHandle: WINBOOL; dwProcessId: DWORD): Handle
optgroup:
htmlgen : optgroup(e: varargs[untyped]): untyped
option:
htmlgen : option(e: varargs[untyped]): untyped
Option:
options : Option
OptionElement:
dom : OptionElement
OptParser:
parseopt : OptParser
parseopt2 : OptParser
ord:
system : ord[T](x: T): int
OrderedSet:
sets : OrderedSet
OrderedTable:
tables : OrderedTable
OrderedTableRef:
tables : OrderedTableRef
Ordinal:
system : Ordinal
O_RDONLY:
posix : O_RDONLY
O_RDWR:
posix : O_RDWR
ORIGO:
basic2d : ORIGO
basic3d : ORIGO
O_RSYNC:
posix : O_RSYNC
OSError:
system : OSError
OSErrorCode:
os : OSErrorCode
ospaths : OSErrorCode
osErrorMsg:
os : osErrorMsg(): string
os : osErrorMsg(errorCode: OSErrorCode): string
osInvalidSocket:
nativesockets : osInvalidSocket
osLastError:
os : osLastError(): OSErrorCode
OSVERSIONINFO:
winlean : OSVERSIONINFO
O_SYNC:
posix : O_SYNC
O_TRUNC:
posix : O_TRUNC
out of memory:
Module system
OutOfMemError:
system : OutOfMemError
outOfMemHook:
system : outOfMemHook
outputHandle:
osproc : outputHandle(p: Process): FileHandle
OutputLevel:
unittest : OutputLevel
outputLevel:
unittest : outputLevel
outputStream:
osproc : outputStream(p: Process): Stream
OutputTarget:
rstgen : OutputTarget
OverflowError:
system : OverflowError
OVERLAPPED:
winlean : OVERLAPPED
ownerDocument:
xmldom : ownerDocument(n: PNode): PDocument
ownerElement:
xmldom : ownerElement(a: PAttr): PElement
O_WRONLY:
posix : O_WRONLY
p:
htmlgen : p(e: varargs[untyped]): untyped
packageName:
nimscript : packageName
PActor:
actors : PActor
PAGE_READONLY:
winlean : PAGE_READONLY
PAGE_READWRITE:
winlean : PAGE_READWRITE
pairs:
critbits : pairs[T](c: CritBitTree[T]): tuple[key: string, val: T]
deques : pairs[T](deq: Deque[T]): tuple[key: int, val: T]
httpcore : pairs(headers: HttpHeaders): tuple[key, value: string]
json : pairs(node: JsonNode): tuple[key: string, val: JsonNode]
queues : pairs[T](q: Queue[T]): tuple[key: int, val: T]
strtabs : pairs(t: StringTableRef): tuple[key, value: string]
system : pairs[IX, T](a: array[IX, T]): tuple[key: IX, val: T]
system : pairs(a: cstring): tuple[key: int, val: char]
system : pairs[T](a: openArray[T]): tuple[key: int, val: T]
system : pairs[T](a: seq[T]): tuple[key: int, val: T]
system : pairs(a: string): tuple[key: int, val: char]
tables : pairs[A](t: CountTable[A]): (A, int)
tables : pairs[A](t: CountTableRef[A]): (A, int)
tables : pairs[A, B](t: OrderedTable[A, B]): (A, B)
tables : pairs[A, B](t: OrderedTableRef[A, B]): (A, B)
tables : pairs[A, B](t: Table[A, B]): (A, B)
tables : pairs[A, B](t: TableRef[A, B]): (A, B)
pairsWithPrefix:
critbits : pairsWithPrefix[T](c: CritBitTree[T]; prefix: string; longestMatch = false): tuple[ key: string, val: T]
P_ALL:
posix : P_ALL
parallel:
threadpool : parallel(body: stmt)
parallelReplace:
pegs : parallelReplace(s: string; subs: varargs[tuple[pattern: Peg, repl: string]]): string
re : parallelReplace(s: string; subs: openArray[tuple[pattern: Regex, repl: string]]): string
param:
htmlgen : param(e: varargs[untyped]): untyped
paramCount:
nimscript : paramCount(): int
os : paramCount(): int
params:
macros : params(someProc: NimNode): NimNode
params=:
macros : params=(someProc: NimNode; params: NimNode)
paramStr:
nimscript : paramStr(i: int): string
os : paramStr(i: int): TaintedString
ParDir:
os : ParDir
ospaths : ParDir
parentDir:
os : parentDir(path: string): string
ospaths : parentDir(path: string): string
parentDirs:
os : parentDirs(path: string; fromRoot = false; inclusive = true): string
ospaths : parentDirs(path: string; fromRoot = false; inclusive = true): string
parentNode:
xmldom : parentNode(n: PNode): PNode
parse:
times : parse(value, layout: string): TimeInfo
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 uint64; start = 0): int
strutils : parseBiggestUInt(s: string): uint64
parseBool:
strutils : parseBool(s: string): bool
parseCmdLine:
os : parseCmdLine(c: string): seq[string]
parseColor:
colors : parseColor(name: string): Color
parseCookies:
cookies : parseCookies(s: string): StringTableRef
parseEnum:
strutils : parseEnum[T: enum](s: string): T
strutils : parseEnum[T: enum](s: string; default: T): T
parseExpr:
macros : parseExpr(s: string): NimNode
parseFile:
json : parseFile(filename: string): JsonNode
parseFloat:
dom : parseFloat*(s: cstring): BiggestFloat
parseutils : parseFloat(s: string; number: var float; start = 0): int
strutils : parseFloat(s: string): float
parseHeader:
httpcore : parseHeader(line: string): tuple[key: string, value: seq[string]]
parseHex:
parseutils : parseHex(s: string; number: var int; start = 0; maxLen = 0): int
parseHexInt:
strutils : parseHexInt(s: string): int
parseHtml:
htmlparser : parseHtml(s: Stream): XmlNode
htmlparser : parseHtml(s: Stream; filename: string; errors: var seq[string]): XmlNode
parseIdent:
parseutils : parseIdent(s: string; start = 0): string
parseutils : parseIdent(s: string; ident: var string; start = 0): int
parseInt:
dom : parseInt*(s: cstring): int
dom : parseInt*(s: cstring; radix: int): int
matchers : parseInt(s: string; value: var int; validRange: Slice[int])
parseutils : parseInt(s: string; number: var int; start = 0): int
strutils : parseInt(s: string): int
parseIpAddress:
net : parseIpAddress(address_str: string): IpAddress
parseJson:
json : parseJson(s: Stream; filename: string): JsonNode
json : parseJson(buffer: string): JsonNode
parseOct:
parseutils : parseOct(s: string; number: var int; start = 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
parseSecureHash:
securehash : parseSecureHash(hash: string): SecureHash
parseSQL:
parsesql : parseSQL(input: Stream; filename: string): SqlNode
parseStmt:
macros : parseStmt(s: string): NimNode
parseToken:
parseutils : parseToken(s: string; token: var string; validChars: set[char]; start = 0): int
parseUInt:
parseutils : parseUInt(s: string; number: var uint; start = 0): int
strutils : parseUInt(s: string): uint
parseUntil:
parseutils : parseUntil(s: string; token: var string; until: char; start = 0): int
parseutils : parseUntil(s: string; token: var string; until: set[char]; start = 0): int
parseutils : parseUntil(s: string; token: var string; until: string; start = 0): int
parseUri:
uri : parseUri(uri: string): Uri
uri : parseUri(uri: string; result: var Uri)
parseWhile:
parseutils : parseWhile(s: string; token: var string; validChars: set[char]; start = 0): int
parseXml:
xmlparser : parseXml(s: Stream): XmlNode
xmlparser : parseXml(s: Stream; filename: string; errors: var seq[string]): XmlNode
partition:
strmisc : partition(s: string; sep: string; right: bool = false): (string, string, string)
Passwd:
posix : Passwd
PAsyncHTTPServer:
httpserver : PAsyncHTTPServer
patchFile:
nimscript : patchFile(package, filename, replacement: string)
PathComponent:
os : PathComponent
pathconf:
posix : pathconf(a1: cstring; a2: cint): int
PathSep:
os : PathSep
ospaths : PathSep
PAttr:
xmldom : PAttr
pause:
posix : pause(): cint
PC_2_SYMLINKS:
posix : PC_2_SYMLINKS
PC_ALLOC_SIZE_MIN:
posix : PC_ALLOC_SIZE_MIN
PC_ASYNC_IO:
posix : PC_ASYNC_IO
PC_CHOWN_RESTRICTED:
posix : PC_CHOWN_RESTRICTED
PCDataSection:
xmldom : PCDataSection
PC_FILESIZEBITS:
posix : PC_FILESIZEBITS
PCharacterData:
xmldom : PCharacterData
PC_LINK_MAX:
posix : PC_LINK_MAX
pclose:
posix : pclose(a: File): cint
PC_MAX_CANON:
posix : PC_MAX_CANON
PC_MAX_INPUT:
posix : PC_MAX_INPUT
PC_NAME_MAX:
posix : PC_NAME_MAX
PC_NO_TRUNC:
posix : PC_NO_TRUNC
PComment:
xmldom : PComment
PC_PATH_MAX:
posix : PC_PATH_MAX
PC_PIPE_BUF:
posix : PC_PIPE_BUF
PC_PRIO_IO:
posix : PC_PRIO_IO
PC_REC_INCR_XFER_SIZE:
posix : PC_REC_INCR_XFER_SIZE
PC_REC_MIN_XFER_SIZE:
posix : PC_REC_MIN_XFER_SIZE
PC_REC_XFER_ALIGN:
posix : PC_REC_XFER_ALIGN
PC_SYMLINK_MAX:
posix : PC_SYMLINK_MAX
PC_SYNC_IO:
posix : PC_SYNC_IO
PCustomOverlapped:
asyncdispatch : PCustomOverlapped
PC_VDISABLE:
posix : PC_VDISABLE
PDispatcher:
asyncdispatch : PDispatcher
PDocument:
xmldom : PDocument
PDocumentFragment:
xmldom : PDocumentFragment
PDOMImplementation:
xmldom : PDOMImplementation
PDWORD:
winlean : PDWORD
peek:
channels : peek*[TMsg](c: var Channel[TMsg]): int
peekBool:
streams : peekBool(s: Stream): bool
peekChar:
streams : peekChar(s: Stream): char
peekData:
streams : peekData(s: Stream; buffer: pointer; bufLen: int): int
peekExitCode:
osproc : peekExitCode(p: Process): int
peekFirst:
deques : peekFirst[T](deq: Deque[T]): T
peekFloat32:
streams : peekFloat32(s: Stream): float32
peekFloat64:
streams : peekFloat64(s: Stream): float64
peekInt16:
streams : peekInt16(s: Stream): int16
peekInt32:
streams : peekInt32(s: Stream): int32
peekInt64:
streams : peekInt64(s: Stream): int64
peekInt8:
streams : peekInt8(s: Stream): int8
peekLast:
deques : peekLast[T](deq: Deque[T]): T
peekLine:
streams : peekLine(s: Stream): TaintedString
streams : peekLine(s: Stream; line: var TaintedString): bool
peekNamedPipe:
winlean : peekNamedPipe(hNamedPipe: Handle; lpBuffer: pointer = nil; nBufferSize: int32 = 0; lpBytesRead: ptr int32 = nil; lpTotalBytesAvail: ptr int32 = nil; lpBytesLeftThisMessage: ptr int32 = nil): bool
peekStr:
streams : peekStr(s: Stream; length: int): TaintedString
Peg:
pegs : Peg
peg:
pegs : peg(pattern: string): Peg
PElement:
xmldom : PElement
PFloat32:
system : PFloat32
PFloat64:
system : PFloat64
PFrame:
system : PFrame
phase:
complex : phase(z: Complex): float
PI:
math : PI
Pid:
posix : Pid
piName:
parsexml : piName(my: XmlParser): string
pinnedSpawn:
threadpool : pinnedSpawn(id: ThreadId; call: expr): expr
PInt32:
system : PInt32
PInt64:
system : PInt64
pinToCpu:
threads : pinToCpu*[Arg](t: var Thread[Arg]; cpu: Natural)
pipe:
posix : pipe(a: array[0 .. 1, cint]): cint
PIPE_ACCESS_DUPLEX:
winlean : PIPE_ACCESS_DUPLEX
PIPE_ACCESS_INBOUND:
winlean : PIPE_ACCESS_INBOUND
PIPE_ACCESS_OUTBOUND:
winlean : PIPE_ACCESS_OUTBOUND
PIPE_NOWAIT:
winlean : PIPE_NOWAIT
piRest:
parsexml : piRest(my: XmlParser): string
play:
dom : play*(e: EmbedElement)
PM_STR:
posix : PM_STR
PNode:
xmldom : PNode
Point2d:
basic2d : Point2d
point2d:
basic2d : point2d(x, y: float): Point2d
Point3d:
basic3d : Point3d
point3d:
basic3d : point3d(x, y, z: float): Point3d
pointer:
system : pointer
polar:
basic2d : polar(p: Point2d; ang, dist: float): Point2d
complex : polar(z: Complex): tuple[r, phi: float]
polarVector2d:
basic2d : polarVector2d(ang: float; len: float): Vector2d
poll:
asyncdispatch : poll(timeout = 500)
asyncio : poll(d: Dispatcher; timeout: int = 500): bool
posix : poll(a1: ptr TPollfd; a2: Tnfds; a3: int): cint
POLLERR:
posix : POLLERR
POLLHUP:
posix : POLLHUP
POLLIN:
posix : POLLIN
POLLNVAL:
posix : POLLNVAL
POLLOUT:
posix : POLLOUT
POLLPRI:
posix : POLLPRI
POLLRDBAND:
posix : POLLRDBAND
POLLRDNORM:
posix : POLLRDNORM
POLLWRBAND:
posix : POLLWRBAND
POLLWRNORM:
posix : POLLWRNORM
pop:
queues : pop[T](q: var Queue[T]): T
system : pop[T](s: var seq[T]): T
popen:
posix : popen(a1, a2: cstring): File
popFirst:
deques : popFirst[T](deq: var Deque[T]): T
popLast:
deques : popLast[T](deq: var Deque[T]): T
port:
httpserver : port(s: var Server): Port
Port:
nativesockets : Port
Positive:
system : Positive
POSIX_ASYNC_IO:
posix : POSIX_ASYNC_IO
POSIX_FADV_DONTNEED:
posix : POSIX_FADV_DONTNEED
posix_fadvise:
posix : posix_fadvise(a1: cint; a2, a3: Off; a4: cint): cint
POSIX_FADV_NOREUSE:
posix : POSIX_FADV_NOREUSE
POSIX_FADV_NORMAL:
posix : POSIX_FADV_NORMAL
POSIX_FADV_RANDOM:
posix : POSIX_FADV_RANDOM
POSIX_FADV_SEQUENTIAL:
posix : POSIX_FADV_SEQUENTIAL
POSIX_FADV_WILLNEED:
posix : POSIX_FADV_WILLNEED
posix_fallocate:
posix : posix_fallocate(a1: cint; a2, a3: Off): cint
POSIX_MADV_DONTNEED:
posix : POSIX_MADV_DONTNEED
posix_madvise:
posix : posix_madvise(a1: pointer; a2: int; a3: cint): cint
POSIX_MADV_NORMAL:
posix : POSIX_MADV_NORMAL
POSIX_MADV_RANDOM:
posix : POSIX_MADV_RANDOM
POSIX_MADV_SEQUENTIAL:
posix : POSIX_MADV_SEQUENTIAL
POSIX_MADV_WILLNEED:
posix : POSIX_MADV_WILLNEED
posix_mem_offset:
posix : posix_mem_offset(a1: pointer; a2: int; a3: var Off; a4: var int; a5: var cint): cint
POSIX_PRIO_IO:
posix : POSIX_PRIO_IO
posix_spawn:
posix : posix_spawn(a1: var Pid; a2: cstring; a3: var Tposix_spawn_file_actions; a4: var Tposix_spawnattr; a5, a6: cstringArray): cint
posix_spawnattr_destroy:
posix : posix_spawnattr_destroy(a1: var Tposix_spawnattr): cint
posix_spawnattr_getflags:
posix : posix_spawnattr_getflags(a1: var Tposix_spawnattr; a2: var cshort): cint
posix_spawnattr_getpgroup:
posix : posix_spawnattr_getpgroup(a1: var Tposix_spawnattr; a2: var Pid): cint
posix_spawnattr_getschedparam:
posix : posix_spawnattr_getschedparam(a1: var Tposix_spawnattr; a2: var Sched_param): cint
posix_spawnattr_getschedpolicy:
posix : posix_spawnattr_getschedpolicy(a1: var Tposix_spawnattr; a2: var cint): cint
posix_spawnattr_getsigdefault:
posix : posix_spawnattr_getsigdefault(a1: var Tposix_spawnattr; a2: var Sigset): cint
posix_spawnattr_getsigmask:
posix : posix_spawnattr_getsigmask(a1: var Tposix_spawnattr; a2: var Sigset): cint
posix_spawnattr_init:
posix : posix_spawnattr_init(a1: var Tposix_spawnattr): cint
posix_spawnattr_setflags:
posix : posix_spawnattr_setflags(a1: var Tposix_spawnattr; a2: cint): cint
posix_spawnattr_setpgroup:
posix : posix_spawnattr_setpgroup(a1: var Tposix_spawnattr; a2: Pid): cint
posix_spawnattr_setschedparam:
posix : posix_spawnattr_setschedparam(a1: var Tposix_spawnattr; a2: var Sched_param): cint
posix_spawnattr_setschedpolicy:
posix : posix_spawnattr_setschedpolicy(a1: var Tposix_spawnattr; a2: cint): cint
posix_spawnattr_setsigdefault:
posix : posix_spawnattr_setsigdefault(a1: var Tposix_spawnattr; a2: var Sigset): cint
posix_spawnattr_setsigmask:
posix : posix_spawnattr_setsigmask(a1: var Tposix_spawnattr; a2: var Sigset): cint
posix_spawn_file_actions_addclose:
posix : posix_spawn_file_actions_addclose(a1: var Tposix_spawn_file_actions; a2: cint): cint
posix_spawn_file_actions_adddup2:
posix : posix_spawn_file_actions_adddup2(a1: var Tposix_spawn_file_actions; a2, a3: cint): cint
posix_spawn_file_actions_addopen:
posix : posix_spawn_file_actions_addopen(a1: var Tposix_spawn_file_actions; a2: cint; a3: cstring; a4: cint; a5: Mode): cint
posix_spawn_file_actions_destroy:
posix : posix_spawn_file_actions_destroy(a1: var Tposix_spawn_file_actions): cint
posix_spawn_file_actions_init:
posix : posix_spawn_file_actions_init(a1: var Tposix_spawn_file_actions): cint
posix_spawnp:
posix : posix_spawnp(a1: var Pid; a2: cstring; a3: var Tposix_spawn_file_actions; a4: var Tposix_spawnattr; a5, a6: cstringArray): cint
POSIX_SPAWN_RESETIDS:
posix : POSIX_SPAWN_RESETIDS
POSIX_SPAWN_SETPGROUP:
posix : POSIX_SPAWN_SETPGROUP
POSIX_SPAWN_SETSCHEDPARAM:
posix : POSIX_SPAWN_SETSCHEDPARAM
POSIX_SPAWN_SETSCHEDULER:
posix : POSIX_SPAWN_SETSCHEDULER
POSIX_SPAWN_SETSIGDEF:
posix : POSIX_SPAWN_SETSIGDEF
POSIX_SPAWN_SETSIGMASK:
posix : POSIX_SPAWN_SETSIGMASK
POSIX_SPAWN_USEVFORK:
posix : POSIX_SPAWN_USEVFORK
POSIX_SYNC_IO:
posix : POSIX_SYNC_IO
POSIX_TYPED_MEM_ALLOCATE:
posix : POSIX_TYPED_MEM_ALLOCATE
POSIX_TYPED_MEM_ALLOCATE_CONTIG:
posix : POSIX_TYPED_MEM_ALLOCATE_CONTIG
posix_typed_mem_get_info:
posix : posix_typed_mem_get_info(a1: cint; a2: var Posix_typed_mem_info): cint
Posix_typed_mem_info:
posix : Posix_typed_mem_info
POSIX_TYPED_MEM_MAP_ALLOCATABLE:
posix : POSIX_TYPED_MEM_MAP_ALLOCATABLE
posix_typed_mem_open:
posix : posix_typed_mem_open(a1: cstring; a2, a3: cint): cint
post:
httpclient : post(client: AsyncHttpClient; url: string; body = ""; multipart: MultipartData = nil): Future[ Response]
httpclient : post(client: HttpClient; url: string; body = ""; multipart: MultipartData = nil): Response
httpclient : post(url: string; extraHeaders = ""; body = ""; maxRedirects = 5; sslContext: SSLContext = defaultSSLContext; timeout = - 1; userAgent = defUserAgent; proxy: Proxy = nil; multipart: MultipartData = nil): Response
postContent:
httpclient : postContent(client: AsyncHttpClient; url: string; body = ""; multipart: MultipartData = nil): Future[string]
httpclient : postContent(client: HttpClient; url: string; body = ""; multipart: MultipartData = nil): string
httpclient : postContent(url: string; extraHeaders = ""; body = ""; maxRedirects = 5; sslContext: SSLContext = defaultSSLContext; timeout = - 1; userAgent = defUserAgent; proxy: Proxy = nil; multipart: MultipartData = nil): string
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
poUseShell:
osproc : poUseShell
POVERLAPPED:
winlean : POVERLAPPED
POVERLAPPED_COMPLETION_ROUTINE:
winlean : POVERLAPPED_COMPLETION_ROUTINE
pow:
complex : pow(x, y: Complex): Complex
math : pow(x, y: float32): float32
math : pow(x, y: float64): float64
P_PGID:
posix : P_PGID
P_PID:
posix : P_PID
PProcessingInstruction:
xmldom : PProcessingInstruction
pragma:
macros : pragma(someProc: NimNode): NimNode
pragma=:
macros : pragma=(someProc: NimNode; val: NimNode)
pre:
htmlgen : pre(e: varargs[untyped]): untyped
pread:
posix : pread(a1: cint; a2: pointer; a3: int; a4: Off): int
pred:
system : pred[T](x: Ordinal[T]; y = 1): T
preferSpawn:
threadpool : preferSpawn(): bool
prefix:
macros : prefix(node: NimNode; op: string): NimNode
prefix=:
xmldom : prefix=(n: PNode; value: string)
prepare:
db_postgres : prepare(db: DbConn; stmtName: string; query: SqlQuery; nParams: int): SqlPrepared
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)
pretty:
json : pretty(node: JsonNode; indent = 2): string
preventDefault:
dom : preventDefault*(ev: Event)
previousSibling:
xmldom : previousSibling(n: PNode): PNode
prevPermutation:
algorithm : prevPermutation[T](x: var openArray[T]): bool
print:
dom : print*(w: Window)
ProcAddr:
system : ProcAddr
procCall:
system : procCall(x: expr)
Process:
osproc : Process
PROCESS_CREATE_PROCESS:
winlean : PROCESS_CREATE_PROCESS
PROCESS_CREATE_THREAD:
winlean : PROCESS_CREATE_THREAD
PROCESS_DUP_HANDLE:
winlean : PROCESS_DUP_HANDLE
processedRows:
parsecsv : processedRows(my: var CsvParser): int
processID:
osproc : processID(p: Process): int
PROCESS_INFORMATION:
winlean : PROCESS_INFORMATION
ProcessingInstructionNode:
xmldom : 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
product:
algorithm : product[T](x: openArray[seq[T]]): seq[seq[T]]
programResult:
system : programResult
ProgressChangedProc:
asyncftpclient : ProgressChangedProc
httpclient : ProgressChangedProc
prompt:
dom : prompt*(w: Window; text, default: cstring): cstring
protect:
system : protect(x: pointer): ForeignCell
PROT_EXEC:
posix : PROT_EXEC
PROT_NONE:
posix : PROT_NONE
Protocol:
nativesockets : Protocol
ProtocolError:
httpclient : ProtocolError
Protoent:
posix : Protoent
PROT_READ:
posix : PROT_READ
PROT_WRITE:
posix : PROT_WRITE
Proxy:
httpclient : Proxy
PRstNode:
rstast : PRstNode
pselect:
posix : pselect(a1: cint; a2, a3, a4: ptr TFdSet; a5: ptr Timespec; a6: var Sigset): cint
pskIdentityHint=:
net : pskIdentityHint=(ctx: SslContext; hint: string)
PText:
xmldom : PText
Pthread:
posix : Pthread
pthread_atfork:
posix : pthread_atfork(a1, a2, a3: proc ()): cint
Pthread_attr:
posix : Pthread_attr
pthread_attr_destroy:
posix : pthread_attr_destroy(a1: ptr Pthread_attr): cint
pthread_attr_getdetachstate:
posix : pthread_attr_getdetachstate(a1: ptr Pthread_attr; a2: cint): cint
pthread_attr_getguardsize:
posix : pthread_attr_getguardsize(a1: ptr Pthread_attr; a2: var cint): cint
pthread_attr_getinheritsched:
posix : pthread_attr_getinheritsched(a1: ptr Pthread_attr; a2: var cint): cint
pthread_attr_getschedparam:
posix : pthread_attr_getschedparam(a1: ptr Pthread_attr; a2: ptr Sched_param): cint
pthread_attr_getschedpolicy:
posix : pthread_attr_getschedpolicy(a1: ptr Pthread_attr; a2: var cint): cint
pthread_attr_getscope:
posix : pthread_attr_getscope(a1: ptr Pthread_attr; a2: var cint): cint
pthread_attr_getstack:
posix : pthread_attr_getstack(a1: ptr Pthread_attr; a2: var pointer; a3: var int): cint
pthread_attr_getstackaddr:
posix : pthread_attr_getstackaddr(a1: ptr Pthread_attr; a2: var pointer): cint
pthread_attr_getstacksize:
posix : pthread_attr_getstacksize(a1: ptr Pthread_attr; a2: var int): cint
pthread_attr_init:
posix : pthread_attr_init(a1: ptr Pthread_attr): cint
pthread_attr_setdetachstate:
posix : pthread_attr_setdetachstate(a1: ptr Pthread_attr; a2: cint): cint
pthread_attr_setguardsize:
posix : pthread_attr_setguardsize(a1: ptr Pthread_attr; a2: int): cint
pthread_attr_setinheritsched:
posix : pthread_attr_setinheritsched(a1: ptr Pthread_attr; a2: cint): cint
pthread_attr_setschedparam:
posix : pthread_attr_setschedparam(a1: ptr Pthread_attr; a2: ptr Sched_param): cint
pthread_attr_setschedpolicy:
posix : pthread_attr_setschedpolicy(a1: ptr Pthread_attr; a2: cint): cint
pthread_attr_setscope:
posix : pthread_attr_setscope(a1: ptr Pthread_attr; a2: cint): cint
pthread_attr_setstack:
posix : pthread_attr_setstack(a1: ptr Pthread_attr; a2: pointer; a3: int): cint
pthread_attr_setstackaddr:
posix : pthread_attr_setstackaddr(a1: ptr Pthread_attr; a2: pointer): cint
pthread_attr_setstacksize:
posix : pthread_attr_setstacksize(a1: ptr Pthread_attr; a2: int): cint
Pthread_barrier:
posix : Pthread_barrier
Pthread_barrierattr:
posix : Pthread_barrierattr
pthread_barrierattr_destroy:
posix : pthread_barrierattr_destroy(a1: ptr Pthread_barrierattr): cint
pthread_barrierattr_getpshared:
posix : pthread_barrierattr_getpshared(a1: ptr Pthread_barrierattr; a2: var cint): cint
pthread_barrierattr_init:
posix : pthread_barrierattr_init(a1: ptr Pthread_barrierattr): cint
pthread_barrierattr_setpshared:
posix : pthread_barrierattr_setpshared(a1: ptr Pthread_barrierattr; a2: cint): cint
pthread_barrier_destroy:
posix : pthread_barrier_destroy(a1: ptr Pthread_barrier): cint
pthread_barrier_init:
posix : pthread_barrier_init(a1: ptr Pthread_barrier; a2: ptr Pthread_barrierattr; a3: cint): cint
PTHREAD_BARRIER_SERIAL_THREAD:
posix : PTHREAD_BARRIER_SERIAL_THREAD
pthread_barrier_wait:
posix : pthread_barrier_wait(a1: ptr Pthread_barrier): cint
pthread_cancel:
posix : pthread_cancel(a1: Pthread): cint
PTHREAD_CANCEL_ASYNCHRONOUS:
posix : PTHREAD_CANCEL_ASYNCHRONOUS
PTHREAD_CANCEL_DEFERRED:
posix : PTHREAD_CANCEL_DEFERRED
PTHREAD_CANCEL_DISABLE:
posix : PTHREAD_CANCEL_DISABLE
PTHREAD_CANCELED:
posix : PTHREAD_CANCELED
PTHREAD_CANCEL_ENABLE:
posix : PTHREAD_CANCEL_ENABLE
pthread_cleanup_pop:
posix : pthread_cleanup_pop(a1: cint)
pthread_cleanup_push:
posix : pthread_cleanup_push(a1: proc (x: pointer); a2: pointer)
Pthread_cond:
posix : Pthread_cond
Pthread_condattr:
posix : Pthread_condattr
pthread_condattr_destroy:
posix : pthread_condattr_destroy(a1: ptr Pthread_condattr): cint
pthread_condattr_getclock:
posix : pthread_condattr_getclock(a1: ptr Pthread_condattr; a2: var ClockId): cint
pthread_condattr_getpshared:
posix : pthread_condattr_getpshared(a1: ptr Pthread_condattr; a2: var cint): cint
pthread_condattr_init:
posix : pthread_condattr_init(a1: ptr Pthread_condattr): cint
pthread_condattr_setclock:
posix : pthread_condattr_setclock(a1: ptr Pthread_condattr; a2: ClockId): cint
pthread_condattr_setpshared:
posix : pthread_condattr_setpshared(a1: ptr Pthread_condattr; a2: cint): cint
pthread_cond_broadcast:
posix : pthread_cond_broadcast(a1: ptr Pthread_cond): cint
pthread_cond_destroy:
posix : pthread_cond_destroy(a1: ptr Pthread_cond): cint
pthread_cond_init:
posix : pthread_cond_init(a1: ptr Pthread_cond; a2: ptr Pthread_condattr): cint
PTHREAD_COND_INITIALIZER:
posix : PTHREAD_COND_INITIALIZER
pthread_cond_signal:
posix : pthread_cond_signal(a1: ptr Pthread_cond): cint
pthread_cond_timedwait:
posix : pthread_cond_timedwait(a1: ptr Pthread_cond; a2: ptr Pthread_mutex; a3: ptr Timespec): cint
pthread_cond_wait:
posix : pthread_cond_wait(a1: ptr Pthread_cond; a2: ptr Pthread_mutex): cint
pthread_create:
posix : pthread_create(a1: ptr Pthread; a2: ptr Pthread_attr; a3: proc (x: pointer): pointer; a4: pointer): cint
PTHREAD_CREATE_DETACHED:
posix : PTHREAD_CREATE_DETACHED
PTHREAD_CREATE_JOINABLE:
posix : PTHREAD_CREATE_JOINABLE
pthread_detach:
posix : pthread_detach(a1: Pthread): cint
pthread_equal:
posix : pthread_equal(a1, a2: Pthread): cint
pthread_exit:
posix : pthread_exit(a1: pointer)
PTHREAD_EXPLICIT_SCHED:
posix : PTHREAD_EXPLICIT_SCHED
pthread_getconcurrency:
posix : pthread_getconcurrency(): cint
pthread_getcpuclockid:
posix : pthread_getcpuclockid(a1: Pthread; a2: var ClockId): cint
pthread_getschedparam:
posix : pthread_getschedparam(a1: Pthread; a2: var cint; a3: ptr Sched_param): cint
pthread_getspecific:
posix : pthread_getspecific(a1: Pthread_key): pointer
PTHREAD_INHERIT_SCHED:
posix : PTHREAD_INHERIT_SCHED
pthread_join:
posix : pthread_join(a1: Pthread; a2: ptr pointer): cint
Pthread_key:
posix : Pthread_key
pthread_key_create:
posix : pthread_key_create(a1: ptr Pthread_key; a2: proc (x: pointer)): cint
pthread_key_delete:
posix : pthread_key_delete(a1: Pthread_key): cint
pthread_kill:
posix : pthread_kill(a1: Pthread; a2: cint): cint
Pthread_mutex:
posix : Pthread_mutex
Pthread_mutexattr:
posix : Pthread_mutexattr
pthread_mutexattr_destroy:
posix : pthread_mutexattr_destroy(a1: ptr Pthread_mutexattr): cint
pthread_mutexattr_getprioceiling:
posix : pthread_mutexattr_getprioceiling(a1: ptr Pthread_mutexattr; a2: var cint): cint
pthread_mutexattr_getprotocol:
posix : pthread_mutexattr_getprotocol(a1: ptr Pthread_mutexattr; a2: var cint): cint
pthread_mutexattr_getpshared:
posix : pthread_mutexattr_getpshared(a1: ptr Pthread_mutexattr; a2: var cint): cint
pthread_mutexattr_gettype:
posix : pthread_mutexattr_gettype(a1: ptr Pthread_mutexattr; a2: var cint): cint
pthread_mutexattr_init:
posix : pthread_mutexattr_init(a1: ptr Pthread_mutexattr): cint
pthread_mutexattr_setprioceiling:
posix : pthread_mutexattr_setprioceiling(a1: ptr Pthread_mutexattr; a2: cint): cint
pthread_mutexattr_setprotocol:
posix : pthread_mutexattr_setprotocol(a1: ptr Pthread_mutexattr; a2: cint): cint
pthread_mutexattr_setpshared:
posix : pthread_mutexattr_setpshared(a1: ptr Pthread_mutexattr; a2: cint): cint
pthread_mutexattr_settype:
posix : pthread_mutexattr_settype(a1: ptr Pthread_mutexattr; a2: cint): cint
PTHREAD_MUTEX_DEFAULT:
posix : PTHREAD_MUTEX_DEFAULT
pthread_mutex_destroy:
posix : pthread_mutex_destroy(a1: ptr Pthread_mutex): cint
PTHREAD_MUTEX_ERRORCHECK:
posix : PTHREAD_MUTEX_ERRORCHECK
pthread_mutex_getprioceiling:
posix : pthread_mutex_getprioceiling(a1: ptr Pthread_mutex; a2: var cint): cint
pthread_mutex_init:
posix : pthread_mutex_init(a1: ptr Pthread_mutex; a2: ptr Pthread_mutexattr): cint
PTHREAD_MUTEX_INITIALIZER:
posix : PTHREAD_MUTEX_INITIALIZER
pthread_mutex_lock:
posix : pthread_mutex_lock(a1: ptr Pthread_mutex): cint
PTHREAD_MUTEX_NORMAL:
posix : PTHREAD_MUTEX_NORMAL
PTHREAD_MUTEX_RECURSIVE:
posix : PTHREAD_MUTEX_RECURSIVE
pthread_mutex_setprioceiling:
posix : pthread_mutex_setprioceiling(a1: ptr Pthread_mutex; a2: cint; a3: var cint): cint
pthread_mutex_timedlock:
posix : pthread_mutex_timedlock(a1: ptr Pthread_mutex; a2: ptr Timespec): cint
pthread_mutex_trylock:
posix : pthread_mutex_trylock(a1: ptr Pthread_mutex): cint
pthread_mutex_unlock:
posix : pthread_mutex_unlock(a1: ptr Pthread_mutex): cint
Pthread_once:
posix : Pthread_once
pthread_once:
posix : pthread_once(a1: ptr Pthread_once; a2: proc ()): cint
PTHREAD_ONCE_INIT:
posix : PTHREAD_ONCE_INIT
PTHREAD_PRIO_INHERIT:
posix : PTHREAD_PRIO_INHERIT
PTHREAD_PRIO_NONE:
posix : PTHREAD_PRIO_NONE
PTHREAD_PRIO_PROTECT:
posix : PTHREAD_PRIO_PROTECT
PTHREAD_PROCESS_PRIVATE:
posix : PTHREAD_PROCESS_PRIVATE
PTHREAD_PROCESS_SHARED:
posix : PTHREAD_PROCESS_SHARED
Pthread_rwlock:
posix : Pthread_rwlock
Pthread_rwlockattr:
posix : Pthread_rwlockattr
pthread_rwlockattr_destroy:
posix : pthread_rwlockattr_destroy(a1: ptr Pthread_rwlockattr): cint
pthread_rwlockattr_getpshared:
posix : pthread_rwlockattr_getpshared(a1: ptr Pthread_rwlockattr; a2: var cint): cint
pthread_rwlockattr_init:
posix : pthread_rwlockattr_init(a1: ptr Pthread_rwlockattr): cint
pthread_rwlockattr_setpshared:
posix : pthread_rwlockattr_setpshared(a1: ptr Pthread_rwlockattr; a2: cint): cint
pthread_rwlock_destroy:
posix : pthread_rwlock_destroy(a1: ptr Pthread_rwlock): cint
pthread_rwlock_init:
posix : pthread_rwlock_init(a1: ptr Pthread_rwlock; a2: ptr Pthread_rwlockattr): cint
pthread_rwlock_rdlock:
posix : pthread_rwlock_rdlock(a1: ptr Pthread_rwlock): cint
pthread_rwlock_timedrdlock:
posix : pthread_rwlock_timedrdlock(a1: ptr Pthread_rwlock; a2: ptr Timespec): cint
pthread_rwlock_timedwrlock:
posix : pthread_rwlock_timedwrlock(a1: ptr Pthread_rwlock; a2: ptr Timespec): cint
pthread_rwlock_tryrdlock:
posix : pthread_rwlock_tryrdlock(a1: ptr Pthread_rwlock): cint
pthread_rwlock_trywrlock:
posix : pthread_rwlock_trywrlock(a1: ptr Pthread_rwlock): cint
pthread_rwlock_unlock:
posix : pthread_rwlock_unlock(a1: ptr Pthread_rwlock): cint
pthread_rwlock_wrlock:
posix : pthread_rwlock_wrlock(a1: ptr Pthread_rwlock): cint
PTHREAD_SCOPE_PROCESS:
posix : PTHREAD_SCOPE_PROCESS
PTHREAD_SCOPE_SYSTEM:
posix : PTHREAD_SCOPE_SYSTEM
pthread_self:
posix : pthread_self(): Pthread
pthread_setcancelstate:
posix : pthread_setcancelstate(a1: cint; a2: var cint): cint
pthread_setcanceltype:
posix : pthread_setcanceltype(a1: cint; a2: var cint): cint
pthread_setconcurrency:
posix : pthread_setconcurrency(a1: cint): cint
pthread_setschedparam:
posix : pthread_setschedparam(a1: Pthread; a2: cint; a3: ptr Sched_param): cint
pthread_setschedprio:
posix : pthread_setschedprio(a1: Pthread; a2: cint): cint
pthread_setspecific:
posix : pthread_setspecific(a1: Pthread_key; a2: pointer): cint
pthread_sigmask:
posix : pthread_sigmask(a1: cint; a2, a3: var Sigset): cint
pthread_spin_destroy:
posix : pthread_spin_destroy(a1: ptr Pthread_spinlock): cint
pthread_spin_init:
posix : pthread_spin_init(a1: ptr Pthread_spinlock; a2: cint): cint
Pthread_spinlock:
posix : Pthread_spinlock
pthread_spin_lock:
posix : pthread_spin_lock(a1: ptr Pthread_spinlock): cint
pthread_spin_trylock:
posix : pthread_spin_trylock(a1: ptr Pthread_spinlock): cint
pthread_spin_unlock:
posix : pthread_spin_unlock(a1: ptr Pthread_spinlock): cint
pthread_testcancel:
posix : pthread_testcancel()
PULONG:
winlean : PULONG
PULONG_PTR:
winlean : PULONG_PTR
push:
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])
put:
nimscript : put(key, value: string)
putEnv:
os : putEnv(key, val: string)
pwd:
asyncftpclient : pwd(ftp: AsyncFtpClient): Future[TaintedString]
ftpclient : pwd[T](ftp: FtpBase[T]): string
PWOHandleArray:
winlean : PWOHandleArray
pwrite:
posix : pwrite(a1: cint; a2: pointer; a3: int; a4: Off): int
q:
htmlgen : q(e: varargs[untyped]): untyped
Queue:
queues : Queue
queue:
Module queues
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
quoteIfContainsWhite:
strutils : quoteIfContainsWhite(s: string): string
quoteShell:
osproc : quoteShell(s: string): string
quoteShellPosix:
osproc : quoteShellPosix(s: string): string
quoteShellWindows:
osproc : quoteShellWindows(s: string): string
RADIXCHAR:
posix : RADIXCHAR
radToDeg:
basic2d : radToDeg(rad: float): float
math : radToDeg[T: float32 | float64](d: T): T
raiseAssert:
system : raiseAssert(msg: string)
raiseInvalidLibrary:
dynlib : raiseInvalidLibrary(name: cstring)
raiseOSError:
os : raiseOSError(errorCode: OSErrorCode; additionalInfo = "")
os : raiseOSError(msg: string = "")
raiseParseErr:
json : raiseParseErr(p: JsonParser; msg: string)
raiseScgiError:
scgi : raiseScgiError(msg: string)
raiseSSLError:
net : raiseSSLError(s = "")
random:
random : random(max: float): float
random : random(max: int): int
random : random[T](a: openArray[T]): T
random : random[T](x: Slice[T]): T
randomize:
random : randomize()
random : randomize(seed: int)
range:
system : range
RangeError:
system : RangeError
Rational:
rationals : Rational
rawData:
parsexml : rawData(my: XmlParser): string
rawData2:
parsexml : rawData2(my: XmlParser): string
rawEnv:
system : rawEnv[T: proc](x: T): pointer
rawMatch:
pegs : rawMatch(s: string; p: Peg; start: int; c: var Captures): int
rawProc:
system : rawProc[T: proc](x: T): pointer
rawTag:
xmltree : rawTag(n: XmlNode): string
rawText:
xmltree : rawText(n: XmlNode): string
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 = {reExtended, reStudy}): Regex
read:
asyncdispatch : read[T](future: Future[T] | FutureVar[T]): T
asyncfile : read(f: AsyncFile; size: int): Future[string]
posix : read(a1: cint; a2: pointer; a3: int): int
readAll:
asyncfile : readAll(f: AsyncFile): Future[string]
streams : readAll(s: Stream): string
system : readAll(file: File): TaintedString
system : readAll(file: File): TaintedString
readBool:
streams : readBool(s: Stream): bool
readBuffer:
asyncfile : readBuffer(f: AsyncFile; buf: pointer; size: int): Future[int]
system : readBuffer(f: File; buffer: pointer; len: Natural): int
system : readBuffer(f: File; buffer: pointer; len: Natural): int
readBytes:
system : readBytes[](f: File; a: var openArray[int8 | uint8]; start, len: Natural): int
system : readBytes[](f: File; a: var openArray[int8 | uint8]; start, len: Natural): int
readChar:
streams : readChar(s: Stream): char
system : readChar(f: File): char
system : readChar(f: File): char
readChars:
system : readChars(f: File; a: var openArray[char]; start, len: Natural): int
system : 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
streams : readData(s: Stream; buffer: pointer; bufLen: int): int
streams : readData(s, unused: Stream; buffer: pointer; bufLen: int): int
ReadDbEffect:
db_common : ReadDbEffect
readdir:
posix : readdir(a1: ptr DIR): ptr Dirent
ReadDirEffect:
os : ReadDirEffect
ospaths : ReadDirEffect
readdir_r:
posix : readdir_r(a1: ptr DIR; a2: ptr Dirent; a3: ptr ptr Dirent): cint
ReadEnvEffect:
os : ReadEnvEffect
ospaths : ReadEnvEffect
readError:
asyncdispatch : readError[T](future: Future[T]): ref Exception
readFile:
system : readFile(filename: string): TaintedString
system : readFile(filename: string): TaintedString
winlean : readFile(hFile: Handle; Buffer: pointer; nNumberOfBytesToRead: int32; lpNumberOfBytesRead: ptr int32; lpOverlapped: pointer): WINBOOL
readFloat32:
streams : readFloat32(s: Stream): float32
readFloat64:
streams : readFloat64(s: Stream): float64
readHeaderRow:
parsecsv : readHeaderRow(my: var CsvParser)
readInt16:
streams : readInt16(s: Stream): int16
readInt32:
streams : readInt32(s: Stream): int32
readInt64:
streams : readInt64(s: Stream): int64
readInt8:
streams : readInt8(s: Stream): int8
ReadIOEffect:
system : ReadIOEffect
readLine:
asyncfile : readLine(f: AsyncFile): Future[string]
asyncio : readLine(s: AsyncSocket; line: var TaintedString): bool
net : readLine(socket: Socket; line: var TaintedString; timeout = - 1; flags = {SafeDisconn}; maxLength = MaxLineLength)
streams : readLine(s: Stream): TaintedString
streams : readLine(s: Stream; line: var TaintedString): bool
system : readLine(f: File): TaintedString
system : readLine(f: File; line: var TaintedString): bool
system : readLine(f: File; line: var TaintedString): bool
system : readLine(f: File): TaintedString
readLineFromStdin:
rdstdin : readLineFromStdin(prompt: string): TaintedString
rdstdin : readLineFromStdin(prompt: string; line: var TaintedString): bool
ReadLineResult:
net : ReadLineResult
readlink:
posix : readlink(a1, a2: cstring; a3: int): int
readPasswordFromStdin:
rdstdin : readPasswordFromStdin(prompt: string): TaintedString
rdstdin : readPasswordFromStdin(prompt: string; password: var TaintedString): bool
readRow:
parsecsv : readRow(my: var CsvParser; columns = 0): bool
readStr:
streams : readStr(s: Stream; length: int): TaintedString
readv:
posix : readv(a1: cint; a2: ptr IOVec; a3: cint): int
ready:
actors : ready[In, Out](a: PActor[In, Out]): bool
channels : ready*[TMsg](c: var Channel[TMsg]): bool
ReadyInfo:
selectors : ReadyInfo
realloc:
system : realloc(p: pointer; newSize: Natural): pointer
reallocShared:
system : reallocShared(p: pointer; newSize: Natural): pointer
realpath:
posix : realpath(name, resolved: cstring): cstring
REALTIME_PRIORITY_CLASS:
winlean : REALTIME_PRIORITY_CLASS
reBinary:
re : reBinary
reciprocal:
rationals : reciprocal[T](x: Rational[T]): Rational[T]
rect:
complex : rect(r: float; phi: float): Complex
recv:
actors : recv[In, Out](a: PActor[In, Out]): Task[In, Out]
asyncdispatch : recv(socket: AsyncFD; size: int; flags = {SafeDisconn}): Future[string]
asyncnet : recv(socket: AsyncSocket; size: int; flags = {SafeDisconn}): Future[string]
channels : recv*[TMsg](c: var Channel[TMsg]): TMsg
net : recv(socket: Socket; size: int; timeout = - 1; flags = {SafeDisconn}): string
net : recv(socket: Socket; data: pointer; size: int): int
net : recv(socket: Socket; data: pointer; size: int; timeout: int): int
net : recv(socket: Socket; data: var string; size: int; timeout = - 1; flags = {SafeDisconn}): int
posix : recv(a1: SocketHandle; a2: pointer; a3: int; a4: cint): int
winlean : recv(s: SocketHandle; buf: pointer; len, flags: cint): cint
recvFrom:
net : recvFrom(socket: Socket; data: var string; length: int; address: var string; port: var Port; flags = 0'i32): int
recvfrom:
posix : recvfrom(a1: SocketHandle; a2: pointer; a3: int; a4: cint; a5: ptr SockAddr; a6: ptr Socklen): int
winlean : recvfrom(s: SocketHandle; buf: cstring; len, flags: cint; fromm: ptr SockAddr; fromlen: ptr SockLen): cint
recvFromInto:
asyncdispatch : recvFromInto(socket: AsyncFD; data: pointer; size: int; saddr: ptr SockAddr; saddrLen: ptr SockLen; flags = {SafeDisconn}): Future[int]
recvInto:
asyncdispatch : recvInto(socket: AsyncFD; buf: pointer; size: int; flags = {SafeDisconn}): Future[int]
asyncnet : recvInto(socket: AsyncSocket; buf: pointer; size: int; flags = {SafeDisconn}): Future[int]
recvLine:
asyncdispatch : recvLine(socket: AsyncFD): Future[string]
asyncio : recvLine(s: AsyncSocket; line: var TaintedString): bool
asyncnet : recvLine(socket: AsyncSocket; flags = {SafeDisconn}; maxLength = MaxLineLength): Future[ string]
net : recvLine(socket: Socket; timeout = - 1; flags = {SafeDisconn}; maxLength = MaxLineLength): TaintedString
ssl : recvLine(sock: SecureSocket; line: var TaintedString): bool
recvLineInto:
asyncnet : recvLineInto(socket: AsyncSocket; resString: FutureVar[string]; flags = {SafeDisconn}; maxLength = MaxLineLength): Future[void]
recvmsg:
posix : recvmsg(a1: SocketHandle; a2: ptr Tmsghdr; a3: cint): int
reduce:
rationals : reduce[T: SomeInteger](x: var Rational[T])
reEmail:
re : reEmail
RefCount:
system : RefCount
reFloat:
re : reFloat
Regex:
nre : Regex
re : Regex
regex:
Substitution Expressions (subex)
RegexError:
nre : RegexError
re : RegexError
RegexFlag:
re : RegexFlag
RegexInternalError:
nre : RegexInternalError
RegexMatch:
nre : RegexMatch
register:
asyncdispatch : register(fd: AsyncFD)
asyncio : register(d: Dispatcher; sock: AsyncSocket): Delegate
asyncio : register(d: Dispatcher; deleg: Delegate)
fsmonitor : register(d: Dispatcher; monitor: FSMonitor; handleEvent: proc (m: FSMonitor; ev: MonitorEvent))
ftpclient : register(d: Dispatcher; ftp: AsyncFtpClient): Delegate
httpserver : register(d: Dispatcher; s: PAsyncHTTPServer)
mimetypes : register(mimedb: var MimeDB; ext: string; mimetype: string)
scgi : register(d: Dispatcher; s: AsyncScgiState): Delegate
selectors : register(s: Selector; fd: SocketHandle; events: set[Event]; data: SelectorData): SelectorKey
registerWaitForSingleObject:
winlean : registerWaitForSingleObject(phNewWaitObject: ptr Handle; hObject: Handle; Callback: WAITORTIMERCALLBACK; Context: pointer; dwMilliseconds: ULONG; dwFlags: ULONG): bool
reHex:
re : reHex
reIdentifier:
re : reIdentifier
reInteger:
re : reInteger
release:
locks : release(lock: var Lock)
rlocks : release(lock: var RLock)
releaseEvents:
dom : releaseEvents*(d: Document; eventMask: int)
dom : releaseEvents*(w: Window; eventMask: int)
reload:
dom : reload*(loc: Location)
remove:
dom : remove*(c: ClassList; class: cstring)
lists : remove[T](L: var DoublyLinkedList[T]; n: DoublyLinkedNode[T])
lists : remove[T](L: var DoublyLinkedRing[T]; n: DoublyLinkedNode[T])
removeAttribute:
dom : removeAttribute*(n: Node; attr: cstring)
dom : removeAttribute*(s: Style; attr: cstring; caseSensitive = false)
xmldom : removeAttribute(el: PElement; name: string)
removeAttributeNode:
dom : removeAttributeNode*(n, attr: Node)
xmldom : removeAttributeNode(el: PElement; oldAttr: PAttr): PAttr
removeAttributeNS:
xmldom : removeAttributeNS(el: PElement; namespaceURI: string; localName: string)
removeChild:
dom : removeChild*(n, child: Node)
xmldom : removeChild(n: PNode; oldChild: PNode): PNode
removeDir:
asyncftpclient : removeDir(ftp: AsyncFtpClient; dir: string): Future[void]
os : removeDir(dir: string)
removeDirectoryW:
winlean : removeDirectoryW(lpPathName: WideCString): int32
removeFile:
asyncftpclient : removeFile(ftp: AsyncFtpClient; filename: string): Future[void]
os : removeFile(file: string)
removeHandler:
events : removeHandler(handler: var EventHandler; fn: proc (e: EventArgs))
removeNamedItem:
xmldom : removeNamedItem(nList: var seq[PNode]; name: string): PNode
removeNamedItemNS:
xmldom : removeNamedItemNS(nList: var seq[PNode]; namespaceURI: string; localName: string): PNode
removeSuffix:
strutils : removeSuffix(s: var string; c: char)
strutils : removeSuffix(s: var string; chars: set[char] = Newlines)
strutils : removeSuffix(s: var string; suffix: string)
rename:
asyncftpclient : rename(ftp: AsyncFtpClient; nameFrom: string; nameTo: string): Future[void]
reNatural:
re : reNatural
renderIndexTerm:
rstgen : renderIndexTerm(d: PDoc; n: PRstNode; result: var string)
renderRstToJson:
rstast : renderRstToJson(node: PRstNode): string
renderRstToOut:
rstgen : renderRstToOut(d: var RstGenerator; n: PRstNode; result: var string)
renderRstToRst:
rstast : renderRstToRst(n: PRstNode; result: var string)
renderSQL:
parsesql : renderSQL(n: SqlNode): string
renderTocEntries:
rstgen : renderTocEntries(d: var RstGenerator; j: var int; lvl: int; result: var string)
reOctal:
re : reOctal
reopen:
system : reopen(f: File; filename: string; mode: FileMode = fmRead): bool
system : 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
repeatChar:
strutils : repeatChar(count: Natural; c: char = ' '): string
repeatStr:
strutils : repeatStr(count: Natural; s: string): string
replace:
dom : replace*(loc: Location; s: 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)
xmldom : replaceChild(n: PNode; newChild: PNode; oldChild: PNode): PNode
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
reply:
actors : reply[In, Out](t: Task[In, Out]; m: Out)
ReplyError:
ftpclient : ReplyError
smtp : ReplyError
repr:
system : repr[T](x: T): string
Request:
asynchttpserver : Request
request:
httpclient : request(client: AsyncHttpClient; url: string; httpMethod = HttpGET; body = ""; headers: HttpHeaders = nil): Future[Response]
httpclient : request(client: AsyncHttpClient; url: string; httpMethod: string; body = ""; headers: HttpHeaders = nil): Future[Response]
httpclient : request(client: HttpClient; url: string; httpMethod = HttpGET; body = ""; headers: HttpHeaders = nil): Response
httpclient : request(client: HttpClient; url: string; httpMethod: string; body = ""; headers: HttpHeaders = nil): Response
httpclient : request(url: string; httpMethod = httpGET; extraHeaders = ""; body = ""; sslContext = defaultSSLContext; timeout = - 1; userAgent = defUserAgent; proxy: Proxy = nil): Response
httpclient : request(url: string; httpMethod: string; extraHeaders = ""; body = ""; sslContext = defaultSSLContext; timeout = - 1; userAgent = defUserAgent; proxy: Proxy = nil): Response
RequestMethod:
cgi : RequestMethod
require:
unittest : require(conditions: untyped)
requires:
nimscript : requires(deps: varargs[string])
requiresData:
nimscript : requiresData
ReraiseError:
system : ReraiseError
reset:
dom : reset*(f: FormElement)
system : reset[T](obj: var T)
resetAttributes:
terminal : resetAttributes()
terminal : resetAttributes(f: File)
resize:
system : resize[T](p: ptr T; newSize: Natural): ptr T
resizeBy:
dom : resizeBy*(w: Window; x, y: int)
resizeShared:
system : resizeShared[T](p: ptr T; newSize: Natural): ptr T
resizeTo:
dom : resizeTo*(w: Window; x, y: int)
resource:
Module system
ResourceExhaustedError:
system : ResourceExhaustedError
respond:
asynchttpserver : respond(req: Request; code: HttpCode; content: string; headers: HttpHeaders = nil): Future[ void]
Response:
httpclient : Response
reStructuredText:
Module rst
Module rstast
Module rstgen
resume:
osproc : resume(p: Process)
resumeThread:
winlean : resumeThread(hThread: Handle): int32
retrFile:
asyncftpclient : retrFile(ftp: AsyncFtpClient; file, dest: string; onProgressChanged: ProgressChangedProc = defaultOnProgressChanged): Future[ void]
ftpclient : retrFile[T](ftp: FtpBase[T]; file, dest: string; async = false)
retrText:
asyncftpclient : retrText(ftp: AsyncFtpClient; file: string): Future[string]
ftpclient : retrText[T](ftp: FtpBase[T]; file: string; async = false): string
reURL:
re : reURL
reverse:
algorithm : reverse[T](a: var openArray[T])
algorithm : reverse[T](a: var openArray[T]; first, last: Natural)
reversed:
algorithm : reversed[T](a: openArray[T]): seq[T]
algorithm : reversed[T](a: openArray[T]; first: Natural; last: int): seq[T]
unicode : reversed(s: string): string
rewinddir:
posix : rewinddir(a1: ptr DIR)
rfind:
strutils : rfind(s: string; sub: char; start: int = - 1): int
strutils : rfind(s, sub: string; start: int = - 1): int
rgb:
colors : rgb(r, g, b: range[0 .. 255]): Color
rightSize:
sets : rightSize(count: Natural): int
tables : rightSize(count: Natural): int
RLock:
rlocks : RLock
rmDir:
nimscript : rmDir(dir: string)
rmdir:
posix : rmdir(a1: cstring): cint
rmFile:
nimscript : rmFile(file: string)
R_OK:
posix : R_OK
RollingFileLogger:
logging : RollingFileLogger
roof:
Module system
RootEffect:
system : RootEffect
RootObj:
system : RootObj
RootRef:
system : RootRef
Rope:
ropes : Rope
rope:
ropes : rope(f: BiggestFloat): Rope
ropes : rope(i: BiggestInt): Rope
ropes : rope(s: string): Rope
Module ropes
rotate:
basic2d : rotate(rad: float): Matrix2d
basic2d : rotate(rad: float; org: Point2d): Matrix2d
basic2d : rotate(p: var Point2d; rad: float)
basic2d : rotate(p: var Point2d; rad: float; org: Point2d)
basic2d : rotate(v: var Vector2d; rad: float)
basic3d : rotate(angle: float; org: Point3d; axis: Vector3d): Matrix3d
basic3d : rotate(angle: float; axis: Vector3d): Matrix3d
basic3d : rotate(p: var Point3d; angle: float; org: Point3d; axis: Vector3d)
basic3d : rotate(p: var Point3d; rad: float; axis: Vector3d)
basic3d : rotate(vec: var Vector3d; angle: float; axis: Vector3d)
rotate180:
basic2d : rotate180(v: var Vector2d)
rotate270:
basic2d : rotate270(v: var Vector2d)
rotate90:
basic2d : rotate90(v: var Vector2d)
rotateX:
basic3d : rotateX(angle: float): Matrix3d
rotateY:
basic3d : rotateY(angle: float): Matrix3d
rotateZ:
basic3d : rotateZ(angle: float): Matrix3d
round:
math : round[T: float32 | float64](x: T; places: int = 0): T
routeEvent:
dom : routeEvent*(d: Document; event: Event)
dom : routeEvent*(w: Window; event: Event)
RoutineNodes:
macros : RoutineNodes
Row:
db_mysql : Row
db_postgres : Row
db_sqlite : Row
rowEntry:
parsecsv : rowEntry(my: var CsvParser; entry: string): string
rows:
db_mysql : rows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
db_postgres : rows(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): Row
db_postgres : rows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
db_sqlite : rows(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row
rpartition:
strmisc : rpartition(s: string; sep: string): (string, string, string)
rsplit:
strutils : rsplit(s: string; sep: char; maxsplit: int = - 1): seq[string]
strutils : rsplit(s: string; seps: set[char] = Whitespace; maxsplit: int = - 1): seq[string]
strutils : rsplit(s: string; sep: string; maxsplit: int = - 1): seq[string]
strutils : rsplit(s: string; sep: char; maxsplit: int = - 1): string
strutils : rsplit(s: string; seps: set[char] = Whitespace; maxsplit: int = - 1): string
strutils : rsplit(s: string; sep: string; maxsplit: int = - 1; keepSeparators: bool = false): string
RstGenerator:
rstgen : RstGenerator
RstNode:
rstast : RstNode
RstNodeKind:
rstast : RstNodeKind
RstNodeSeq:
rstast : RstNodeSeq
rstnodeToRefname:
rst : rstnodeToRefname(n: PRstNode): string
rstParse:
rst : rstParse(text, filename: string; line, column: int; hasToc: var bool; options: RstParseOptions; findFile: FindFileHandler = nil; msgHandler: MsgHandler = nil): PRstNode
RstParseOption:
rst : RstParseOption
RstParseOptions:
rst : RstParseOptions
rstToHtml:
rstgen : rstToHtml(s: string; options: RstParseOptions; config: StringTableRef): string
RTLD_GLOBAL:
posix : RTLD_GLOBAL
RTLD_LAZY:
posix : RTLD_LAZY
RTLD_LOCAL:
posix : RTLD_LOCAL
RTLD_NOW:
posix : RTLD_NOW
RTTI:
Module typeinfo
run:
coro : run()
httpserver : run(handleRequest: proc (client: Socket; path, query: string): bool; port = Port(80))
scgi : run(handleRequest: proc (client: Socket; input: string; headers: StringTableRef): bool; port = Port(4000))
Rune:
unicode : Rune
Rune16:
unicode : Rune16
runeAt:
unicode : runeAt(s: string; i: Natural): Rune
runeAtPos:
unicode : runeAtPos(s: string; pos: int): Rune
RuneImpl:
unicode : RuneImpl
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
runForever:
asyncdispatch : runForever()
running:
actors : running[In, Out](a: PActor[In, Out]): bool
osproc : running(p: Process): bool
threads : running*[TArg](t: Thread[TArg]): bool
RunningRegress:
stats : RunningRegress
RunningStat:
stats : RunningStat
runtime type information:
Module typeinfo
safeAdd:
system : safeAdd[T](x: var seq[T]; y: T)
system : safeAdd(x: var string; y: char)
system : safeAdd(x: var string; y: string)
sameFile:
os : sameFile(path1, path2: string): bool
sameFileContent:
os : sameFileContent(path1, path2: string): bool
sameType:
macros : sameType(a, b: NimNode): bool
samp:
htmlgen : samp(e: varargs[untyped]): untyped
SA_NOCLDSTOP:
posix : SA_NOCLDSTOP
SA_NOCLDWAIT:
posix : SA_NOCLDWAIT
SA_NODEFER:
posix : SA_NODEFER
SA_ONSTACK:
posix : SA_ONSTACK
SA_RESETHAND:
posix : SA_RESETHAND
SA_RESTART:
posix : SA_RESTART
SA_SIGINFO:
posix : SA_SIGINFO
SC_2_C_BIND:
posix : SC_2_C_BIND
SC_2_C_DEV:
posix : SC_2_C_DEV
SC_2_CHAR_TERM:
posix : SC_2_CHAR_TERM
SC_2_FORT_DEV:
posix : SC_2_FORT_DEV
SC_2_FORT_RUN:
posix : SC_2_FORT_RUN
SC_2_LOCALEDEF:
posix : SC_2_LOCALEDEF
SC_2_PBS:
posix : SC_2_PBS
SC_2_PBS_ACCOUNTING:
posix : SC_2_PBS_ACCOUNTING
SC_2_PBS_CHECKPOINT:
posix : SC_2_PBS_CHECKPOINT
SC_2_PBS_LOCATE:
posix : SC_2_PBS_LOCATE
SC_2_PBS_MESSAGE:
posix : SC_2_PBS_MESSAGE
SC_2_PBS_TRACK:
posix : SC_2_PBS_TRACK
SC_2_SW_DEV:
posix : SC_2_SW_DEV
SC_2_UPE:
posix : SC_2_UPE
SC_2_VERSION:
posix : SC_2_VERSION
SC_ADVISORY_INFO:
posix : SC_ADVISORY_INFO
SC_AIO_LISTIO_MAX:
posix : SC_AIO_LISTIO_MAX
SC_AIO_MAX:
posix : SC_AIO_MAX
SC_AIO_PRIO_DELTA_MAX:
posix : SC_AIO_PRIO_DELTA_MAX
scale:
basic2d : scale(s: float): Matrix2d
basic2d : scale(s: float; org: Point2d): Matrix2d
basic2d : scale(p: var Point2d; fac: float)
basic2d : scale(p: var Point2d; fac: float; org: Point2d)
basic2d : scale(v: var Vector2d; fac: float)
basic3d : scale(s: float): Matrix3d
basic3d : scale(s: float; org: Point3d): Matrix3d
basic3d : scale(p: var Point3d; fac: float)
basic3d : scale(p: var Point3d; fac: float; org: Point3d)
basic3d : scale(v: var Vector3d; s: float)
scanf:
strscans : scanf[](input: string; pattern: static[string]; results: varargs[typed]): bool
Module strscans
scanp:
strscans : scanp(input, idx: typed; pattern: varargs[untyped]): bool
SC_ARG_MAX:
posix : SC_ARG_MAX
SC_ASYNCHRONOUS_IO:
posix : SC_ASYNCHRONOUS_IO
SC_ATEXIT_MAX:
posix : SC_ATEXIT_MAX
SC_BARRIERS:
posix : SC_BARRIERS
SC_BC_BASE_MAX:
posix : SC_BC_BASE_MAX
SC_BC_DIM_MAX:
posix : SC_BC_DIM_MAX
SC_BC_SCALE_MAX:
posix : SC_BC_SCALE_MAX
SC_BC_STRING_MAX:
posix : SC_BC_STRING_MAX
SC_CHILD_MAX:
posix : SC_CHILD_MAX
SC_CLK_TCK:
posix : SC_CLK_TCK
SC_CLOCK_SELECTION:
posix : SC_CLOCK_SELECTION
SC_COLL_WEIGHTS_MAX:
posix : SC_COLL_WEIGHTS_MAX
SC_CPUTIME:
posix : SC_CPUTIME
SC_DELAYTIMER_MAX:
posix : SC_DELAYTIMER_MAX
SC_EXPR_NEST_MAX:
posix : SC_EXPR_NEST_MAX
SC_FSYNC:
posix : SC_FSYNC
SC_GETGR_R_SIZE_MAX:
posix : SC_GETGR_R_SIZE_MAX
SC_GETPW_R_SIZE_MAX:
posix : SC_GETPW_R_SIZE_MAX
ScgiError:
scgi : ScgiError
ScgiState:
scgi : ScgiState
SCHED_FIFO:
posix : SCHED_FIFO
sched_getparam:
posix : sched_getparam(a1: Pid; a2: var Sched_param): cint
sched_get_priority_max:
posix : sched_get_priority_max(a1: cint): cint
sched_get_priority_min:
posix : sched_get_priority_min(a1: cint): cint
sched_getscheduler:
posix : sched_getscheduler(a1: Pid): cint
SCHED_OTHER:
posix : SCHED_OTHER
Sched_param:
posix : Sched_param
SCHED_RR:
posix : SCHED_RR
sched_rr_get_interval:
posix : sched_rr_get_interval(a1: Pid; a2: var Timespec): cint
sched_setparam:
posix : sched_setparam(a1: Pid; a2: var Sched_param): cint
sched_setscheduler:
posix : sched_setscheduler(a1: Pid; a2: cint; a3: var Sched_param): cint
SCHED_SPORADIC:
posix : SCHED_SPORADIC
sched_yield:
posix : sched_yield(): cint
SC_HOST_NAME_MAX:
posix : SC_HOST_NAME_MAX
SC_IOV_MAX:
posix : SC_IOV_MAX
SC_IPV6:
posix : SC_IPV6
SC_JOB_CONTROL:
posix : SC_JOB_CONTROL
SC_LINE_MAX:
posix : SC_LINE_MAX
SC_LOGIN_NAME_MAX:
posix : SC_LOGIN_NAME_MAX
SC_MAPPED_FILES:
posix : SC_MAPPED_FILES
SC_MEMLOCK:
posix : SC_MEMLOCK
SC_MEMLOCK_RANGE:
posix : SC_MEMLOCK_RANGE
SC_MEMORY_PROTECTION:
posix : SC_MEMORY_PROTECTION
SC_MESSAGE_PASSING:
posix : SC_MESSAGE_PASSING
SC_MONOTONIC_CLOCK:
posix : SC_MONOTONIC_CLOCK
SC_MQ_OPEN_MAX:
posix : SC_MQ_OPEN_MAX
SC_MQ_PRIO_MAX:
posix : SC_MQ_PRIO_MAX
SCM_RIGHTS:
posix : SCM_RIGHTS
SC_NGROUPS_MAX:
posix : SC_NGROUPS_MAX
SC_NPROCESSORS_ONLN:
posix : SC_NPROCESSORS_ONLN
SC_OPEN_MAX:
posix : SC_OPEN_MAX
SC_PAGE_SIZE:
posix : SC_PAGE_SIZE
SC_PRIORITIZED_IO:
posix : SC_PRIORITIZED_IO
SC_PRIORITY_SCHEDULING:
posix : SC_PRIORITY_SCHEDULING
SC_RAW_SOCKETS:
posix : SC_RAW_SOCKETS
SC_READER_WRITER_LOCKS:
posix : SC_READER_WRITER_LOCKS
SC_REALTIME_SIGNALS:
posix : SC_REALTIME_SIGNALS
SC_RE_DUP_MAX:
posix : SC_RE_DUP_MAX
screen:
dom : screen
SC_REGEXP:
posix : SC_REGEXP
script:
htmlgen : script(e: varargs[untyped]): untyped
ScriptExt:
os : ScriptExt
ospaths : ScriptExt
ScriptMode:
nimscript : ScriptMode
scrollBy:
dom : scrollBy*(w: Window; x, y: int)
scrollIntoView:
dom : scrollIntoView*(n: Node)
scrollTo:
dom : scrollTo*(w: Window; x, y: int)
SC_RTSIG_MAX:
posix : SC_RTSIG_MAX
SC_SAVED_IDS:
posix : SC_SAVED_IDS
SC_SEMAPHORES:
posix : SC_SEMAPHORES
SC_SEM_NSEMS_MAX:
posix : SC_SEM_NSEMS_MAX
SC_SEM_VALUE_MAX:
posix : SC_SEM_VALUE_MAX
SC_SHARED_MEMORY_OBJECTS:
posix : SC_SHARED_MEMORY_OBJECTS
SC_SHELL:
posix : SC_SHELL
SC_SIGQUEUE_MAX:
posix : SC_SIGQUEUE_MAX
SC_SPAWN:
posix : SC_SPAWN
SC_SPIN_LOCKS:
posix : SC_SPIN_LOCKS
SC_SPORADIC_SERVER:
posix : SC_SPORADIC_SERVER
SC_SS_REPL_MAX:
posix : SC_SS_REPL_MAX
SC_STREAM_MAX:
posix : SC_STREAM_MAX
SC_SYMLOOP_MAX:
posix : SC_SYMLOOP_MAX
SC_SYNCHRONIZED_IO:
posix : SC_SYNCHRONIZED_IO
SC_THREAD_ATTR_STACKADDR:
posix : SC_THREAD_ATTR_STACKADDR
SC_THREAD_ATTR_STACKSIZE:
posix : SC_THREAD_ATTR_STACKSIZE
SC_THREAD_CPUTIME:
posix : SC_THREAD_CPUTIME
SC_THREAD_DESTRUCTOR_ITERATIONS:
posix : SC_THREAD_DESTRUCTOR_ITERATIONS
SC_THREAD_KEYS_MAX:
posix : SC_THREAD_KEYS_MAX
SC_THREAD_PRIO_INHERIT:
posix : SC_THREAD_PRIO_INHERIT
SC_THREAD_PRIO_PROTECT:
posix : SC_THREAD_PRIO_PROTECT
SC_THREAD_PRIORITY_SCHEDULING:
posix : SC_THREAD_PRIORITY_SCHEDULING
SC_THREAD_PROCESS_SHARED:
posix : SC_THREAD_PROCESS_SHARED
SC_THREADS:
posix : SC_THREADS
SC_THREAD_SAFE_FUNCTIONS:
posix : SC_THREAD_SAFE_FUNCTIONS
SC_THREAD_SPORADIC_SERVER:
posix : SC_THREAD_SPORADIC_SERVER
SC_THREAD_STACK_MIN:
posix : SC_THREAD_STACK_MIN
SC_THREAD_THREADS_MAX:
posix : SC_THREAD_THREADS_MAX
SC_TIMEOUTS:
posix : SC_TIMEOUTS
SC_TIMER_MAX:
posix : SC_TIMER_MAX
SC_TIMERS:
posix : SC_TIMERS
SC_TRACE:
posix : SC_TRACE
SC_TRACE_EVENT_FILTER:
posix : SC_TRACE_EVENT_FILTER
SC_TRACE_EVENT_NAME_MAX:
posix : SC_TRACE_EVENT_NAME_MAX
SC_TRACE_INHERIT:
posix : SC_TRACE_INHERIT
SC_TRACE_LOG:
posix : SC_TRACE_LOG
SC_TRACE_NAME_MAX:
posix : SC_TRACE_NAME_MAX
SC_TRACE_SYS_MAX:
posix : SC_TRACE_SYS_MAX
SC_TRACE_USER_EVENT_MAX:
posix : SC_TRACE_USER_EVENT_MAX
SC_TTY_NAME_MAX:
posix : SC_TTY_NAME_MAX
SC_TYPED_MEMORY_OBJECTS:
posix : SC_TYPED_MEMORY_OBJECTS
SC_TZNAME_MAX:
posix : SC_TZNAME_MAX
SC_V6_ILP32_OFF32:
posix : SC_V6_ILP32_OFF32
SC_V6_ILP32_OFFBIG:
posix : SC_V6_ILP32_OFFBIG
SC_V6_LP64_OFF64:
posix : SC_V6_LP64_OFF64
SC_V6_LPBIG_OFFBIG:
posix : SC_V6_LPBIG_OFFBIG
SC_VERSION:
posix : SC_VERSION
SC_XBS5_ILP32_OFF32:
posix : SC_XBS5_ILP32_OFF32
SC_XBS5_ILP32_OFFBIG:
posix : SC_XBS5_ILP32_OFFBIG
SC_XBS5_LP64_OFF64:
posix : SC_XBS5_LP64_OFF64
SC_XBS5_LPBIG_OFFBIG:
posix : SC_XBS5_LPBIG_OFFBIG
SC_XOPEN_CRYPT:
posix : SC_XOPEN_CRYPT
SC_XOPEN_ENH_I18N:
posix : SC_XOPEN_ENH_I18N
SC_XOPEN_LEGACY:
posix : SC_XOPEN_LEGACY
SC_XOPEN_REALTIME:
posix : SC_XOPEN_REALTIME
SC_XOPEN_REALTIME_THREADS:
posix : SC_XOPEN_REALTIME_THREADS
SC_XOPEN_SHM:
posix : SC_XOPEN_SHM
SC_XOPEN_STREAMS:
posix : SC_XOPEN_STREAMS
SC_XOPEN_UNIX:
posix : SC_XOPEN_UNIX
SC_XOPEN_VERSION:
posix : SC_XOPEN_VERSION
sec:
complex : sec(z: Complex): Complex
sech:
complex : sech(z: Complex): Complex
seconds:
times : seconds(s: int): TimeInterval
SecureHash:
securehash : SecureHash
secureHash:
securehash : secureHash(str: string): SecureHash
secureHashFile:
securehash : secureHashFile(filename: string): SecureHash
SecureSocket:
ssl : SecureSocket
SECURITY_ATTRIBUTES:
winlean : SECURITY_ATTRIBUTES
SEEK_CUR:
posix : SEEK_CUR
seekdir:
posix : seekdir(a1: ptr DIR; a2: int)
SEEK_END:
posix : SEEK_END
SEEK_SET:
posix : SEEK_SET
select:
dom : select*(e: Element)
htmlgen : select(e: varargs[untyped]): untyped
nativesockets : select(readfds: var seq[SocketHandle]; timeout = 500): int
osproc : select(readfds: var seq[Process]; timeout = 500): int
posix : select[](a1: cint | SocketHandle; a2, a3, a4: ptr TFdSet; a5: ptr Timeval): cint
selectors : select(s: Selector; timeout: int): seq[ReadyInfo]
winlean : select(nfds: cint; readfds, writefds, exceptfds: ptr TFdSet; timeout: ptr Timeval): cint
Selector:
selectors : Selector
SelectorData:
selectors : SelectorData
SelectorKey:
selectors : SelectorKey
selectWrite:
nativesockets : selectWrite(writefds: var seq[SocketHandle]; timeout = 500): int
selfExe:
nimscript : selfExe(): string
selfExec:
nimscript : selfExec(command: string)
Sem:
posix : Sem
sem_close:
posix : sem_close(a1: ptr Sem): cint
sem_destroy:
posix : sem_destroy(a1: ptr Sem): cint
SEM_FAILED:
posix : SEM_FAILED
sem_getvalue:
posix : sem_getvalue(a1: ptr Sem; a2: var cint): cint
sem_init:
posix : sem_init(a1: ptr Sem; a2: cint; a3: cint): cint
sem_open:
posix : sem_open(a1: cstring; a2: cint): ptr Sem
sem_post:
posix : sem_post(a1: ptr Sem): cint
sem_timedwait:
posix : sem_timedwait(a1: ptr Sem; a2: ptr Timespec): cint
sem_trywait:
posix : sem_trywait(a1: ptr Sem): cint
sem_unlink:
posix : sem_unlink(a1: cstring): cint
sem_wait:
posix : sem_wait(a1: ptr Sem): cint
send:
actors : send[In, Out, X, Y](receiver: PActor[In, Out]; msg: In; sender: PActor[X, Y])
actors : send[In, Out](receiver: PActor[In, Out]; msg: In; sender: ptr Channel[Out] = nil)
asyncdispatch : send(socket: AsyncFD; buf: pointer; size: int; flags = {SafeDisconn}): Future[void]
asyncdispatch : send(socket: AsyncFD; data: string; flags = {SafeDisconn}): Future[void]
asyncftpclient : send(ftp: AsyncFtpClient; m: string): Future[TaintedString]
asyncio : send(sock: AsyncSocket; data: string)
asyncnet : send(socket: AsyncSocket; buf: pointer; size: int; flags = {SafeDisconn}): Future[void]
asyncnet : send(socket: AsyncSocket; data: string; flags = {SafeDisconn}): Future[void]
channels : send*[TMsg](c: var Channel[TMsg]; msg: TMsg)
ftpclient : send[T](ftp: FtpBase[T]; m: string): TaintedString
net : send(socket: Socket; data: pointer; size: int): int
net : send(socket: Socket; data: string; flags = {SafeDisconn})
posix : send(a1: SocketHandle; a2: pointer; a3: int; a4: cint): int
ssl : send(sock: SecureSocket; data: string)
winlean : send(s: SocketHandle; buf: pointer; len, flags: cint): cint
sendHeaders:
asynchttpserver : sendHeaders(req: Request; headers: HttpHeaders): Future[void]
sendMail:
smtp : sendMail(smtp: AsyncSmtp; fromAddr: string; toAddrs: seq[string]; msg: string): Future[ void]
sendmail:
smtp : sendmail(smtp: var Smtp; fromaddr: string; toaddrs: seq[string]; msg: string)
sendmsg:
posix : sendmsg(a1: SocketHandle; a2: ptr Tmsghdr; a3: cint): int
sendShutdown:
actors : sendShutdown[In, Out](receiver: PActor[In, Out])
sendTo:
asyncdispatch : sendTo(socket: AsyncFD; data: pointer; size: int; saddr: ptr SockAddr; saddrLen: SockLen; flags = {SafeDisconn}): Future[void]
net : sendTo(socket: Socket; address: string; port: Port; data: pointer; size: int; af: Domain = AF_INET; flags = 0'i32): int
net : sendTo(socket: Socket; address: string; port: Port; data: string): int
sendto:
posix : sendto(a1: SocketHandle; a2: pointer; a3: int; a4: cint; a5: ptr SockAddr; a6: Socklen): int
winlean : sendto(s: SocketHandle; buf: pointer; len, flags: cint; to: ptr SockAddr; tolen: SockLen): cint
seq:
Module sequtils
system : seq
sequence:
pegs : sequence(a: varargs[Peg]): Peg
serialization:
Module marshal
serve:
asynchttpserver : serve(server: AsyncHttpServer; port: Port; callback: proc (request: Request): Future[void]; address = ""): Future[void]
serveFile:
httpserver : serveFile(client: Socket; filename: string)
Servent:
nativesockets : Servent
posix : Servent
winlean : Servent
Server:
httpserver : Server
serverGetPskFunc:
net : serverGetPskFunc(ctx: SslContext): SslServerGetPskFunc
serverGetPskFunc=:
net : serverGetPskFunc=(ctx: SslContext; fun: SslServerGetPskFunc)
set:
system : set
setAttribute:
dom : setAttribute*(n: Node; name, value: cstring)
dom : setAttribute*(s: Style; attr, value: cstring; caseSensitive = false)
xmldom : setAttribute(el: PElement; name: string; value: string)
setAttributeNode:
dom : setAttributeNode*(n: Node; attr: Node)
xmldom : setAttributeNode(el: PElement; newAttr: PAttr): PAttr
setAttributeNodeNS:
xmldom : setAttributeNodeNS(el: PElement; newAttr: PAttr): PAttr
setAttributeNS:
xmldom : setAttributeNS(el: PElement; namespaceURI, localName, value: string)
setBackgroundColor:
terminal : setBackgroundColor(f: File; bg: BackgroundColor; bright = false)
terminal : setBackgroundColor(bg: BackgroundColor; bright = false)
setBiggestFloat:
typeinfo : setBiggestFloat(x: Any; y: BiggestFloat)
setBiggestInt:
typeinfo : setBiggestInt(x: Any; y: BiggestInt)
setBiggestUint:
typeinfo : setBiggestUint(x: Any; y: uint64)
setBlocking:
nativesockets : setBlocking(s: SocketHandle; blocking: bool)
setCommand:
nimscript : setCommand(cmd: string; project = "")
setcontext:
posix : setcontext(a1: var Ucontext): cint
setControlCHook:
system : setControlCHook(hook: proc () not nil)
system : setControlCHook(hook: proc () not nil)
setCookie:
cgi : setCookie(name, value: string)
cookies : setCookie(key, value: string; domain = ""; path = ""; expires = ""; noName = false; secure = false; httpOnly = false): string
cookies : setCookie(key, value: string; expires: TimeInfo; domain = ""; path = ""; noName = false; secure = false; httpOnly = false): string
setCurrentDir:
os : setCurrentDir(newDir: string)
setCurrentDirectoryW:
winlean : setCurrentDirectoryW(lpPathName: WideCString): int32
setCurrentException:
system : setCurrentException(exc: ref Exception)
setCursorPos:
terminal : setCursorPos(f: File; x, y: int)
terminal : setCursorPos(x, y: int)
setCursorXPos:
terminal : setCursorXPos(f: File; x: int)
terminal : setCursorXPos(x: int)
setegid:
posix : setegid(a1: Gid): cint
setElements:
basic2d : setElements(t: var Matrix2d; ax, ay, bx, by, tx, ty: float)
basic3d : setElements(t: var Matrix3d; ax, ay, az, aw, bx, by, bz, bw, cx, cy, cz, cw, tx, ty, tz, tw: float)
setEncoding:
db_mysql : 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
seteuid:
posix : seteuid(a1: Uid): cint
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])
setFilePointer:
winlean : setFilePointer(hFile: Handle; lDistanceToMove: LONG; lpDistanceToMoveHigh: ptr LONG; dwMoveMethod: DWORD): DWORD
setFilePos:
asyncfile : setFilePos(f: AsyncFile; pos: int64)
system : setFilePos(f: File; pos: int64; relativeTo: FileSeekPos = fspSet)
system : setFilePos(f: File; pos: int64; relativeTo: FileSeekPos = fspSet)
setForegroundColor:
terminal : setForegroundColor(f: File; fg: ForegroundColor; bright = false)
terminal : setForegroundColor(fg: ForegroundColor; bright = false)
setFrame:
system : setFrame(s: PFrame)
setgid:
posix : setgid(a1: Gid): cint
setgrent:
posix : setgrent()
setHandleWrite:
asyncio : setHandleWrite(s: AsyncSocket; handleWrite: proc (s: AsyncSocket))
sethostent:
posix : sethostent(a1: cint)
setIndexTerm:
rstgen : setIndexTerm(d: var RstGenerator; id, term: string; linkTitle, linkDesc = "")
setInterval:
dom : setInterval*(w: Window; code: cstring; pause: int): ref TInterval
dom : setInterval*(w: Window; function: proc (); pause: int): ref TInterval
setLastError:
winlean : setLastError(error: int32)
setLen:
system : setLen[T](s: var seq[T]; newlen: Natural)
system : setLen(s: var string; newlen: Natural)
setlocale:
posix : setlocale(a1: cint; a2: cstring): cstring
setLogFilter:
logging : setLogFilter(lvl: Level)
setMaxPoolSize:
threadpool : setMaxPoolSize(size: range[1 .. MaxThreadPoolSize])
setMinPoolSize:
threadpool : setMinPoolSize(size: range[1 .. MaxThreadPoolSize])
setNamedItem:
xmldom : setNamedItem(nList: var seq[PAttr]; arg: PAttr): PAttr
xmldom : setNamedItem(nList: var seq[PNode]; arg: PNode): PNode
setNamedItemNS:
xmldom : setNamedItemNS(nList: var seq[PAttr]; arg: PAttr): PAttr
xmldom : setNamedItemNS(nList: var seq[PNode]; arg: PNode): PNode
setnetent:
posix : setnetent(a1: cint)
setObjectRuntimeType:
typeinfo : setObjectRuntimeType(x: Any)
setpgid:
posix : setpgid(a1, a2: Pid): cint
setpgrp:
posix : setpgrp(): Pid
setPointer:
typeinfo : setPointer(x: Any; y: pointer)
setPosition:
streams : setPosition(s: Stream; pos: int)
streams : setPosition(s, unused: Stream; pos: int)
setprotoent:
posix : setprotoent(a1: cint)
setpwent:
posix : setpwent()
setregid:
posix : setregid(a1, a2: Gid): cint
setreuid:
posix : setreuid(a1, a2: Uid): cint
setSamplingFrequency:
nimprof : setSamplingFrequency(intervalInUs: int)
setSectionKey:
parsecfg : setSectionKey(dict: var Config; section, key, value: string)
setservent:
posix : setservent(a1: cint)
setsid:
posix : setsid(): Pid
setSockOpt:
asyncnet : setSockOpt(socket: AsyncSocket; opt: SOBool; value: bool; level = SOL_SOCKET)
net : setSockOpt(socket: Socket; opt: SOBool; value: bool; level = SOL_SOCKET)
setsockopt:
posix : setsockopt(a1: SocketHandle; a2, a3: cint; a4: pointer; a5: Socklen): cint
winlean : setsockopt(s: SocketHandle; level, optname: cint; optval: pointer; optlen: SockLen): cint
setSockOptInt:
nativesockets : setSockOptInt(socket: SocketHandle; level, optname, optval: int)
setStackTraceNewLine:
cgi : setStackTraceNewLine()
setStackTraceStdout:
cgi : setStackTraceStdout()
setStdHandle:
winlean : setStdHandle(nStdHandle: int32; hHandle: Handle): WINBOOL
setStdIoUnbuffered:
system : setStdIoUnbuffered()
system : setStdIoUnbuffered()
setString:
typeinfo : setString(x: Any; y: string)
setStyle:
terminal : setStyle(f: File; style: set[Style])
terminal : setStyle(style: set[Style])
setTestData:
cgi : setTestData(keysvalues: varargs[string])
setTimeout:
dom : setTimeout*(w: Window; code: cstring; pause: int): ref TTimeOut
dom : setTimeout*(w: Window; function: proc (); pause: int): ref TInterval
setuid:
posix : setuid(a1: Uid): cint
setupForeignThreadGc:
system : setupForeignThreadGc(): stmt
sgnArea:
basic2d : sgnArea(a, b, c: Point2d): float
Sha1State:
securehash : Sha1State
shallow:
system : shallow[T](s: var seq[T])
system : shallow(s: var string)
Module system
Module system
shallow copy:
Module system
shallowCopy:
system : shallowCopy[T](x: var T; y: T)
shared object:
Module os
Module ospaths
shell command:
Module os
shellExecuteW:
winlean : shellExecuteW(HWND: Handle; lpOperation, lpFile, lpParameters, lpDirectory: WideCString; nShowCmd: int32): Handle
shm_open:
posix : shm_open(a1: cstring; a2: cint; a3: Mode): cint
shm_unlink:
posix : shm_unlink(a1: cstring): cint
showCursor:
terminal : showCursor(f: File)
terminal : showCursor()
shuffle:
random : shuffle[T](x: var seq[T])
shutdown:
posix : shutdown(a1: SocketHandle; a2: cint): cint
winlean : shutdown(s: SocketHandle; how: cint): cint
SHUT_RD:
posix : SHUT_RD
SHUT_RDWR:
posix : SHUT_RDWR
SHUT_WR:
posix : SHUT_WR
S_IFBLK:
posix : S_IFBLK
S_IFCHR:
posix : S_IFCHR
S_IFDIR:
posix : S_IFDIR
S_IFIFO:
posix : S_IFIFO
S_IFLNK:
posix : S_IFLNK
S_IFMT:
posix : S_IFMT
S_IFREG:
posix : S_IFREG
S_IFSOCK:
posix : S_IFSOCK
SIGABRT:
posix : SIGABRT
Sigaction:
posix : Sigaction
sigaction:
posix : sigaction(a1: cint; a2, a3: var Sigaction): cint
sigaddset:
posix : sigaddset(a1: var Sigset; a2: cint): cint
SIGALRM:
posix : SIGALRM
sigaltstack:
posix : sigaltstack(a1, a2: var Stack): cint
Sig_atomic:
posix : Sig_atomic
SIG_BLOCK:
posix : SIG_BLOCK
SIGBUS:
posix : SIGBUS
SIGCHLD:
posix : SIGCHLD
SIGCONT:
posix : SIGCONT
sigdelset:
posix : sigdelset(a1: var Sigset; a2: cint): cint
SIG_DFL:
posix : SIG_DFL
sigemptyset:
posix : sigemptyset(a1: var Sigset): cint
SIG_ERR:
posix : SIG_ERR
SigEvent:
posix : SigEvent
SIGEV_NONE:
posix : SIGEV_NONE
SIGEV_SIGNAL:
posix : SIGEV_SIGNAL
SIGEV_THREAD:
posix : SIGEV_THREAD
sigfillset:
posix : sigfillset(a1: var Sigset): cint
SIGFPE:
posix : SIGFPE
sighold:
posix : sighold(a1: cint): cint
SIGHUP:
posix : SIGHUP
SIG_IGN:
posix : SIG_IGN
sigignore:
posix : sigignore(a1: cint): cint
SIGILL:
posix : SIGILL
SigInfo:
posix : SigInfo
SIGINT:
posix : SIGINT
siginterrupt:
posix : siginterrupt(a1, a2: cint): cint
sigismember:
posix : sigismember(a1: var Sigset; a2: cint): cint
SIGKILL:
posix : SIGKILL
signal:
locks : signal(cond: var Cond)
posix : signal(a1: cint; a2: proc (x: cint))
sigpause:
posix : sigpause(a1: cint): cint
sigpending:
posix : sigpending(a1: var Sigset): cint
SIGPIPE:
posix : SIGPIPE
SIGPOLL:
posix : SIGPOLL
sigprocmask:
posix : sigprocmask(a1: cint; a2, a3: var Sigset): cint
SIGPROF:
posix : SIGPROF
sigqueue:
posix : sigqueue(a1: Pid; a2: cint; a3: SigVal): cint
SIGQUIT:
posix : SIGQUIT
sigrelse:
posix : sigrelse(a1: cint): cint
SIGSEGV:
posix : SIGSEGV
Sigset:
posix : Sigset
sigset:
posix : sigset(a1: int; a2: proc (x: cint))
SIG_SETMASK:
posix : SIG_SETMASK
SigStack:
posix : SigStack
SIGSTKSZ:
posix : SIGSTKSZ
SIGSTOP:
posix : SIGSTOP
sigsuspend:
posix : sigsuspend(a1: var Sigset): cint
SIGSYS:
posix : SIGSYS
SIGTERM:
posix : SIGTERM
sigtimedwait:
posix : sigtimedwait(a1: var Sigset; a2: var SigInfo; a3: var Timespec): cint
SIGTRAP:
posix : SIGTRAP
SIGTSTP:
posix : SIGTSTP
SIGTTIN:
posix : SIGTTIN
SIGTTOU:
posix : SIGTTOU
SIG_UNBLOCK:
posix : SIG_UNBLOCK
SIGURG:
posix : SIGURG
SIGUSR1:
posix : SIGUSR1
SIGUSR2:
posix : SIGUSR2
SigVal:
posix : SigVal
SIGVTALRM:
posix : SIGVTALRM
sigwait:
posix : sigwait(a1: var Sigset; a2: var cint): cint
sigwaitinfo:
posix : sigwaitinfo(a1: var Sigset; a2: var SigInfo): cint
SIGXCPU:
posix : SIGXCPU
SIGXFSZ:
posix : SIGXFSZ
simple assertions:
Simple assertions
simpleGetOrDefault:
json : simpleGetOrDefault{{}(node, [key]) }(node: JsonNode; key: string): JsonNode
sin:
complex : sin(z: Complex): Complex
math : sin(x: float32): float32
math : sin(x: float64): float64
SingleTags:
htmlparser : SingleTags
SinglyLinkedList:
lists : SinglyLinkedList
SinglyLinkedNode:
lists : SinglyLinkedNode
SinglyLinkedNodeObj:
lists : SinglyLinkedNodeObj
SinglyLinkedRing:
lists : SinglyLinkedRing
sinh:
complex : sinh(z: Complex): Complex
math : sinh(x: float32): float32
math : sinh(x: float64): float64
SIO_GET_EXTENSION_FUNCTION_POINTER:
winlean : SIO_GET_EXTENSION_FUNCTION_POINTER
S_IRGRP:
posix : S_IRGRP
S_IROTH:
posix : S_IROTH
S_IRUSR:
posix : S_IRUSR
S_IRWXG:
posix : S_IRWXG
S_IRWXO:
posix : S_IRWXO
S_IRWXU:
posix : S_IRWXU
S_ISBLK:
posix : S_ISBLK(m: Mode): bool
S_ISCHR:
posix : S_ISCHR(m: Mode): bool
S_ISDIR:
posix : S_ISDIR(m: Mode): bool
S_ISFIFO:
posix : S_ISFIFO(m: Mode): bool
S_ISGID:
posix : S_ISGID
S_ISLNK:
posix : S_ISLNK(m: Mode): bool
S_ISREG:
posix : S_ISREG(m: Mode): bool
S_ISSOCK:
posix : S_ISSOCK(m: Mode): bool
S_ISUID:
posix : S_ISUID
S_ISVTX:
posix : S_ISVTX
S_IWGRP:
posix : S_IWGRP
S_IWOTH:
posix : S_IWOTH
S_IWUSR:
posix : S_IWUSR
S_IXGRP:
posix : S_IXGRP
S_IXOTH:
posix : S_IXOTH
S_IXUSR:
posix : S_IXUSR
size:
typeinfo : size(x: Any): int
sizeof:
system : sizeof[T](x: T): int
system : sizeof[](x: typedesc): int
skew:
basic2d : skew(xskew, yskew: float): Matrix2d
skewness:
stats : skewness[T](x: openArray[T]): float
stats : skewness(s: RunningStat): float
skewnessS:
stats : skewnessS[T](x: openArray[T]): float
stats : skewnessS(s: RunningStat): float
skip:
net : skip(socket: Socket; size: int; timeout = - 1)
parseutils : skip(s, token: string; start = 0): int
unittest : skip()
skipDirs:
nimscript : skipDirs
skipExt:
nimscript : skipExt
skipFiles:
nimscript : skipFiles
skipIgnoreCase:
parseutils : skipIgnoreCase(s, token: string; start = 0): int
skipRange:
typeinfo : skipRange(x: Any): Any
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)
posix : sleep(a1: cint): cint
winlean : sleep(dwMilliseconds: int32)
sleepAsync:
asyncdispatch : sleepAsync(ms: int): Future[void]
Slice:
system : Slice
slice:
Module system
Module system
slope:
stats : slope(r: RunningRegress): float
slopeVector2d:
basic2d : slopeVector2d(slope: float; len: float): Vector2d
slurp:
system : slurp(filename: string): string
small:
htmlgen : small(e: varargs[untyped]): untyped
smallest:
tables : smallest[A](t: CountTable[A]): tuple[key: A, val: int]
tables : smallest[A](t: CountTableRef[A]): (A, int)
smartBinarySearch:
algorithm : smartBinarySearch[T](a: openArray[T]; key: T): int
Smtp:
smtp : Smtp
SO_ACCEPTCONN:
posix : SO_ACCEPTCONN
winlean : SO_ACCEPTCONN
SOBool:
net : SOBool
SO_BROADCAST:
posix : SO_BROADCAST
winlean : SO_BROADCAST
SockAddr:
posix : SockAddr
winlean : SockAddr
Sockaddr_in:
posix : Sockaddr_in
winlean : Sockaddr_in
Sockaddr_in6:
posix : Sockaddr_in6
winlean : Sockaddr_in6
Sockaddr_in6_old:
winlean : Sockaddr_in6_old
Sockaddr_storage:
posix : Sockaddr_storage
Sockaddr_un:
posix : Sockaddr_un
Sockaddr_un_path_length:
posix : Sockaddr_un_path_length
sockatmark:
posix : sockatmark(a1: cint): cint
SOCK_DGRAM:
posix : SOCK_DGRAM
Socket:
net : Socket
socket:
posix : socket(a1, a2, a3: cint): SocketHandle
winlean : socket(af, typ, protocol: cint): SocketHandle
socketError:
net : socketError(socket: Socket; err: int = - 1; async = false; lastError = -1.OSErrorCode): void
SocketFlag:
net : SocketFlag
SocketHandle:
posix : SocketHandle
winlean : SocketHandle
SocketImpl:
net : SocketImpl
socketpair:
posix : socketpair(a1, a2, a3: cint; a4: var array[0 .. 1, cint]): cint
SocketStatus:
asyncio : SocketStatus
Socklen:
posix : Socklen
SockLen:
winlean : SockLen
SOCK_RAW:
posix : SOCK_RAW
SOCK_SEQPACKET:
posix : SOCK_SEQPACKET
SOCK_STREAM:
posix : SOCK_STREAM
SockType:
nativesockets : SockType
SO_DEBUG:
posix : SO_DEBUG
winlean : SO_DEBUG
SO_DONTLINGER:
winlean : SO_DONTLINGER
SO_DONTROUTE:
posix : SO_DONTROUTE
winlean : SO_DONTROUTE
SO_ERROR:
posix : SO_ERROR
winlean : SO_ERROR
SO_EXCLUSIVEADDRUSE:
winlean : SO_EXCLUSIVEADDRUSE
SO_KEEPALIVE:
posix : SO_KEEPALIVE
winlean : SO_KEEPALIVE
SO_LINGER:
posix : SO_LINGER
winlean : SO_LINGER
SOL_SOCKET:
posix : SOL_SOCKET
winlean : SOL_SOCKET
SOMAXCONN:
posix : SOMAXCONN
winlean : SOMAXCONN
some:
options : some[T](val: T): Option[T]
SomeInteger:
system : SomeInteger
SomeNumber:
system : SomeNumber
SomeOrdinal:
system : SomeOrdinal
SomeReal:
system : SomeReal
SomeSignedInt:
system : SomeSignedInt
SomeUnsignedInt:
system : SomeUnsignedInt
SO_OOBINLINE:
posix : SO_OOBINLINE
winlean : SO_OOBINLINE
SO_RCVBUF:
posix : SO_RCVBUF
SO_RCVLOWAT:
posix : SO_RCVLOWAT
SO_RCVTIMEO:
posix : SO_RCVTIMEO
SO_REUSEADDR:
posix : SO_REUSEADDR
winlean : SO_REUSEADDR
SO_REUSEPORT:
posix : SO_REUSEPORT
winlean : SO_REUSEPORT
sort:
algorithm : sort[T](a: var openArray[T]; cmp: proc (x, y: T): int; order = SortOrder.Ascending)
tables : sort[A](t: var CountTable[A])
tables : sort[A](t: CountTableRef[A])
tables : sort[A, B](t: var OrderedTable[A, B]; cmp: proc (x, y: (A, B)): int)
tables : sort[A, B](t: OrderedTableRef[A, B]; cmp: proc (x, y: (A, B)): int)
sorted:
algorithm : sorted[T](a: openArray[T]; cmp: proc (x, y: T): int; order = SortOrder.Ascending): seq[T]
sortedByIt:
algorithm : sortedByIt(seq1, op: untyped): untyped
SortOrder:
algorithm : SortOrder
SO_SNDBUF:
posix : SO_SNDBUF
SO_SNDLOWAT:
posix : SO_SNDLOWAT
SO_SNDTIMEO:
posix : SO_SNDTIMEO
SO_TYPE:
posix : SO_TYPE
SO_UPDATE_ACCEPT_CONTEXT:
winlean : SO_UPDATE_ACCEPT_CONTEXT
SourceLanguage:
highlite : SourceLanguage
sourceLanguageToStr:
highlite : sourceLanguageToStr
SO_USELOOPBACK:
winlean : SO_USELOOPBACK
spaces:
strutils : spaces(n: Natural): string
span:
htmlgen : span(e: varargs[untyped]): untyped
sparse bit set:
Module intsets
spawn:
actors : spawn[In, Out](p: var ActorPool[In, Out]; input: In; action: proc (input: In): Out): ptr Channel[Out]
actors : spawn[In](p: var ActorPool[In, void]; input: In; action: proc (input: In))
actors : spawn[In, Out](action: proc (self: PActor[In, Out])): PActor[In, Out]
threadpool : spawn(call: expr): expr
spawnX:
threadpool : spawnX(call: expr): expr
specified:
xmldom : specified(a: PAttr): bool
splice:
Module system
Module system
split:
nre : split(str: string; pattern: Regex; maxSplit = - 1; start = 0): seq[string]
pegs : split(s: string; sep: Peg): seq[string]
pegs : split(s: string; sep: Peg): string
re : split(s: string; sep: Regex): seq[string]
re : split(s: string; sep: Regex): 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
splitData:
xmldom : splitData(textNode: PText; offset: int): PText
splitDecimal:
math : splitDecimal[T: float32 | float64](x: T): tuple[intpart: T, floatpart: T]
splitFile:
os : splitFile(path: string): tuple[dir, name, ext: string]
ospaths : splitFile(path: string): tuple[dir, name, ext: string]
splitLines:
strutils : splitLines(s: string): seq[string]
strutils : splitLines(s: string): string
splitPath:
os : splitPath(path: string): tuple[head, tail: string]
ospaths : splitPath(path: string): tuple[head, tail: string]
splitter:
rstgen : splitter
splitWhitespace:
strutils : splitWhitespace(s: string): seq[string]
strutils : splitWhitespace(s: string): string
sql:
db_common : sql(query: string): SqlQuery
SQLite:
Module db_sqlite
SqlLexer:
parsesql : SqlLexer
SqlNode:
parsesql : SqlNode
SqlNodeKind:
parsesql : SqlNodeKind
SqlNodeObj:
parsesql : SqlNodeObj
SqlParseError:
parsesql : SqlParseError
SqlParser:
parsesql : SqlParser
SqlPrepared:
db_postgres : SqlPrepared
SqlQuery:
db_common : SqlQuery
sqrDist:
basic2d : sqrDist(a, b: Point2d): float
basic3d : sqrDist(a, b: Point3d): float
sqrLen:
basic2d : sqrLen(v: Vector2d): float
basic3d : sqrLen(v: Vector3d): float
sqrt:
complex : sqrt(z: Complex): Complex
math : sqrt(x: float32): float32
math : sqrt(x: float64): float64
srcDir:
nimscript : srcDir
SS_DISABLE:
posix : SS_DISABLE
SslAcceptResult:
net : SslAcceptResult
SslClientGetPskFunc:
net : SslClientGetPskFunc
SslContext:
net : SslContext
SslCVerifyMode:
net : SslCVerifyMode
SslError:
net : SslError
SslHandshakeType:
net : SslHandshakeType
SslProtVersion:
net : SslProtVersion
SslServerGetPskFunc:
net : SslServerGetPskFunc
SS_ONSTACK:
posix : SS_ONSTACK
Stack:
posix : Stack
StackOverflowError:
system : StackOverflowError
stackTraceAvailable:
system : stackTraceAvailable(): bool
system : stackTraceAvailable(): bool
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
start:
coro : start(c: proc (); stacksize: int = defaultStackSize)
startAnchor:
pegs : startAnchor(): Peg
startCmd:
osproc : startCmd(command: string; options: set[ProcessOption] = {poStdErrToStdOut, poUsePath}): Process
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}): Process
startsWith:
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
STARTUPINFO:
winlean : STARTUPINFO
Stat:
posix : Stat
stat:
posix : stat(a1: cstring; a2: var Stat): cint
staticExec:
system : staticExec(command: string; input = ""; cache = ""): string
staticRead:
system : staticRead(filename: string): string
STATUS_PENDING:
winlean : STATUS_PENDING
Statvfs:
posix : Statvfs
statvfs:
posix : statvfs(a1: cstring; a2: var Statvfs): cint
stderr:
system : stderr
STDERR_FILENO:
posix : STDERR_FILENO
STD_ERROR_HANDLE:
winlean : STD_ERROR_HANDLE
stdin:
Module rdstdin
system : stdin
STDIN_FILENO:
posix : STDIN_FILENO
STD_INPUT_HANDLE:
winlean : STD_INPUT_HANDLE
stdmsg:
system : stdmsg(): File
stdout:
system : stdout
STDOUT_FILENO:
posix : STDOUT_FILENO
STD_OUTPUT_HANDLE:
winlean : STD_OUTPUT_HANDLE
stmt:
system : stmt
ST_NOSUID:
posix : ST_NOSUID
stop:
dom : stop*(e: EmbedElement)
dom : stop*(w: Window)
store:
asyncftpclient : store(ftp: AsyncFtpClient; file, dest: string; onProgressChanged: ProgressChangedProc = defaultOnProgressChanged): Future[ void]
ftpclient : store[T](ftp: FtpBase[T]; file, dest: string; async = false)
marshal : store[T](s: Stream; data: T)
str:
json : str(my: JsonParser): string
ST_RDONLY:
posix : ST_RDONLY
Stream:
streams : Stream
StreamObj:
streams : StreamObj
strerror:
posix : strerror(errnum: cint): cstring
stretch:
basic2d : stretch(sx, sy: float): Matrix2d
basic2d : stretch(sx, sy: float; org: Point2d): Matrix2d
basic2d : stretch(p: var Point2d; facx, facy: float)
basic2d : stretch(p: var Point2d; facx, facy: float; org: Point2d)
basic2d : stretch(v: var Vector2d; facx, facy: float)
basic3d : stretch(sx, sy, sz: float): Matrix3d
basic3d : stretch(sx, sy, sz: float; org: Point3d): Matrix3d
basic3d : stretch(p: var Point3d; facx, facy, facz: float)
basic3d : stretch(p: var Point3d; facx, facy, facz: float; org: Point3d)
basic3d : stretch(v: var Vector3d; sx, sy, sz: float)
strfmon:
posix : strfmon(a1: cstring; a2: int; a3: cstring): int
strftime:
posix : strftime(a1: cstring; a2: int; a3: cstring; a4: var Tm): int
string:
system : string
string interpolation:
Module strutils
Examples
Examples
StringStream:
streams : StringStream
StringStreamObj:
streams : StringStreamObj
StringTableMode:
strtabs : StringTableMode
StringTableObj:
strtabs : StringTableObj
StringTableRef:
strtabs : StringTableRef
strip:
strutils : strip(s: string; leading = true; trailing = true; chars: set[char] = Whitespace): string
strong:
htmlgen : strong(e: varargs[untyped]): untyped
strptime:
posix : strptime(a1, a2: cstring; a3: var Tm): cstring
strVal:
macros : strVal(n: NimNode): string
strVal=:
macros : strVal=(n: NimNode; val: string)
StudyError:
nre : StudyError
style:
htmlgen : style(e: varargs[untyped]): untyped
Style:
terminal : Style
styledEcho:
terminal : styledEcho(args: varargs[expr]): expr
styledWriteLine:
terminal : styledWriteLine(f: File; m: varargs[expr]): stmt
S_TYPEISMQ:
posix : S_TYPEISMQ(buf: var Stat): bool
S_TYPEISSEM:
posix : S_TYPEISSEM(buf: var Stat): bool
S_TYPEISSHM:
posix : S_TYPEISSHM(buf: var Stat): bool
S_TYPEISTMO:
posix : S_TYPEISTMO(buf: var Stat): bool
sub:
htmlgen : sub(e: varargs[untyped]): untyped
Subex:
subexes : Subex
subex:
subexes : subex(s: string): Subex
Module subexes
SubexError:
subexes : SubexError
submit:
dom : submit*(f: FormElement)
substituteLog:
logging : substituteLog(frmt: string; level: Level; args: varargs[string, `$`]): string
substitution:
Module strutils
Examples
Examples
substitution expressions:
Module subexes
substr:
system : substr(s: string; first = 0): string
system : substr(s: string; first, last: int): string
succ:
system : succ[T](x: Ordinal[T]; y = 1): T
success:
strscans : success(x: int): bool
suite:
unittest : suite(name, body)
sum:
math : sum[T](x: openArray[T]): T
sup:
htmlgen : sup(e: varargs[untyped]): untyped
super:
Module system
Suseconds:
posix : Suseconds
suspend:
coro : suspend(sleepTime: float = 0)
osproc : suspend(p: Process)
suspendThread:
winlean : suspendThread(hThread: Handle): int32
swab:
posix : swab(a1, a2: pointer; a3: int)
swap:
system : swap[T](a, b: var T)
swapCase:
unicode : swapCase(s: string): string
swapcontext:
posix : swapcontext(a1, a2: var Ucontext): cint
swapEndian16:
endians : swapEndian16(outp, inp: pointer)
swapEndian32:
endians : swapEndian32(outp, inp: pointer)
swapEndian64:
endians : swapEndian64(outp, inp: pointer)
switch:
nimscript : switch(key: string; val = "")
SW_SHOWNORMAL:
winlean : SW_SHOWNORMAL
symAddr:
dynlib : symAddr(lib: LibHandle; name: cstring): pointer
symbol:
macros : symbol(n: NimNode): NimSym
symbol=:
macros : symbol=(n: NimNode; val: NimSym)
symlink:
posix : symlink(a1, a2: cstring): cint
symlinkExists:
os : symlinkExists(link: string): bool
symmetricDifference:
sets : symmetricDifference[A](s1, s2: HashSet[A]): HashSet[A]
sync:
actors : sync[In, Out](a: var ActorPool[In, Out]; polling = 50)
posix : sync()
threadpool : sync()
SYNCHRONIZE:
winlean : SYNCHRONIZE
SyntaxError:
nre : SyntaxError
sysconf:
posix : sysconf(a1: cint): int
system:
Module osproc
SystemError:
system : SystemError
SysThread:
threads : SysThread
table:
htmlgen : table(e: varargs[untyped]): untyped
Table:
tables : Table
TableRef:
tables : TableRef
tag:
xmltree : tag(n: XmlNode): string
tag=:
xmltree : tag=(n: XmlNode; tag: string)
tagName:
xmldom : tagName(el: PElement): string
tagToStr:
htmlparser : tagToStr
tailDir:
os : tailDir(path: string): string
ospaths : tailDir(path: string): string
tainted:
Module system
TaintedString:
system : TaintedString
Taiocb:
posix : Taiocb
tan:
complex : tan(z: Complex): Complex
math : tan(x: float32): float32
math : tan(x: float64): float64
TAnchor:
dom : TAnchor
tanh:
complex : tanh(z: Complex): Complex
math : tanh(x: float32): float32
math : tanh(x: float64): float64
TApplet:
dom : TApplet
target:
xmldom : target(pi: PProcessingInstruction): string
Task:
actors : Task
task:
nimscript : task(name: untyped; description: string; body: untyped): untyped
TAU:
math : TAU
tbody:
htmlgen : tbody(e: varargs[untyped]): untyped
tcgetpgrp:
posix : tcgetpgrp(a1: cint): Pid
Tcmsghdr:
posix : Tcmsghdr
TCP_NODELAY:
posix : TCP_NODELAY
tcsetpgrp:
posix : tcsetpgrp(a1: cint; a2: Pid): cint
td:
htmlgen : td(e: varargs[untyped]): untyped
TDocument:
dom : TDocument
TElement:
dom : TElement
telldir:
posix : telldir(a1: ptr DIR): int
TEmbed:
dom : TEmbed
term:
pegs : term(t: char): Peg
pegs : term(t: string): Peg
termIgnoreCase:
pegs : termIgnoreCase(t: string): Peg
termIgnoreStyle:
pegs : termIgnoreStyle(t: string): Peg
TerminalCmd:
terminal : TerminalCmd
terminalHeight:
terminal : terminalHeight(): int
terminalHeightIoctl:
terminal : terminalHeightIoctl(fds: openArray[int]): int
terminalSize:
terminal : terminalSize(): tuple[w, h: int]
terminalWidth:
terminal : terminalWidth(): int
terminalWidthIoctl:
terminal : terminalWidthIoctl(fds: openArray[int]): int
terminate:
actors : terminate[In, Out](a: var ActorPool[In, Out])
osproc : terminate(p: Process)
terminateProcess:
winlean : terminateProcess(hProcess: Handle; uExitCode: int): WINBOOL
test:
unittest : test(name, body)
TestStatus:
unittest : TestStatus
TEvent:
dom : TEvent
TEventHandlers:
dom : TEventHandlers
text:
xmltree : text(n: XmlNode): string
text=:
xmltree : text=(n: XmlNode; text: string)
textarea:
htmlgen : textarea(e: varargs[untyped]): untyped
TextNode:
xmldom : TextNode
TFdSet:
posix : TFdSet
winlean : TFdSet
Tfenv:
fenv : Tfenv
Tfexcept:
fenv : Tfexcept
Tflock:
posix : Tflock
T_FMT:
posix : T_FMT
T_FMT_AMPM:
posix : T_FMT_AMPM
tfoot:
htmlgen : tfoot(e: varargs[untyped]): untyped
TForm:
dom : TForm
TFrame:
dom : TFrame
system : TFrame
tgamma:
math : tgamma(x: float32): float32
math : tgamma(x: float64): float64
th:
htmlgen : th(e: varargs[untyped]): untyped
thead:
htmlgen : thead(e: varargs[untyped]): untyped
thisDir:
nimscript : thisDir(): string
THistory:
dom : THistory
THOUSEP:
posix : THOUSEP
Thread:
threads : Thread
ThreadId:
threadpool : ThreadId
threads : ThreadId
threadId:
threads : threadId*[TArg](t: var Thread[TArg]): ThreadId[TArg]
Tif_nameindex:
posix : Tif_nameindex
TImage:
dom : TImage
Time:
nimprof : Time
time:
posix : time(a1: var Time): Time
Time:
times : Time
TimeEffect:
system : TimeEffect
timegm:
posix : timegm(a1: var Tm): Time
TimeImpl:
times : TimeImpl
TimeInfo:
times : TimeInfo
timeInfoToTime:
times : timeInfoToTime(timeInfo: TimeInfo): Time
TimeInterval:
times : TimeInterval
TimeoutError:
net : TimeoutError
Timer:
posix : Timer
TIMER_ABSTIME:
posix : TIMER_ABSTIME
timer_create:
posix : timer_create(a1: ClockId; a2: var SigEvent; a3: var Timer): cint
timer_delete:
posix : timer_delete(a1: Timer): cint
timer_getoverrun:
posix : timer_getoverrun(a1: Timer): cint
timer_gettime:
posix : timer_gettime(a1: Timer; a2: var Itimerspec): cint
timer_settime:
posix : timer_settime(a1: Timer; a2: cint; a3: var Itimerspec; a4: var Itimerspec): cint
Timespec:
posix : Timespec
timeToTimeInfo:
times : timeToTimeInfo(t: Time): TimeInfo
timeToTimeInterval:
times : timeToTimeInterval(t: Time): TimeInterval
Timeval:
posix : Timeval
winlean : Timeval
timezone:
posix : timezone
TInterval:
dom : TInterval
Tipv6_mreq:
posix : Tipv6_mreq
title:
htmlgen : title(e: varargs[untyped]): untyped
unicode : title(s: string): string
TLinger:
posix : TLinger
TLink:
dom : TLink
TLocation:
dom : TLocation
TLocationBar:
dom : TLocationBar
Tm:
posix : Tm
TMenuBar:
dom : TMenuBar
TMimeType:
dom : TMimeType
Tmsghdr:
posix : Tmsghdr
TNavigator:
dom : TNavigator
Tnetent:
posix : Tnetent
Tnfds:
posix : Tnfds
TNimSymKinds:
macros : TNimSymKinds
TNimTypeKinds:
macros : TNimTypeKinds
TNode:
dom : TNode
TNodeType:
dom : TNodeType
to:
marshal : to[T](data: string): T
toAny:
typeinfo : toAny[T](x: var T): Any
toAsyncSocket:
asyncio : toAsyncSocket(sock: Socket; state: SocketStatus = SockConnected): AsyncSocket
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
toComplex:
complex : toComplex[SomeInteger](x: SomeInteger): Complex
toCountTable:
tables : toCountTable[A](keys: openArray[A]): CountTable[A]
toDll:
nimscript : toDll(filename: string): string
toExe:
nimscript : toExe(filename: string): string
toFloat:
rationals : toFloat[T](x: Rational[T]): float
system : toFloat(i: int): float
toggle:
dom : toggle*(c: ClassList; class: cstring)
toHex:
strutils : toHex(x: BiggestInt; len: Positive): string
strutils : toHex[T](x: T): string
toInt:
nativesockets : toInt(domain: Domain): cint
nativesockets : toInt(p: Protocol): cint
nativesockets : toInt(typ: SockType): cint
rationals : toInt[T](x: Rational[T]): int
system : toInt(f: float): int
TokenClass:
highlite : TokenClass
tokenClassToStr:
highlite : tokenClassToStr
tokenize:
strutils : tokenize(s: string; seps: set[char] = Whitespace): tuple[token: string, isSep: bool]
toLower:
strutils : toLower(c: char): char
strutils : toLower(s: string): string
unicode : toLower(c: Rune): Rune
unicode : toLower(s: string): string
toLowerAscii:
strutils : toLowerAscii(c: char): char
strutils : toLowerAscii(s: string): string
toMD5:
md5 : toMD5(s: string): MD5Digest
toOct:
strutils : toOct(x: BiggestInt; len: Positive): string
toOctal:
strutils : toOctal(c: char): string
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
TOption:
dom : TOption
toRational:
rationals : toRational(x: float; n: int = high(int)): Rational[int]
rationals : toRational[T: SomeInteger](x: T): Rational[T]
toRunes:
unicode : toRunes(s: string): seq[Rune]
toSeconds:
times : toSeconds(time: Time): float
toSeq:
nre : toSeq(pattern: CaptureBounds; default = none(Slice[int])): seq[Option[Slice[int]]]
nre : toSeq(pattern: Captures; default: string = nil): seq[string]
sequtils : toSeq(iter: untyped): untyped
toSet:
sets : toSet[A](keys: openArray[A]): HashSet[A]
toString:
httpcore : toString(values: HttpHeaderValues): string
Module system
toStrLit:
macros : toStrLit(n: NimNode): NimNode
toTable:
nre : toTable(pattern: CaptureBounds; default = none(Slice[int])): Table[string, Option[Slice[int]]]
nre : toTable(pattern: Captures; default: string = nil): Table[string, string]
tables : toTable[A, B](pairs: openArray[(A, B)]): Table[A, B]
toTime:
times : toTime(timeInfo: TimeInfo): Time
toTimeInterval:
times : toTimeInterval(t: Time): TimeInterval
toTitle:
unicode : toTitle(c: Rune): Rune
toU16:
system : toU16(x: int): int16
toU32:
system : toU32(x: int64): int32
toU8:
system : toU8(x: int): int8
toUgly:
json : toUgly(result: var string; node: JsonNode)
toUpper:
strutils : toUpper(c: char): char
strutils : toUpper(s: string): string
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
TPersonalBar:
dom : TPersonalBar
TPlugin:
dom : TPlugin
TPollfd:
posix : TPollfd
Tposix_spawnattr:
posix : Tposix_spawnattr
Tposix_spawn_file_actions:
posix : Tposix_spawn_file_actions
tr:
htmlgen : tr(e: varargs[untyped]): untyped
Trace_attr:
posix : Trace_attr
Trace_event_id:
posix : Trace_event_id
Trace_event_set:
posix : Trace_event_set
Trace_id:
posix : Trace_id
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]])
transformInv:
basic2d : transformInv(p: var Point2d; t: Matrix2d)
basic2d : transformInv(v: var Vector2d; t: Matrix2d)
basic3d : transformInv(p: var Point3d; m: Matrix3d)
basic3d : transformInv(v: var Vector3d; m: Matrix3d)
transformNorm:
basic2d : transformNorm(v: var Vector2d; t: Matrix2d)
basic3d : transformNorm(v: var Vector3d; m: Matrix3d)
transformNormInv:
basic2d : transformNormInv(v: var Vector2d; t: Matrix2d)
basic3d : transformNormInv(vec: var Vector3d; m: Matrix3d)
translate:
unicode : translate(s: string; replacements: proc (key: string): string): string
transpose:
basic3d : transpose(m: Matrix3d): Matrix3d
treeRepr:
macros : treeRepr(n: NimNode): string
trimZeros:
strutils : trimZeros(x: var string)
trunc:
math : trunc(x: float32): float32
math : trunc(x: float64): float64
truncate:
posix : truncate(a1: cstring; a2: Off): cint
tryAcquire:
locks : tryAcquire(lock: var Lock): bool
rlocks : tryAcquire(lock: var RLock): bool
TRY_AGAIN:
posix : TRY_AGAIN
tryExec:
db_mysql : tryExec(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): bool
db_postgres : tryExec(db: DbConn; stmtName: SqlPrepared; args: varargs[string, `$`]): bool
db_postgres : tryExec(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): bool
db_sqlite : tryExec(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): bool
tryInsertId:
db_mysql : tryInsertId(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
tryInsertID:
db_postgres : tryInsertID(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
db_sqlite : tryInsertID(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64
tryNormalize:
basic2d : tryNormalize(v: var Vector2d): bool
basic3d : tryNormalize(v: var Vector3d): bool
tryRecv:
channels : tryRecv*[TMsg](c: var Channel[TMsg]): tuple[dataAvailable: bool, msg: TMsg]
trySend:
net : trySend(socket: Socket; data: string): bool
TSa_Family:
posix : TSa_Family
TScreen:
dom : TScreen
TScrollBars:
dom : TScrollBars
TStatusBar:
dom : TStatusBar
TStyle:
dom : TStyle
tt:
htmlgen : tt(e: varargs[untyped]): untyped
TTimeOut:
dom : TTimeOut
TToolBar:
dom : TToolBar
ttyname:
posix : ttyname(a1: cint): cstring
ttyname_r:
posix : ttyname_r(a1: cint; a2: cstring; a3: int): cint
turnAngle:
basic2d : turnAngle(v1, v2: Vector2d): float
TWindow:
dom : TWindow
TWSABuf:
winlean : TWSABuf
type:
Special node kinds
typed:
system : typed
typedesc:
system : typedesc
typeKind:
macros : typeKind(n: NimNode): NimTypeKind
tzset:
posix : tzset()
ualarm:
posix : ualarm(a1, a2: Useconds): Useconds
Ucontext:
posix : Ucontext
ui:
random : ui
Uid:
posix : Uid
uint:
system : uint
uint16:
system : uint16
uint32:
system : uint32
uint64:
system : uint64
uint8:
system : uint8
ul:
htmlgen : ul(e: varargs[untyped]): untyped
ULONG:
winlean : ULONG
ULONG_PTR:
winlean : ULONG_PTR
umask:
posix : umask(a1: Mode): Mode
uname:
posix : uname(a1: var Utsname): cint
unescape:
dom : unescape*(uri: cstring): cstring
strutils : unescape(s: string; prefix = "\""; suffix = "\""): string
unicodeLetter:
pegs : unicodeLetter(): Peg
unicodeLower:
pegs : unicodeLower(): Peg
unicodeTitle:
pegs : unicodeTitle(): Peg
unicodeUpper:
pegs : unicodeUpper(): Peg
unicodeWhitespace:
pegs : unicodeWhitespace(): Peg
unidecode:
unidecode : unidecode(s: string): string
unindent:
strutils : unindent(s: string): string
strutils : unindent(s: string; count: Natural; padding: string = " "): string
union:
sets : union[A](s1, s2: HashSet[A]): HashSet[A]
unixTimeToWinTime:
times : unixTimeToWinTime(t: Time): int64
unixToNativePath:
os : unixToNativePath(path: string; drive = ""): string
ospaths : unixToNativePath(path: string; drive = ""): string
unlikely:
system : unlikely(val: bool): bool
unlink:
posix : unlink(a1: cstring): cint
unloadLib:
dynlib : unloadLib(lib: LibHandle)
unmapMem:
memfiles : unmapMem(f: var MemFile; p: pointer; size: int)
unmapViewOfFile:
winlean : unmapViewOfFile(lpBaseAddress: pointer): WINBOOL
UnpackError:
options : UnpackError
unpackInfix:
macros : unpackInfix(node: NimNode): tuple[left: NimNode, op: string, right: NimNode]
unpackPostfix:
macros : unpackPostfix(node: NimNode): tuple[node: NimNode, op: string]
unpackPrefix:
macros : unpackPrefix(node: NimNode): tuple[node: NimNode, op: string]
unregister:
asyncdispatch : unregister(fd: AsyncFD)
asyncio : unregister(d: Dispatcher; deleg: Delegate)
selectors : unregister(s: Selector; fd: SocketHandle): SelectorKey
unregisterWait:
winlean : unregisterWait(WaitHandle: Handle): DWORD
unsafeAddr:
system : unsafeAddr[T](x: T): ptr T
unsafeGet:
options : unsafeGet[T](self: Option[T]): T
unsafeNew:
system : unsafeNew[T](a: var ref T; size: Natural)
unsafeRead:
threadpool : unsafeRead[T](fv: FlowVar[ref T]): foreign ptr T
untyped:
system : untyped
update:
selectors : update(s: Selector; fd: SocketHandle; events: set[Event]): SelectorKey
Uri:
uri : Uri
Url:
uri : Url
Useconds:
posix : Useconds
useWinUnicode:
winlean : useWinUnicode
usleep:
posix : usleep(a1: Useconds): cint
Utf16Char:
system : Utf16Char
utf8:
unicode : utf8(s: string): string
utimes:
posix : utimes(path: cstring; times: ptr array[2, Timeval]): int
Utsname:
posix : Utsname
validateData:
cgi : validateData(data: StringTableRef; validKeys: varargs[string])
validateUtf8:
unicode : validateUtf8(s: string): int
validEmailAddress:
matchers : validEmailAddress(s: string): bool
validIdentifier:
strutils : validIdentifier(s: string): bool
ValueError:
system : ValueError
values:
critbits : values[T](c: CritBitTree[T]): T
strtabs : values(t: StringTableRef): string
tables : values[A](t: CountTable[A]): int
tables : values[A](t: CountTableRef[A]): int
tables : values[A, B](t: OrderedTable[A, B]): B
tables : values[A, B](t: OrderedTableRef[A, B]): B
tables : values[A, B](t: Table[A, B]): B
tables : values[A, B](t: TableRef[A, B]): B
valuesWithPrefix:
critbits : valuesWithPrefix[T](c: CritBitTree[T]; prefix: string; longestMatch = false): T
varargs:
system : varargs
variance:
stats : variance[T](x: openArray[T]): float
stats : variance(s: RunningStat): float
varianceS:
stats : varianceS[T](x: openArray[T]): float
stats : varianceS(s: RunningStat): float
Vector2d:
basic2d : Vector2d
vector2d:
basic2d : vector2d(x, y: float): Vector2d
Vector3d:
basic3d : Vector3d
vector3d:
basic3d : vector3d(x, y, z: float): Vector3d
verboseFmtStr:
logging : verboseFmtStr
version:
nimscript : version
vfork:
posix : vfork(): Pid
void:
system : void
wait:
coro : wait(c: proc (); interval = 0.01'f64)
locks : wait(cond: var Cond; lock: var Lock)
posix : wait(a1: ptr cint): Pid
WAIT_FAILED:
winlean : WAIT_FAILED
waitFor:
asyncdispatch : waitFor[T](fut: Future[T]): T
waitForExit:
osproc : waitForExit(p: Process; timeout: int = - 1): int
waitForMultipleObjects:
winlean : waitForMultipleObjects(nCount: DWORD; lpHandles: PWOHandleArray; bWaitAll: WINBOOL; dwMilliseconds: DWORD): DWORD
waitForSingleObject:
winlean : waitForSingleObject(hHandle: Handle; dwMilliseconds: int32): int32
waitid:
posix : waitid(a1: cint; a2: Id; a3: var SigInfo; a4: cint): cint
WAIT_OBJECT_0:
winlean : WAIT_OBJECT_0
WAITORTIMERCALLBACK:
winlean : WAITORTIMERCALLBACK
waitpid:
posix : waitpid(a1: Pid; a2: var cint; a3: cint): Pid
WAIT_TIMEOUT:
winlean : WAIT_TIMEOUT
walkDir:
os : walkDir(dir: string; relative = false): tuple[kind: PathComponent, path: string]
walkDirRec:
os : walkDirRec(dir: string; filter = {pcFile, pcDir}): string
walkDirs:
os : walkDirs(pattern: string): string
walkFiles:
os : walkFiles(pattern: string): string
walkPattern:
os : walkPattern(pattern: string): string
warn:
logging : warn(args: varargs[string, `$`])
warning:
macros : warning(msg: string)
nimscript : warning(name: string; val: bool)
warningStr:
parsecfg : warningStr(c: CfgParser; msg: string): string
WCONTINUED:
posix : WCONTINUED
WeekDay:
times : WeekDay
WEXITED:
posix : WEXITED
WEXITSTATUS:
posix : WEXITSTATUS
whichMsgClass:
rst : whichMsgClass(k: MsgKind): MsgClass
whitespace:
pegs : whitespace(): expr
Whitespace:
strutils : Whitespace
WideCString:
system : WideCString
WIFCONTINUED:
posix : WIFCONTINUED(s: cint): bool
WIFEXITED:
posix : WIFEXITED(s: cint): bool
WIFSIGNALED:
posix : WIFSIGNALED(s: cint): bool
WIFSTOPPED:
posix : WIFSTOPPED(s: cint): bool
WIN32_FIND_DATA:
winlean : WIN32_FIND_DATA
WINBOOL:
winlean : WINBOOL
WinChar:
winlean : WinChar
Window:
dom : Window
window:
dom : window
winTimeToUnixTime:
times : winTimeToUnixTime(t: int64): Time
withDir:
nimscript : withDir(dir: string; body: untyped): untyped
withLock:
locks : withLock(a: Lock; body: untyped)
withRLock:
rlocks : withRLock(lock: var RLock; code: untyped): untyped
withTimeout:
asyncdispatch : withTimeout[T](fut: Future[T]; timeout: int): Future[bool]
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)
WNOHANG:
posix : WNOHANG
WNOWAIT:
posix : WNOWAIT
WOHandleArray:
winlean : WOHandleArray
W_OK:
posix : W_OK
wordWrap:
strutils : wordWrap(s: string; maxLineWidth = 80; splitLongWords = true; seps: set[char] = Whitespace; newLine = "\x0A"): string
wrapConnectedSocket:
asyncnet : wrapConnectedSocket(ctx: SslContext; socket: AsyncSocket; handshake: SslHandshakeType)
net : wrapConnectedSocket(ctx: SslContext; socket: Socket; handshake: SslHandshakeType)
wrapSocket:
asyncnet : wrapSocket(ctx: SslContext; socket: AsyncSocket)
net : wrapSocket(ctx: SslContext; socket: Socket)
write:
asyncfile : write(f: AsyncFile; data: string): Future[void]
dom : write*(d: Document; text: cstring)
posix : write(a1: cint; a2: pointer; a3: int): int
ropes : write(f: File; r: Rope)
streams : write(s: Stream; x: string)
streams : write[T](s: Stream; x: T)
system : write(f: File; r: BiggestFloat)
system : write(f: File; r: BiggestFloat)
system : write(f: File; i: BiggestInt)
system : write(f: File; i: BiggestInt)
system : write(f: File; b: bool)
system : write(f: File; b: bool)
system : write(f: File; c: char)
system : write(f: File; c: char)
system : write(f: File; c: cstring)
system : write(f: File; c: cstring)
system : write(f: File; r: float32)
system : write(f: File; r: float32)
system : write(f: File; i: int)
system : write(f: File; i: int)
system : write(f: File; s: string)
system : write(f: File; s: string)
system : write(f: File; a: varargs[string, `$`])
system : write(f: File; a: varargs[string, `$`])
writeBuffer:
asyncfile : writeBuffer(f: AsyncFile; buf: pointer; size: int): Future[void]
system : writeBuffer(f: File; buffer: pointer; len: Natural): int
system : writeBuffer(f: File; buffer: pointer; len: Natural): int
writeBytes:
system : writeBytes[](f: File; a: openArray[int8 | uint8]; start, len: Natural): int
system : writeBytes[](f: File; a: openArray[int8 | uint8]; start, len: Natural): int
writeChars:
system : writeChars(f: File; a: openArray[char]; start, len: Natural): int
system : writeChars(f: File; a: openArray[char]; start, len: Natural): int
writeConfig:
parsecfg : writeConfig(dict: Config; filename: string)
writeContentType:
cgi : writeContentType()
writeData:
streams : writeData(s: Stream; buffer: pointer; bufLen: int)
streams : writeData(s, unused: Stream; buffer: pointer; bufLen: int)
WriteDbEffect:
db_common : WriteDbEffect
WriteDirEffect:
os : WriteDirEffect
ospaths : WriteDirEffect
WriteEnvEffect:
os : WriteEnvEffect
ospaths : WriteEnvEffect
writeErrorMessage:
cgi : writeErrorMessage(data: string)
writeFile:
system : writeFile(filename, content: string)
system : 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:
streams : writeLine(s: Stream; args: varargs[string, `$`])
system : writeLine[Ty](f: File; x: varargs[Ty, `$`])
system : writeLine[Ty](f: File; x: varargs[Ty, `$`])
writeln:
dom : writeln*(d: Document; text: cstring)
writeLn:
streams : writeLn(s: Stream; args: varargs[string, `$`])
system : writeLn[Ty](f: File; x: varargs[Ty, `$`])
system : writeLn[Ty](f: File; x: varargs[Ty, `$`])
writeStackTrace:
system : writeStackTrace()
system : writeStackTrace()
writeStatusOkTextContent:
scgi : writeStatusOkTextContent(c: Socket; contentType = "text/html")
writeStyled:
terminal : writeStyled(txt: string; style: set[Style] = {styleBright})
writev:
posix : writev(a1: cint; a2: ptr IOVec; a3: cint): int
wsaCloseEvent:
winlean : wsaCloseEvent(hEvent: Handle): bool
wsaCreateEvent:
winlean : wsaCreateEvent(): Handle
WSAData:
winlean : WSAData
WSADESCRIPTION_LEN:
winlean : WSADESCRIPTION_LEN
WSAEADDRINUSE:
winlean : WSAEADDRINUSE
WSAECONNABORTED:
winlean : WSAECONNABORTED
WSAECONNRESET:
winlean : WSAECONNRESET
WSAEDISCON:
winlean : WSAEDISCON
WSAEINPROGRESS:
winlean : WSAEINPROGRESS
WSAENETRESET:
winlean : WSAENETRESET
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
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
WSTOPPED:
posix : WSTOPPED
WSTOPSIG:
posix : WSTOPSIG
WTERMSIG:
posix : WTERMSIG
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
WUNTRACED:
posix : WUNTRACED
wwwNL:
httpserver : wwwNL
XAXIS:
basic2d : XAXIS
basic3d : XAXIS
xlen:
system : xlen[T](x: seq[T]): int
system : xlen(x: string): int
XML:
Module htmlgen
Module parsexml
XmlAttributes:
xmltree : XmlAttributes
xmlCheckedTag:
htmlgen : xmlCheckedTag(e: NimNode; tag: string; optAttr = ""; reqAttr = ""; isLeaf = false): NimNode
xmlEncode:
cgi : xmlEncode(s: string): string
XmlError:
xmlparser : XmlError
XmlErrorKind:
parsexml : XmlErrorKind
XmlEventKind:
parsexml : XmlEventKind
xmlHeader:
xmltree : xmlHeader
XmlNode:
xmltree : XmlNode
XmlNodeKind:
xmltree : XmlNodeKind
XmlParseOption:
parsexml : XmlParseOption
XmlParser:
parsexml : XmlParser
X_OK:
posix : X_OK
YAXIS:
basic2d : YAXIS
basic3d : YAXIS
years:
times : years(y: int): TimeInterval
YESEXPR:
posix : YESEXPR
yield:
Module coro
ZAXIS:
basic3d : ZAXIS
ze:
system : ze(x: int16): int
system : ze(x: int8): int
ze64:
system : ze64(x: int): int64
system : ze64(x: int16): int64
system : ze64(x: int32): int64
system : ze64(x: int8): int64
zeroMem:
system : zeroMem(p: pointer; size: Natural)
zip:
sequtils : zip[S, T](seq1: seq[S]; seq2: seq[T]): seq[tuple[a: S, b: T]]