system

Исходный код Редактировать

Для корректной работы компилятора необходим модуль System, а модуль System, в свою очередь, зависит от компилятора. Большинство функций, перечисленных здесь, используют специальную магию компилятора.

Каждый модуль неявно импортирует модуль System; его не нужно указывать явно. Из-за этого не может быть пользовательского модуля с именем system.

Модуль System

Модуль System импортирует несколько отдельных модулей, и их документация находится в отдельных файлах:

Ниже приведён краткий обзор наиболее часто используемых функций из модуля system. Названия функций в таблицах ниже являются кликабельными и ведут к полной документации функции.

Доступно намного больше функций, чем перечисленные в этом обзоре. Используйте таблицу содержания слева и/или Ctrl+F для навигации по данному модулю.

Строки и символы

Процедура	Использование
len(s)	Возвращает длину строки
chr(i)	Преобразует `int` в диапазоне `0..255` в символ
ord(c)	Возвращает `int` значение символа
a & b	Конкатенация двух строк
s.add(c)	Добавление символа в строку
$	Преобразование различных типов в строку

См. также:

модуль strutils для общих функций обработки строк
модуль strformat для интерполяции и форматирования строк
модуль unicode для обработки Unicode UTF-8
strscans для scanf и scanp макросов, которые предлагают более удобный способ извлечения подстрок, чем регулярные выражения
модуль strtabs для эффективных хеш-таблиц (словарей в некоторых языках программирования), сопоставляющих строки со строками

Последовательности (Seqs)

Процедура	Использование
newSeq	Создание новой последовательности заданной длины
newSeqOfCap	Создание новой последовательности с нулевой длиной и заданной ёмкостью
setLen	Установка длины последовательности
len	Возвращение длины последовательности
@	Преобразование массива в последовательность
add	Добавление элемента в последовательность
insert	Вставка элемента в определённую позицию
delete	Удаление элемента с сохранением порядка элементов (операция `O(n)`)
del	Удаление элемента, не сохраняя порядок (`O(1)`)
pop	Удаление и возврат последнего элемента последовательности
x & y	Конкатенация двух последовательностей
x[a .. b]	Срезы последовательности (обе границы включены)
x[a .. ^b]	Срезы последовательности, но `b` — это индекс в обратном порядке (обе границы включены)
x[a ..< b]	Срез последовательности (верхняя граница исключена)

См. также:

модуль sequtils для операций над типами контейнеров (включая строки)
модуль json для структуры, допускающей гетерогенные члены
модуль lists для связанных списков

Множества

Встроенные битовые множества.

Процедура	Использование
incl	Включение элемента `y` в множество `x`
excl	Исключение элемента `y` из множества `x`
card	Возвращает мощность множества, то есть количество элементов
a * b	Пересечение
a + b	Объединение
a - b	Разность
contains	Проверка наличия элемента в множестве
a < b	Проверка, является ли `a` подмножеством `b`

См. также:

модуль setutils для удобных функций работы с битовыми множествами
модуль sets для хеш-множеств
модуль intsets для эффективных множеств целых чисел

Числа

Процедура	Использование	Также известно как (на других языках)
div	Целочисленное деление	`//`
mod	Целочисленное остаток от деления (modulo)	`%`
shl	Сдвиг влево	`<<`
shr	Сдвиг вправо	`>>`
ashr	Арифметический сдвиг вправо
and	Побитовое `and`	`&`
or	Побитовое `or`	`\|`
xor	Побитовое `xor`	`^`
not	Побитовое `not` (дополнение)	`~`
toInt	Преобразование числа с плавающей запятой в `int`
toFloat	Преобразование целого числа в `float`

См. также:

модуль math для математических операций, таких как тригонометрические функции, логарифмы, квадратные и кубические корни и т. д.
модуль complex для операций над комплексными числами
модуль rationals для рациональных чисел

Порядковые типы (Ordinals)

Тип Ordinal включает целые числа, булевы значения, символы и перечисления, а также их подтипы.

Процедура	Использование
succ	Преемник значения
pred	Предшественник значения
inc	Инкрементирование порядкового типа
dec	Декрементирование порядкового типа
high	Возвращает наибольшее возможное значение
low	Возвращает наименьшее возможное значение
ord	Возвращает `int` значение порядкового значения

Разное

Процедура	Использование
is	Проверка, являются ли два аргумента одного типа
isnot	Отрицание `is`
!=	Не равно
addr	Получение адреса местоположения в памяти
T and F	Булево `and`
T or F	Булево `or`
T xor F	Булево `xor` (исключающее ИЛИ)
not T	Булево `not`
a[^x]	Получение элемента по индексу в обратном порядке `x`
a .. b	Двухместный срез, формирующий интервал `[a, b]`
a ..^ b	Интервал `[a, b]`, но `b` как индекс в обратном порядке
a ..< b	Интервал `[a, b)` (верхняя граница исключена)
runnableExamples	Создание тестируемой документации

Реализация новых строк, используемая ядром Nim.Реализация seq, используемая ядром Nim.

Поддержка каналов для потоков.

Примечание: Это часть модуля system. Не импортируйте его напрямую. Для активации поддержки потоков используйте --threads:on переключатель командной строки.

Примечание: Каналы предназначены для типа Thread. Они нестабильны при использовании с spawn.

Примечание: Текущая реализация передачи сообщений не работает с циклическими структурами данных.

Примечание: Каналы не могут передаваться между потоками. Используйте глобальные переменные или передавайте их с помощью ptr.

Пример

Ниже приведён простой пример использования каналов двумя способами: блокирующий и неблокирующий.

# Be sure to compile with --threads:on.
# The channels and threads modules are part of system and should not be
# imported.
import std/os

# Channels can either be:
#  - declared at the module level, or
#  - passed to procedures by ptr (raw pointer) -- see note on safety.
#
# For simplicity, in this example a channel is declared at module scope.
# Channels are generic, and they include support for passing objects between
# threads.
# Note that objects passed through channels will be deeply copied.
var chan: Channel[string]

# This proc will be run in another thread using the threads module.
proc firstWorker() =
  chan.send("Hello World!")

# This is another proc to run in a background thread. This proc takes a while
# to send the message since it sleeps for 2 seconds (or 2000 milliseconds).
proc secondWorker() =
  sleep(2000)
  chan.send("Another message")

# Initialize the channel.
chan.open()

# Launch the worker.
var worker1: Thread[void]
createThread(worker1, firstWorker)

# Block until the message arrives, then print it out.
echo chan.recv() # "Hello World!"

# Wait for the thread to exit before moving on to the next example.
worker1.joinThread()

# Launch the other worker.
var worker2: Thread[void]
createThread(worker2, secondWorker)
# This time, use a non-blocking approach with tryRecv.
# Since the main thread is not blocked, it could be used to perform other
# useful work while it waits for data to arrive on the channel.
while true:
  let tried = chan.tryRecv()
  if tried.dataAvailable:
    echo tried.msg # "Another message"
    break
  
  echo "Pretend I'm doing useful work..."
  # For this example, sleep in order not to flood stdout with the above
  # message.
  sleep(400)

# Wait for the second thread to exit before cleaning up the channel.
worker2.joinThread()

# Clean up the channel.
chan.close()

Пример вывода

Программа должна вывести что-то подобное, но имейте в виду, что точные результаты могут отличаться в реальной среде:

Hello World!
Pretend I'm doing useful work...
Pretend I'm doing useful work...
Pretend I'm doing useful work...
Pretend I'm doing useful work...
Pretend I'm doing useful work...
Another message

Безопасная передача каналов

Обратите внимание, что при передаче объектов в процедуры в другом потоке по указателю (например, через аргумент потока), объекты, созданные с помощью стандартного аллокатора, будут использовать локальную память потока, управляемую сборщиком мусора. Поэтому обычно безопаснее хранить объекты каналов в глобальных переменных (как в приведённом выше примере), в таком случае они будут использовать общую кучу всего процесса (защищённую от одновременного доступа потоков).

Однако, можно вручную выделять общую память для каналов, например, используя system.allocShared0 и передавать эти указатели в качестве аргументов потока:

proc worker(channel: ptr Channel[string]) =
  let greeting = channel[].recv()
  echo greeting

proc localChannelExample() =
  # Use allocShared0 to allocate some shared-heap memory and zero it.
  # The usual warnings about dealing with raw pointers apply. Exercise caution.
  var channel = cast[ptr Channel[string]](
    allocShared0(sizeof(Channel[string]))
  )
  channel[].open()
  # Create a thread which will receive the channel as an argument.
  var thread: Thread[ptr Channel[string]]
  createThread(thread, worker, channel)
  channel[].send("Hello from the main thread!")
  # Clean up resources.
  thread.joinThread()
  channel[].close()
  deallocShared(channel)

localChannelExample() # "Hello from the main thread!"

Импорты

исключения, с момента, ctypes, ctypes, sysatomics, ansi_c, память, syslocks, threadtypes, утверждения, итераторы, coro_detection, dollars, typedthreads, miscdollars, stacktraces, countbits_impl, syslocks, sysatomics, digitsutils, syslocks, digitsutils, repr_v2, widestrs, syncio

Типы

AllocStats = object

Исходный код Изменить

any {....deprecated: "Deprecated since v1.5; Use auto instead.".} = distinct auto

Устаревшее: Устарело начиная с версии v1.5; Используйте auto вместо этого.

Устарело; Используйте auto вместо этого. См. https://github.com/nim-lang/RFCs/issues/281 Исходный код Изменить

array[I; T] {.magic: "Array".}

Обобщённый тип для создания массивов фиксированной длины. Исходный код Изменить

auto {.magic: Expr.}

Метатип для автоматического определения типа. Исходный код Изменить

BackwardsIndex = distinct int

Тип, созданный ^ для обращённого доступа к элементам массива. (См. шаблон ^) Исходный код Изменить

bool {.magic: "Bool".} = enum
  false = 0, true = 1

Встроенный булевый тип. Исходный код Изменить

byte = uint8

Это псевдоним для uint8, представляющего собой целое без знака, 8 бит в ширину. Исходный код Изменить

CatchableError = object of Exception

Абстрактный класс для всех исключений, которые можно перехватить. Исходный код Изменить

Channel[TMsg] {....gcsafe.} = RawChannel

канал для межпотоковой коммуникации Исходный код Изменить

char {.magic: Char.}

Встроенный 8-битный символьный тип (без знака). Исходный код Изменить

csize {.importc: "size_t", nodecl, ...deprecated: "use `csize_t` instead".} = int

Устаревшее: Используйте `csize_t` вместо этого

Это не то же самое, что size_t в C. Не используйте его. Исходный код Изменить

cstring {.magic: Cstring.}

Встроенный тип cstring (совместимая строка). Исходный код Изменить

Defect = object of Exception

Абстрактный базовый класс для всех исключений, которые поднимает исполняемый код Nim, но которые строго нельзя перехватить, так как они также могут быть сопоставлены с операцией quit / trap / exit. Исходный код Изменить

Endianness = enum
  littleEndian, bigEndian

Тип, описывающий порядок байтов процессора. Исходный код Изменить

Exception {.compilerproc, magic: "Exception".} = object of RootObj
  parent*: ref Exception     ## Parent exception (can be used as a stack).
  name*: cstring             ## The exception's name is its Nim identifier.
                             ## This field is filled automatically in the
                             ## `raise` statement.
  msg* {.exportc: "message".}: string ## The exception's message. Not
                                      ## providing an exception message
                                      ## is bad style.
  when defined(js):
    trace*: string
  else:
    trace*: seq[StackTraceEntry]

Базовый класс исключений.

Каждое исключение должно наследоваться от Exception. См. полную иерархию исключений.

Исходный код Изменить

float {.magic: Float.}

Типовое значение с плавающей точкой по умолчанию. Исходный код Изменить

float32 {.magic: Float32.}

32-битный тип с плавающей точкой. Исходный код Изменить

float64 {.magic: Float.}

64-битный тип с плавающей точкой. Исходный код Изменить

ForeignCell = object
  data*: pointer

Исходный код Изменить

ForLoopStmt {.compilerproc.} = object

Специальный тип, который отмечает макрос как макрос цикла for. См. "Макрос цикла For". Исходный код Изменить

GC_Strategy = enum
  gcThroughput,             ## optimize for throughput
  gcResponsiveness,         ## optimize for responsiveness (default)
  gcOptimizeTime,           ## optimize for speed
  gcOptimizeSpace            ## optimize for memory footprint

Стратегия, которую должен использовать сборщик мусора для приложения. Исходный код Изменить

HSlice[T; U] = object
  a*: T                      ## The lower bound (inclusive).
  b*: U                      ## The upper bound (inclusive).

Тип "гетерогенного" среза. Исходный код Изменить

int {.magic: Int.}

Целочисленный тип по умолчанию; разрядность зависит от архитектуры, но всегда совпадает с размером указателя. Исходный код Изменить

int8 {.magic: Int8.}

Целочисленный тип со знаком, 8 бит. Исходный код Изменить

int16 {.magic: Int16.}

Целочисленный тип со знаком, 16 бит. Исходный код Изменить

int32 {.magic: Int32.}

Целочисленный тип со знаком, 32 бит. Исходный код Изменить

int64 {.magic: Int64.}

Целочисленный тип со знаком, 64 бит. Исходный код Изменить

iterable[T] {.magic: IterableType.}

Представляет выражение, которое возвращает T Исходный код Изменить

JsRoot = ref object of RootObj

Корневой тип иерархии объектов JavaScript Исходный код Изменить

lent[T] {.magic: "BuiltinType".}

Исходный код Изменить

Natural = range[0 .. high(int)]

это int тип, изменяющийся от нуля до максимального значения int. Этот тип часто полезен для документации и отладки. Исходный код Изменить

NimNode {.magic: "PNimrodNode".} = ref NimNodeObj

Представляет узел AST Nim. Макросы работают с этим типом. Исходный код Изменить

NimSeqV2[T] = object

Исходный код Изменить

END_OF_DOCUMENT_MARKER

openArray[T] {.magic: "OpenArray".}

Обобщённый тип для создания открытых массивов. Открытые массивы реализуются как указатель на данные массива и поле длины. Исходный код Редактировать

Ordinal[T] {.magic: Ordinal.}

Обобщённый порядковый тип. Включает целые числа, булевы значения, символы и перечисления, а также их подтипы. См. также SomeOrdinal. Исходный код Редактировать

owned[T] {.magic: "BuiltinType".}

Конструктор типа для маркировки ссылок/указателей или замыканий как owned. Исходный код Редактировать

PFrame = ptr TFrame

Представляет собой кадр выполнения стека вызовов; часть API отладчика. Исходный код Редактировать

pointer {.magic: Pointer.}

Встроенный тип указателя, используйте оператор addr для получения указателя на переменную. Исходный код Редактировать

Positive = range[1 .. high(int)]

Это тип int, изменяющийся от единицы до максимального значения int. Этот тип часто полезен для документирования и отладки. Исходный код Редактировать

ptr[T] {.magic: Pointer.}

Встроенный обобщённый тип неотслеживаемого указателя. Исходный код Редактировать

range[T] {.magic: "Range".}

Обобщённый тип для построения типов диапазонов. Исходный код Редактировать

ref[T] {.magic: Pointer.}

Встроенный обобщённый тип отслеживаемого указателя. Исходный код Редактировать

RootEffect {.compilerproc.} = object of RootObj

Базовый класс эффекта.

Каждый эффект должен наследоваться от RootEffect, если вы не знаете, что делаете.

Исходный код Редактировать

RootObj {.compilerproc, inheritable.} = object

Корень иерархии объектов Nim.

Объекты должны наследоваться от RootObj или одного из его потомков. Однако допускаются и объекты без предков.

Исходный код Редактировать

RootRef = ref RootObj

Ссылка на RootObj. Исходный код Редактировать

seq[T] {.magic: "Seq".}

Обобщённый тип для создания последовательностей. Исходный код Редактировать

set[T] {.magic: "Set".}

Обобщённый тип для создания битовых множеств. Исходный код Редактировать

sink[T] {.magic: "BuiltinType".}

Исходный код Редактировать

Slice[T] = HSlice[T, T]

Псевдоним для HSlice[T, T]. Исходный код Редактировать

SomeFloat = float | float32 | float64

Класс типов, соответствующий всем типам чисел с плавающей запятой. Исходный код Редактировать

SomeInteger = SomeSignedInt | SomeUnsignedInt

Класс типов, соответствующий всем целым типам. Исходный код Редактировать

SomeNumber = SomeInteger | SomeFloat

Класс типов, соответствующий всем числовым типам. Исходный код Редактировать

SomeOrdinal = int | int8 | int16 | int32 | int64 | bool | enum | uint | uint8 |
    uint16 |
    uint32 |
    uint64

Класс типов, соответствующий всем порядковым типам; однако это включает перечисления с пропусками. См. также Ordinal. Исходный код Редактировать

SomeSignedInt = int | int8 | int16 | int32 | int64

Класс типов, соответствующий всем целым типам со знаком. Исходный код Редактировать

SomeUnsignedInt = uint | uint8 | uint16 | uint32 | uint64

Класс типов, соответствующий всем целым типам без знака. Исходный код Редактировать

StackTraceEntry = object
  procname*: cstring         ## Name of the proc that is currently executing.
  line*: int                 ## Line number of the proc that is currently executing.
  filename*: cstring         ## Filename of the proc that is currently executing.
  when NimStackTraceMsgs:
    frameMsg*: string ## When a stacktrace is generated in a given frame and
                      ## rendered at a later time, we should ensure the stacktrace
                      ## data isn't invalidated; any pointer into PFrame is
                      ## subject to being invalidated so shouldn't be stored.
  when defined(nimStackTraceOverride):
    programCounter*: uint ## Program counter - will be used to get the rest of the info,
                          ## when `$` is called on this type. We can't use
                          ## "cuintptr_t" in here.
    procnameStr*, filenameStr*: string ## GC-ed alternatives to "procname" and "filename"

В режиме отладки исключения хранят трассировку стека, которая привела к ним. StackTraceEntry — это одна запись трассировки стека. Исходный код Редактировать

static[T] {.magic: "Static".}

Метатип, представляющий все значения, которые могут быть вычислены во время компиляции.

Преобразование типа static(x) может быть использовано для принудительного вычисления во время компиляции данного выражения x.

Исходный код Редактировать

string {.magic: String.}

Встроенный тип строки. Исходный код Редактировать

TaintedString {....deprecated: "Deprecated since 1.5".} = string

Устаревшее: Устарело начиная с версии 1.5

Исходный код Редактировать

TFrame {.importc, nodecl, final.} = object
  prev*: PFrame              ## Previous frame; used for chaining the call stack.
  procname*: cstring         ## Name of the proc that is currently executing.
  line*: int                 ## Line number of the proc that is currently executing.
  filename*: cstring         ## Filename of the proc that is currently executing.
  len*: int16                ## Length of the inspectable slots.
  calldepth*: int16          ## Used for max call depth checking.
  when NimStackTraceMsgs:
    frameMsgLen*: int        ## end position in frameMsgBuf for this frame.

