Index
Documents:
API naming design
,
Embedded Nim Debugger (ENDB) User Guide
,
Embedded Stack Trace Profiler (ESTP) User Guide
,
Internals of the Nim Compiler
,
Nim Backend Integration
,
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
,
Tools available with Nim
.
Modules:
actors
,
algorithm
,
asyncdispatch
,
asyncfile
,
asyncftpclient
,
asynchttpserver
,
asyncio
,
asyncnet
,
base64
,
basic2d
,
basic3d
,
browsers
,
cgi
,
channels
,
colors
,
complex
,
cookies
,
cpuinfo
,
critbits
,
db_mysql
,
db_postgres
,
db_sqlite
,
dom
,
dynlib
,
encodings
,
endians
,
events
,
fenv
,
fsmonitor
,
ftpclient
,
future
,
hashes
,
highlite
,
htmlgen
,
htmlparser
,
httpclient
,
httpserver
,
intsets
,
json
,
lexbase
,
lists
,
locks
,
logging
,
macros
,
marshal
,
matchers
,
math
,
md5
,
memfiles
,
mimetypes
,
net
,
nimprof
,
nimscript
,
oids
,
os
,
ospaths
,
osproc
,
parsecfg
,
parsecsv
,
parseopt
,
parseopt2
,
parsesql
,
parseutils
,
parsexml
,
pegs
,
posix
,
queues
,
rationals
,
rawsockets
,
re
,
ropes
,
rst
,
rstast
,
rstgen
,
scgi
,
selectors
,
sequtils
,
sets
,
smtp
,
ssl
,
streams
,
strtabs
,
strutils
,
subexes
,
system
,
tables
,
terminal
,
threadpool
,
threads
,
times
,
typeinfo
,
typetraits
,
unicode
,
unidecode
,
unittest
,
uri
,
xmldom
,
xmldomparser
,
xmlparser
,
xmltree
.
Documentation files
API naming design
Naming scheme
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
Internals of the Nim Compiler
Directory structure
Bootstrapping the compiler
Coding Guidelines
Porting to new platforms
Runtime type information
Debugging the compiler
The compiler's architecture
Short description of Nim's modules
The syntax tree
How the RTL is compiled
Compilation cache
Frontend issues
Methods and type converters
Generics
Backend issues
Debugging Nim's memory management
The Garbage Collector
Introduction
The CellSet data structure
Further complications
Code generation for closures
lambda lifting
Design
Alternative
Accumulator
Internals
Nim Backend Integration
Introduction
Backends
The C like targets
The JavaScript target
JavaScript
nodejs
Interfacing
Nim code calling the backend
C invocation example
JavaScript invocation example
Backend code calling Nim
Nim invocation example from C
Nim invocation example from JavaScript
Nimcache naming logic
nimcache
Nimcache and C like targets
Nimcache and the Javascript target
Memory management
Strings and C strings
Custom data types
Thread coordination
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 interactive mode
REPL
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
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
Strong spaces
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
Lazy type resolution for expr
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
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
Ordinary vs immediate templates
Passing a code block to a template
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
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
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
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
Tools available with Nim
API symbols
`!$`:
hashes : `!$`(h: Hash): Hash
`!&`:
hashes : `!&`(h: Hash; val: int): Hash
`!*\`:
pegs : `!*\`(a: Peg): Peg
`!*`:
pegs : `!*`(a: Peg): Peg
`!=`:
system : `!=`(x, y: expr): expr
`!`:
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
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
net : `$`(address: IpAddress): string
oids : `$`(oid: Oid): 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
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](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](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: expr): expr
`%`:
json : `%`(n: BiggestInt): JsonNode
json : `%`(b: bool): JsonNode
json : `%`(n: float): JsonNode
json : `%`(elements: openArray[JsonNode]): JsonNode
json : `%`(keyVals: openArray[tuple[key: string, val: JsonNode]]): JsonNode
json : `%`(s: string): 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)
system : `&=`(x: var string; y: string)
`&`:
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: expr): expr
`>=%`:
system : `>=%`(x, y: expr): expr
`>=`:
system : `>=`(x, y: expr): expr
`>`:
system : `>`(x, y: expr): expr
`<%`:
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](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](x, y: T): bool
system : `<=`[T](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](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](x, y: T): bool
system : `<`[T](x, y: T): bool
times : `<`(a, b: Time): bool
`*%`:
system : `*%`(x, y: int64): int64
system : `*%`[IntMax32](x, y: IntMax32): IntMax32
`*=`:
basic2d : `*=`(a: var Vector2d; b: float)
basic2d : `*=`(a: var Vector2d; b: Vector2d)
basic3d : `*=`(a: var Vector3d; b: float)
basic3d : `*=`(a: var Vector3d; b: 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](x: var T; y: T)
system : `*=`[T](x: var T; y: T)
`*`:
algorithm : `*`(x: int; order: SortOrder): int
basic2d : `*`(a: float; b: Vector2d): Vector2d
basic2d : `*`(a: Vector2d; b: float): Vector2d
basic2d : `*`(a, b: Vector2d): Vector2d
basic3d : `*`(a: float; b: Vector3d): Vector3d
basic3d : `*`(a: Vector3d; b: float): Vector3d
basic3d : `*`(a, b: 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](x, y: T): T
`+%`:
system : `+%`(x, y: int64): int64
system : `+%`[IntMax32](x, y: IntMax32): IntMax32
`+=`:
basic2d : `+=`(p: var Point2d; v: Vector2d)
basic2d : `+=`(a: var Vector2d; b: float)
basic2d : `+=`(a: var Vector2d; b: Vector2d)
basic3d : `+=`(p: var Point3d; v: Vector3d)
basic3d : `+=`(a: var Vector3d; b: float)
basic3d : `+=`(a: var Vector3d; b: 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](x: var T; y: T)
system : `+=`[T](x: var T; y: T)
`+`:
basic2d : `+`(a: float; b: Vector2d): Vector2d
basic2d : `+`(p: Point2d; v: Vector2d): Point2d
basic2d : `+`(a: Vector2d; b: float): Vector2d
basic2d : `+`(a, b: Vector2d): Vector2d
basic3d : `+`(a: float; b: Vector3d): Vector3d
basic3d : `+`(p: Point3d; v: Vector3d): Point3d
basic3d : `+`(a: Vector3d; b: float): Vector3d
basic3d : `+`(a, b: 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]
system : `+`(x: float): float
system : `+`(x, y: float): float
system : `+`(x: float32): float32
system : `+`(x, y: float32): float32
system : `+`(x: int): int
system : `+`(x, y: int): int
system : `+`(x: int16): int16
system : `+`(x, y: int16): int16
system : `+`(x: int32): int32
system : `+`(x, y: int32): int32
system : `+`(x: int64): int64
system : `+`(x, y: int64): int64
system : `+`(x: int8): int8
system : `+`(x, y: int8): int8
system : `+`[T](x, y: set[T]): set[T]
system : `+`[T](x, y: T): T
times : `+`(a: TimeInfo; interval: TimeInterval): TimeInfo
`-%`:
system : `-%`(x, y: int64): int64
system : `-%`[IntMax32](x, y: IntMax32): IntMax32
`->`:
future : `->`(p, b: expr): expr
`-+-`:
sets : `-+-`[A](s1, s2: HashSet[A]): HashSet[A]
`--`:
nimscript : `--`(key: untyped)
nimscript : `--`(key, val: untyped)
`-=`:
basic2d : `-=`(p: var Point2d; v: Vector2d)
basic2d : `-=`(a: var Vector2d; b: float)
basic2d : `-=`(a: var Vector2d; b: Vector2d)
basic3d : `-=`(p: var Point3d; v: Vector3d)
basic3d : `-=`(a: var Vector3d; b: float)
basic3d : `-=`(a: var Vector3d; b: 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](x: var T; y: T)
system : `-=`[T](x: var T; y: T)
`-`:
basic2d : `-`(a: float; b: Vector2d): Vector2d
basic2d : `-`(p1, p2: Point2d): Vector2d
basic2d : `-`(p: Point2d; v: Vector2d): Point2d
basic2d : `-`(v: Vector2d): Vector2d
basic2d : `-`(a: Vector2d; b: float): Vector2d
basic2d : `-`(a, b: Vector2d): Vector2d
basic3d : `-`(a: float; b: Vector3d): Vector3d
basic3d : `-`(p1, p2: Point3d): Vector3d
basic3d : `-`(p: Point3d; v: Vector3d): Point3d
basic3d : `-`(v: Vector3d): Vector3d
basic3d : `-`(a: Vector3d; b: float): Vector3d
basic3d : `-`(a, b: 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](x, y: T): T
times : `-`(a, b: Time): int64
times : `-`(a: TimeInfo; interval: TimeInterval): TimeInfo
`..<`:
system : `..<`(a, b: expr): expr
`..^`:
system : `..^`(a, b: expr): expr
`..`:
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 : `/=`(a: var Vector2d; b: float)
basic2d : `/=`(a: var Vector2d; b: Vector2d)
basic3d : `/=`(a: var Vector3d; b: float)
basic3d : `/=`(a: var Vector3d; b: 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](x: var T; y: T)
`/`:
basic2d : `/`(a: float; b: Vector2d): Vector2d
basic2d : `/`(a: Vector2d; b: float): Vector2d
basic2d : `/`(a, b: Vector2d): Vector2d
basic3d : `/`(a: float; b: Vector3d): Vector3d
basic3d : `/`(a: Vector3d; b: float): Vector3d
basic3d : `/`(a, b: 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: expr): expr
`==`:
asyncdispatch : `==`(x: AsyncFD; y: AsyncFD): bool
asynchttpserver : `==`(protocol: tuple[orig: string, major, minor: int]; ver: HttpVersion): bool
colors : `==`(a, b: Color): bool
complex : `==`(x, y: Complex): bool
json : `==`(a, b: JsonNode): bool
macros : `==`(a, b: NimIdent): bool
macros : `==`(a, b: NimNode): bool
md5 : `==`(D1, D2: MD5Digest): bool
net : `==`(lhs, rhs: IpAddress): bool
oids : `==`(oid1: Oid; oid2: Oid): bool
os : `==`(err1, err2: OSErrorCode): bool
posix : `==`(x, y: SocketHandle): bool
rationals : `==`[Rational](x, y: Rational): 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](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](x, y: T): bool
system : `==`[T](x, y: T): bool
system : `==`[T](x, y: T): 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
`=`:
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)
httpclient : `[]=`(p: var MultipartData; name, content: string)
httpclient : `[]=`(p: var MultipartData; name: string; file: tuple[name, contentType, content: string])
json : `[]=`(obj: JsonNode; key: string; val: JsonNode)
macros : `[]=`(n: NimNode; i: int; child: NimNode)
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, 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
future : `[]`(lc: ListComprehension; comp, typ: expr): expr
json : `[]`(node: JsonNode; index: int): JsonNode
json : `[]`(node: JsonNode; name: string): JsonNode
macros : `[]`(n: NimNode; i: int): NimNode
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, 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](x, y: T): T
`div`:
htmlgen : `div`(e: expr): expr
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](x, y: T): T
`in`:
system : `in`(x, y: expr): expr
`is`:
system : `is`[T, S](x: T; y: S): bool
`isnot`:
system : `isnot`(x, y: expr): expr
`mod`:
math : `mod`(x, y: float): float
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](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](x: T): T
`notin`:
system : `notin`(x, y: expr): expr
`object`:
htmlgen : `object`(e: expr): expr
`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](x, y: T): T
`ptr`:
system : ptr
`raise`:
posix : `raise`(a1: cint): cint
`ref`:
system : ref
`shl`:
system : `shl`(x, y: int): int
system : `shl`(x, y: int16): int16
system : `shl`(x, y: int32): int32
system : `shl`(x, y: int64): int64
system : `shl`(x, y: int8): int8
system : `shl`[T](x, y: T): T
`shr`:
system : `shr`(x, y: int): int
system : `shr`(x, y: int16): int16
system : `shr`(x, y: int32): int32
system : `shr`(x, y: int64): int64
system : `shr`(x, y: int8): int8
system : `shr`[T](x, y: T): T
`type`:
system : `type`[expr, ](x: expr): typedesc
`var`:
htmlgen : `var`(e: expr): expr
`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](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: expr): expr
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
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
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)
acronym:
htmlgen : acronym(e: expr): expr
Actor:
Module actors
ActorPool:
actors : ActorPool
add:
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)
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(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)
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
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)
addNodes:
rst : addNodes(n: PRstNode): string
addQuitProc:
system : addQuitProc(QuitProc: proc ())
address:
htmlgen : address(e: expr): expr
AddrInfo:
posix : AddrInfo
addSep:
strutils : addSep(dest: var string; sep = ", "; startLen: Natural = 0)
affinity:
Module threads
AF_INET:
posix : AF_INET
AF_INET6:
posix : 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
alarm:
posix : alarm(a1: cint): cint
align:
strutils : align(s: string; count: Natural; padding = ' '): string
AlignType:
system : AlignType
all:
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: expr): 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: expr): 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:
xmldom : appendChild(n: PNode; newChild: PNode)
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: expr)
appType:
system : appType
arbitraryAxis:
basic3d : arbitraryAxis(norm: Vector3d): Matrix3d
arccos:
complex : arccos(z: Complex): Complex
math : arccos(x: float): float
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: float): float
arcsinh:
complex : arcsinh(z: Complex): Complex
arctan:
complex : arctan(z: Complex): Complex
math : arctan(x: float): float
arctan2:
math : arctan2(y, x: float): float
arctanh:
complex : arctanh(z: Complex): Complex
area:
basic2d : area(a, b, c: Point2d): float
basic3d : area(a, b, c: Point3d): float
htmlgen : area(e: expr): expr
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: stmt): stmt
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
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: expr): expr
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: expr): expr
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: expr): expr
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
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 = "")
net : bindAddr(socket: Socket; port = Port(0); address = "")
binDir:
nimscript : binDir
bindSocket:
posix : bindSocket(a1: SocketHandle; a2: ptr SockAddr; a3: Socklen): cint
bindSym:
macros : bindSym(ident: string; rule: BindSymRule = brClosed): NimNode
BindSymRule:
macros : BindSymRule
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: expr): expr
BlockTags:
htmlparser : BlockTags
body:
htmlgen : body(e: expr): expr
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: expr): expr
bsd_signal:
posix : bsd_signal(a1: cint; a2: proc (x: pointer))
BufferSize:
net : BufferSize
button:
htmlgen : button(e: expr): expr
byte:
system : byte
ByteAddress:
system : ByteAddress
callback=:
asyncdispatch : callback=[T](future: Future[T]; cb: proc (future: Future[T]))
asyncdispatch : callback=(future: FutureBase; cb: proc ())
CallNodes:
macros : CallNodes
callsite:
macros : callsite(): NimNode
capitalize:
strutils : capitalize(s: string): string
caption:
htmlgen : caption(e: expr): expr
capture:
pegs : capture(a: Peg): Peg
captureBetween:
parseutils : captureBetween(s: string; first: char; second = '\0'; start = 0): string
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](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: float): float
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: float): float
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: stmt): stmt
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: expr): expr
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:
strtabs : clear(s: StringTableRef; mode: StringTableMode)
clearHandlers:
events : clearHandlers(handler: var EventHandler)
clientData:
xmltree : clientData(n: XmlNode): int
clientData=:
xmltree : clientData=(n: XmlNode; data: int)
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:
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)
encodings : close(c: EncodingConverter)
ftpclient : close[T](ftp: FtpBase[T])
httpclient : close(client: AsyncHttpClient)
httpserver : close(h: PAsyncHTTPServer)
httpserver : close(s: Server)
json : close(my: var JsonParser)
lexbase : close(L: var BaseLexer)
memfiles : close(f: var MemFile)
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)
closedir:
posix : closedir(a1: ptr DIR): cint
closeSocket:
asyncdispatch : closeSocket(socket: AsyncFD)
closestPoint:
basic2d : closestPoint(p: Point2d; pts: varargs[Point2d]): Point2d
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: expr): expr
CODESET:
posix : CODESET
col:
htmlgen : col(e: expr): expr
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: expr): expr
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[expr](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])
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
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
ConsoleLogger:
logging : ConsoleLogger
contains:
critbits : contains[T](c: CritBitTree[T]; key: string): bool
intsets : contains(s: IntSet; key: int): 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
pegs : contains(s: string; pattern: Peg; start = 0): bool
pegs : contains(s: string; pattern: Peg; matches: var openArray[string]; start = 0): bool
re : contains(s: string; pattern: Regex; start = 0): bool
re : contains(s: string; pattern: Regex; matches: var openArray[string]; start = 0): bool
selectors : contains(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)
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
cos:
complex : cos(z: Complex): Complex
math : cos(x: float): float
cosh:
complex : cosh(z: Complex): Complex
math : cosh(x: float): float
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)
createAttribute:
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)
createDocument:
xmldom : createDocument(dom: PDOMImplementation; n: PElement): PDocument
xmldom : createDocument(dom: PDOMImplementation; namespaceURI: string; qualifiedName: string): PDocument
createDocumentFragment:
xmldom : createDocumentFragment(doc: PDocument): PDocumentFragment
createElement:
xmldom : createElement(doc: PDocument; tagName: string): PElement
createElementNS:
xmldom : createElementNS(doc: PDocument; namespaceURI: string; qualifiedName: string): PElement
createHardlink:
os : createHardlink(src, dest: string)
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
createProcessingInstruction:
xmldom : createProcessingInstruction(doc: PDocument; target: string; data: string): PProcessingInstruction
createShared:
system : createShared[](T: typedesc; size = 1.Positive): ptr T:type
createSharedU:
system : createSharedU[](T: typedesc; size = 1.Positive): ptr T:type
createSymlink:
os : createSymlink(src, dest: string)
createTextNode:
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
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
DbConn:
db_mysql : DbConn
db_postgres : DbConn
db_sqlite : DbConn
dbError:
db_mysql : dbError(msg: string)
db_postgres : dbError(db: DbConn)
db_postgres : dbError(msg: string)
db_sqlite : dbError(msg: string)
dbQuote:
db_mysql : dbQuote(s: string): string
db_postgres : dbQuote(s: string): string
dd:
htmlgen : dd(e: expr): expr
DeadThreadError:
system : DeadThreadError
dealloc:
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](x: var T; y = 1)
declared:
system : declared[expr](x: expr): bool
declaredInScope:
system : declaredInScope[expr](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[expr](x: expr): bool
definedInScope:
system : definedInScope[expr](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](d: T): T
deinitCond:
locks : deinitCond(cond: var Cond)
deinitGeneralTokenizer:
highlite : deinitGeneralTokenizer(g: var GeneralTokenizer)
deinitLock:
locks : deinitLock(lock: var Lock)
del:
fsmonitor : del(monitor: FSMonitor; wd: cint)
htmlgen : del(e: expr): expr
macros : del(father: NimNode; idx = 0; n = 1)
system : del[T](x: var seq[T]; i: Natural)
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)
delHandleWrite:
asyncio : delHandleWrite(s: AsyncSocket)
dequeue:
queues : dequeue[T](q: var Queue[T]): T
description:
nimscript : description
deseralization:
Module marshal
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: expr): expr
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
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()
disableProfiling:
nimprof : disableProfiling()
disjoint:
sets : disjoint[A](s1, s2: HashSet[A]): bool
Dispatcher:
asyncio : Dispatcher
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: expr): expr
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
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: expr): expr
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
dumpLisp:
macros : dumpLisp(s: stmt): stmt
dumpLispImm:
macros : dumpLispImm(s: stmt): stmt
dumpTree:
macros : dumpTree(s: stmt): stmt
dumpTreeImm:
macros : dumpTreeImm(s: stmt): stmt
dup:
posix : dup(a1: cint): cint
dup2:
posix : dup2(a1, a2: cint): cint
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
EDb:
db_mysql : EDb
db_postgres : EDb
db_sqlite : EDb
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: expr): expr
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]): stmt
EMLINK:
posix : EMLINK
empty:
intsets : empty(s: IntSet): bool
EMSGSIZE:
posix : EMSGSIZE
EMULTIHOP:
posix : EMULTIHOP
enableCache:
ropes : enableCache()
enableProfiling:
nimprof : enableProfiling()
ENamespaceErr:
xmldom : ENamespaceErr
ENAMETOOLONG:
posix : ENAMETOOLONG
encode:
base64 : encode[T](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, 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(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: float): float
erfc:
math : erfc(x: float): float
EROFS:
posix : EROFS
errno:
posix : errno
error:
logging : error(args: varargs[string, `$`])
macros : error(msg: string)
errorHandle:
osproc : errorHandle(p: Process): FileHandle
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
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
escapePeg:
pegs : escapePeg(s: string): string
escapeRe:
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:
selectors : Event
EventArgs:
events : EventArgs
eventAttr:
htmlgen : eventAttr
EventEmitter:
events : EventEmitter
EventError:
events : EventError
EventHandler:
events : EventHandler
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
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
exitnow:
posix : exitnow(code: int): void
exp:
complex : exp(z: Complex): Complex
math : exp(x: float): float
expandFilename:
os : expandFilename(filename: string): string
expandSymlink:
os : expandSymlink(symlinkPath: string): string
expandTilde:
os : expandTilde(path: string): string
ospaths : expandTilde(path: string): string
expect:
unittest : expect(exceptions: varargs[expr]; body: stmt): stmt
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: expr; 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
fdatasync:
posix : fdatasync(a1: cint): cint
FDb:
db_mysql : FDb
db_postgres : FDb
db_sqlite : FDb
FD_CLOEXEC:
posix : FD_CLOEXEC
FD_CLR:
posix : FD_CLR(a1: cint; a2: var TFdSet)
FD_ISSET:
posix : FD_ISSET[](a1: cint | SocketHandle; a2: var TFdSet): cint
FD_SET:
posix : FD_SET[](a1: cint | SocketHandle; a2: var TFdSet)
FD_SETSIZE:
posix : FD_SETSIZE
F_DUPFD:
posix : F_DUPFD
FD_ZERO:
posix : FD_ZERO(a1: 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
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, T](x: S; y: T): tuple[a, b: expr]
system : fieldPairs[T](x: T): RootObj
fields:
system : fields[S, T](x: S; y: T): tuple[a, b: expr]
system : fields[T](x: T): RootObj
typeinfo : fields(x: Any): tuple[name: string, any: Any]
fieldset:
htmlgen : fieldset(e: expr): expr
File:
system : File
fileExists:
ftpclient : fileExists(ftp: FtpClient; file: string): bool
nimscript : fileExists(filename: string): bool
os : fileExists(filename: string): bool
FileHandle:
system : FileHandle
FileId:
os : FileId
FileInfo:
os : FileInfo
FileLogger:
logging : FileLogger
FileMode:
system : FileMode
fileNewer:
os : fileNewer(a, b: string): bool
FilePermission:
os : FilePermission
FileStream:
streams : FileStream
FileStreamObj:
streams : FileStreamObj
FileSystemCaseSensitive:
os : FileSystemCaseSensitive
ospaths : FileSystemCaseSensitive
fill:
algorithm : fill[T](a: var openArray[T]; first, last: Natural; value: T)
algorithm : fill[T](a: var openArray[T]; value: T)
filter:
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: expr): expr
find:
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]
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:
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: expr): NimNode
findExe:
os : findExe(exe: string): string
ospaths : findExe(exe: string): string
FindFileHandler:
rst : FindFileHandler
finished:
asyncdispatch : finished[T](future: Future[T]): bool
system : finished[T](x: T): bool
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: float): float
FlowVar:
threadpool : FlowVar
FlowVarBase:
threadpool : FlowVarBase
flush:
streams : flush(s: Stream)
flushFile:
system : flushFile(f: File)
fmod:
math : fmod(x, y: float): float
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
F_OK:
posix : F_OK
foldl:
sequtils : foldl(sequence, operation: expr): expr
foldr:
sequtils : foldr(sequence, operation: expr): expr
ForegroundColor:
terminal : ForegroundColor
foreign:
threadpool : foreign
fork:
posix : fork(): Pid
form:
htmlgen : form(e: expr): expr
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
FormatFlag:
strtabs : FormatFlag
formatFloat:
strutils : formatFloat(f: float; format: FloatFormatMode = ffDefault; precision: range[0 .. 32] = 16; decimalSep = '.'): string
formatNamedVars:
rstgen : formatNamedVars(frmt: string; varnames: openArray[string]; varvalues: openArray[string]): string
formatSize:
strutils : formatSize(bytes: BiggestInt; decimalSep = '.'): string
FormElement:
dom : FormElement
fpathconf:
posix : fpathconf(a1, a2: cint): int
fpRadix:
fenv : fpRadix(): int
Frame:
dom : Frame
F_RDLCK:
posix : F_RDLCK
FReadDb:
db_mysql : FReadDb
db_postgres : FReadDb
db_sqlite : FReadDb
freeaddrinfo:
posix : freeaddrinfo(a1: ptr AddrInfo)
freeShared:
system : freeShared[T](p: ptr T)
frexp:
math : frexp(x: float; exponent: var int): float
fromSeconds:
times : fromSeconds(since1970: float): Time
times : fromSeconds(since1970: int64): Time
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
FWriteDb:
db_mysql : FWriteDb
db_postgres : FWriteDb
db_sqlite : FWriteDb
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
genOid:
oids : genOid(): Oid
genSym:
macros : genSym(kind: NimSymKind = nskLet; ident = ""): NimNode
get:
httpclient : get(client: AsyncHttpClient; url: string): Future[Response]
httpclient : get(url: string; extraHeaders = ""; maxRedirects = 5; sslContext: SSLContext = defaultSSLContext; timeout = - 1; userAgent = defUserAgent; proxy: Proxy = nil): Response
nimscript : get(key: string): string
getaddrinfo:
posix : getaddrinfo(a1, a2: cstring; a3: ptr AddrInfo; a4: var ptr AddrInfo): cint
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[expr](macroOrTemplate: expr): NimNode
getAttribute:
xmldom : getAttribute(el: PElement; name: string): string
getAttributeNode:
xmldom : getAttributeNode(el: PElement; name: string): PAttr
getAttributeNodeNS:
xmldom : getAttributeNodeNS(el: PElement; namespaceURI: string; localName: string): PAttr
getAttributeNS:
xmldom : getAttributeNS(el: PElement; 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
getConfigDir:
os : getConfigDir(): string
ospaths : getConfigDir(): string
getContent:
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
getCurrentEncoding:
encodings : getCurrentEncoding(): string
getCurrentException:
system : getCurrentException(): ref Exception
getCurrentExceptionMsg:
system : getCurrentExceptionMsg(): string
getCurrentLine:
lexbase : getCurrentLine(L: BaseLexer; marker: bool = true): string
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
getElementsByTagName:
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
geteuid:
posix : geteuid(): Uid
getExt:
mimetypes : getExt(mimedb: MimeDB; mimetype: string; default = "txt"): string
getFd:
asyncnet : getFd(socket: AsyncSocket): SocketHandle
net : getFd(socket: Socket): SocketHandle
getFields:
json : getFields(n: JsonNode; default: seq[tuple[key: string, val: JsonNode]] = @ []): seq[ tuple[key: string, val: JsonNode]]
getFieldValue:
rst : getFieldValue(n: PRstNode): string
rst : getFieldValue(n: PRstNode; fieldname: string): string
getFileHandle:
system : getFileHandle(f: File): FileHandle
getFileInfo:
os : getFileInfo(file: File): FileInfo
os : getFileInfo(handle: FileHandle): FileInfo
os : getFileInfo(path: string; followSymlink = true): FileInfo
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
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
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:
posix : gethostbyaddr(a1: pointer; a2: Socklen; a3: cint): ptr Hostent
gethostbyname:
posix : gethostbyname(a1: 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
getLastModificationTime:
os : getLastModificationTime(file: string): Time
getLine:
json : getLine(my: JsonParser): int
parsecfg : getLine(c: CfgParser): int
parsexml : getLine(my: XmlParser): int
getLocalAddr:
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
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
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
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:
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
getPathInfo:
cgi : getPathInfo(): string
getPathTranslated:
cgi : getPathTranslated(): string
getPeerAddr:
net : getPeerAddr(socket: Socket): (string, Port)
getpeername:
posix : getpeername(a1: SocketHandle; a2: ptr SockAddr; a3: 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
getprotobyname:
posix : getprotobyname(a1: cstring): ptr Protoent
getprotobynumber:
posix : getprotobynumber(a1: cint): ptr Protoent
getprotoent:
posix : getprotoent(): ptr Protoent
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
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
getservbyname:
posix : getservbyname(a1, a2: cstring): ptr Servent
getservbyport:
posix : getservbyport(a1: cint; a2: 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
getSocket:
asyncio : getSocket(s: AsyncSocket): Socket
getSocketError:
net : getSocketError(socket: Socket): OSErrorCode
getsockname:
posix : getsockname(a1: SocketHandle; a2: ptr SockAddr; a3: 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
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
getStr:
json : getStr(n: JsonNode; default: string = ""): string
getString:
typeinfo : getString(x: Any): string
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
getTypeInfo:
system : getTypeInfo[T](x: T): pointer
getTzname:
times : getTzname(): tuple[nonDST, DST: string]
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; query: SqlQuery; args: varargs[string, `$`]): string
db_sqlite : getValue(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): string
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
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
gorge:
system : gorge(command: string; input = ""; cache = ""): string
graphemeLen:
unicode : graphemeLen(s: string; i: Natural): Natural
Group:
posix : Group
guarded:
system : guarded
h1:
htmlgen : h1(e: expr): expr
h2:
htmlgen : h2(e: expr): expr
h3:
htmlgen : h3(e: expr): expr
h4:
htmlgen : h4(e: expr): expr
h5:
htmlgen : h5(e: expr): expr
h6:
htmlgen : h6(e: expr): expr
handleCR:
lexbase : handleCR(L: var BaseLexer; pos: int): int
handleLF:
lexbase : handleLF(L: var BaseLexer; pos: int): int
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:
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](x: T): Hash
hashes : hash[T](x: T): Hash
hashes : hash[T](x: T): Hash
json : hash(n: 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
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
head:
htmlgen : head(e: expr): expr
h_errno:
posix : h_errno
hexbyte:
oids : hexbyte(hex: char): int
HexDigits:
strutils : HexDigits
high:
system : high[T](x: T): T
hint:
macros : hint(msg: string)
hostCPU:
system : hostCPU
Hostent:
posix : Hostent
HOST_NOT_FOUND:
posix : HOST_NOT_FOUND
hostOS:
system : hostOS
hr:
htmlgen : hr(): expr
hstrerror:
posix : hstrerror(herrnum: cint): cstring
html:
htmlgen : html(e: expr): expr
HTML:
Module htmlgen
Module parsexml
HtmlTag:
htmlparser : HtmlTag
htmlTag:
htmlparser : htmlTag(s: string): HtmlTag
htmlparser : htmlTag(n: XmlNode): HtmlTag
htonl:
posix : htonl(a1: int32): int32
htons:
posix : htons(a1: int16): int16
HttpCode:
asynchttpserver : HttpCode
HttpMethod:
httpclient : HttpMethod
HttpRequestError:
httpclient : HttpRequestError
HttpVersion:
asynchttpserver : HttpVersion
hypot:
math : hypot(x, y: float): float
i:
htmlgen : i(e: expr): expr
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
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: expr): expr
implementation:
xmldom : implementation(doc: PDocument): PDOMImplementation
importNode:
xmldom : importNode(doc: PDocument; importedNode: PNode; deep: bool): PNode
In6Addr:
posix : In6Addr
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
INADDR_ANY:
posix : INADDR_ANY
INADDR_BROADCAST:
posix : INADDR_BROADCAST
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](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
INET_ADDRSTRLEN:
posix : INET_ADDRSTRLEN
inet_ntoa:
posix : inet_ntoa(a1: InAddr): cstring
inet_ntop:
posix : inet_ntop(a1: cint; a2: pointer; a3: cstring; a4: int32): cstring
inet_pton:
posix : inet_pton(a1: cint; a2: cstring; a3: pointer): cint
Inf:
system : Inf
infix:
macros : infix(a: NimNode; op: string; b: NimNode): NimNode
info:
logging : info(args: varargs[string, `$`])
init:
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]
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 = 4): Queue[T]
initRational:
rationals : initRational[T](num, den: T): Rational[T]
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: expr): expr
inputHandle:
osproc : inputHandle(p: Process): FileHandle
inputStream:
osproc : inputStream(p: Process): Stream
ins:
htmlgen : ins(e: expr): expr
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:
xmldom : insertBefore(n: PNode; newChild: PNode; refChild: PNode): PNode
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; 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; 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
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_SOCKET:
posix : INVALID_SOCKET
inverse:
basic2d : inverse(m: Matrix2d): Matrix2d
basic3d : inverse(m: Matrix3d): Matrix3d
invokeNew:
typeinfo : invokeNew(x: Any)
invokeNewSeq:
typeinfo : invokeNewSeq(x: Any; len: int)
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
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
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
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](x: T): bool
typeinfo : isNil(x: Any): 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
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
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
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
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
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
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): string
Itimerspec:
posix : Itimerspec
join:
actors : join[In, Out](a: var ActorPool[In, Out])
actors : join[In, Out](a: PActor[In, Out])
strutils : join(a: openArray[string]): string
strutils : join(a: openArray[string]; 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: expr): expr
keepIf:
sequtils : keepIf[T](seq1: var seq[T]; pred: proc (item: T): bool)
keepItIf:
sequtils : keepItIf[seq](varSeq: seq; pred: expr)
Key:
posix : Key
KeyError:
system : KeyError
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): 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
label:
htmlgen : label(e: expr): expr
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: expr): expr
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
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
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](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: float): float
li:
htmlgen : li(e: expr): expr
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: expr): expr
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)
net : listen(socket: Socket; backlog = SOMAXCONN)
posix : listen(a1: SocketHandle; a2: 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: float): float
load:
marshal : load[T](s: Stream; data: var T)
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
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
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
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: float): float
log2:
complex : log2(z: Complex): Complex
math : log2(x: float): float
Logger:
logging : Logger
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
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: expr): expr
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: expr): expr
sequtils : mapIt(seq1, typ, op: expr): expr
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
markdown:
Module rst
match:
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
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
MAX_INT:
Module system
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:
math : mean[T](x: openArray[T]): 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
Message:
smtp : Message
meta:
htmlgen : meta(e: expr): expr
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)
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
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:
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
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
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
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
moveFile:
os : moveFile(source, dest: string)
moveMem:
system : moveMem(dest, source: pointer; size: Natural)
mpairs:
critbits : mpairs[T](c: var CritBitTree[T]): tuple[key: string, val: var T]
json : mpairs(node: var JsonNode): var tuple[key: string, val: 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): 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
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
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): 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
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): AsyncHttpClient
newAsyncHttpServer:
asynchttpserver : newAsyncHttpServer(reuseAddr = true): 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
newConsoleLogger:
logging : newConsoleLogger(levelThreshold = lvlAll; fmtStr = defaultFmtStr): ConsoleLogger
newConstStmt:
macros : newConstStmt(name, value: NimNode): NimNode
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(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]
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
newMimetypes:
mimetypes : newMimetypes(): MimeDB
newMonitor:
fsmonitor : newMonitor(): FSMonitor
newMultipartData:
httpclient : newMultipartData(): MultipartData
httpclient : newMultipartData(xs: MultipartEntries): MultipartData
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
newRawSocket:
rawsockets : newRawSocket(domain, sockType, protocol: cint): expr
rawsockets : newRawSocket(domain: Domain = AF_INET; sockType: SockType = SOCK_STREAM; protocol: Protocol = IPPROTO_TCP): expr
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)
newSeqWith:
sequtils : newSeqWith(len: int; init: expr): expr
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:
xmldom : nodeType(n: PNode): int
NOEXPR:
posix : NOEXPR
NoFakeVars:
system : NoFakeVars
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)
normAngle:
basic2d : normAngle(ang: float): float
noscript:
htmlgen : noscript(e: expr): expr
ntohl:
posix : ntohl(a1: int32): int32
ntohs:
posix : ntohs(a1: int16): int16
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: expr): expr
on:
events : on(emitter: var EventEmitter; event: string; fn: proc (e: EventArgs))
system : on
onFailedAssert:
system : onFailedAssert(msg: expr; code: stmt): stmt
O_NOCTTY:
posix : O_NOCTTY
O_NONBLOCK:
posix : O_NONBLOCK
onRaise:
system : onRaise(action: proc (e: ref Exception): bool)
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
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)
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
OpenMP:
Module system
optgroup:
htmlgen : optgroup(e: expr): expr
option:
htmlgen : option(e: expr): expr
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
osLastError:
os : osLastError(): OSErrorCode
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
ownerDocument:
xmldom : ownerDocument(n: PNode): PDocument
ownerElement:
xmldom : ownerElement(a: PAttr): PElement
O_WRONLY:
posix : O_WRONLY
p:
htmlgen : p(e: expr): expr
packageName:
nimscript : packageName
PActor:
actors : PActor
pairs:
critbits : pairs[T](c: CritBitTree[T]): tuple[key: string, val: T]
json : pairs(node: JsonNode): tuple[key: string, val: JsonNode]
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): 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: expr): expr
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
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](s: string): T
strutils : parseEnum[T](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
parseHex:
parseutils : parseHex(s: string; number: var int; start = 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
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
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
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
Passwd:
posix : Passwd
PAsyncHTTPServer:
httpserver : PAsyncHTTPServer
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
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
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
peekLine:
streams : peekLine(s: Stream): TaintedString
streams : peekLine(s: Stream; line: var TaintedString): 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[expr](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
piRest:
parsexml : piRest(my: XmlParser): string
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:
system : pop[T](s: var seq[T]): T
popen:
posix : popen(a1, a2: cstring): File
port:
httpserver : port(s: var Server): 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(url: string; extraHeaders = ""; body = ""; maxRedirects = 5; sslContext: SSLContext = defaultSSLContext; timeout = - 1; userAgent = defUserAgent; proxy: Proxy = nil; multipart: MultipartData = nil): Response
postContent:
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
poUseShell:
osproc : poUseShell
pow:
complex : pow(x, y: Complex): Complex
math : pow(x, y: float): float
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: expr): expr
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
previousSibling:
xmldom : previousSibling(n: PNode): PNode
prevPermutation:
algorithm : prevPermutation[T](x: var openArray[T]): bool
ProcAddr:
system : ProcAddr
procCall:
system : procCall[expr](x: expr)
Process:
osproc : Process
processedRows:
parsecsv : processedRows(my: var CsvParser): int
processID:
osproc : processID(p: Process): int
ProcessingInstructionNode:
xmldom : ProcessingInstructionNode
ProcessOption:
osproc : ProcessOption
product:
algorithm : product[T](x: openArray[seq[T]]): seq[seq[T]]
programResult:
system : programResult
ProgressChangedProc:
asyncftpclient : ProgressChangedProc
PROT_EXEC:
posix : PROT_EXEC
PROT_NONE:
posix : PROT_NONE
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
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()
push:
math : push(s: var RunningStat; x: float)
math : push(s: var RunningStat; x: 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
pwrite:
posix : pwrite(a1: cint; a2: pointer; a3: int; a4: Off): int
q:
htmlgen : q(e: expr): expr
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: stmt; 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](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)
random:
math : random(max: float): float
math : random(max: int): int
math : random[T](a: openArray[T]): T
math : random[T](x: Slice[T]): T
randomize:
math : randomize()
math : 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](x: T): pointer
rawMatch:
pegs : rawMatch(s: string; p: Peg; start: int; c: var Captures): int
rawProc:
system : rawProc[T](x: T): pointer
rawTag:
xmltree : rawTag(n: XmlNode): string
rawText:
xmltree : rawText(n: XmlNode): string
re:
re : re(s: string; flags = {reExtended, reStudy}): Regex
read:
asyncdispatch : read[T](future: Future[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:
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
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
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
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
readFloat32:
streams : readFloat32(s: Stream): float32
readFloat64:
streams : readFloat64(s: Stream): float64
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})
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
ReadLineResult:
net : ReadLineResult
readlink:
posix : readlink(a1, a2: cstring; a3: int): int
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
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; 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
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
recvInto:
asyncdispatch : recvInto(socket: AsyncFD; buf: cstring; 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}): Future[string]
ssl : recvLine(sock: SecureSocket; line: var TaintedString): bool
recvLineInto:
asyncnet : recvLineInto(socket: AsyncSocket; resString: FutureVar[string]; flags = {SafeDisconn}): Future[void]
recvmsg:
posix : recvmsg(a1: SocketHandle; a2: ptr Tmsghdr; a3: cint): int
reduce:
rationals : reduce[T](x: var Rational[T])
reEmail:
re : reEmail
RefCount:
system : RefCount
reFloat:
re : reFloat
Regex:
re : Regex
regex:
Substitution Expressions (subex)
RegexError:
re : RegexError
RegexFlag:
re : RegexFlag
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
reHex:
re : reHex
reIdentifier:
re : reIdentifier
reInteger:
re : reInteger
release:
locks : release(lock: var Lock)
remove:
lists : remove[T](L: var DoublyLinkedList[T]; n: DoublyLinkedNode[T])
lists : remove[T](L: var DoublyLinkedRing[T]; n: DoublyLinkedNode[T])
removeAttribute:
xmldom : removeAttribute(el: PElement; name: string)
removeAttributeNode:
xmldom : removeAttributeNode(el: PElement; oldAttr: PAttr): PAttr
removeAttributeNS:
xmldom : removeAttributeNS(el: PElement; namespaceURI: string; localName: string)
removeChild:
xmldom : removeChild(n: PNode; oldChild: PNode): PNode
removeDir:
os : removeDir(dir: string)
removeFile:
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)
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:
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:
xmldom : replaceChild(n: PNode; newChild: PNode; oldChild: PNode): PNode
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 = ""): Future[ Response]
httpclient : request(client: AsyncHttpClient; url: string; httpMethod: string; body = ""): Future[ 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: stmt): stmt
requires:
nimscript : requires(deps: varargs[string])
requiresData:
nimscript : requiresData
ReraiseError:
system : ReraiseError
reset:
system : reset[T](obj: var T)
resetAttributes:
terminal : resetAttributes()
terminal : resetAttributes(f: File)
resize:
system : resize[T](p: ptr T; newSize: Natural): ptr T
resizeShared:
system : resizeShared[T](p: ptr T; newSize: Natural): ptr T
resource:
Module system
ResourceExhaustedError:
system : ResourceExhaustedError
respond:
asynchttpserver : respond(req: Request; code: HttpCode; content: string; headers: StringTableRef = nil): Future[ void]
Response:
httpclient : Response
reStructuredText:
Module rst
Module rstast
Module rstgen
resume:
osproc : resume(p: Process)
retrFile:
asyncftpclient : retrFile(ftp: AsyncFtpClient; file, dest: string; onProgressChanged = 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
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(x: float): int
RoutineNodes:
macros : RoutineNodes
Row:
db_mysql : Row
db_postgres : Row
db_sqlite : Row
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
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:
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
RuneImpl:
unicode : RuneImpl
runeLen:
unicode : runeLen(s: string): int
runeLenAt:
unicode : runeLenAt(s: string; i: Natural): int
runes:
unicode : runes(s: string): Rune
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
RunningStat:
math : 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: expr): expr
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)
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: expr): expr
ScriptExt:
os : ScriptExt
ospaths : ScriptExt
ScriptMode:
nimscript : ScriptMode
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
SecureSocket:
ssl : SecureSocket
SEEK_CUR:
posix : SEEK_CUR
seekdir:
posix : seekdir(a1: ptr DIR; a2: int)
SEEK_END:
posix : SEEK_END
SEEK_SET:
posix : SEEK_SET
select:
htmlgen : select(e: expr): expr
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]
Selector:
selectors : Selector
SelectorData:
selectors : SelectorData
SelectorKey:
selectors : SelectorKey
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; data: string; flags = {SafeDisconn}): Future[void]
asyncftpclient : send(ftp: AsyncFtpClient; m: string): Future[TaintedString]
asyncio : send(sock: AsyncSocket; data: string)
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)
sendHeaders:
asynchttpserver : sendHeaders(req: Request; headers: StringTableRef): 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:
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
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:
posix : Servent
Server:
httpserver : Server
set:
system : set
setAttribute:
xmldom : setAttribute(el: PElement; name: string; value: string)
setAttributeNode:
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)
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)
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
seteuid:
posix : seteuid(a1: Uid): cint
setFilePermissions:
os : setFilePermissions(filename: string; permissions: set[FilePermission])
setFilePos:
asyncfile : setFilePos(f: AsyncFile; pos: int64)
system : setFilePos(f: File; pos: int64)
system : setFilePos(f: File; pos: int64)
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 = "")
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)
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
setStackTraceNewLine:
cgi : setStackTraceNewLine()
setStackTraceStdout:
cgi : setStackTraceStdout()
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])
setuid:
posix : setuid(a1: Uid): cint
setupForeignThreadGc:
system : setupForeignThreadGc()
sgnArea:
basic2d : sgnArea(a, b, c: Point2d): float
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:
system : shared
shared object:
Module os
Module ospaths
shell command:
Module os
shm_open:
posix : shm_open(a1: cstring; a2: cint; a3: Mode): cint
shm_unlink:
posix : shm_unlink(a1: cstring): cint
shutdown:
posix : shutdown(a1: SocketHandle; a2: 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
sin:
complex : sin(z: Complex): Complex
math : sin(x: float): float
SingleTags:
htmlparser : SingleTags
SinglyLinkedList:
lists : SinglyLinkedList
SinglyLinkedNode:
lists : SinglyLinkedNode
SinglyLinkedNodeObj:
lists : SinglyLinkedNodeObj
SinglyLinkedRing:
lists : SinglyLinkedRing
sinh:
complex : sinh(z: Complex): Complex
math : sinh(x: float): float
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
skip:
net : skip(socket: Socket; size: int; timeout = - 1)
parseutils : skip(s, token: string; start = 0): int
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
sleepAsync:
asyncdispatch : sleepAsync(ms: int): Future[void]
Slice:
system : Slice
slice:
Module system
Module system
slopeVector2d:
basic2d : slopeVector2d(slope: float; len: float): Vector2d
slurp:
system : slurp(filename: string): string
small:
htmlgen : small(e: expr): expr
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
SOBool:
net : SOBool
SO_BROADCAST:
posix : SO_BROADCAST
SockAddr:
posix : SockAddr
Sockaddr_in:
posix : Sockaddr_in
Sockaddr_in6:
posix : Sockaddr_in6
Sockaddr_storage:
posix : Sockaddr_storage
sockatmark:
posix : sockatmark(a1: cint): cint
SOCK_DGRAM:
posix : SOCK_DGRAM
Socket:
net : Socket
socket:
posix : socket(a1, a2, a3: cint): SocketHandle
socketError:
net : socketError(socket: Socket; err: int = - 1; async = false; lastError = -1.OSErrorCode): void
SocketFlag:
net : SocketFlag
SocketHandle:
posix : SocketHandle
SocketImpl:
net : SocketImpl
socketpair:
posix : socketpair(a1, a2, a3: cint; a4: var array[0 .. 1, cint]): cint
SocketStatus:
asyncio : SocketStatus
Socklen:
posix : Socklen
SOCK_RAW:
posix : SOCK_RAW
SOCK_SEQPACKET:
posix : SOCK_SEQPACKET
SOCK_STREAM:
posix : SOCK_STREAM
SO_DEBUG:
posix : SO_DEBUG
SO_DONTROUTE:
posix : SO_DONTROUTE
SO_ERROR:
posix : SO_ERROR
SO_KEEPALIVE:
posix : SO_KEEPALIVE
SO_LINGER:
posix : SO_LINGER
SOL_SOCKET:
posix : SOL_SOCKET
SOMAXCONN:
posix : SOMAXCONN
SomeInteger:
system : SomeInteger
SomeNumber:
system : SomeNumber
SomeOrdinal:
system : SomeOrdinal
SomeReal:
system : SomeReal
SomeSignedInt:
system : SomeSignedInt
SomeUnsignedInt:
system : SomeUnsignedInt
SO_OOBINLINE:
posix : SO_OOBINLINE
SO_RCVBUF:
posix : SO_RCVBUF
SO_RCVLOWAT:
posix : SO_RCVLOWAT
SO_RCVTIMEO:
posix : SO_RCVTIMEO
SO_REUSEADDR:
posix : SO_REUSEADDR
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: expr): expr
SortOrder:
algorithm : SortOrder
SO_SNDBUF:
posix : SO_SNDBUF
SO_SNDLOWAT:
posix : SO_SNDLOWAT
SO_SNDTIMEO:
posix : SO_SNDTIMEO
SO_TYPE:
posix : SO_TYPE
SourceLanguage:
highlite : SourceLanguage
sourceLanguageToStr:
highlite : sourceLanguageToStr
spaces:
strutils : spaces(n: Natural): string
span:
htmlgen : span(e: expr): expr
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[expr](call: expr): expr
spawnX:
threadpool : spawnX(call: expr): expr
specified:
xmldom : specified(a: PAttr): bool
splice:
Module system
Module system
split:
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): seq[string]
strutils : split(s: string; seps: set[char] = Whitespace): seq[string]
strutils : split(s: string; sep: string): seq[string]
strutils : split(s: string; sep: char): string
strutils : split(s: string; seps: set[char] = Whitespace): string
strutils : split(s: string; sep: string): string
splitData:
xmldom : splitData(textNode: PText; offset: int): PText
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
sql:
db_mysql : sql(query: string): SqlQuery
db_postgres : sql(query: string): SqlQuery
db_sqlite : 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_mysql : SqlQuery
db_postgres : SqlQuery
db_sqlite : 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: float): float
srcdir:
nimscript : srcdir
SS_DISABLE:
posix : SS_DISABLE
SS_ONSTACK:
posix : SS_ONSTACK
Stack:
posix : Stack
StackOverflowError:
system : StackOverflowError
stackTraceAvailable:
system : stackTraceAvailable(): bool
system : stackTraceAvailable(): bool
standardDeviation:
math : standardDeviation(s: RunningStat): float
startAnchor:
pegs : startAnchor(): Peg
startCmd:
osproc : startCmd(command: string; options: set[ProcessOption] = {poStdErrToStdOut, poUsePath}): Process
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, prefix: string): bool
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
Statvfs:
posix : Statvfs
statvfs:
posix : statvfs(a1: cstring; a2: var Statvfs): cint
stderr:
system : stderr
STDERR_FILENO:
posix : STDERR_FILENO
stdin:
system : stdin
STDIN_FILENO:
posix : STDIN_FILENO
stdmsg:
system : stdmsg(): File
stdout:
system : stdout
STDOUT_FILENO:
posix : STDOUT_FILENO
stmt:
system : stmt
ST_NOSUID:
posix : ST_NOSUID
store:
asyncftpclient : store(ftp: AsyncFtpClient; file, dest: string; onProgressChanged = 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: expr): expr
strptime:
posix : strptime(a1, a2: cstring; a3: var Tm): cstring
strVal:
macros : strVal(n: NimNode): string
strVal=:
macros : strVal=(n: NimNode; val: string)
style:
htmlgen : style(e: expr): expr
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: expr): expr
Subex:
subexes : Subex
subex:
subexes : subex(s: string): Subex
Module subexes
SubexError:
subexes : SubexError
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
suite:
unittest : suite(name: expr; body: stmt): stmt
sum:
math : sum[T](x: openArray[T]): T
sup:
htmlgen : sup(e: expr): expr
super:
Module system
Suseconds:
posix : Suseconds
suspend:
osproc : suspend(p: Process)
swab:
posix : swab(a1, a2: pointer; a3: int)
swap:
system : swap[T](a, b: var T)
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 = "")
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()
sysconf:
posix : sysconf(a1: cint): int
system:
Module osproc
SystemError:
system : SystemError
table:
htmlgen : table(e: expr): expr
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: float): float
TAnchor:
dom : TAnchor
tanh:
complex : tanh(z: Complex): Complex
math : tanh(x: float): float
TApplet:
dom : TApplet
target:
xmldom : target(pi: PProcessingInstruction): string
Task:
actors : Task
task:
nimscript : task(name: untyped; description: string; body: untyped): untyped
tbody:
htmlgen : tbody(e: expr): expr
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: expr): expr
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
terminate:
actors : terminate[In, Out](a: var ActorPool[In, Out])
osproc : terminate(p: Process)
test:
unittest : test(name: expr; body: stmt): stmt
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: expr): expr
TextNode:
xmldom : TextNode
TFdSet:
posix : 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: expr): expr
TForm:
dom : TForm
TFrame:
dom : TFrame
system : TFrame
tgamma:
math : tgamma(x: float): float
th:
htmlgen : th(e: expr): expr
thead:
htmlgen : thead(e: expr): expr
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:
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: var ClockId; a2: var SigEvent; a3: var Timer): cint
timer_delete:
posix : timer_delete(a1: var 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
timezone:
posix : timezone
TInterval:
dom : TInterval
Tipv6_mreq:
posix : Tipv6_mreq
title:
htmlgen : title(e: expr): expr
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
toHex:
strutils : toHex(x: BiggestInt; len: Positive): string
toInt:
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
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](x: T): Rational[T]
toRunes:
unicode : toRunes(s: string): seq[Rune]
toSeconds:
times : toSeconds(time: Time): float
toSeq:
sequtils : toSeq(iter: expr): expr
toSet:
sets : toSet[A](keys: openArray[A]): HashSet[A]
toString:
Module system
toStrLit:
macros : toStrLit(n: NimNode): NimNode
toTable:
tables : toTable[A, B](pairs: openArray[(A, B)]): Table[A, B]
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
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: expr): expr
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)
transpose:
basic3d : transpose(m: Matrix3d): Matrix3d
treeRepr:
macros : treeRepr(n: NimNode): string
TResult:
system : TResult
trunc:
math : trunc(x: float): float
truncate:
posix : truncate(a1: cstring; a2: Off): cint
tryAcquire:
locks : tryAcquire(lock: var Lock): 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: expr): expr
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
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
Uid:
posix : Uid
uint:
system : uint
uint16:
system : uint16
uint32:
system : uint32
uint64:
system : uint64
uint8:
system : uint8
ul:
htmlgen : ul(e: expr): expr
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; eatAllIndent = false): 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)
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
unsafeAddr:
system : unsafeAddr[T](x: var T): ptr 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
usleep:
posix : usleep(a1: Useconds): cint
Utf16Char:
system : Utf16Char
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): T
varargs:
system : varargs
variance:
math : variance[T](x: openArray[T]): float
math : variance(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:
locks : wait(cond: var Cond; lock: var Lock)
posix : wait(a1: ptr cint): Pid
waitFor:
asyncdispatch : waitFor[T](fut: Future[T]): T
waitForExit:
osproc : waitForExit(p: Process; timeout: int = - 1): int
waitid:
posix : waitid(a1: cint; a2: Id; a3: var SigInfo; a4: cint): cint
waitpid:
posix : waitpid(a1: Pid; a2: var cint; a3: cint): Pid
walkDir:
os : walkDir(dir: string; relative = false): tuple[kind: PathComponent, path: string]
walkDirRec:
os : walkDirRec(dir: string; filter = {pcFile, pcDir}): string
walkFiles:
os : walkFiles(pattern: string): string
warn:
logging : warn(args: varargs[string, `$`])
warning:
macros : warning(msg: string)
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
Window:
dom : Window
window:
dom : window
winTimeToUnixTime:
times : winTimeToUnixTime(t: int64): Time
withDir:
nimscript : withDir(dir: string; body: untyped): untyped
WNOHANG:
posix : WNOHANG
WNOWAIT:
posix : WNOWAIT
W_OK:
posix : W_OK
wordWrap:
strutils : wordWrap(s: string; maxLineWidth = 80; splitLongWords = true; seps: set[char] = Whitespace; newLine = "\x0A"): string
write:
asyncfile : write(f: AsyncFile; data: string): Future[void]
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:
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
writeContentType:
cgi : writeContentType()
writeData:
streams : writeData(s: Stream; buffer: pointer; bufLen: int)
streams : writeData(s, unused: Stream; buffer: pointer; bufLen: int)
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)
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:
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
WSTOPPED:
posix : WSTOPPED
WSTOPSIG:
posix : WSTOPSIG
WTERMSIG:
posix : WTERMSIG
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
YESEXPR:
posix : YESEXPR
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]]