Сам кадр. Исходный код Редактировать

type[T] {.magic: "Type".}

Метатип, представляющий тип всех значений типа.

Преобразование type(x) может быть использовано для получения типа данного выражения x.

Исходный код Редактировать

typed {.magic: Stmt.}

Метатип для обозначения выражения, которое разрешено (для шаблонов). Исходный код Редактировать

typedesc {.magic: TypeDesc.}

Метатип для обозначения описания типа. Исходный код Редактировать

TypeOfMode = enum
  typeOfProc,               ## Prefer the interpretation that means `x` is a proc call.
  typeOfIter                 ## Prefer the interpretation that means `x` is an iterator call.

Возможные режимы typeof. Исходный код Редактировать

uint {.magic: UInt.}

Тип целого числа по умолчанию без знака. Исходный код Редактировать

uint8 {.magic: UInt8.}

Тип целого числа без знака 8 бит. Исходный код Редактировать

uint16 {.magic: UInt16.}: Беззнаковый 16-битный целочисленный тип. Исходный код Изменить
uint32 {.magic: UInt32.}: Беззнаковый 32-битный целочисленный тип. Исходный код Изменить
uint64 {.magic: UInt64.}: Беззнаковый 64-битный целочисленный тип. Исходный код Изменить
UncheckedArray[T] {.magic: "UncheckedArray".}: Исходный код Изменить
untyped {.magic: Expr.}: Метатип, обозначающий выражение, которое не разрешено (для шаблонов). Исходный код Изменить
varargs[T] {.magic: "Varargs".}: Общий тип для создания типа varargs. Исходный код Изменить
void {.magic: "VoidType".}: Метатип, обозначающий отсутствие любого типа. Исходный код Изменить

Переменные

errorMessageWriter: (proc (msg: string) {....tags: [WriteIOEffect], gcsafe, nimcall.})

Функция, которая будет вызвана вместо stdmsg.write при выводе трассировки стека. Нестабильный API. Исходный код Изменить

globalRaiseHook: proc (e: ref Exception): bool {.nimcall, ...gcsafe.}

С помощью этого обработчика можно влиять на обработку исключений на глобальном уровне. Если не пусто, каждая инструкция 'raise' вызывает этот обработчик.

Предупреждение: Обычный код приложения никогда не должен устанавливать этот обработчик! Вы должны понимать, что вы делаете, устанавливая его.

Если globalRaiseHook возвращает false, исключение перехватывается и не распространяется дальше по стеку вызовов.

Исходный код Изменить

localRaiseHook {.threadvar.}: proc (e: ref Exception): bool {.nimcall, ...gcsafe.}

С помощью этого обработчика можно влиять на обработку исключений на уровне потока. Если не пусто, каждая инструкция 'raise' вызывает этот обработчик.

Если localRaiseHook возвращает false, исключение перехватывается и не распространяется дальше по стеку вызовов.

Исходный код Изменить

nimThreadDestructionHandlers {.threadvar.}: seq[
    proc () {.closure, ...gcsafe, raises: [].}]

Исходный код Изменить

onUnhandledException: (proc (errorMsg: string) {.nimcall, ...gcsafe.})

Установите этот обработчик ошибок, чтобы переопределить стандартное поведение при возникновении необработанного исключения.

По умолчанию трассировка стека записывается в stderr и затем вызывается quit(1). Нестабильный API.

Исходный код Изменить

outOfMemHook: proc () {.nimcall, ...tags: [], gcsafe, raises: [].}

Установите эту переменную, чтобы указать процедуру, которая должна быть вызвана в случае события недостатка памяти. Стандартный обработчик записывает сообщение об ошибке и завершает программу.

outOfMemHook может быть использован для поднятия исключения в случае OOM следующим образом:

var gOutOfMem: ref EOutOfMemory
new(gOutOfMem) # need to be allocated *before* OOM really happened!
gOutOfMem.msg = "out of memory"

proc handleOOM() =
  raise gOutOfMem

system.outOfMemHook = handleOOM

Если обработчик не поднимает исключение, обычный поток управления продолжается, и программа завершается.

Исходный код Изменить

programResult {.compilerproc, exportc: "nim_program_result".}: int

устарело, используйте quit или exitprocs.getProgramResult, exitprocs.setProgramResult. Исходный код Изменить

unhandledExceptionHook: proc (e: ref Exception) {.nimcall, ...tags: [], gcsafe,
    raises: [].}

Установите эту переменную, чтобы указать процедуру, которая должна быть вызвана в случае события необработанного исключения. Стандартный обработчик выводит сообщение об ошибке и завершает программу, за исключением случаев использования --os:any Исходный код Изменить

Константы

nimvm {.magic: "Nimvm", compileTime.}: bool = false: Может быть использован только в when выражении. Он равен true в контексте Nim VM и false в противном случае. Исходный код Изменить

Константы

appType {.magic: "AppType".}: string = ""

Строка, описывающая тип приложения. Возможные значения: "console", "gui", "lib". Исходный код Изменить

CompileDate {.magic: "CompileDate".}: string = "0000-00-00"

Дата компиляции (в UTC) в виде строки формата YYYY-MM-DD. Работает благодаря магии компилятора. Исходный код Изменить

CompileTime {.magic: "CompileTime".}: string = "00:00:00"

Время компиляции (в UTC) в виде строки формата HH:MM:SS. Работает благодаря магии компилятора. Исходный код Изменить

cpuEndian {.magic: "CpuEndian".}: Endianness = littleEndian

Порядок байтов целевого процессора. Эта информация полезна только для низкоуровневого кода. Работает благодаря магии компилятора. Исходный код Изменить

hostCPU {.magic: "HostCPU".}: string = ""

Строка, описывающая процессор хоста.

Возможные значения: "i386", "alpha", "powerpc", "powerpc64", "powerpc64el", "sparc", "amd64", "mips", "mipsel", "arm", "arm64", "mips64", "mips64el", "riscv32", "riscv64", "loongarch64".

Исходный код Изменить

hostOS {.magic: "HostOS".}: string = ""

Строка, описывающая операционную систему хоста.

Возможные значения: "windows", "macosx", "linux", "netbsd", "freebsd", "openbsd", "solaris", "aix", "haiku", "standalone".

Исходный код Изменить

Inf = 0x7FF0000000000000'f64

Содержит значение положительной бесконечности в формате IEEE для чисел с плавающей запятой. Исходный код Изменить

isMainModule {.magic: "IsMainModule".}: bool = false

Истинно только при обращении в основном модуле. Работает благодаря магии компилятора. Полезно для встраивания тестового кода в модуль. Исходный код Изменить

NaN = 0x7FF7FFFFFFFFFFFF'f64

Содержит значение Не число (NaN) в формате IEEE для чисел с плавающей запятой.

Обратите внимание, что вы не можете сравнивать число с плавающей запятой с этим значением и ожидать разумного результата. Используйте процедуру isNaN или classify в модуле math для проверки NaN.

Исходный код Изменить

NegInf = 0xFFF0000000000000'f64

Содержит значение отрицательной бесконечности в формате IEEE для чисел с плавающей запятой. Исходный код Изменить

NimMajor {.intdefine.}: int = 2

Главный номер версии Nim. Пример:

when (NimMajor, NimMinor, NimPatch) >= (1, 3, 1): discard

Исходный код Изменить

NimMinor {.intdefine.}: int = 2

Вспомогательный номер версии Nim. Нечетное значение для devel, четное для релизов. Исходный код Изменить

NimPatch {.intdefine.}: int = 0

Номер исправления версии Nim. Нечетное значение для devel, четное для релизов. Исходный код Изменить

NimVersion: string = "2.2.0"

Версия Nim в виде строки. Исходный код Изменить

off = false

Псевдоним для false. Исходный код Изменить

on = true

Псевдоним для true. Исходный код Изменить

QuitFailure = 1

Значение, которое следует передать в quit для обозначения ошибки. Исходный код Изменить

QuitSuccess = 0

Значение, которое следует передать в quit для обозначения успеха. Исходный код Изменить

Процедуры

proc `%%`(x, y: int): int {.inline, ...raises: [], tags: [], forbids: [].}: Обрабатывает x и y как беззнаковые и вычисляет модуль x и y.

Результат усекается для соответствия результату. Это реализует арифметику по модулю. Ошибки переполнения невозможны.
Исходный код Изменить
proc `%%`(x, y: int8): int8 {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `%%`(x, y: int16): int16 {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `%%`(x, y: int32): int32 {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `%%`(x, y: int64): int64 {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `&`(x, y: char): string {.magic: "ConStrStr", noSideEffect, ...raises: [], tags: [], forbids: [].}: Объединяет символы x и y в строку.

assert('a' & 'b' == "ab")
Исходный код Изменить
proc `&`(x, y: string): string {.magic: "ConStrStr", noSideEffect, ...raises: [], tags: [], forbids: [].}: Объединяет строки x и y.

assert("ab" & "cd" == "abcd")
Исходный код Изменить
proc `&`(x: char; y: string): string {.magic: "ConStrStr", noSideEffect, ...raises: [], tags: [], forbids: [].}: Объединяет x со y.

assert('a' & "bc" == "abc")
Исходный код Изменить
proc `&`(x: string; y: char): string {.magic: "ConStrStr", noSideEffect, ...raises: [], tags: [], forbids: [].}: Объединяет x со y.

assert("ab" & 'c' == "abc")
Исходный код Изменить
proc `&`[T](x, y: sink seq[T]): seq[T] {.noSideEffect.}: Объединяет две последовательности.

Требуется копирование последовательностей.

assert(@[1, 2, 3, 4] & @[5, 6] == @[1, 2, 3, 4, 5, 6])

См. также:

add(var seq[T], openArray[T])

Исходный код Изменить
proc `&`[T](x: sink seq[T]; y: sink T): seq[T] {.noSideEffect.}: Добавляет элемент y в конец последовательности.

Требуется копирование последовательности.

assert(@[1, 2, 3] & 4 == @[1, 2, 3, 4])

См. также:

add(var seq[T], T)

Исходный код Изменить
proc `&`[T](x: sink T; y: sink seq[T]): seq[T] {.noSideEffect.}: Вставляет элемент x в начало последовательности.

Требуется копирование последовательности.

assert(1 & @[2, 3, 4] == @[1, 2, 3, 4])
Исходный код Изменить
proc `&=`(x: var string; y: string) {.magic: "AppendStrStr", noSideEffect, ...raises: [], tags: [], forbids: [].}: Добавляет в строку на месте.

var a = "abc" a &= "de" # a <- "abcde"
Исходный код Изменить
proc `*`(x, y: float): float {.magic: "MulF64", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `*`(x, y: float32): float32 {.magic: "MulF64", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `*`(x, y: int): int {.magic: "MulI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Бинарный * оператор для целого числа. Исходный код Изменить
proc `*`(x, y: int8): int8 {.magic: "MulI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `*`(x, y: int16): int16 {.magic: "MulI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `*`(x, y: int32): int32 {.magic: "MulI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `*`(x, y: int64): int64 {.magic: "MulI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `*`(x, y: uint): uint {.magic: "MulU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Бинарный * оператор для беззнаковых целых чисел. Исходный код Изменить
proc `*`(x, y: uint8): uint8 {.magic: "MulU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `*`(x, y: uint16): uint16 {.magic: "MulU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `*`(x, y: uint32): uint32 {.magic: "MulU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `*`(x, y: uint64): uint64 {.magic: "MulU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
func `*`[T](x, y: set[T]): set[T] {.magic: "MulSet", ...raises: [], tags: [], forbids: [].}: Этот оператор вычисляет пересечение двух множеств.
Пример:

assert {1, 2, 3} * {2, 3, 4} == {2, 3}
Исходный код Изменить
proc `*%`(x, y: int): int {.inline, ...raises: [], tags: [], forbids: [].}: Обрабатывает x и y как беззнаковые и умножает их.

Результат усекается для соответствия результату. Это реализует арифметику по модулю. Ошибки переполнения невозможны.
Исходный код Изменить
proc `*%`(x, y: int8): int8 {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `*%`(x, y: int16): int16 {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `*%`(x, y: int32): int32 {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `*%`(x, y: int64): int64 {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить

proc `*=`[T: float | float32 | float64](x: var T; y: T) {.inline, noSideEffect.}: Умножает на месте число с плавающей точкой. Исходный код Редактировать
proc `*=`[T: SomeInteger](x: var T; y: T) {.inline, noSideEffect.}: Бинарный оператор *= для целых чисел. Исходный код Редактировать
proc `+`(x, y: float): float {.magic: "AddF64", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `+`(x, y: float32): float32 {.magic: "AddF64", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `+`(x, y: int): int {.magic: "AddI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Бинарный оператор + для целого числа. Исходный код Редактировать
proc `+`(x, y: int8): int8 {.magic: "AddI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `+`(x, y: int16): int16 {.magic: "AddI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `+`(x, y: int32): int32 {.magic: "AddI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `+`(x, y: int64): int64 {.magic: "AddI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `+`(x, y: uint): uint {.magic: "AddU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Бинарный оператор + для беззнаковых целых чисел. Исходный код Редактировать
proc `+`(x, y: uint8): uint8 {.magic: "AddU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `+`(x, y: uint16): uint16 {.magic: "AddU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `+`(x, y: uint32): uint32 {.magic: "AddU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `+`(x, y: uint64): uint64 {.magic: "AddU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `+`(x: float): float {.magic: "UnaryPlusF64", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `+`(x: float32): float32 {.magic: "UnaryPlusF64", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `+`(x: int): int {.magic: "UnaryPlusI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Унарный оператор + для целого числа. Не оказывает никакого влияния. Исходный код Редактировать
proc `+`(x: int8): int8 {.magic: "UnaryPlusI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `+`(x: int16): int16 {.magic: "UnaryPlusI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `+`(x: int32): int32 {.magic: "UnaryPlusI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `+`(x: int64): int64 {.magic: "UnaryPlusI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
func `+`[T](x, y: set[T]): set[T] {.magic: "PlusSet", ...raises: [], tags: [], forbids: [].}: Этот оператор вычисляет объединение двух множеств.
Пример:

assert {1, 2, 3} + {2, 3, 4} == {1, 2, 3, 4}
Исходный код Редактировать
proc `+%`(x, y: int): int {.inline, ...raises: [], tags: [], forbids: [].}: Обращается с x и y как с беззнаковыми и складывает их.

Результат усекается для соответствия результату. Это реализует модульную арифметику. Ошибки переполнения невозможны.
Исходный код Редактировать
proc `+%`(x, y: int8): int8 {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `+%`(x, y: int16): int16 {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `+%`(x, y: int32): int32 {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `+%`(x, y: int64): int64 {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `+=`[T: float | float32 | float64](x: var T; y: T) {.inline, noSideEffect.}: Увеличивает на месте число с плавающей точкой. Исходный код Редактировать
proc `+=`[T: SomeInteger](x: var T; y: T) {.magic: "Inc", noSideEffect, ...raises: [], tags: [], forbids: [].}: Увеличивает целое число. Исходный код Редактировать

proc `-`(a, b: AllocStats): AllocStats {....raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `-`(x, y: float): float {.magic: "SubF64", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `-`(x, y: float32): float32 {.magic: "SubF64", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `-`(x, y: int): int {.magic: "SubI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Бинарный - оператор для целого числа. Исходный код Редактировать
proc `-`(x, y: int8): int8 {.magic: "SubI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `-`(x, y: int16): int16 {.magic: "SubI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `-`(x, y: int32): int32 {.magic: "SubI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `-`(x, y: int64): int64 {.magic: "SubI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `-`(x, y: uint): uint {.magic: "SubU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Бинарный - оператор для беззнаковых целых чисел. Исходный код Редактировать
proc `-`(x, y: uint8): uint8 {.magic: "SubU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `-`(x, y: uint16): uint16 {.magic: "SubU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `-`(x, y: uint32): uint32 {.magic: "SubU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `-`(x, y: uint64): uint64 {.magic: "SubU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `-`(x: float): float {.magic: "UnaryMinusF64", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `-`(x: float32): float32 {.magic: "UnaryMinusF64", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `-`(x: int): int {.magic: "UnaryMinusI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Унарный - оператор для целого числа. Инвертирует x. Исходный код Редактировать
proc `-`(x: int8): int8 {.magic: "UnaryMinusI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `-`(x: int16): int16 {.magic: "UnaryMinusI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `-`(x: int32): int32 {.magic: "UnaryMinusI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `-`(x: int64): int64 {.magic: "UnaryMinusI64", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
func `-`[T](x, y: set[T]): set[T] {.magic: "MinusSet", ...raises: [], tags: [], forbids: [].}: Этот оператор вычисляет разность двух множеств.
Пример:

assert {1, 2, 3} - {2, 3, 4} == {1}
Исходный код Редактировать
proc `-%`(x, y: int): int {.inline, ...raises: [], tags: [], forbids: [].}: Рассматривает x и y как беззнаковые и вычитает их.

Результат усекается для соответствия результату. Это реализует модульную арифметику. Ошибки переполнения невозможны.
Исходный код Редактировать
proc `-%`(x, y: int8): int8 {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `-%`(x, y: int16): int16 {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `-%`(x, y: int32): int32 {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `-%`(x, y: int64): int64 {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `-=`[T: float | float32 | float64](x: var T; y: T) {.inline, noSideEffect.}: Уменьшает значение числа с плавающей точкой на месте. Исходный код Редактировать
proc `-=`[T: SomeInteger](x: var T; y: T) {.magic: "Dec", noSideEffect, ...raises: [], tags: [], forbids: [].}: Уменьшает целое число. Исходный код Редактировать
proc `..`[T, U](a: sink T; b: sink U): HSlice[T, U] {.noSideEffect, inline, magic: "DotDot", ...raises: [], tags: [], forbids: [].}: Бинарный оператор slice, который создаёт интервал [a, b], при этом a и b включительно.

Слайсы также могут использоваться в конструкторе множеств и в операторах выбора по порядковому номеру, но тогда они обрабатываются компилятором как специальные случаи.

let a = [10, 20, 30, 40, 50] echo a[2 .. 3] # @[30, 40]
Исходный код Редактировать
proc `..`[T](b: sink T): HSlice[int, T] {.noSideEffect, inline, magic: "DotDot", ...deprecated: "replace `..b` with `0..b`", raises: [], tags: [], forbids: [].}: Устарело: заменить `..b` на `0..b`

Унарный оператор slice, который создаёт интервал [default(int), b].

let a = [10, 20, 30, 40, 50] echo a[.. 2] # @[10, 20, 30]
Исходный код Редактировать
proc `/`(x, y: float): float {.magic: "DivF64", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `/`(x, y: float32): float32 {.magic: "DivF64", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `/`(x, y: int): float {.inline, noSideEffect, ...raises: [], tags: [], forbids: [].}: Деление целых чисел с результатом с плавающей точкой.

echo 7 / 5 # => 1.4

См. также:

div

mod

Исходный код Редактировать

proc `/%`(x, y: int): int {.inline, ...raises: [], tags: [], forbids: [].}: Обрабатывает x и y как беззнаковые и делит их.

Результат усекается для соответствия результату. Это реализует арифметику по модулю. Ошибки переполнения невозможны.
Исходный код Изменить
proc `/%`(x, y: int8): int8 {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `/%`(x, y: int16): int16 {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `/%`(x, y: int32): int32 {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `/%`(x, y: int64): int64 {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `/=`(x: var float64; y: float64) {.inline, noSideEffect, ...raises: [], tags: [], forbids: [].}: Делит число с плавающей точкой на месте. Исходный код Изменить
proc `/=`[T: float | float32](x: var T; y: T) {.inline, noSideEffect.}: Делит число с плавающей точкой на месте. Исходный код Изменить
proc `<`(x, y: bool): bool {.magic: "LtB", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<`(x, y: char): bool {.magic: "LtCh", noSideEffect, ...raises: [], tags: [], forbids: [].}: Сравнивает два символа и возвращает true, если x стоит лексикографически перед y (заглавные буквы стоят перед строчными).
Пример:

let a = 'a' b = 'b' c = 'Z' assert a < b assert not (a < a) assert not (a < c)
Исходный код Изменить
proc `<`(x, y: float): bool {.magic: "LtF64", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<`(x, y: float32): bool {.magic: "LtF64", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<`(x, y: int): bool {.magic: "LtI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает true, если x меньше y. Исходный код Изменить
proc `<`(x, y: int8): bool {.magic: "LtI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<`(x, y: int16): bool {.magic: "LtI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<`(x, y: int32): bool {.magic: "LtI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<`(x, y: int64): bool {.magic: "LtI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<`(x, y: pointer): bool {.magic: "LtPtr", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<`(x, y: string): bool {.magic: "LtStr", noSideEffect, ...raises: [], tags: [], forbids: [].}: Сравнивает две строки и возвращает true, если x стоит лексикографически перед y (заглавные буквы стоят перед строчными).
Пример:

let a = "abc" b = "abd" c = "ZZZ" assert a < b assert not (a < a) assert not (a < c)
Исходный код Изменить
proc `<`(x, y: uint): bool {.magic: "LtU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает true, если x < y. Исходный код Изменить
proc `<`(x, y: uint8): bool {.magic: "LtU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<`(x, y: uint16): bool {.magic: "LtU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<`(x, y: uint32): bool {.magic: "LtU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<`(x, y: uint64): bool {.magic: "LtU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<`[Enum: enum](x, y: Enum): bool {.magic: "LtEnum", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<`[T: tuple](x, y: T): bool: Общий лексикографический < оператор для кортежей, который поднимается из компонентов x и y. Эта реализация использует cmp. Исходный код Изменить
proc `<`[T](x, y: ptr T): bool {.magic: "LtPtr", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<`[T](x, y: ref T): bool {.magic: "LtPtr", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<`[T](x, y: set[T]): bool {.magic: "LtSet", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает true, если x является строгим или надлежащим подмножеством y.

Строгое или надлежащее подмножество x содержит все свои элементы в y, но y имеет больше элементов, чем y.

Пример:

let a = {3, 5} b = {1, 3, 5, 7} c = {2} assert a < b assert not (a < a) assert not (a < c)
Исходный код Изменить

proc `<%`(x, y: int): bool {.inline, ...raises: [], tags: [], forbids: [].}: Обрабатывает x и y как беззнаковые и сравнивает их. Возвращает true, если unsigned(x) < unsigned(y). Исходный код Изменить
proc `<%`(x, y: int8): bool {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<%`(x, y: int16): bool {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<%`(x, y: int32): bool {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<%`(x, y: int64): bool {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<=`(x, y: bool): bool {.magic: "LeB", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<=`(x, y: char): bool {.magic: "LeCh", noSideEffect, ...raises: [], tags: [], forbids: [].}: Сравнивает два символа и возвращает true, если x лексикографически предшествует y (заглавные буквы предшествуют строчным).
Пример:

let a = 'a' b = 'b' c = 'Z' assert a <= b assert a <= a assert not (a <= c)
Исходный код Изменить
proc `<=`(x, y: float): bool {.magic: "LeF64", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<=`(x, y: float32): bool {.magic: "LeF64", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<=`(x, y: int): bool {.magic: "LeI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает true, если x меньше или равно y. Исходный код Изменить
proc `<=`(x, y: int8): bool {.magic: "LeI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<=`(x, y: int16): bool {.magic: "LeI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<=`(x, y: int32): bool {.magic: "LeI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<=`(x, y: int64): bool {.magic: "LeI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<=`(x, y: pointer): bool {.magic: "LePtr", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<=`(x, y: string): bool {.magic: "LeStr", noSideEffect, ...raises: [], tags: [], forbids: [].}: Сравнивает две строки и возвращает true, если x лексикографически предшествует y (заглавные буквы предшествуют строчным).
Пример:

let a = "abc" b = "abd" c = "ZZZ" assert a <= b assert a <= a assert not (a <= c)
Исходный код Изменить
proc `<=`(x, y: uint): bool {.magic: "LeU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает true, если x <= y. Исходный код Изменить
proc `<=`(x, y: uint8): bool {.magic: "LeU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<=`(x, y: uint16): bool {.magic: "LeU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<=`(x, y: uint32): bool {.magic: "LeU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<=`(x, y: uint64): bool {.magic: "LeU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<=`[Enum: enum](x, y: Enum): bool {.magic: "LeEnum", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<=`[T: tuple](x, y: T): bool: Универсальный лексикографический оператор сравнения для кортежей, полученный из компонентов x и y. Эта реализация использует cmp. Исходный код Изменить
proc `<=`[T](x, y: ref T): bool {.magic: "LePtr", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<=`[T](x, y: set[T]): bool {.magic: "LeSet", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает true, если x является подмножеством y.

Подмножество x содержит все свои члены в y, и y не обязательно имеет больше членов, чем x. То есть x может быть равно y.

Пример:

let a = {3, 5} b = {1, 3, 5, 7} c = {2} assert a <= b assert a <= a assert not (a <= c)
Исходный код Изменить
proc `<=%`(x, y: int): bool {.inline, ...raises: [], tags: [], forbids: [].}: Обрабатывает x и y как беззнаковые и сравнивает их. Возвращает true, если unsigned(x) <= unsigned(y). Исходный код Изменить
proc `<=%`(x, y: int8): bool {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<=%`(x, y: int16): bool {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<=%`(x, y: int32): bool {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `<=%`(x, y: int64): bool {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `=`[T](dest: var T; src: T) {.noSideEffect, magic: "Asgn", ...raises: [], tags: [], forbids: [].}: Исходный код Изменить

proc `==`(x, y: bool): bool {.magic: "EqB", noSideEffect, ...raises: [], tags: [], forbids: [].}: Проверяет равенство двух переменных типа bool. Исходный код Изменить
proc `==`(x, y: char): bool {.magic: "EqCh", noSideEffect, ...raises: [], tags: [], forbids: [].}: Проверяет равенство двух переменных типа char. Исходный код Изменить
proc `==`(x, y: cstring): bool {.magic: "EqCString", noSideEffect, inline, ...raises: [], tags: [], forbids: [].}: Проверяет равенство двух переменных типа cstring. Исходный код Изменить
proc `==`(x, y: float): bool {.magic: "EqF64", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `==`(x, y: float32): bool {.magic: "EqF64", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `==`(x, y: int): bool {.magic: "EqI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Сравнивает два целых числа на равенство. Исходный код Изменить
proc `==`(x, y: int8): bool {.magic: "EqI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `==`(x, y: int16): bool {.magic: "EqI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `==`(x, y: int32): bool {.magic: "EqI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `==`(x, y: int64): bool {.magic: "EqI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `==`(x, y: pointer): bool {.magic: "EqRef", noSideEffect, ...raises: [], tags: [], forbids: [].}: Проверяет равенство двух переменных типа pointer.
Пример:

var # this is a wildly dangerous example a = cast[pointer](0) b = cast[pointer](nil) assert a == b # true due to the special meaning of `nil`/0 as a pointer
Исходный код Изменить
proc `==`(x, y: string): bool {.magic: "EqStr", noSideEffect, ...raises: [], tags: [], forbids: [].}: Проверяет равенство двух переменных типа string. Исходный код Изменить
proc `==`(x, y: uint): bool {.magic: "EqI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Сравнивает два беззнаковых целых числа на равенство. Исходный код Изменить
proc `==`(x, y: uint8): bool {.magic: "EqI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `==`(x, y: uint16): bool {.magic: "EqI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `==`(x, y: uint32): bool {.magic: "EqI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `==`(x, y: uint64): bool {.magic: "EqI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `==`[Enum: enum](x, y: Enum): bool {.magic: "EqEnum", noSideEffect, ...raises: [], tags: [], forbids: [].}: Проверяет, имеют ли значения в одном и том же перечислении одинаковое значение в основе.
Пример:

type Enum1 = enum field1 = 3, field2 Enum2 = enum place1, place2 = 3 var e1 = field1 e2 = place2.ord.Enum1 assert e1 == e2 assert not compiles(e1 == place2) # raises error
Исходный код Изменить
proc `==`[I, T](x, y: array[I, T]): bool: Исходный код Изменить
proc `==`[T: proc | iterator](x, y: T): bool {.magic: "EqProc", noSideEffect, ...raises: [], tags: [], forbids: [].}: Проверяет, ссылаются ли две переменные proc на одну и ту же процедуру. Исходный код Изменить
proc `==`[T: tuple | object](x, y: T): bool: Общий оператор == для кортежей, который поднимается из компонентов x и y. Исходный код Изменить
proc `==`[T](x, y: openArray[T]): bool: Исходный код Изменить
proc `==`[T](x, y: ptr T): bool {.magic: "EqRef", noSideEffect, ...raises: [], tags: [], forbids: [].}: Проверяет, ссылаются ли две переменные ptr на один и тот же элемент. Исходный код Изменить
proc `==`[T](x, y: ref T): bool {.magic: "EqRef", noSideEffect, ...raises: [], tags: [], forbids: [].}: Проверяет, ссылаются ли две переменные ref на один и тот же элемент. Исходный код Изменить
proc `==`[T](x, y: seq[T]): bool {.noSideEffect.}: Общий оператор равенства для последовательностей: опирается на оператор равенства для типа элемента T. Исходный код Изменить
proc `==`[T](x, y: set[T]): bool {.magic: "EqSet", noSideEffect, ...raises: [], tags: [], forbids: [].}: Проверяет равенство двух переменных типа set.
Пример:

assert {1, 2, 2, 3} == {1, 2, 3} # duplication in sets is ignored
Исходный код Изменить
proc `=copy`[T](dest: var T; src: T) {.noSideEffect, magic: "Asgn", ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `=destroy`(x: string) {.inline, magic: "Destroy", enforceNoRaises, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `=destroy`[T](x: ref T) {.inline, magic: "Destroy", ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `=destroy`[T](x: seq[T]) {.inline, magic: "Destroy", ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `=destroy`[T](x: var T) {.inline, magic: "Destroy", ...raises: [], tags: [], forbids: [].}: Реализация универсального деструктора, которую можно переопределить. Исходный код Изменить
proc `=dup`[T](x: T): T {.inline, magic: "Dup", ...raises: [], tags: [], forbids: [].}: Реализация универсального dup, которую можно переопределить. Исходный код Изменить
proc `=sink`[T](x: var T; y: T) {.inline, nodestroy, magic: "Asgn", ...raises: [], tags: [], forbids: [].}: Реализация универсального sink, которую можно переопределить. Исходный код Изменить

proc `=trace`[T](x: var T; env: pointer) {.inline, magic: "Trace", ...raises: [], tags: [], forbids: [].}: Общее отслеживание реализация, которую можно переопределить. Исходный код Редактировать
proc `=wasMoved`[T](obj: var T) {.magic: "WasMoved", noSideEffect, ...raises: [], tags: [], forbids: [].}: Общая реализация wasMoved, которую можно переопределить. Исходный код Редактировать
proc `@`[IDX, T](a: sink array[IDX, T]): seq[T] {.magic: "ArrToSeq", noSideEffect, ...raises: [], tags: [], forbids: [].}: Преобразует массив в последовательность.

Это чаще всего используется для создания последовательностей с конструктором массива: @[1, 2, 3] имеет тип seq[int], в то время как [1, 2, 3] имеет тип array[0..2, int].

let a = [1, 3, 5] b = "foo" echo @a # => @[1, 3, 5] echo @b # => @['f', 'o', 'o']
Исходный код Редактировать
proc `@`[T](a: openArray[T]): seq[T] {.magic: "OpenArrayToSeq", ...raises: [], tags: [], forbids: [].}: Преобразует openArray в последовательность.

Это не так эффективно, как преобразование массива фиксированной длины в последовательность, так как он всегда копирует каждый элемент a.
Исходный код Редактировать
proc `[]`(s: string; i: BackwardsIndex): char {.inline, systemRaisesDefect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `[]`(s: var string; i: BackwardsIndex): var char {.inline, systemRaisesDefect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `[]`[I: Ordinal; T](a: T; i: I): T {.noSideEffect, magic: "ArrGet", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `[]`[Idx, T; U, V: Ordinal](a: array[Idx, T]; x: HSlice[U, V]): seq[T] {. systemRaisesDefect.}: Операция среза для массивов. Возвращает диапазон [a[x.a], a[x.b]].

var a = [1, 2, 3, 4] assert a[0..2] == @[1, 2, 3]

См. также:

toOpenArray(array[I, T];I,I)

Исходный код Редактировать
proc `[]`[Idx, T](a: array[Idx, T]; i: BackwardsIndex): T {.inline, systemRaisesDefect.}: Исходный код Редактировать
proc `[]`[Idx, T](a: var array[Idx, T]; i: BackwardsIndex): var T {.inline, systemRaisesDefect.}: Исходный код Редактировать
proc `[]`[T, U: Ordinal](s: string; x: HSlice[T, U]): string {.inline, systemRaisesDefect.}: Операция среза для строк. Возвращает диапазон [s[x.a], s[x.b]].

var s = "abcdef" assert s[1..3] == "bcd"
Исходный код Редактировать
proc `[]`[T; U, V: Ordinal](s: openArray[T]; x: HSlice[U, V]): seq[T] {. systemRaisesDefect.}: Операция среза для последовательностей. Возвращает диапазон [s[x.a], s[x.b]].

var s = @[1, 2, 3, 4] assert s[0..2] == @[1, 2, 3]

См. также:

toOpenArray(openArray[T];int,int)

Исходный код Редактировать
proc `[]`[T](s: openArray[T]; i: BackwardsIndex): T {.inline, systemRaisesDefect.}: Исходный код Редактировать
proc `[]`[T](s: var openArray[T]; i: BackwardsIndex): var T {.inline, systemRaisesDefect.}: Исходный код Редактировать
proc `[]=`(s: var string; i: BackwardsIndex; x: char) {.inline, systemRaisesDefect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `[]=`[I: Ordinal; T, S](a: T; i: I; x: sink S) {.noSideEffect, magic: "ArrPut", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `[]=`[Idx, T; U, V: Ordinal](a: var array[Idx, T]; x: HSlice[U, V]; b: openArray[T]) {.systemRaisesDefect.}: Присвоение среза для массивов.

var a = [10, 20, 30, 40, 50] a[1..2] = @[99, 88] assert a == [10, 99, 88, 40, 50]
Исходный код Редактировать
proc `[]=`[Idx, T](a: var array[Idx, T]; i: BackwardsIndex; x: T) {.inline, systemRaisesDefect.}: Исходный код Редактировать
proc `[]=`[T, U: Ordinal](s: var string; x: HSlice[T, U]; b: string) {. systemRaisesDefect.}: Присвоение среза для строк.

Если b.len не равно количеству элементов, на которые ссылается x, выполняется вставка:

Пример:

var s = "abcdefgh" s[1 .. ^2] = "xyz" assert s == "axyzh"
Исходный код Редактировать
proc `[]=`[T; U, V: Ordinal](s: var seq[T]; x: HSlice[U, V]; b: openArray[T]) {. systemRaisesDefect.}: Присвоение среза для последовательностей.

Если b.len не равно количеству элементов, на которые ссылается x, выполняется вставка.

Пример:

var s = @"abcdefgh" s[1 .. ^2] = @"xyz" assert s == @"axyzh"
Исходный код Редактировать
proc `[]=`[T](s: var openArray[T]; i: BackwardsIndex; x: T) {.inline, systemRaisesDefect.}: Исходный код Редактировать
func abs(x: int): int {.magic: "AbsI", inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
func abs(x: int8): int8 {.magic: "AbsI", inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
func abs(x: int16): int16 {.magic: "AbsI", inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
func abs(x: int32): int32 {.magic: "AbsI", inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
func abs(x: int64): int64 {.magic: "AbsI", inline, ...raises: [], tags: [], forbids: [].}: Возвращает абсолютное значение x.

Если x равно low(x) (то есть -MININT для его типа), возникает исключение переполнения (если проверка переполнения включена).
Исходный код Редактировать
proc abs[T: float64 | float32](x: T): T {.noSideEffect, inline.}: Исходный код Редактировать

proc add(x: var cstring; y: cstring) {.magic: "AppendStrStr", ...raises: [], tags: [], forbids: [].}: Добавляет y к x на месте. Реализовано только для JS бэкэнда.
Пример:

when defined(js): var tmp: cstring = "" tmp.add(cstring("ab")) tmp.add(cstring("cd")) doAssert tmp == cstring("abcd")
Исходный код Изменить
proc add(x: var string; y: char) {.magic: "AppendStrCh", noSideEffect, ...raises: [], tags: [], forbids: [].}: Добавляет y к x на месте.

var tmp = "" tmp.add('a') tmp.add('b') assert(tmp == "ab")
Исходный код Изменить
proc add(x: var string; y: cstring) {.asmNoStackFrame, ...raises: [], tags: [], forbids: [].}: Добавляет y к x на месте.
Пример:

var tmp = "" tmp.add(cstring("ab")) tmp.add(cstring("cd")) doAssert tmp == "abcd"
Исходный код Изменить
proc add(x: var string; y: string) {.magic: "AppendStrStr", noSideEffect, ...raises: [], tags: [], forbids: [].}: Конкатенирует x и y на месте.

См. также strbasics.add.

Пример:

var tmp = "" tmp.add("ab") tmp.add("cd") assert tmp == "abcd"
Исходный код Изменить
proc add[T](x: var seq[T]; y: openArray[T]) {.noSideEffect.}: Обобщённая процедура для добавления контейнера y в контейнер x.

Для контейнеров с порядком add означает добавление в конец. Новые обобщённые контейнеры также должны вызывать свою процедуру добавления add для согласованности. Обобщённый код становится значительно проще для написания, если соблюдается схема именования Nim.

См. также:

& процедура

Пример:

var a = @["a1", "a2"] a.add(["b1", "b2"]) assert a == @["a1", "a2", "b1", "b2"] var c = @["c0", "c1", "c2", "c3"] a.add(c.toOpenArray(1, 2)) assert a == @["a1", "a2", "b1", "b2", "c1", "c2"]
Исходный код Изменить
proc add[T](x: var seq[T]; y: sink T) {.magic: "AppendSeqElem", noSideEffect, nodestroy, ...raises: [], tags: [], forbids: [].}: Обобщённая процедура для добавления элемента данных y в контейнер x.

Для контейнеров с порядком add означает добавление в конец. Новые обобщённые контейнеры также должны вызывать свою процедуру добавления add для согласованности. Обобщённый код становится значительно проще для написания, если соблюдается схема именования Nim.
Исходный код Изменить
proc addEscapedChar(s: var string; c: char) {.noSideEffect, inline, ...raises: [], tags: [], forbids: [].}: Добавляет символ к строке s и применяет следующие экранирования:

заменяет любой \ на \\

заменяет любой ' на \'

заменяет любой " на \"

заменяет любой \a на \\a

заменяет любой \b на \\b

заменяет любой \t на \\t

заменяет любой \n на \\n

заменяет любой \v на \\v

заменяет любой \f на \\f

заменяет любой \r на \\r

заменяет любой \e на \\e

заменяет любой другой символ, не входящий в набор {\21..\126} на \xHH где HH - его шестнадцатеричное значение

Процедура разработана таким образом, чтобы её вывод был пригоден для многих различных распространённых синтаксисов.

Предупреждение: Это неверно для генерации кода ANSI C!
Исходный код Изменить
proc addQuitProc(quitProc: proc () {.noconv.}) {.importc: "atexit", header: "<stdlib.h>", ...deprecated: "use exitprocs.addExitProc", raises: [], tags: [], forbids: [].}: Устаревшее: используйте exitprocs.addExitProc

Добавляет/регистрирует процедуру завершения.

Каждый вызов addQuitProc регистрирует ещё одну процедуру завершения. Может быть зарегистрировано до 30 процедур. Они выполняются по принципу LIFO (последняя зарегистрированная функция выполняется первой). addQuitProc выводит исключение EOutOfIndex, если quitProc не может быть зарегистрировано.
Исходный код Изменить
proc addQuoted[T](s: var string; x: T): Добавляет x к строке s на месте, применяя цитирование и экранирование, если x является строкой или символом.

См. addEscapedChar для схемы экранирования. Когда x является строкой, символы в диапазоне {\128..\255} никогда не экранируются, чтобы многобайтовые символы UTF-8 оставались без изменений (обратите внимание, что это поведение отличается от addEscapedChar).

Стандартная библиотека Nim использует эту функцию для элементов коллекций при создании строкового представления коллекции. Рекомендуется использовать эту функцию и для коллекций со стороны пользователя. Пользователи могут перегрузить addQuoted для пользовательских (строкоподобных) типов, если они хотят реализовать настраиваемое представление элемента.

var tmp = "" tmp.addQuoted(1) tmp.add(", ") tmp.addQuoted("string") tmp.add(", ") tmp.addQuoted('c') assert(tmp == """1, "string", 'c'""")
Исходный код Изменить
proc `addr`[T](x: T): ptr T {.magic: "Addr", noSideEffect, ...raises: [], tags: [], forbids: [].}: Встроенный оператор addr для получения адреса области памяти.
Примечание: Это работает для let переменных или параметров для лучшей совместимости с C. При использовании для написания обёртки для библиотеки C и получения адреса let переменных или параметров, всегда необходимо проверять, что исходная библиотека никогда не записывает в данные за указателем, возвращаемым этой процедурой.

Не может быть перегружена.

var buf: seq[char] = @['a','b','c'] p = buf[1].addr echo p.repr # ref 0x7faa35c40059 --> 'b' echo p[] # b
Исходный код Изменить
proc alignof(x: typedesc): int {.magic: "AlignOf", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc alignof[T](x: T): int {.magic: "AlignOf", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc alloc0Impl(size: Natural): pointer {.noconv, ...gcsafe, tags: [], gcsafe, raises: [], forbids: [].}: Исходный код Изменить
proc allocCStringArray(a: openArray[string]): cstringArray {....raises: [], tags: [], forbids: [].}: Создаёт массив cstring, завершаемый нулём, из a. Результат необходимо освободить с помощью deallocCStringArray после того, как он больше не нужен. Исходный код Изменить
proc allocImpl(size: Natural): pointer {.noconv, ...gcsafe, tags: [], gcsafe, raises: [], forbids: [].}: Исходный код Изменить
proc allocShared0Impl(size: Natural): pointer {.noconv, ...gcsafe, gcsafe, raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc allocSharedImpl(size: Natural): pointer {.noconv, compilerproc, ...gcsafe, gcsafe, raises: [], tags: [], forbids: [].}: Исходный код Изменить

proc `and`(a, b: typedesc): typedesc {.magic: "TypeTrait", noSideEffect, ...raises: [], tags: [], forbids: [].}: Создаёт метакласс and. Исходный код Изменить
proc `and`(x, y: bool): bool {.magic: "And", noSideEffect, ...raises: [], tags: [], forbids: [].}: Булево and; возвращает true, если x == y == true (если оба аргумента true).

Вычисление ленивое: если x ложно, то y даже не будет вычислено.
Исходный код Изменить
proc `and`(x, y: int): int {.magic: "BitandI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Вычисляет bitwise and чисел x и y.
Пример:

assert (0b0011 and 0b0101) == 0b0001 assert (0b0111 and 0b1100) == 0b0100
Исходный код Изменить
proc `and`(x, y: int8): int8 {.magic: "BitandI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `and`(x, y: int16): int16 {.magic: "BitandI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `and`(x, y: int32): int32 {.magic: "BitandI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `and`(x, y: int64): int64 {.magic: "BitandI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `and`(x, y: uint): uint {.magic: "BitandI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Вычисляет bitwise and чисел x и y. Исходный код Изменить
proc `and`(x, y: uint8): uint8 {.magic: "BitandI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `and`(x, y: uint16): uint16 {.magic: "BitandI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `and`(x, y: uint32): uint32 {.magic: "BitandI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `and`(x, y: uint64): uint64 {.magic: "BitandI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc arrayWith[T](y: T; size: static int): array[size, T] {....raises: [].}: Создаёт новый массив, заполненный y. Исходный код Изменить
proc ashr(x: int8; y: SomeInteger): int8 {.magic: "AshrI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc ashr(x: int16; y: SomeInteger): int16 {.magic: "AshrI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc ashr(x: int32; y: SomeInteger): int32 {.magic: "AshrI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc ashr(x: int64; y: SomeInteger): int64 {.magic: "AshrI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc ashr(x: int; y: SomeInteger): int {.magic: "AshrI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Сдвигает вправо, заполняя освободившиеся биты копией самого левого бита слева, а правые биты отбрасывает.

Обратите внимание, что ashr не является оператором, поэтому используйте обычный синтаксис вызова функции.

См. также:

shr функция

Пример:

assert ashr(0b0001_0000'i8, 2) == 0b0000_0100'i8 assert ashr(0b1000_0000'i8, 8) == 0b1111_1111'i8 assert ashr(0b1000_0000'i8, 1) == 0b1100_0000'i8
Исходный код Изменить
proc astToStr[T](x: T): string {.magic: "AstToStr", noSideEffect, ...raises: [], tags: [], forbids: [].}: Преобразует абстрактное синтаксическое дерево (AST) x в строковое представление. Это очень полезно для отладки. Исходный код Изменить
func capacity(self: string): int {.inline, ...raises: [], tags: [], forbids: [].}: Возвращает текущую ёмкость строки.
Пример:

var str = newStringOfCap(cap = 42) str.add "Nim" assert str.capacity == 42
Исходный код Изменить
func capacity[T](self: seq[T]): int {.inline.}: Возвращает текущую ёмкость последовательности.
Пример:

var lst = newSeqOfCap[string](cap = 42) lst.add "Nim" assert lst.capacity == 42
Исходный код Изменить
func card[T](x: set[T]): int {.magic: "Card", ...raises: [], tags: [], forbids: [].}: Возвращает мощность множества x, то есть количество элементов в множестве.
Пример:

var a = {1, 3, 5, 7} assert card(a) == 4 var b = {1, 3, 5, 7, 5} assert card(b) == 4 # repeated 5 doesn't count
Исходный код Изменить
func chr(u: range[0 .. 255]): char {.magic: "Chr", ...raises: [], tags: [], forbids: [].}: Преобразует u в char, то же самое, что char(u).
Пример:

doAssert chr(65) == 'A' doAssert chr(255) == '\255' doAssert chr(255) == char(255) doAssert not compiles chr(256) doAssert not compiles char(256) var x = 256 doAssertRaises(RangeDefect): discard chr(x) doAssertRaises(RangeDefect): discard char(x)
Исходный код Изменить
proc clamp[T](x, a, b: T): T: Ограничивает значение x в интервале [a, b]. Эта функция эквивалентна, но быстрее, чем max(a, min(b, x)).
Предупреждение: a <= b предполагается и не будет проверяться (на данный момент).

См. также: math.clamp для версии, принимающей Slice[T] вместо.

Пример:

assert (1.4).clamp(0.0, 1.0) == 1.0 assert (0.5).clamp(0.0, 1.0) == 0.5 assert 4.clamp(1, 3) == max(1, min(3, 4))
Исходный код Изменить
proc close[TMsg](c: var Channel[TMsg]): Закрывает канал c и освобождает связанные ресурсы. Исходный код Изменить
proc cmp(x, y: string): int {.noSideEffect, ...raises: [], tags: [], forbids: [].}: Функция сравнения для строк. Более эффективна, чем общая версия.

Примечание: точные значения результатов зависят от используемой библиотеки C-времени выполнения и могут отличаться между операционными системами!
Исходный код Изменить
proc cmp[T](x, y: T): int: Общая функция сравнения.

Возвращает:

значение меньше нуля, если x < y

значение больше нуля, если x > y

ноль, если x == y

Это полезно для написания общих алгоритмов без потери производительности. Эта общая реализация использует операторы == и <.

import std/algorithm echo sorted(@[4, 2, 6, 5, 8, 7], cmp[int])
Исходный код Изменить

proc cmpMem(a, b: pointer; size: Natural): int {.inline, noSideEffect, ...tags: [], raises: [], forbids: [].}: Сравнивает блоки памяти a и b. Будет сравнено size байтов.

Возвращает:

значение меньше нуля, если a < b

значение больше нуля, если a > b

ноль, если a == b

Как любая процедура, работающая с сырой памятью, это небезопасно.
Исходный код Изменить
proc compileOption(option, arg: string): bool {.magic: "CompileOptionArg", noSideEffect, ...raises: [], tags: [], forbids: [].}: Может быть использована для определения компиляционной опции перечисления.

См. также:

compileOption для опций on|off

defined

модуль std/compilesettings

Пример:

when compileOption("opt", "size") and compileOption("gc", "boehm"): discard "compiled with optimization for size and uses Boehm's GC"
Исходный код Изменить
proc compileOption(option: string): bool {.magic: "CompileOption", noSideEffect, ...raises: [], tags: [], forbids: [].}: Может быть использована для определения on|off компиляционной опции.

См. также:

compileOption для опций перечислений

defined

модуль std/compilesettings

Пример: cmd: --floatChecks:off

static: doAssert not compileOption("floatchecks") {.push floatChecks: on.} static: doAssert compileOption("floatchecks") # floating point NaN and Inf checks enabled in this scope {.pop.}
Исходный код Изменить
proc compiles(x: untyped): bool {.magic: "Compiles", noSideEffect, compileTime, ...raises: [], tags: [], forbids: [].}: Специальная процедура компиляции, которая проверяет, может ли x быть скомпилирована без каких-либо семантических ошибок. Это можно использовать для проверки, поддерживает ли тип какую-либо операцию:

when compiles(3 + 4): echo "'+' for integers is available"
Исходный код Изменить
proc contains[T](a: openArray[T]; item: T): bool {.inline.}: Возвращает true, если item содержится в a, или false, если не найдено. Это сокращение для find(a, item) >= 0.

Это позволяет использовать оператор in: a.contains(item) эквивалентно item in a.

var a = @[1, 3, 5] assert a.contains(5) assert 3 in a assert 99 notin a
Исходный код Изменить
func contains[T](x: set[T]; y: T): bool {.magic: "InSet", ...raises: [], tags: [], forbids: [].}: Необходимо перегрузить эту процедуру, если необходимо перегрузить оператор in.

Параметры расположены в обратном порядке! a in b является шаблоном для contains(b, a). Это связано с тем, что алгоритм унификации, используемый Nim для разрешения перегрузки, работает слева направо. Но для оператора in этот порядок был бы неверным для этого фрагмента кода:

Пример:

var s: set[range['a'..'z']] = {'a'..'c'} assert s.contains('c') assert 'b' in s assert 'd' notin s assert set['a'..'z'] is set[range['a'..'z']]
Если in был объявлен как [T](elem: T, s: set[T]) , то T был бы привязан к char. Но s несовместим с типом set[char]! Решением является привязка T к range['a'..'z']. Это достигается изменением порядка параметров для contains; in затем передает свои аргументы в обратном порядке. Исходный код Изменить
proc contains[U, V, W](s: HSlice[U, V]; value: W): bool {.noSideEffect, inline.}: Проверяет, находится ли value в диапазоне s; возвращает true, если value >= s.a and value <= s.b.

assert((1..3).contains(1) == true) assert((1..3).contains(2) == true) assert((1..3).contains(4) == false)
Исходный код Изменить
proc copyMem(dest, source: pointer; size: Natural) {.inline, ...gcsafe, tags: [], raises: [], forbids: [].}: Копирует содержимое из памяти по адресу source в память по адресу dest. Будет скопировано ровно size байтов. Области памяти не должны перекрываться. Как любая процедура, работающая с сырой памятью, это небезопасно. Исходный код Изменить
proc create(T: typedesc; size = 1.Positive): ptr T:type {.inline, ...gcsafe, raises: [].}: Выделяет новый блок памяти с размером не менее T.sizeof * size байтов.

Блок необходимо освободить с помощью resize(block, 0) или dealloc(block). Блок инициализируется нулями, поэтому он несколько безопаснее, чем createU.

Выделенная память принадлежит потоку, который её выделил! Используйте createShared для выделения из общей кучи.
Исходный код Изменить
proc createShared(T: typedesc; size = 1.Positive): ptr T:type {.inline.}: Выделяет новый блок памяти в общей куче размером не менее T.sizeof * size байтов.

Блок необходимо освободить с помощью resizeShared(block, 0) или freeShared(block).

Блок инициализируется нулями, поэтому он несколько безопаснее, чем createSharedU.
Исходный код Изменить
proc createSharedU(T: typedesc; size = 1.Positive): ptr T:type {.inline, ...tags: [], gcsafe, raises: [].}: Выделяет новый блок памяти в общей куче с размером не менее T.sizeof * size байтов.

Блок необходимо освободить с помощью resizeShared(block, 0) или freeShared(block).

Блок не инициализирован, поэтому чтение из него до записи в него — неопределённое поведение!

См. также:

createShared

Исходный код Изменить
proc createU(T: typedesc; size = 1.Positive): ptr T:type {.inline, ...gcsafe, raises: [].}: Выделяет новый блок памяти с размером не менее T.sizeof * size байтов.

Блок необходимо освободить с помощью resize(block, 0) или dealloc(block). Блок не инициализирован, поэтому чтение из него до записи в него — неопределённое поведение!

Выделенная память принадлежит потоку, который её выделил! Используйте createSharedU для выделения из общей кучи.

См. также:

create

Исходный код Изменить
proc cstringArrayToSeq(a: cstringArray): seq[string] {....raises: [], tags: [], forbids: [].}: Преобразует cstringArray в seq[string]. a должен быть завершён nil. Исходный код Изменить
proc cstringArrayToSeq(a: cstringArray; len: Natural): seq[string] {....raises: [], tags: [], forbids: [].}: Преобразует cstringArray в seq[string]. a должен иметь длину len. Исходный код Изменить
proc dealloc(p: pointer) {.noconv, compilerproc, ...gcsafe, gcsafe, raises: [], tags: [], forbids: [].}: Освобождает память, выделенную с помощью alloc, alloc0, realloc, create или createU.

Эта процедура опасна! Если вы забудете освободить память, произойдёт утечка; если вы попытаетесь получить доступ к освобождённой памяти (или освободить её дважды!) может произойти сбой ядра или быть повреждена другая память.

Освобождаемая память должна принадлежать потоку, который её выделил! Используйте deallocShared для освобождения из общей кучи.
Исходный код Изменить
proc deallocCStringArray(a: cstringArray) {....raises: [], tags: [], forbids: [].}: Освобождает массив cstring, завершённый нулём. Исходный код Изменить
proc deallocImpl(p: pointer) {.noconv, ...gcsafe, tags: [], gcsafe, raises: [], forbids: [].}: Исходный код Изменить

END_OF_DOCUMENT_MARKER

proc deallocShared(p: pointer) {.noconv, compilerproc, ...gcsafe, gcsafe, raises: [], tags: [], forbids: [].}: Освобождает память, выделенную с помощью allocShared, allocShared0 или reallocShared.

Эта процедура опасна! Если забыть освободить память, произойдёт утечка; если попытаться обратиться к освобождённой памяти (или освободить её дважды!), может произойти сбой ядра или повредиться другая память.
Исходный код Редактировать
proc deallocSharedImpl(p: pointer) {.noconv, ...gcsafe, gcsafe, raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc debugEcho(x: varargs[typed, `$`]) {.magic: "Echo", noSideEffect, ...tags: [], raises: [], forbids: [].}: Аналогично echo, но, согласно специальному правилу семантики, debugEcho имитирует отсутствие побочных эффектов, чтобы его можно было использовать в отладочных процедурах, помеченных как noSideEffect. Исходный код Редактировать
proc dec[T, V: Ordinal](x: var T; y: V = 1) {.magic: "Dec", noSideEffect, ...raises: [], tags: [], forbids: [].}: Уменьшает порядковый x на y.

Если такого значения не существует, поднимается OverflowDefect или возникает ошибка времени компиляции. Это краткая запись для: x = pred(x, y).

Пример:

var i = 2 dec(i) assert i == 1 dec(i, 3) assert i == -2
Исходный код Редактировать
proc declared(x: untyped): bool {.magic: "Declared", noSideEffect, compileTime, ...raises: [], tags: [], forbids: [].}: Специальная процедура времени компиляции, которая проверяет, объявлено ли x. x должен быть идентификатором или квалифицированным идентификатором.

Это можно использовать для проверки, предоставляет ли библиотека определённую функцию или нет:

when not declared(strutils.toUpper): # provide our own toUpper proc here, because strutils is # missing it.

См. также:

declaredInScope

Исходный код Редактировать
proc declaredInScope(x: untyped): bool {.magic: "DeclaredInScope", noSideEffect, compileTime, ...raises: [], tags: [], forbids: [].}: Специальная процедура времени компиляции, которая проверяет, объявлено ли x в текущем пространстве имён. x должен быть идентификатором. Исходный код Редактировать
proc deepCopy[T](x: var T; y: T) {.noSideEffect, magic: "DeepCopy", ...raises: [], tags: [], forbids: [].}: Выполняет глубокую копию y и копирует её в x.

Это также используется генератором кода для реализации spawn.

Для --mm:arc или --mm:orc поддержка deepcopy должна быть включена через --deepcopy:on.
Исходный код Редактировать
proc deepCopy[T](y: T): T: Обёртка для перегрузки deepCopy. Исходный код Редактировать
proc default[T](_: typedesc[T]): T {.magic: "Default", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает значение по умолчанию типа T. В отличие от zeroDefault, учитывает поля по умолчанию объекта.

См. также:

zeroDefault

Пример: cmd: -d:nimPreviewRangeDefault

assert (int, float).default == (0, 0.0) type Foo = object a: range[2..6] var x = Foo.default assert x.a == 2
Исходный код Редактировать
proc defined(x: untyped): bool {.magic: "Defined", noSideEffect, compileTime, ...raises: [], tags: [], forbids: [].}: Специальная процедура времени компиляции, которая проверяет, определено ли x.

x — это внешний символ, введённый через параметр компилятора -d:x для включения условных операторов на этапе сборки:

when not defined(release): # Do here programmer friendly expensive sanity checks. # Put here the normal code

См. также:

compileOption для параметров on|off

compileOption для параметров перечисления

макросы define

Исходный код Редактировать
proc del[T](x: var seq[T]; i: Natural) {.noSideEffect.}: Удаляет элемент по индексу i, помещая x[high(x)] в позицию i.

Это операция O(1).

См. также:

delete для сохранения порядка

Пример:

var a = @[10, 11, 12, 13, 14] a.del(2) assert a == @[10, 11, 14, 13]
Исходный код Редактировать
proc delete[T](x: var seq[T]; i: Natural) {.noSideEffect, systemRaisesDefect.}: Удаляет элемент по индексу i, сдвигая все x[i+1..^1] элементы на одну позицию.

Это операция O(n).

См. также:

del для O(1) операции

Пример:

var s = @[1, 2, 3, 4, 5] s.delete(2) doAssert s == @[1, 2, 4, 5]
Исходный код Редактировать
proc dispose(x: ForeignCell) {....raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `div`(x, y: int): int {.magic: "DivI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Вычисляет целочисленное деление.

Приблизительно то же, что math.trunc(x/y).int.

Пример:

assert (1 div 2) == 0 assert (2 div 2) == 1 assert (3 div 2) == 1 assert (7 div 3) == 2 assert (-7 div 3) == -2 assert (7 div -3) == -2 assert (-7 div -3) == 2
Исходный код Редактировать
proc `div`(x, y: int8): int8 {.magic: "DivI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `div`(x, y: int16): int16 {.magic: "DivI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `div`(x, y: int32): int32 {.magic: "DivI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `div`(x, y: int64): int64 {.magic: "DivI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `div`(x, y: uint): uint {.magic: "DivU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Вычисляет целочисленное деление для беззнаковых целых чисел. Это примерно то же, что trunc(x/y). Исходный код Редактировать
proc `div`(x, y: uint8): uint8 {.magic: "DivU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `div`(x, y: uint16): uint16 {.magic: "DivU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `div`(x, y: uint32): uint32 {.magic: "DivU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `div`(x, y: uint64): uint64 {.magic: "DivU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать

proc echo(x: varargs[typed, `$`]) {.magic: "Echo", ...gcsafe, sideEffect, ...raises: [], tags: [], forbids: [].}: Записывает и сбрасывает параметры в стандартный вывод.

Специальная встроенная функция, принимающая переменное количество аргументов. Каждый аргумент преобразуется в строку с помощью $, поэтому она работает для пользовательских типов, имеющих перегруженный оператор $. Она примерно эквивалентна writeLine(stdout, x); flushFile(stdout), но также доступна для целевой платформы JavaScript.

В отличие от других операций ввода/вывода, эта гарантированно потокобезопасна, так как echo очень часто используется для удобства отладки. Если вы хотите использовать echo внутри процедуры без побочных эффектов, вы можете использовать debugEcho вместо неё.
Исходный код Редактировать
proc ensureMove[T](x: T): T {.magic: "EnsureMove", noSideEffect, ...raises: [], tags: [], forbids: [].}: Обеспечивает перемещение x в новое местоположение, в противном случае возникает ошибка во время компиляции.
Пример:

proc foo = var x = "Hello" let y = ensureMove(x) doAssert y == "Hello" foo()
Исходный код Редактировать
proc equalMem(a, b: pointer; size: Natural): bool {.inline, noSideEffect, ...tags: [], raises: [], forbids: [].}: Сравнивает блоки памяти a и b. Будет сравнено size байт.

Если блоки равны, возвращается true, в противном случае false. Как и любая процедура, работающая с сырой памятью, она является неопасной.
Исходный код Редактировать
func excl[T](x: var set[T]; y: T) {.magic: "Excl", ...raises: [], tags: [], forbids: [].}: Исключает элемент y из набора x.

Это то же самое, что и x = x - {y}, но может быть более эффективным.

Пример:

var b = {2, 3, 5, 6, 12, 54} b.excl(5) assert b == {2, 3, 6, 12, 54}
Исходный код Редактировать
proc find[T, S](a: T; item: S): int {.inline.}: Возвращает первый индекс item в a или -1, если не найдено. Для работы требуется соответствующие операции items и ==. Исходный код Редактировать
proc finished[T: iterator {.closure.}](x: T): bool {.noSideEffect, inline, magic: "Finished", ...raises: [], tags: [], forbids: [].}: Может использоваться для определения завершения итератора первого класса. Исходный код Редактировать
proc freeShared[T](p: ptr T) {.inline, ...gcsafe, raises: [].}: Освобождает память, выделенную с помощью createShared, createSharedU или resizeShared.

Эта процедура опасна! Если забыть освободить память, произойдёт утечка; если попытаться получить доступ к освобождённой памяти (или освободить её дважды!) может произойти сбой ядра или повреждение другой памяти.
Исходный код Редактировать
proc GC_disableMarkAndSweep() {....raises: [], tags: [], forbids: [].}: Для --mm:orc псевдоним для GC_disableOrc. Исходный код Редактировать
proc GC_disableOrc() {....raises: [], tags: [], forbids: [].}: Отключает подсистему коллектора циклов для --mm:orc. Это API, специфичное для --mm:orc. Проверьте с помощью when defined(gcOrc) на его существование. Исходный код Редактировать
proc GC_enableMarkAndSweep() {....raises: [], tags: [], forbids: [].}: Для --mm:orc псевдоним для GC_enableOrc. Исходный код Редактировать
proc GC_enableOrc() {....raises: [], tags: [], forbids: [].}: Включает подсистему коллектора циклов для --mm:orc. Это API, специфичное для --mm:orc. Проверьте с помощью when defined(gcOrc) на его существование. Исходный код Редактировать
proc GC_fullCollect() {....raises: [Exception], tags: [RootEffect], forbids: [].}: Вынуждает выполнение полного прохода сборки мусора. С --mm:orc запускается коллектор циклов. Это псевдоним для GC_runOrc. Исходный код Редактировать
proc GC_getStatistics(): string {....raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc GC_partialCollect(limit: int) {....raises: [Exception], tags: [RootEffect], forbids: [].}: Исходный код Редактировать
proc GC_prepareOrc(): int {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc GC_ref[T](x: ref T): Новая среда выполнения поддерживает эту операцию только для 'ref T'. Исходный код Редактировать
proc GC_runOrc() {....raises: [Exception], tags: [RootEffect], forbids: [].}: Вынуждает выполнение прохода сборки циклов. Исходный код Редактировать
proc GC_unref[T](x: ref T): Новая среда выполнения поддерживает эту операцию только для 'ref T'. Исходный код Редактировать
proc getAllocStats(): AllocStats {....raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc getCurrentException(): ref Exception {.compilerproc, inline, ...gcsafe, raises: [], tags: [], forbids: [].}: Возвращает текущее исключение; если исключения нет, возвращает nil. Исходный код Редактировать
proc getCurrentExceptionMsg(): string {.inline, ...gcsafe, raises: [], tags: [], forbids: [].}: Возвращает сообщение об ошибке, прикреплённое к текущему исключению; если сообщение отсутствует, возвращает "". Исходный код Редактировать
proc getFrame(): PFrame {.compilerproc, inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc getFrameState(): FrameState {.compilerproc, inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc getFreeMem(): int {....gcsafe, raises: [], tags: [], forbids: [].}: Возвращает количество байтов, принадлежащих процессу, но не содержащих значимых данных. Исходный код Редактировать
proc getFreeSharedMem(): int {....gcsafe, raises: [], tags: [], forbids: [].}: Возвращает количество байтов, принадлежащих процессу в общей куче, но не содержащих значимых данных. Доступно только при включенных потоках. Исходный код Редактировать

proc getMaxMem(): int {....raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc getOccupiedMem(): int {....gcsafe, raises: [], tags: [], forbids: [].}: Возвращает количество байтов, принадлежащих процессу и содержащих данные. Исходный код Редактировать
proc getOccupiedSharedMem(): int {....gcsafe, raises: [], tags: [], forbids: [].}: Возвращает количество байтов, принадлежащих процессу на общей куче и содержащих данные. Доступно только при включённых потоках. Исходный код Редактировать
proc getStackTrace(): string {....gcsafe, raises: [], tags: [], forbids: [].}: Получает текущий стек вызовов. Работает только в отладочных сборках. Исходный код Редактировать
proc getStackTrace(e: ref Exception): string {....gcsafe, raises: [], tags: [], forbids: [].}: Получает стек вызовов, связанный с e, который является стеком, приведшим к raise оператору. Работает только в отладочных сборках. Исходный код Редактировать
proc getStackTraceEntries(): seq[StackTraceEntry] {....raises: [], tags: [], forbids: [].}: Возвращает записи стека вызовов для текущего стека вызовов. Пока недоступно для JS-бекенда. Исходный код Редактировать
proc getStackTraceEntries(e: ref Exception): lent seq[StackTraceEntry] {. ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc getThreadId(): int {....raises: [], tags: [], forbids: [].}: Получает идентификатор текущего выполняющегося потока. Исходный код Редактировать
proc getTotalMem(): int {....gcsafe, raises: [], tags: [], forbids: [].}: Возвращает количество байтов, принадлежащих процессу. Исходный код Редактировать
proc getTotalSharedMem(): int {....gcsafe, raises: [], tags: [], forbids: [].}: Возвращает количество байтов на общей куче, принадлежащих процессу. Доступно только при включённых потоках. Исходный код Редактировать
proc getTypeInfo[T](x: T): pointer {.magic: "GetTypeInfo", ...gcsafe, raises: [], tags: [], forbids: [].}: Получить информацию о типе x.

Обычный код не должен использовать это, а вместо этого использовать модуль typeinfo.
Исходный код Редактировать
proc gorge(command: string; input = ""; cache = ""): string {. magic: "StaticExec", ...raises: [], tags: [], forbids: [].}: Это псевдоним для staticExec. Исходный код Редактировать
proc gorgeEx(command: string; input = ""; cache = ""): tuple[output: string, exitCode: int] {....raises: [], tags: [], forbids: [].}: Аналогично gorge, но также возвращает код возврата. Исходный код Редактировать
proc grow[T](x: var seq[T]; newLen: Natural; value: T) {.nodestroy.}: Исходный код Редактировать
proc high(T: typedesc[SomeFloat]): T:type: Исходный код Редактировать
proc high(x: cstring): int {.magic: "High", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает максимальный возможный индекс совместимой строки x. Иногда это операция O(n).

См. также:

low(cstring)

Исходный код Редактировать
proc high(x: string): int {.magic: "High", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает максимальный возможный индекс строки x.

var str = "Hello world!" high(str) # => 11

См. также:

low(string)

Исходный код Редактировать
proc high[I, T](x: array[I, T]): I {.magic: "High", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает максимальный возможный индекс массива x.

Для пустых массивов возвращаемый тип int.

var arr = [1, 2, 3, 4, 5, 6, 7] high(arr) # => 6 for i in low(arr)..high(arr): echo arr[i]

См. также:

low(array)

Исходный код Редактировать
proc high[I, T](x: typedesc[array[I, T]]): I {.magic: "High", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает максимальный возможный индекс типа массива.

Для пустых массивов возвращаемый тип int.

high(array[7, int]) # => 6

См. также:

low(typedesc[array])

Исходный код Редактировать
proc high[T: Ordinal | enum | range](x: T): T {.magic: "High", noSideEffect, ...deprecated: "Deprecated since v1.4; there should not be `high(value)`. Use `high(type)`.", raises: [], tags: [], forbids: [].}: Устаревшее: Устарело начиная с версии 1.4; не должно быть `high(value)`. Используйте `high(type)`.

Возвращает максимальное возможное значение порядкового значения x.

В качестве специального семантического правила x может также быть идентификатором типа.

Эта процедура устарела, используйте эту вместо неё:

high(typedesc)

high(2) # => 9223372036854775807
Исходный код Редактировать
proc high[T: Ordinal | enum | range](x: typedesc[T]): T {.magic: "High", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает максимальное возможное значение порядкового или перечислимого типа.

high(int) - это способ написания Nim INT_MAX или MAX_INT.

high(int) # => 9223372036854775807

См. также:

low(typedesc)

Исходный код Редактировать
proc high[T](x: openArray[T]): int {.magic: "High", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает максимальный возможный индекс последовательности x.

var s = @[1, 2, 3, 4, 5, 6, 7] high(s) # => 6 for i in low(s)..high(s): echo s[i]

См. также:

low(openArray)

Исходный код Редактировать
proc inc[T, V: Ordinal](x: var T; y: V = 1) {.magic: "Inc", noSideEffect, ...raises: [], tags: [], forbids: [].}: Увеличивает порядковый номер x на y.

Если такого значения не существует, OverflowDefect или происходит ошибка компиляции. Это сокращённая запись для: x = succ(x, y).

Пример:

var i = 2 inc(i) assert i == 3 inc(i, 3) assert i == 6
Исходный код Редактировать
func incl[T](x: var set[T]; y: T) {.magic: "Incl", ...raises: [], tags: [], forbids: [].}: Включает элемент y в множество x.

Это то же самое, что x = x + {y}, но может быть более эффективным.

Пример:

var a = {1, 3, 5} a.incl(2) assert a == {1, 2, 3, 5} a.incl(4) assert a == {1, 2, 3, 4, 5}
Исходный код Редактировать

proc insert(x: var string; item: string; i = 0.Natural) {.noSideEffect, ...raises: [], tags: [], forbids: [].}: Вставляет item в x в позиции i.

var a = "abc" a.insert("zz", 0) # a <- "zzabc"
Исходный код Редактировать
proc insert[T](x: var seq[T]; item: sink T; i = 0.Natural) {.noSideEffect.}: Вставляет item в x в позиции i.

var i = @[1, 3, 5] i.insert(99, 0) # i <- @[99, 1, 3, 5]
Исходный код Редактировать
proc instantiationInfo(index = -1; fullPaths = false): tuple[filename: string, line: int, column: int] {.magic: "InstantiationInfo", noSideEffect, ...raises: [], tags: [], forbids: [].}: Обеспечивает доступ к информации о строке стека экземпляции компилятора для шаблона.

Хотя похожа на информацию о вызывающей процедуре (caller info) других языков, она определяется на этапе компиляции.

Эта процедура в основном полезна для метапрограммирования (например, assert шаблон), чтобы извлечь информацию о текущем имени файла и номере строки. Пример:

import std/strutils template testException(exception, code: untyped): typed = try: let pos = instantiationInfo() discard(code) echo "Test failure at $1:$2 with '$3'" % [pos.filename, $pos.line, astToStr(code)] assert false, "A test expecting failure succeeded?" except exception: discard proc tester(pos: int): int = let a = @[1, 2, 3] result = a[pos] when isMainModule: testException(IndexDefect, tester(30)) testException(IndexDefect, tester(1)) # --> Test failure at example.nim:20 with 'tester(1)'
Исходный код Редактировать
proc `is`[T, S](x: T; y: S): bool {.magic: "Is", noSideEffect, ...raises: [], tags: [], forbids: [].}: Проверяет, является ли T того же типа, что и S.

Для отрицательного варианта используйте isnot.

assert 42 is int assert @[1, 2] is seq proc test[T](a: T): int = when (T is int): return a else: return 0 assert(test[int](3) == 3) assert(test[string]("xyz") == 0)
Исходный код Редактировать
proc isNil(x: cstring): bool {.noSideEffect, magic: "IsNil", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc isNil(x: pointer): bool {.noSideEffect, magic: "IsNil", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc isNil[T: proc | iterator {.closure.}](x: T): bool {.noSideEffect, magic: "IsNil", ...raises: [], tags: [], forbids: [].}: Быстрая проверка, является ли x нулевым. Иногда это более эффективно, чем == nil. Исходный код Редактировать
proc isNil[T](x: ptr T): bool {.noSideEffect, magic: "IsNil", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc isNil[T](x: ref T): bool {.noSideEffect, magic: "IsNil", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc isNotForeign(x: ForeignCell): bool {....raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc isUniqueRef[T](x: ref T): bool {.inline.}: Возвращает true, если объект, на который указывает x, имеет единственную ссылку. Такой объект потенциально может безопасно передаваться в другую нить, если соблюдаются все меры предосторожности. Эта процедура запрашивает внутренний счетчик ссылок объекта, который подвержен множеству оптимизаций! Другими словами, значение isUniqueRef может зависеть от используемой версии компилятора и настроек оптимизатора. Тем не менее, он может служить очень ценным инструментом отладки и может использоваться для указания ограничений API, связанных с многопоточностью, через assert isUniqueRef(x). Исходный код Редактировать
proc iterToProc(iter: typed; envType: typedesc; procName: untyped) {. magic: "Plugin", compileTime, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
func len(x: (type array) | array): int {.magic: "LengthArray", ...raises: [], tags: [], forbids: [].}: Возвращает длину массива или типа массива. Примерно то же самое, что и high(T)-low(T)+1.
Пример:

var a = [1, 1, 1] assert a.len == 3 assert array[0, float].len == 0 static: assert array[-2..2, float].len == 5
Исходный код Редактировать
proc len(x: cstring): int {.magic: "LengthStr", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает длину совместимой строки. Это операция O(n), за исключением js во время выполнения.

Примечание: На JS-бекенде в настоящее время подсчитываются кодовые точки UTF-16 вместо байтов во время выполнения (не на этапе компиляции). Пока что, если вам нужна длина байтов UTF-8 кодирования, сначала преобразуйте в строку с помощью $, а затем вызовите len.

Пример:

doAssert len(cstring"abc") == 3 doAssert len(cstring r"ab\0c") == 5 # \0 is escaped doAssert len(cstring"ab\0c") == 5 # ditto var a: cstring = "ab\0c" when defined(js): doAssert a.len == 4 # len ignores \0 for js else: doAssert a.len == 2 # \0 is a null terminator static: var a2: cstring = "ab\0c" doAssert a2.len == 2 # \0 is a null terminator, even in js vm
Исходный код Редактировать
func len(x: string): int {.magic: "LengthStr", ...raises: [], tags: [], forbids: [].}: Возвращает длину строки.
Пример:

assert "abc".len == 3 assert "".len == 0 assert string.default.len == 0
Исходный код Редактировать
func len[T](x: seq[T]): int {.magic: "LengthSeq", ...raises: [], tags: [], forbids: [].}: Возвращает длину x.
Пример:

assert @[0, 1].len == 2 assert seq[int].default.len == 0 assert newSeq[int](3).len == 3 let s = newSeqOfCap[int](3) assert s.len == 0
Исходный код Редактировать
func len[T](x: set[T]): int {.magic: "Card", ...raises: [], tags: [], forbids: [].}: Псевдоним для card(x). Исходный код Редактировать
func len[TOpenArray: openArray | varargs](x: TOpenArray): int {. magic: "LengthOpenArray", ...raises: [], tags: [], forbids: [].}: Возвращает длину openArray.
Пример:

proc bar[T](a: openArray[T]): int = len(a) assert bar([1,2]) == 2 assert [1,2].len == 2
Исходный код Редактировать
proc len[U: Ordinal; V: Ordinal](x: HSlice[U, V]): int {.noSideEffect, inline.}: Длина порядкового среза. Если x.b < x.a, возвращает длину ноль.

assert((0..5).len == 6) assert((5..2).len == 0)
Исходный код Редактировать
proc locals(): RootObj {.magic: "Plugin", noSideEffect, ...raises: [], tags: [], forbids: [].}: Генерирует выражение конструктора кортежа, перечисляя все локальные переменные в текущем области видимости.

Это довольно быстро, так как не использует никакой отладочной или информации о времени выполнения. Обратите внимание, что в отличие от того, что говорит официальная подпись, тип возврата не RootObj, а кортеж структуры, зависящей от текущей области видимости. Пример:

proc testLocals() = var a = "something" b = 4 c = locals() d = "super!" b = 1 for name, value in fieldPairs(c): echo "name ", name, " with value ", value echo "B is ", b # -> name a with value something # -> name b with value 4 # -> B is 1
Исходный код Редактировать

proc low(T: typedesc[SomeFloat]): T:type: Исходный код Редактировать
proc low(x: cstring): int {.magic: "Low", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает минимальный возможный индекс совместимой строки x.

См. также:

high(cstring)

Исходный код Редактировать
proc low(x: string): int {.magic: "Low", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает минимальный возможный индекс строки x.

var str = "Hello world!" low(str) # => 0

См. также:

high(string)

Исходный код Редактировать
proc low[I, T](x: array[I, T]): I {.magic: "Low", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает минимальный возможный индекс массива x.

Для пустых массивов тип возврата — int.

var arr = [1, 2, 3, 4, 5, 6, 7] low(arr) # => 0 for i in low(arr)..high(arr): echo arr[i]

См. также:

high(array)

Исходный код Редактировать
proc low[I, T](x: typedesc[array[I, T]]): I {.magic: "Low", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает минимальный возможный индекс типа массива.

Для пустых массивов тип возврата — int.

low(array[7, int]) # => 0

См. также:

high(typedesc[array])

Исходный код Редактировать
proc low[T: Ordinal | enum | range](x: T): T {.magic: "Low", noSideEffect, ...deprecated: "Deprecated since v1.4; there should not be `low(value)`. Use `low(type)`.", raises: [], tags: [], forbids: [].}: Устарело: Устарело начиная с v1.4; не должно быть `low(value)`. Используйте `low(type)`.

Возвращает минимальное возможное значение порядкового значения x. В качестве специального семантического правила x может также быть идентификатором типа.

Эта процедура устарела, используйте вместо неё:

low(typedesc)

low(2) # => -9223372036854775808
Исходный код Редактировать
proc low[T: Ordinal | enum | range](x: typedesc[T]): T {.magic: "Low", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает минимальное возможное значение порядкового или перечисления типа.

low(int) — способ написания Nim INT_MIN или MIN_INT.

low(int) # => -9223372036854775808

См. также:

high(typedesc)

Исходный код Редактировать
proc low[T](x: openArray[T]): int {.magic: "Low", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает минимальный возможный индекс последовательности x.

var s = @[1, 2, 3, 4, 5, 6, 7] low(s) # => 0 for i in low(s)..high(s): echo s[i]

См. также:

high(openArray)

Исходный код Редактировать
proc max(x, y: float32): float32 {.noSideEffect, inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc max(x, y: float64): float64 {.noSideEffect, inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc max(x, y: int): int {.magic: "MaxI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc max(x, y: int8): int8 {.magic: "MaxI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc max(x, y: int16): int16 {.magic: "MaxI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc max(x, y: int32): int32 {.magic: "MaxI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc max(x, y: int64): int64 {.magic: "MaxI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Максимальное значение двух целых чисел. Исходный код Редактировать
proc max[T: not SomeFloat](x, y: T): T {.inline.}: Общий оператор нахождения максимального значения из 2 значений на основе <=. Исходный код Редактировать
proc max[T](x: openArray[T]): T: Максимальное значение x. T необходимо иметь оператор < . Исходный код Редактировать
proc min(x, y: float32): float32 {.noSideEffect, inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc min(x, y: float64): float64 {.noSideEffect, inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc min(x, y: int): int {.magic: "MinI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc min(x, y: int8): int8 {.magic: "MinI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc min(x, y: int16): int16 {.magic: "MinI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc min(x, y: int32): int32 {.magic: "MinI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc min(x, y: int64): int64 {.magic: "MinI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Минимальное значение двух целых чисел. Исходный код Редактировать
proc min[T: not SomeFloat](x, y: T): T {.inline.}: Общий оператор нахождения минимального значения из 2 значений на основе <=. Исходный код Редактировать
proc min[T](x: openArray[T]): T: Минимальное значение x. T необходимо иметь оператор < . Исходный код Редактировать

proc `mod`(x, y: int): int {.magic: "ModI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Вычисляет целочисленную операцию modulo (остаток).

Это то же самое, что и x - (x div y) * y.

Пример:

assert (7 mod 5) == 2 assert (-7 mod 5) == -2 assert (7 mod -5) == 2 assert (-7 mod -5) == -2
Исходный код Изменить
proc `mod`(x, y: int8): int8 {.magic: "ModI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `mod`(x, y: int16): int16 {.magic: "ModI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `mod`(x, y: int32): int32 {.magic: "ModI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `mod`(x, y: int64): int64 {.magic: "ModI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `mod`(x, y: uint): uint {.magic: "ModU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Вычисляет целочисленную операцию modulo (остаток) для беззнаковых целых чисел. Это то же самое, что и x - (x div y) * y. Исходный код Изменить
proc `mod`(x, y: uint8): uint8 {.magic: "ModU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `mod`(x, y: uint16): uint16 {.magic: "ModU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `mod`(x, y: uint32): uint32 {.magic: "ModU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `mod`(x, y: uint64): uint64 {.magic: "ModU", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc move[T](x: var T): T {.magic: "Move", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc moveMem(dest, source: pointer; size: Natural) {.inline, ...gcsafe, tags: [], raises: [], forbids: [].}: Копирует содержимое памяти по адресу source в память по адресу dest.

Будет скопировано ровно size байт. Области памяти могут перекрываться, moveMem корректно обрабатывает этот случай и поэтому несколько безопаснее, чем copyMem. Однако, как любая процедура, работающая с сырой памятью, она всё ещё является небезопасной.
Исходный код Изменить
proc new(t: typedesc): auto: Создает новый объект типа T и возвращает безопасную (отслеживаемую) ссылку на него в качестве результата.

Когда T является типом ref, то результирующий тип будет T, в противном случае он будет ref T.
Исходный код Изменить
proc new[T](a: var ref T) {.magic: "New", noSideEffect, ...raises: [], tags: [], forbids: [].}: Создает новый объект типа T и возвращает безопасную (отслеживаемую) ссылку на него в a. Исходный код Изменить
proc new[T](a: var ref T; finalizer: proc (x: ref T) {.nimcall.}) {. magic: "NewFinalize", noSideEffect, ...raises: [], tags: [], forbids: [].}: Создает новый объект типа T и возвращает безопасную (отслеживаемую) ссылку на него в a.

Когда сборщик мусора освобождает объект, вызывается finalizer. finalizer может не сохранять ссылку на объект, на который указывает x. finalizer не может предотвратить освобождение объекта сборщиком мусора.

Примечание: finalizer относится к типу T, а не к объекту! Это означает, что для каждого объекта типа T будет вызван финализатор!
Исходный код Изменить
proc newSeq[T](len = 0.Natural): seq[T]: Создает новую последовательность типа seq[T] длиной len.

Обратите внимание, что последовательность будет заполнена нулевыми элементами. После создания последовательности вы должны назначить значения элементам последовательности, а не добавлять их.

var inputStrings = newSeq[string](3) assert len(inputStrings) == 3 inputStrings[0] = "The fourth" inputStrings[1] = "assignment" inputStrings[2] = "would crash" #inputStrings[3] = "out of bounds"

См. также:

newSeqOfCap

newSeqUninit

Исходный код Изменить
proc newSeq[T](s: var seq[T]; len: Natural) {.magic: "NewSeq", noSideEffect, ...raises: [], tags: [], forbids: [].}: Создает новую последовательность типа seq[T] длиной len.

Это эквивалентно s = @[]; setlen(s, len), но более эффективно, так как перераспределения не требуется.

Обратите внимание, что последовательность будет заполнена нулевыми элементами. После создания последовательности вы должны назначить значения элементам последовательности, а не добавлять их. Пример:

var inputStrings: seq[string] newSeq(inputStrings, 3) assert len(inputStrings) == 3 inputStrings[0] = "The fourth" inputStrings[1] = "assignment" inputStrings[2] = "would crash" #inputStrings[3] = "out of bounds"
Исходный код Изменить
proc newSeqOfCap[T](cap: Natural): seq[T] {.magic: "NewSeqOfCap", noSideEffect, ...raises: [], tags: [], forbids: [].}: Создает новую последовательность типа seq[T] длиной ноль и емкостью cap. Пример:

var x = newSeqOfCap[int](5) assert len(x) == 0 x.add(10) assert len(x) == 1
Исходный код Изменить
func newSeqUninit[T](len: Natural): seq[T]: Создает новую последовательность типа seq[T] длиной len.

Доступно только для типов, не содержащих управляемой памяти или не имеющих деструкторов. Обратите внимание, что последовательность не будет инициализирована. После создания последовательности вы должны назначить значения элементам последовательности, а не добавлять их.

Пример:

var x = newSeqUninit[int](3) assert len(x) == 3 x[0] = 10
Исходный код Изменить
proc newSeqUninitialized[T: SomeNumber](len: Natural): seq[T] {. ...deprecated: "Use `newSeqUninit` instead".}: Устарело: Используйте `newSeqUninit` вместо этого

Создает новую последовательность типа seq[T] длиной len.

Доступно только для числовых типов. Обратите внимание, что последовательность не будет инициализирована. После создания последовательности вы должны назначить значения элементам последовательности, а не добавлять их. Пример:

var x = newSeqUninitialized[int](3) assert len(x) == 3 x[0] = 10
Исходный код Изменить
proc newString(len: Natural): string {.magic: "NewString", importc: "mnewString", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает новую строку длиной len. Необходимо заполнить строку символами по индексу с помощью оператора s[i].

Эта процедура существует только для целей оптимизации; тот же эффект можно достичь с помощью оператора & или с add.
Исходный код Изменить
proc newStringOfCap(cap: Natural): string {.magic: "NewStringOfCap", importc: "rawNewString", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает новую строку длиной 0 но с емкостью cap.

Эта процедура существует только для целей оптимизации; тот же эффект можно достичь с помощью оператора & или с add.
Исходный код Изменить

proc newStringUninit(len: Natural): string {....raises: [], tags: [], forbids: [].}: Возвращает новую строку длиной len, но с неинициализированным содержимым. Необходимо заполнить строку посимвольно с помощью оператора индекса s[i].

Эта процедура существует только для оптимизации; тот же эффект можно достичь с помощью оператора & или с помощью add.
Исходный код Изменить
proc `not`(a: typedesc): typedesc {.magic: "TypeTrait", noSideEffect, ...raises: [], tags: [], forbids: [].}: Создаёт метакласс not . Исходный код Изменить
proc `not`(x: bool): bool {.magic: "Not", noSideEffect, ...raises: [], tags: [], forbids: [].}: Логическое отрицание; возвращает true, если x == false. Исходный код Изменить
proc `not`(x: int): int {.magic: "BitnotI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Вычисляет bitwise complement целого числа x.
Пример:

assert not 0'u8 == 255 assert not 0'i8 == -1 assert not 1000'u16 == 64535 assert not 1000'i16 == -1001
Исходный код Изменить
proc `not`(x: int8): int8 {.magic: "BitnotI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `not`(x: int16): int16 {.magic: "BitnotI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `not`(x: int32): int32 {.magic: "BitnotI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `not`(x: int64): int64 {.magic: "BitnotI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `not`(x: uint): uint {.magic: "BitnotI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Вычисляет bitwise complement целого числа x. Исходный код Изменить
proc `not`(x: uint8): uint8 {.magic: "BitnotI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `not`(x: uint16): uint16 {.magic: "BitnotI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `not`(x: uint32): uint32 {.magic: "BitnotI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `not`(x: uint64): uint64 {.magic: "BitnotI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `of`[T, S](x: T; y: typedesc[S]): bool {.magic: "Of", noSideEffect, ...raises: [], tags: [], forbids: [].}: Проверяет, является ли x экземпляром y .
Пример:

type Base = ref object of RootObj Sub1 = ref object of Base Sub2 = ref object of Base Unrelated = ref object var base: Base = Sub1() # downcast doAssert base of Base # generates `CondTrue` (statically true) doAssert base of Sub1 doAssert base isnot Sub1 doAssert not (base of Sub2) base = Sub2() # re-assign doAssert base of Sub2 doAssert Sub2(base) != nil # upcast doAssertRaises(ObjectConversionDefect): discard Sub1(base) var sub1 = Sub1() doAssert sub1 of Base doAssert sub1.Base of Sub1 doAssert not compiles(base of Unrelated)
Исходный код Изменить
proc onThreadDestruction(handler: proc () {.closure, ...gcsafe, raises: [].}) {. ...raises: [], tags: [], forbids: [].}: Регистрирует обработчик локальный для потока, который вызывается при уничтожении потока.

Поток уничтожается, когда процедура .thread возвращается нормально или когда она вызывает исключение. Обратите внимание, что необработанные исключения в потоке тем не менее приводят к смерти всего процесса.
Исходный код Изменить
proc open[TMsg](c: var Channel[TMsg]; maxItems: int = 0): Открывает канал c для межпоточной связи.

Операция send будет блокироваться, пока количество необработанных элементов не станет меньше maxItems.

Для неограниченной очереди установите maxItems в 0.
Исходный код Изменить
proc `or`(a, b: typedesc): typedesc {.magic: "TypeTrait", noSideEffect, ...raises: [], tags: [], forbids: [].}: Создаёт метакласс or . Исходный код Изменить
proc `or`(x, y: bool): bool {.magic: "Or", noSideEffect, ...raises: [], tags: [], forbids: [].}: Логическое or; возвращает true, если not (not x and not y) (если любой из аргументов равен true).

Вычисление ленивое: если x равно true, y даже не будет вычислено.
Исходный код Изменить
proc `or`(x, y: int): int {.magic: "BitorI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Вычисляет bitwise or чисел x и y .
Пример:

assert (0b0011 or 0b0101) == 0b0111 assert (0b0111 or 0b1100) == 0b1111
Исходный код Изменить
proc `or`(x, y: int8): int8 {.magic: "BitorI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `or`(x, y: int16): int16 {.magic: "BitorI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `or`(x, y: int32): int32 {.magic: "BitorI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `or`(x, y: int64): int64 {.magic: "BitorI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `or`(x, y: uint): uint {.magic: "BitorI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Вычисляет bitwise or чисел x и y . Исходный код Изменить
proc `or`(x, y: uint8): uint8 {.magic: "BitorI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `or`(x, y: uint16): uint16 {.magic: "BitorI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `or`(x, y: uint32): uint32 {.magic: "BitorI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
proc `or`(x, y: uint64): uint64 {.magic: "BitorI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
func ord[T: Ordinal | enum](x: T): int {.magic: "Ord", ...raises: [], tags: [], forbids: [].}: Возвращает внутреннее значение int x, включая перечисления с пропущенными значениями и разные типы порядковых чисел.
Пример:

assert ord('A') == 65 type Foo = enum f0 = 0, f1 = 3 assert f1.ord == 3 type Bar = distinct int assert 3.Bar.ord == 3
Исходный код Изменить

proc peek[TMsg](c: var Channel[TMsg]): int: Возвращает текущее количество сообщений в канале c.

Возвращает -1, если канал закрыт.

Примечание: Использование данной функции опасно, так как она способствует возникновению гонок. Лучше использовать процедуру tryRecv вместо неё.
Исходный код Редактировать
proc pop[T](s: var seq[T]): T {.inline, noSideEffect.}: Возвращает последний элемент s и уменьшает s.len на единицу. Это рассматривает s как стек и реализует общую операцию pop.

Вызывает IndexDefect если s пустой.

Пример:

var a = @[1, 3, 5, 7] let b = pop(a) assert b == 7 assert a == @[1, 3, 5]
Исходный код Редактировать
proc pred[T, V: Ordinal](x: T; y: V = 1): T {.magic: "Pred", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает предшественника значения x (по умолчанию: 1).

Если такого значения нет, вызывается OverflowDefect или происходит ошибка во время компиляции.

Пример:

assert pred(5) == 4 assert pred(5, 3) == 2
Исходный код Редактировать
proc prepareMutation(s: var string) {.inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc procCall(x: untyped) {.magic: "ProcCall", compileTime, ...raises: [], tags: [], forbids: [].}: Специальная магическая функция для запрета динамической привязки для вызовов метода. Это аналогично super в обычных языках ООП.

# 'someMethod' will be resolved fully statically: procCall someMethod(a, b)
Исходный код Редактировать
proc protect(x: pointer): ForeignCell {....raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc quit(errorcode: int = QuitSuccess) {.magic: "Exit", noreturn, ...raises: [], tags: [], forbids: [].}: Немедленно останавливает программу с кодом завершения.

Перед остановкой программы вызываются "процедуры завершения" в обратном порядке, в котором они были добавлены с помощью addExitProc.

Процедура quit(QuitSuccess) вызывается неявно, когда ваша программа Nim завершается без ошибок для платформ, где это ожидаемое поведение. Вызванная необработанная исключительная ситуация эквивалентна вызову quit(QuitFailure).

Обратите внимание, что это вызов времени выполнения, и использование quit внутри макроса не повлияет на время компиляции. Если вам нужно остановить компилятор внутри макроса, используйте директивы error или fatal.

Предупреждение: errorcode переполняется, когда превышает допустимый диапазон на конкретной платформе. На Posix допустимый диапазон low(int8)..high(int8). На Windows допустимый диапазон low(int32)..high(int32). Например, quit(int(0x100000000)) равно quit(127) на Linux.

Внимание: В большинстве случаев, особенно в коде библиотек, предпочтительны альтернативы, например raiseAssert или поднятие Defect. quit обходит стандартный поток управления, особенно defer, try, catch, finally и destructors, и исключения, которые могли быть вызваны процедурой addExitProc, а также код очистки в других потоках. Он не вызывает сборщик мусора для освобождения всей памяти, если процедура addExitProc не вызывает GC_fullCollect.
Исходный код Редактировать
proc quit(errormsg: string; errorcode = QuitFailure) {.noreturn, ...raises: [], tags: [], forbids: [].}: Краткая форма echo(errormsg); quit(errorcode). Исходный код Редактировать
proc rawEnv[T: proc {.closure.} | iterator {.closure.}](x: T): pointer {. noSideEffect, inline.}: Получает указатель на исходную среду закрытия x. См. также rawProc. Эта функция недоступна для целевой платформы JS. Исходный код Редактировать
proc rawProc[T: proc {.closure.} | iterator {.closure.}](x: T): pointer {. noSideEffect, inline.}: Получает исходный указатель на процедуру закрытия x. Это полезно для взаимодействия замыканий с C/C++, вычислений хешей и т. д. Если rawEnv(x) возвращает nil, процедура, на которую указывает результат, принимает столько же параметров, сколько x, но с соглашением вызова {.nimcall.} вместо {.closure.}, иначе она принимает еще один параметр, который является pointer, и все еще использует соглашение вызова {.nimcall.}. Для вызова полученной процедуры возвращаемое значение необходимо привести к типу proc, а не ptr proc, и в случае, когда rawEnv(x) возвращает не-nil, последний и дополнительный аргумент должен быть результатом rawEnv(x). Эта функция недоступна для целевой платформы JS.
Пример:

proc makeClosure(x: int): (proc(y: int): int) = var n = x result = ( proc(y: int): int = n += y return n ) var c1 = makeClosure(10) e = c1.rawEnv() p = c1.rawProc() if e.isNil(): let c2 = cast[proc(y: int): int {.nimcall.}](p) echo c2(2) else: let c3 = cast[proc(y: int; env: pointer): int {.nimcall.}](p) echo c3(3, e)
Исходный код Редактировать
proc ready[TMsg](c: var Channel[TMsg]): bool: Возвращает true, если какой-то поток ожидает на канале c новых сообщений. Исходный код Редактировать
proc realloc0Impl(p: pointer; oldSize, newSize: Natural): pointer {.noconv, ...gcsafe, tags: [], gcsafe, raises: [], forbids: [].}: Исходный код Редактировать
proc reallocImpl(p: pointer; newSize: Natural): pointer {.noconv, ...gcsafe, tags: [], gcsafe, raises: [], forbids: [].}: Исходный код Редактировать
proc reallocShared0Impl(p: pointer; oldSize, newSize: Natural): pointer {. noconv, ...gcsafe, tags: [], gcsafe, raises: [], forbids: [].}: Исходный код Редактировать
proc reallocSharedImpl(p: pointer; newSize: Natural): pointer {.noconv, ...gcsafe, tags: [], gcsafe, raises: [], forbids: [].}: Исходный код Редактировать
proc recv[TMsg](c: var Channel[TMsg]): TMsg: Принимает сообщение из канала c.

Эта операция блокируется, пока сообщение не придёт! Используйте peek процедуру чтобы избежать блокировки.
Исходный код Редактировать
proc repr[T, U](x: HSlice[T, U]): string: Общая операция repr для слайсов, которая взята из компонентов x. Пример:

$(1 .. 5) == "1 .. 5"
Исходный код Редактировать
proc reset[T](obj: var T) {.noSideEffect.}: Сбрасывает объект obj до его значения по умолчанию. Исходный код Редактировать
proc resize[T](p: ptr T; newSize: Natural): ptr T {.inline, ...gcsafe, raises: [].}: Увеличивает или уменьшает заданный блок памяти.

Если p равно nil, возвращается новый блок памяти. В любом случае размер блока составляет как минимум T.sizeof * newSize байта. Если newSize == 0 и p не равны nil, resize вызывает dealloc(p). В других случаях блок памяти нужно освободить с помощью free.

Выделенная память принадлежит потоку, который её выделил! Используйте resizeShared для выделения из общей кучи.
Исходный код Редактировать

proc resizeShared[T](p: ptr T; newSize: Natural): ptr T {.inline, ...raises: [].}: Увеличивает или уменьшает заданный блок памяти в куче.

Если p равно nil, то возвращается новый блок памяти. В любом случае размер блока составляет не менее T.sizeof * newSize байт. Если newSize == 0 и p не равны nil, resizeShared вызывает freeShared(p). В противном случае блок необходимо освободить с помощью freeShared.
Исходный код Редактировать
proc runnableExamples(rdoccmd = ""; body: untyped) {.magic: "RunnableExamples", ...raises: [], tags: [], forbids: [].}: Раздел, который следует использовать для маркировки кода примера, который можно запустить с.

В обычных сборках отладки и релизных сборках код внутри раздела runnableExamples игнорируется.

Генератор документации осведомлен об этих примерах и рассматривает их как часть комментария документации ##. В качестве последнего шага генерации документации каждый runnableExample помещается в свой файл $file_examples$i.nim, компилируется и тестируется. Собраные примеры помещаются в собственный модуль, чтобы убедиться, что примеры не ссылаются на неэкспортированные символы.

Пример:

proc timesTwo*(x: int): int = ## This proc doubles a number. runnableExamples: # at module scope const exported* = 123 assert timesTwo(5) == 10 block: # at block scope defer: echo "done" runnableExamples "-d:foo -b:cpp": import std/compilesettings assert querySetting(backend) == "cpp" assert defined(foo) runnableExamples "-r:off": ## this one is only compiled import std/browsers openDefaultBrowser "https://forum.nim-lang.org/" 2 * x
Исходный код Редактировать
proc send[TMsg](c: var Channel[TMsg]; msg: sink TMsg) {.inline.}: Отправка сообщения в поток. msg глубоко копируется. Исходный код Редактировать
proc setControlCHook(hook: proc () {.noconv.}) {....raises: [], tags: [], forbids: [].}: Позволяет переопределить поведение вашего приложения при нажатии CTRL+C. Поддерживается только один такой обработчик. Пример:

proc ctrlc() {.noconv.} = echo "Ctrl+C fired!" # do clean up stuff quit() setControlCHook(ctrlc)
Исходный код Редактировать
proc setCurrentException(exc: ref Exception) {.inline, ...gcsafe, raises: [], tags: [], forbids: [].}: Устанавливает текущее исключение.
Предупреждение: Используйте только в том случае, если вы знаете, что делаете.
Исходный код Редактировать
proc setFrame(s: PFrame) {.compilerproc, inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc setFrameState(state: FrameState) {.compilerproc, inline, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc setLen(s: var string; newlen: Natural) {.magic: "SetLengthStr", noSideEffect, ...raises: [], tags: [], forbids: [].}: Устанавливает длину строки s на newlen.

Если текущая длина больше новой длины, s будет усечена.

var myS = "Nim is great!!" myS.setLen(3) # myS <- "Nim" echo myS, " is fantastic!!"
Исходный код Редактировать
proc setLen[T](s: var seq[T]; newlen: Natural) {.magic: "SetLengthSeq", noSideEffect, nodestroy, ...raises: [], tags: [], forbids: [].}: Устанавливает длину последовательности s на newlen. T может быть любым типом последовательности.

Если текущая длина больше новой длины, s будет усечена.

var x = @[10, 20] x.setLen(5) x[4] = 50 assert x == @[10, 20, 0, 0, 50] x.setLen(1) assert x == @[10]
Исходный код Редактировать
func setLenUninit[T](s: var seq[T]; newlen: Natural) {.nodestroy.}: Устанавливает длину последовательности s на newlen. T может быть любым типом последовательности. Новые слоты не будут инициализированы.

Если текущая длина больше новой длины, s будет усечена.

var x = @[10, 20] x.setLenUninit(5) x[4] = 50 assert x[4] == 50 x.setLenUninit(1) assert x == @[10]
Исходный код Редактировать
proc `shl`(x: int8; y: SomeInteger): int8 {.magic: "ShlI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `shl`(x: int16; y: SomeInteger): int16 {.magic: "ShlI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `shl`(x: int32; y: SomeInteger): int32 {.magic: "ShlI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `shl`(x: int64; y: SomeInteger): int64 {.magic: "ShlI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `shl`(x: int; y: SomeInteger): int {.magic: "ShlI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Вычисляет операцию shift left для x и y.

Примечание: Приоритет операторов отличается от C.

Пример:

assert 1'i32 shl 4 == 0x0000_0010 assert 1'i64 shl 4 == 0x0000_0000_0000_0010
Исходный код Редактировать
proc `shl`(x: uint8; y: SomeInteger): uint8 {.magic: "ShlI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `shl`(x: uint16; y: SomeInteger): uint16 {.magic: "ShlI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `shl`(x: uint32; y: SomeInteger): uint32 {.magic: "ShlI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `shl`(x: uint64; y: SomeInteger): uint64 {.magic: "ShlI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `shl`(x: uint; y: SomeInteger): uint {.magic: "ShlI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Вычисляет операцию shift left для x и y. Исходный код Редактировать

proc `shr`(x: int8; y: SomeInteger): int8 {.magic: "AshrI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `shr`(x: int16; y: SomeInteger): int16 {.magic: "AshrI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `shr`(x: int32; y: SomeInteger): int32 {.magic: "AshrI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `shr`(x: int64; y: SomeInteger): int64 {.magic: "AshrI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `shr`(x: int; y: SomeInteger): int {.magic: "AshrI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Вычисляет операцию shift right над x и y, заполняя свободные битовые позиции битом знака.

Примечание: Приоритет операторов отличается от C.

См. также:

Функция ashr для арифметического сдвига вправо

Пример:

assert 0b0001_0000'i8 shr 2 == 0b0000_0100'i8 assert 0b0000_0001'i8 shr 1 == 0b0000_0000'i8 assert 0b1000_0000'i8 shr 4 == 0b1111_1000'i8 assert -1 shr 5 == -1 assert 1 shr 5 == 0 assert 16 shr 2 == 4 assert -16 shr 2 == -4
Исходный код Редактировать
proc `shr`(x: uint8; y: SomeInteger): uint8 {.magic: "ShrI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `shr`(x: uint16; y: SomeInteger): uint16 {.magic: "ShrI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `shr`(x: uint32; y: SomeInteger): uint32 {.magic: "ShrI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `shr`(x: uint64; y: SomeInteger): uint64 {.magic: "ShrI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `shr`(x: uint; y: SomeInteger): uint {.magic: "ShrI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Вычисляет операцию shift right над x и y. Исходный код Редактировать
proc shrink[T](x: var seq[T]; newLen: Natural) {....tags: [], raises: [].}: Исходный код Редактировать
proc sizeof(x: typedesc): int {.magic: "SizeOf", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc sizeof[T](x: T): int {.magic: "SizeOf", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает размер x в байтах.

Поскольку это процедура низкого уровня, её использование не рекомендуется — в большинстве случаев достаточно использовать new, чтобы никогда не знать размер x.

В качестве специального семантического правила, x может также быть идентификатором типа (sizeof(int) допустимо).

Ограничения: Если используется для типов, импортированных из C или C++, sizeof должен перейти к sizeof в компиляторе C. Результат недоступен для компилятора Nim и поэтому не может использоваться внутри макросов.

sizeof('A') # => 1 sizeof(2) # => 8
Исходный код Редактировать
proc slurp(filename: string): string {.magic: "Slurp", ...raises: [], tags: [], forbids: [].}: Это псевдоним для staticRead. Исходный код Редактировать
proc stackTraceAvailable(): bool {....raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc staticExec(command: string; input = ""; cache = ""): string {. magic: "StaticExec", ...raises: [], tags: [], forbids: [].}: Выполняет внешний процесс во время компиляции и возвращает вывод текста (stdout + stderr).

Если input не пустая строка, она будет передана как стандартный ввод исполняемой программе.

const buildInfo = "Revision " & staticExec("git rev-parse HEAD") & "\nCompiled on " & staticExec("uname -v")

gorge является псевдонимом для staticExec.

Обратите внимание, что вы можете использовать эту процедуру внутри псевдокода, например, passc или passl.

Если cache не пустая, результаты staticExec кешируются в каталоге nimcache. Используйте --forceBuild для отключения этого поведения кэширования. command & input & cache (склеенная строка) используется для определения того, является ли запись в кэше по-прежнему актуальной. Вы можете использовать информацию о версии для cache.

const stateMachine = staticExec("dfaoptimizer", "input", "0.8.0")
Исходный код Редактировать
proc staticRead(filename: string): string {.magic: "Slurp", ...raises: [], tags: [], forbids: [].}: Процедура readFile во время компиляции для простого внедрения ресурсов:

Максимальный предел размера файла, который могут читать staticRead и slurp, равен или близок к свободной памяти используемого вами устройства для компиляции.

const myResource = staticRead"mydatafile.bin"

slurp является псевдонимом для staticRead.
Исходный код Редактировать
proc substr(s: openArray[char]): string {....raises: [], tags: [], forbids: [].}: Копирует фрагмент s в новую строку и возвращает эту новую строку.
Пример:

let a = "abcdefgh" assert a.substr(2, 5) == "cdef" assert a.substr(2) == "cdefgh" assert a.substr(5, 99) == "fgh"
Исходный код Редактировать
proc substr(s: string; first = 0): string {....raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc substr(s: string; first, last: int): string {....raises: [], tags: [], forbids: [].}: Копирует фрагмент s в новую строку и возвращает эту новую строку.

Границы first и last обозначают индексы первого и последнего символов, которые будут скопированы. Если last опущено, оно обрабатывается как high(s). Если last >= s.len, s.len используется вместо этого: Это означает, что substr также может использоваться для вырезания или ограничения длины строки.

Пример:

let a = "abcdefgh" assert a.substr(2, 5) == "cdef" assert a.substr(2) == "cdefgh" assert a.substr(5, 99) == "fgh"
Исходный код Редактировать
proc succ[T, V: Ordinal](x: T; y: V = 1): T {.magic: "Succ", noSideEffect, ...raises: [], tags: [], forbids: [].}: Возвращает y-й преемник (по умолчанию: 1) значения x.

Если такого значения не существует, OverflowDefect генерируется или возникает ошибка во время компиляции.

Пример:

assert succ(5) == 6 assert succ(5, 3) == 8
Исходный код Редактировать
proc swap[T](a, b: var T) {.magic: "Swap", noSideEffect, ...raises: [], tags: [], forbids: [].}: Меняет местами значения a и b.

Это часто более эффективно, чем tmp = a; a = b; b = tmp. Особенно полезно для сортирующих алгоритмов.

var a = 5 b = 9 swap(a, b) assert a == 9 assert b == 5
Исходный код Редактировать
proc toBiggestFloat(i: BiggestInt): BiggestFloat {.noSideEffect, inline, ...raises: [], tags: [], forbids: [].}: То же, что и toFloat, но для BiggestInt по BiggestFloat. Исходный код Редактировать

proc toBiggestInt(f: BiggestFloat): BiggestInt {.noSideEffect, ...raises: [], tags: [], forbids: [].}: То же самое, что и toInt, но для BiggestFloat по BiggestInt. Исходный код Редактировать
proc toFloat(i: int): float {.noSideEffect, inline, ...raises: [], tags: [], forbids: [].}: Преобразует целое число i в float. То же самое, что и float(i).

Если преобразование не выполняется, генерируется ValueError. Однако на большинстве платформ преобразование не может завершиться ошибкой.

let a = 2 b = 3.7 echo a.toFloat + b # => 5.7
Исходный код Редактировать
proc toInt(f: float): int {.noSideEffect, ...raises: [], tags: [], forbids: [].}: Преобразует число с плавающей запятой f в целое число int.

Преобразование округляет f по правилу "половина от нуля", см. Округление до ближайшего целого в сторону от нуля, в отличие от преобразования типов, которое округляет к нулю.

Обратите внимание, что некоторые числа с плавающей запятой (например, бесконечность или даже 1e19) не могут быть точно преобразованы.

doAssert toInt(0.49) == 0 doAssert toInt(0.5) == 1 doAssert toInt(-0.5) == -1 # rounding is symmetrical
Исходный код Редактировать
proc toOpenArray(x: cstring; first, last: int): openArray[char] {. magic: "Slice", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc toOpenArray(x: string; first, last: int): openArray[char] {.magic: "Slice", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc toOpenArray[I, T](x: array[I, T]; first, last: I): openArray[T] {. magic: "Slice", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc toOpenArray[T](x: openArray[T]; first, last: int): openArray[T] {. magic: "Slice", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc toOpenArray[T](x: ptr UncheckedArray[T]; first, last: int): openArray[T] {. magic: "Slice", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc toOpenArray[T](x: seq[T]; first, last: int): openArray[T] {.magic: "Slice", ...raises: [], tags: [], forbids: [].}: Позволяет передать срез x с элемента по first до элемента по last в параметры openArray[T] без копирования.

Пример:

proc test(x: openArray[int]) = doAssert x == [1, 2, 3] let s = @[0, 1, 2, 3, 4] s.toOpenArray(1, 3).test
Исходный код Редактировать
proc toOpenArrayByte(x: cstring; first, last: int): openArray[byte] {. magic: "Slice", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc toOpenArrayByte(x: openArray[char]; first, last: int): openArray[byte] {. magic: "Slice", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc toOpenArrayByte(x: seq[char]; first, last: int): openArray[byte] {. magic: "Slice", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc toOpenArrayByte(x: string; first, last: int): openArray[byte] {. magic: "Slice", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc toOpenArrayChar(x: openArray[byte]; first, last: int): openArray[char] {. magic: "Slice", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc tryRecv[TMsg](c: var Channel[TMsg]): tuple[dataAvailable: bool, msg: TMsg]: Попытка получить сообщение из канала c, но это может завершиться ошибкой по разным причинам, включая конкуренцию.

В случае неудачи возвращает (false, default(msg)), в противном случае (true, msg).
Исходный код Редактировать
proc trySend[TMsg](c: var Channel[TMsg]; msg: sink TMsg): bool {.inline.}: Попытка отправить сообщение в поток.

msg глубоко копируется. Не блокирует.

Возвращает false если сообщение не было отправлено, потому что количество ожидающих элементов в канале превысило maxItems.
Исходный код Редактировать
proc typeof(x: untyped; mode = typeOfIter): typedesc {.magic: "TypeOf", noSideEffect, compileTime, ...raises: [], tags: [], forbids: [].}: Встроенная typeof операция для доступа к типу выражения. С версии 0.20.0.
Пример:

proc myFoo(): float = 0.0 iterator myFoo(): string = yield "abc" iterator myFoo2(): string = yield "abc" iterator myFoo3(): string {.closure.} = yield "abc" doAssert type(myFoo()) is string doAssert typeof(myFoo()) is string doAssert typeof(myFoo(), typeOfIter) is string doAssert typeof(myFoo3) is iterator doAssert typeof(myFoo(), typeOfProc) is float doAssert typeof(0.0, typeOfProc) is float doAssert typeof(myFoo3, typeOfProc) is iterator doAssert not compiles(typeof(myFoo2(), typeOfProc)) # this would give: Error: attempting to call routine: 'myFoo2' # since `typeOfProc` expects a typed expression and `myFoo2()` can # only be used in a `for` context.
Исходный код Редактировать
proc unsafeAddr[T](x: T): ptr T {.magic: "Addr", noSideEffect, ...raises: [], tags: [], forbids: [].}: Предупреждение: unsafeAddr - устаревший псевдоним для addr, используйте addr вместо него.
Исходный код Редактировать
proc unsafeNew[T](a: var ref T; size: Natural) {.magic: "New", noSideEffect, ...raises: [], tags: [], forbids: [].}: Создаёт новый объект типа T и возвращает безопасную (отслеживаемую) ссылку на него в a.

Это небезопасно, так как выделяет объект указанного size. Используйте только в целях оптимизации, если точно знаете что делаете!

См. также:

new

Исходный код Редактировать
proc unsetControlCHook() {....raises: [], tags: [], forbids: [].}: Отменяет вызов setControlCHook. Исходный код Редактировать
proc wasMoved[T](obj: var T) {.inline, noSideEffect.}: Сбрасывает объект obj до его исходного (двоичного нулевого) значения, чтобы указать, что он был "перемещён", и чтобы его деструктор ничего не делал и, по возможности, был оптимизирован. Исходный код Редактировать
proc writeStackTrace() {....tags: [], gcsafe, raises: [], forbids: [].}: Записывает текущий стек вызовов в stderr. Работает только в отладочных сборках. Поскольку обычно используется для отладки, это объявлено без эффектов ввода-вывода! Исходный код Редактировать

proc `xor`(x, y: bool): bool {.magic: "Xor", noSideEffect, ...raises: [], tags: [], forbids: [].}: Булево exclusive or; возвращает true, если x != y (если любой из аргументов имеет значение true, а другой — false). Исходный код Редактировать
proc `xor`(x, y: int): int {.magic: "BitxorI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Вычисляет bitwise xor чисел x и y.
Пример:

assert (0b0011 xor 0b0101) == 0b0110 assert (0b0111 xor 0b1100) == 0b1011
Исходный код Редактировать
proc `xor`(x, y: int8): int8 {.magic: "BitxorI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `xor`(x, y: int16): int16 {.magic: "BitxorI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `xor`(x, y: int32): int32 {.magic: "BitxorI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `xor`(x, y: int64): int64 {.magic: "BitxorI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `xor`(x, y: uint): uint {.magic: "BitxorI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Вычисляет bitwise xor чисел x и y. Исходный код Редактировать
proc `xor`(x, y: uint8): uint8 {.magic: "BitxorI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `xor`(x, y: uint16): uint16 {.magic: "BitxorI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `xor`(x, y: uint32): uint32 {.magic: "BitxorI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
proc `xor`(x, y: uint64): uint64 {.magic: "BitxorI", noSideEffect, ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
func zeroDefault[T](_: typedesc[T]): T {.magic: "ZeroDefault", ...raises: [], tags: [], forbids: [].}: Возвращает двоичное представление нулей для типа T. Оно игнорирует поля по умолчанию объекта.

См. также:

default

Исходный код Редактировать
proc zeroMem(p: pointer; size: Natural) {.inline, noSideEffect, ...tags: [], raises: [], forbids: [].}: Заменяет содержимое памяти по адресу p значением 0.

Будет заменено ровно size байта. Как и любая процедура, работающая с сырой памятью, это опасно.
Исходный код Редактировать
proc `|`(a, b: typedesc): typedesc: Исходный код Редактировать

Итераторы

iterator `..`(a, b: int32): int32 {.inline, ...raises: [], tags: [], forbids: [].}: A type specialized version of .. for convenience so that mixing integer types works better.

См. также:

..<

Исходный код Изменить
iterator `..`(a, b: int64): int64 {.inline, ...raises: [], tags: [], forbids: [].}: A type specialized version of .. for convenience so that mixing integer types works better.

См. также:

..<

Исходный код Изменить
iterator `..`(a, b: uint32): uint32 {.inline, ...raises: [], tags: [], forbids: [].}: A type specialized version of .. for convenience so that mixing integer types works better.

См. также:

..<

Исходный код Изменить
iterator `..`(a, b: uint64): uint64 {.inline, ...raises: [], tags: [], forbids: [].}: A type specialized version of .. for convenience so that mixing integer types works better.

См. также:

..<

Исходный код Изменить
iterator `..`[T](a, b: T): T {.inline.}: Alias for countup(a, b, 1).

См. также:

..<

Пример:

import std/sugar let x = collect(newSeq): for i in 3 .. 7: i assert x == @[3, 4, 5, 6, 7]
Исходный код Изменить
iterator `..<`(a, b: int32): int32 {.inline, ...raises: [], tags: [], forbids: [].}: A type specialized version of ..< for convenience so that mixing integer types works better. Исходный код Изменить
iterator `..<`(a, b: int64): int64 {.inline, ...raises: [], tags: [], forbids: [].}: A type specialized version of ..< for convenience so that mixing integer types works better. Исходный код Изменить
iterator `..<`(a, b: uint32): uint32 {.inline, ...raises: [], tags: [], forbids: [].}: A type specialized version of ..< for convenience so that mixing integer types works better. Исходный код Изменить
iterator `..<`(a, b: uint64): uint64 {.inline, ...raises: [], tags: [], forbids: [].}: A type specialized version of ..< for convenience so that mixing integer types works better. Исходный код Изменить
iterator `..<`[T](a, b: T): T {.inline.}: Исходный код Изменить
iterator countdown[T](a, b: T; step: Positive = 1): T {.inline.}: Считает от порядкового значения a вниз до b (включительно) с заданным шагом.

T может быть любым порядковым типом, step может быть только положительным.

Примечание: Это не считает до low(int) если T = int по причинам эффективности.

Пример:

import std/sugar let x = collect(newSeq): for i in countdown(7, 3): i assert x == @[7, 6, 5, 4, 3] let y = collect(newseq): for i in countdown(9, 2, 3): i assert y == @[9, 6, 3]
Исходный код Изменить
iterator countup[T](a, b: T; step: Positive = 1): T {.inline.}: Считает от порядкового значения a до b (включительно) с заданным шагом.

T может быть любым порядковым типом, step может быть только положительным.

Примечание: Это не считает до high(int) если T = int по причинам эффективности.

Пример:

import std/sugar let x = collect(newSeq): for i in countup(3, 7): i assert x == @[3, 4, 5, 6, 7] let y = collect(newseq): for i in countup(2, 9, 3): i assert y == @[2, 5, 8]
Исходный код Изменить
iterator `||`[S, T](a: S; b: T; annotation: static string = "parallel for"): T {. inline, magic: "OmpParFor", sideEffect, ...raises: [], tags: [], forbids: [].}: Итератор параллельного цикла OpenMP. Такой же, как .., но цикл может выполняться параллельно.

annotation — дополнительная аннотация для использования генератором кода. По умолчанию аннотация parallel for. Подробную информацию см. в Справочнике по синтаксису OpenMP.

Обратите внимание, что компилятор отображает это на конструкцию #pragma omp parallel for OpenMP и поэтому не осведомлён о параллелизме в вашем коде! Будьте осторожны! Более поздние версии || получат надлежащую поддержку генератором кода и сборщиком мусора Nim.
Исходный код Изменить
iterator `||`[S, T](a: S; b: T; step: Positive; annotation: static string = "parallel for"): T {.inline, magic: "OmpParFor", sideEffect, ...raises: [], tags: [], forbids: [].}: Итератор параллельного цикла OpenMP с шагом. Такой же, как countup, но цикл может выполняться параллельно.

annotation — дополнительная аннотация для использования генератором кода. По умолчанию аннотация parallel for. Подробную информацию см. в Справочнике по синтаксису OpenMP.

Обратите внимание, что компилятор отображает это на конструкцию #pragma omp parallel for OpenMP и поэтому не осведомлён о параллелизме в вашем коде! Будьте осторожны! Более поздние версии || получат надлежащую поддержку генератором кода и сборщиком мусора Nim.
Исходный код Изменить

Макросы

macro varargsLen(x: varargs[untyped]): int: возвращает количество аргументов varargs в x Исходный код Изменить

Шаблоны

template `!=`(x, y: untyped): untyped {.callsite.}: Оператор неравенства. Это сокращение для not (x == y). Исходный код Редактировать
template `&=`(x, y: typed): Обобщённый оператор 'sink' для Nim.

Если не специализирован дальше, является псевдонимом для add.
Исходный код Редактировать
template `..<`(a, b: untyped): untyped: Сокращение для a .. pred(b).

for i in 5 ..< 9: echo i # => 5; 6; 7; 8
Исходный код Редактировать
template `..^`(a, b: untyped): untyped: Сокращение для .. ^ для избежания распространённой ошибки, когда требуется пробел между '..' и '^'. Исходный код Редактировать
template `=dispose`[T](x: owned(ref T)): Исходный код Редактировать
template `>`(x, y: untyped): untyped {.callsite.}: Оператор "больше". Это то же самое, что и y < x. Исходный код Редактировать
template `>%`(x, y: untyped): untyped: Рассматривает x и y как беззнаковые и сравнивает их. Возвращает true, если unsigned(x) > unsigned(y). Исходный код Редактировать
template `>=`(x, y: untyped): untyped {.callsite.}: Оператор "больше или равно". Это то же самое, что и y <= x. Исходный код Редактировать
template `>=%`(x, y: untyped): untyped: Рассматривает x и y как беззнаковые и сравнивает их. Возвращает true, если unsigned(x) >= unsigned(y). Исходный код Редактировать
template `[]`(s: string; i: int): char: Исходный код Редактировать
template `[]=`(s: string; i: int; val: char): Исходный код Редактировать
template `^`(x: int): BackwardsIndex: Встроенный оператор roof, который можно использовать для удобного доступа к элементам массива. a[^x] является сокращением для a[a.len-x].

let a = [1, 3, 5, 7, 9] b = "abcdefgh" echo a[^1] # => 9 echo b[^2] # => g
Исходный код Редактировать
template alloc(size: Natural): pointer: Выделяет новый блок памяти с размером не менее size байт.

Блок нужно освободить с помощью realloc(block, 0) или dealloc(block). Блок не инициализирован, поэтому чтение из него до записи в него — неопределённое поведение!

Выделенная память принадлежит потоку, который её выделил! Используйте allocShared для выделения из общей кучи.

См. также:

alloc0

Исходный код Редактировать
template alloc0(size: Natural): pointer: Выделяет новый блок памяти с размером не менее size байт.

Блок нужно освободить с помощью realloc(block, 0) или dealloc(block). Блок инициализирован нулями, поэтому он несколько безопаснее, чем alloc.

Выделенная память принадлежит потоку, который её выделил! Используйте allocShared0 для выделения из общей кучи.
Исходный код Редактировать
template allocShared(size: Natural): pointer: Выделяет новый блок памяти в общей куче с размером не менее size байт.

Блок нужно освободить с помощью reallocShared(block, 0) или deallocShared(block).

Блок не инициализирован, поэтому чтение из него до записи в него — неопределённое поведение!

См. также:

allocShared0.

Исходный код Редактировать
template allocShared0(size: Natural): pointer: Выделяет новый блок памяти в общей куче с размером не менее size байт.

Блок нужно освободить с помощью reallocShared(block, 0) или deallocShared(block).

Блок инициализирован нулями, поэтому он несколько безопаснее, чем allocShared.
Исходный код Редактировать
template closureScope(body: untyped): untyped: Полезно при создании замыкания в цикле для захвата локальных переменных цикла по значениям текущей итерации.

Примечание: Этот шаблон может не работать в некоторых случаях, используйте capture вместо этого.

Пример:

var myClosure : proc() # without closureScope: for i in 0 .. 5: let j = i if j == 3: myClosure = proc() = echo j myClosure() # outputs 5. `j` is changed after closure creation # with closureScope: for i in 0 .. 5: closureScope: # Everything in this scope is locked after closure creation let j = i if j == 3: myClosure = proc() = echo j myClosure() # outputs 3
Исходный код Редактировать
template currentSourcePath(): string: Возвращает полный путь к текущему исходному файлу в файловой системе.

Для получения каталога, содержащего текущий исходный код, используйте его с ospaths2.parentDir() как currentSourcePath.parentDir().

Путь, возвращаемый этим шаблоном, устанавливается во время компиляции.

См. строку документации для macros.getProjectPath(), чтобы увидеть разницу между currentSourcePath() и getProjectPath().

См. также:

ospaths2.getCurrentDir() proc

Исходный код Редактировать
template disarm(x: typed): Полезно для disarming явных висячих указателей для --newruntime. Независимо от того, используется ли --newruntime или нет, это устанавливает указатель или обратный вызов x в nil. Это экспериментальный API! Исходный код Редактировать
template dumpAllocstats(code: untyped): Исходный код Редактировать
template excl[T](x: var set[T]; y: set[T]) {.callsite.}: Исключение множества y из множества x.
Пример:

var a = {1, 3, 5, 7} var b = {3, 4, 5} a.excl(b) assert a == {1, 7}
Исходный код Редактировать

template formatErrorIndexBound[T](i, a, b: T): string: Исходный код Редактировать
template formatErrorIndexBound[T](i, n: T): string: Исходный код Редактировать
template formatFieldDefect(f, discVal): string: Исходный код Редактировать
template `in`(x, y: untyped): untyped {.dirty, callsite.}: Упрощение для contains.

assert(1 in (1..3) == true) assert(5 in (1..3) == false)
Исходный код Редактировать
template incl[T](x: var set[T]; y: set[T]) {.callsite.}: Включает множество y в множество x.
Пример:

var a = {1, 3, 5, 7} var b = {4, 5, 6} a.incl(b) assert a == {1, 3, 4, 5, 6, 7}
Исходный код Редактировать
template `isnot`(x, y: untyped): untyped {.callsite.}: Отрицательная версия is. Эквивалентно not(x is y).

assert 42 isnot float assert @[1, 2] isnot enum
Исходный код Редактировать
template likely(val: bool): bool: Подсказывает оптимизатору, что val, вероятно, будет истинным.

Вы можете использовать эту шаблонную функцию для оформления условия ветвления. На некоторых платформах это может помочь процессору лучше предсказать, какой ветвь будет выполнена. Пример:

for value in inputValues: if likely(value <= 100): process(value) else: echo "Value too big!"

На платформах без предсказания ветвей (JS и виртуальная машина nimscript), этот шаблон не повлияет на выполнение кода.
Исходный код Редактировать
template newException(exceptn: typedesc; message: string; parentException: ref Exception = nil): untyped: Создаёт объект исключения типа exceptn и устанавливает поле msg в message. Возвращает новый объект исключения. Исходный код Редактировать
template nimThreadProcWrapperBody(closure: untyped): untyped: Исходный код Редактировать
template `notin`(x, y: untyped): untyped {.dirty, callsite.}: Упрощение для not contains.

assert(1 notin (1..3) == false) assert(5 notin (1..3) == true)
Исходный код Редактировать
template offsetOf[T](t: typedesc[T]; member: untyped): int: Исходный код Редактировать
template offsetOf[T](value: T; member: untyped): int: Исходный код Редактировать
template once(body: untyped): untyped: Выполняет блок кода только один раз (в первый раз, когда блок достигается).

proc draw(t: Triangle) = once: graphicsInit() line(t.p1, t.p2) line(t.p2, t.p3) line(t.p3, t.p1)
Исходный код Редактировать
template rangeCheck(cond): Помощник для выполнения пользовательских проверок диапазона. Такие проверки будут выполняться только при включении компиляционной опции rangechecks. Исходный код Редактировать
template realloc(p: pointer; newSize: Natural): pointer: Увеличивает или уменьшает заданный блок памяти.

Если p равно nil, то возвращается новый блок памяти. В любом случае блок имеет как минимум newSize байт. Если newSize == 0 и p не равны nil, realloc вызывает dealloc(p). В других случаях блок необходимо освободить с помощью dealloc(block).

Выделенная память принадлежит потоку, который её выделил! Используйте reallocShared для выделения памяти из общей кучи.
Исходный код Редактировать
template realloc0(p: pointer; oldSize, newSize: Natural): pointer: Увеличивает или уменьшает заданный блок памяти.

Если p равно nil, то возвращается новый блок памяти. В любом случае блок имеет как минимум newSize байт. Если newSize == 0 и p не равны nil, realloc вызывает dealloc(p). В других случаях блок необходимо освободить с помощью dealloc(block).

Блок инициализируется всеми байтами нулями, поэтому он несколько безопаснее, чем realloc

Выделенная память принадлежит потоку, который её выделил! Используйте reallocShared для выделения памяти из общей кучи.
Исходный код Редактировать
template reallocShared(p: pointer; newSize: Natural): pointer: Увеличивает или уменьшает заданный блок памяти в куче.

Если p равно nil, то возвращается новый блок памяти. В любом случае блок имеет как минимум newSize байт. Если newSize == 0 и p не равны nil, reallocShared вызывает deallocShared(p). В других случаях блок необходимо освободить с помощью deallocShared.
Исходный код Редактировать
template reallocShared0(p: pointer; oldSize, newSize: Natural): pointer: Увеличивает или уменьшает заданный блок памяти в куче.

При увеличении новые байты блока инициализируются нулями, что делает его несколько безопаснее, чем reallocShared

Если p равно nil, то возвращается новый блок памяти. В любом случае блок имеет как минимум newSize байт. Если newSize == 0 и p не равны nil, reallocShared вызывает deallocShared(p). В других случаях блок необходимо освободить с помощью deallocShared.
Исходный код Редактировать
template setupForeignThreadGc(): При --mm:arc — ничто. Исходный код Редактировать
template tearDownForeignThreadGc(): При --mm:arc — ничто. Исходный код Редактировать
template unlikely(val: bool): bool: Подсказывает оптимизатору, что val, вероятно, будет ложным.

Вы можете использовать эту функцию для оформления условия ветвления. На некоторых платформах это может помочь процессору лучше предсказать, какой ветвь будет выполнена. Пример:

for value in inputValues: if unlikely(value > 100): echo "Value too big!" else: process(value)

На платформах без предсказания ветвей (JS и виртуальная машина nimscript), этот шаблон не повлияет на выполнение кода.
Исходный код Редактировать
template unown(x: typed): untyped: Исходный код Редактировать