Spec-Zone.ru › Nim 1

system

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

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

Модуль System

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

  • итераторы
  • утверждения
  • доллары
  • ввод/вывод
  • широкие строки

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

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

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

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

См. также:

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

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

Процедура Использование
newSeq Создание новой последовательности заданной длины
newSeqOfCap Создание новой последовательности с нулевой длиной и заданной емкостью
setLen Установка длины последовательности
len Возвращение длины последовательности
@ Преобразование массива в последовательность
add Добавление элемента в последовательность
insert Вставка элемента в определённую позицию
delete Удаление элемента, сохраняя порядок элементов (операция O(n))
del Удаление элемента, не сохраняя порядок
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

См. также:

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

Числа

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

См. также:

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

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

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

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

Разное

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

Импорты

since, ansi_c, память, утверждения, итераторы, доллары, miscдоллары, stacktraces, formatfloat, широкие строки, ввод/вывод

Типы

float {...}{.magic: Float.}
Тип плавающей точки по умолчанию. Исходный код Редактировать
float32 {...}{.magic: Float32.}
Тип плавающей точки 32 бита. Исходный код Редактировать
float64 {...}{.magic: Float.}
Тип плавающей точки 64 бита. Исходный код Редактировать
char {...}{.magic: Char.}
Встроенный тип символа 8 бит (без знака). Исходный код Редактировать
string {...}{.magic: String.}
Встроенный тип строки. Исходный код Редактировать
cstring {...}{.magic: Cstring.}
Встроенный тип cstring (совместимая строка). Исходный код Редактировать
pointer {...}{.magic: Pointer.}
Встроенный тип указателя, используйте оператор addr для получения указателя на переменную. Исходный код Редактировать
typedesc {...}{.magic: TypeDesc.}
Метатип для обозначения описания типа. Исходный код Редактировать
ptr[T] {...}{.magic: Pointer.}
Встроенный универсальный тип указателя без отслеживания. Исходный код Редактировать
ref[T] {...}{.magic: Pointer.}
Встроенный универсальный тип отслеживаемого указателя. Исходный код Редактировать
void {...}{.magic: "VoidType".}
Метатип для обозначения отсутствия типа. Исходный код Редактировать
auto {...}{.magic: Expr.}
Метатип для автоматического определения типа. Исходный код Редактировать
any = distinct auto
Метатип для любого поддерживаемого типа. Исходный код Редактировать
untyped {...}{.magic: Expr.}
Метатип для обозначения неразрешённого выражения (для шаблонов). Исходный код Редактировать
typed {...}{.magic: Stmt.}
Метатип для обозначения разрешённого выражения (для шаблонов). Исходный код Редактировать
int {...}{.magic: "Int".}
Тип целого числа по умолчанию; разрядность зависит от архитектуры, но всегда совпадает с разрядностью указателя. Исходный код Редактировать
int8 {...}{.magic: "Int8".}
Целый тип со знаком 8 бит. Исходный код Редактировать
int16 {...}{.magic: "Int16".}
Целый тип со знаком 16 бит. Исходный код Редактировать
int32 {...}{.magic: "Int32".}
Целый тип со знаком 32 бита. Исходный код Редактировать
int64 {...}{.magic: "Int64".}
Целый тип со знаком 64 бита. Исходный код Редактировать
uint {...}{.magic: "UInt".}
Тип целого числа по умолчанию без знака. Исходный код Редактировать
uint8 {...}{.magic: "UInt8".}
Целый тип без знака 8 бит. Исходный код Редактировать
uint16 {...}{.magic: "UInt16".}
Целый тип без знака 16 бит. Исходный код Редактировать
uint32 {...}{.magic: "UInt32".}
Целый тип без знака 32 бита. Исходный код Редактировать
uint64 {...}{.magic: "UInt64".}
Целый тип без знака 64 бита. Исходный код Редактировать
bool {...}{.magic: "Bool".} = enum
  false = 0, true = 1
Встроенный логический тип. Исходный код Редактировать
SomeSignedInt = int | int8 | int16 | int32 | int64
Класс типа, соответствующий всем целым типам со знаком. Исходный код Редактировать
SomeUnsignedInt = uint | uint8 | uint16 | uint32 | uint64
Класс типа, соответствующий всем целым типам без знака. Исходный код Редактировать
SomeInteger = SomeSignedInt | SomeUnsignedInt
Класс типа, соответствующий всем целым типам. Исходный код Редактировать
SomeOrdinal = int | int8 | int16 | int32 | int64 | bool | enum | uint | uint8 |
    uint16 |
    uint32 |
    uint64
Класс типа, соответствующий всем порядковым типам; однако это включает перечисления с пробелами. См. также Ordinal. Исходный код Редактировать
BiggestInt = int64
является псевдонимом самого большого целого типа со знаком, который поддерживает компилятор Nim. В настоящее время это int64, но в общем случае зависит от платформы. Исходный код Редактировать
SomeFloat = float | float32 | float64
Класс типа, соответствующий всем типам чисел с плавающей точкой. Исходный код Редактировать
SomeNumber = SomeInteger | SomeFloat
Класс типа, соответствующий всем числовым типам. Исходный код Редактировать
Ordinal[T] {...}{.magic: Ordinal.}
Универсальный порядковый тип. Включает целые числа, bool, символы и типы перечислений, а также их подтипы. См. также SomeOrdinal. Исходный код Редактировать
static[T] {...}{.magic: "Static".}

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

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

Исходный код Редактировать
type[T] {...}{.magic: "Type".}

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

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

Исходный код Редактировать
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. Исходный код Редактировать
range[T] {...}{.magic: "Range".}
Обобщённый тип для построения типов диапазонов. Исходный код Изменить
array[I; T] {...}{.magic: "Array".}
Обобщённый тип для построения массивов фиксированной длины. Исходный код Изменить
openArray[T] {...}{.magic: "OpenArray".}
Обобщённый тип для построения открытых массивов. Открытые массивы реализованы как указатель на данные массива и поле длины. Исходный код Изменить
varargs[T] {...}{.magic: "Varargs".}
Обобщённый тип для построения типа varargs. Исходный код Изменить
seq[T] {...}{.magic: "Seq".}
Обобщённый тип для построения последовательностей. Исходный код Изменить
set[T] {...}{.magic: "Set".}
Обобщённый тип для построения битовых наборов. Исходный код Изменить
UncheckedArray[T] {...}{.magic: "UncheckedArray".}
Исходный код Изменить
sink[T] {...}{.magic: "BuiltinType".}
Исходный код Изменить
lent[T] {...}{.magic: "BuiltinType".}
Исходный код Изменить
HSlice[T; U] = object
  a*: T                      ## The lower bound (inclusive).
  b*: U                      ## The upper bound (inclusive).
"Гетерогенный" тип среза. Исходный код Изменить
Slice[T] = HSlice[T, T]
Псевдоним для HSlice[T, T]. Исходный код Изменить
byte = uint8
Это псевдоним для uint8, беззнакового целого типа, шириной 8 бит. Исходный код Изменить
Natural = range[0 .. high(int)]
является типом int, изменяющимся от нуля до максимального значения int. Этот тип часто полезен для документации и отладки. Исходный код Изменить
Positive = range[1 .. high(int)]
это тип int, изменяющийся от единицы до максимального значения int. Этот тип часто полезен для документации и отладки. Исходный код Изменить
RootObj {...}{.compilerproc, inheritable.} = object

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

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

Исходный код Изменить
RootRef = ref RootObj
Ссылка на RootObj. Исходный код Изменить
RootEffect {...}{.compilerproc.} = object of RootObj

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

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

Исходный код Изменить
TimeEffect = object of RootEffect
Эффект времени. Исходный код Изменить
IOEffect = object of RootEffect
Эффект ввода-вывода. Исходный код Изменить
ReadIOEffect = object of IOEffect
Эффект, описывающий операцию чтения ввода-вывода. Исходный код Изменить
WriteIOEffect = object of IOEffect
Эффект, описывающий операцию записи ввода-вывода. Исходный код Изменить
ExecIOEffect = object of IOEffect
Эффект, описывающий выполняемую операцию ввода-вывода. Исходный код Изменить
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 — это одна запись трассировки стека. Исходный код Изменить
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]

  up: ref Exception

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

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

Исходный код Изменить
Defect = object of Exception
Абстрактный базовый класс для всех исключений, которые поднимает runtime Nim, но которые строго недоступны для перехвата, так как они также могут быть сопоставлены с операцией quit / trap / exit. Исходный код Изменить
CatchableError = object of Exception
Абстрактный класс для всех перехватываемых исключений. Исходный код Изменить
IOError = object of CatchableError
Вызывается при возникновении ошибки ввода-вывода. Исходный код Изменить
EOFError = object of IOError
Вызывается при возникновении ошибки "конец файла" ввода-вывода. Исходный код Изменить
OSError = object of CatchableError
  errorCode*: int32          ## OS-defined error code describing this error.
Вызывается, если операционная система не выполнила запрос. Исходный код Изменить
LibraryError = object of OSError
Вызывается, если не удалось загрузить динамическую библиотеку. Исходный код Изменить
ResourceExhaustedError = object of CatchableError
Вызывается, если запрос на ресурс не может быть выполнен. Исходный код Изменить
ArithmeticDefect = object of Defect
Вызывается при возникновении любой арифметической ошибки. Исходный код Изменить
DivByZeroDefect = object of ArithmeticDefect
Вызывается при возникновении ошибки деления на ноль при выполнении целочисленного деления. Исходный код Изменить
OverflowDefect = object of ArithmeticDefect

Вызывается при переполнении целого числа во время выполнения.

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

Исходный код Изменить
AccessViolationDefect = object of Defect
Вызывается при ошибках доступа к памяти. Исходный код Изменить
AssertionDefect = object of Defect

Вызывается, когда утверждение оказалось неверным.

Обычно результатом использования шаблона assert().

Исходный код Изменить
ValueError = object of CatchableError
Поднято при ошибках преобразования строк и объектов. Исходный код Редактировать
KeyError = object of ValueError

Поднимается, если ключ не найден в таблице.

В основном используется модулем tables, но также может быть поднят другими модулями коллекций, такими как sets или strtabs.

Исходный код Редактировать
OutOfMemDefect = object of Defect
Поднимается при неудачных попытках выделения памяти. Исходный код Редактировать
IndexDefect = object of Defect
Поднимается, если индекс массива выходит за пределы допустимого диапазона. Исходный код Редактировать
FieldDefect = object of Defect
Поднимается, если поле записи недоступно, потому что значение его дискриминанта не подходит. Исходный код Редактировать
RangeDefect = object of Defect
Поднимается, если произошла ошибка проверки диапазона. Исходный код Редактировать
StackOverflowDefect = object of Defect
Поднимается, если стек аппаратного обеспечения, используемый для вызовов подпрограмм, переполнился. Исходный код Редактировать
ReraiseDefect = object of Defect
Поднимается, если нет исключения для повторного поднятия. Исходный код Редактировать
ObjectAssignmentDefect = object of Defect
Поднимается, если объекту присваивается объект его родителя. Исходный код Редактировать
ObjectConversionDefect = object of Defect
Базовый класс для исключений с плавающей запятой. Исходный код Редактировать
FloatingPointDefect = object of Defect
Базовый класс для исключений с плавающей точкой. Исходный код Редактировать
FloatInvalidOpDefect = object of FloatingPointDefect

Поднимается при недопустимых операциях в соответствии со стандартом IEEE.

Поднимается, например, 0.0/0.0.

Исходный код Редактировать
FloatDivByZeroDefect = object of FloatingPointDefect

Поднимается при делении на ноль.

Делитель равен нулю, а делимое — конечное ненулевое число.

Исходный код Редактировать
FloatOverflowDefect = object of FloatingPointDefect

Поднимается при переполнении.

Операция даёт результат, превышающий диапазон показателя.

Исходный код Редактировать
FloatUnderflowDefect = object of FloatingPointDefect

Поднимается при недополнении.

Операция даёт результат, слишком малый для представления в виде нормального числа.

Исходный код Редактировать
FloatInexactDefect = object of FloatingPointDefect

Поднимается для неточных результатов.

Операция даёт результат, который нельзя представить с бесконечной точностью — например: 2.0 / 3.0, log(1.1)

Примечание: в настоящее время Nim не обнаруживает этого!

Исходный код Редактировать
DeadThreadDefect = object of Defect
Поднимается, если попытка отправить сообщение мёртвой нити. Исходный код Редактировать
NilAccessDefect = object of Defect

Поднимается при разыменовании nil указателей.

Это поднимается только в том случае, если был импортирован модуль segfaults!

Исходный код Редактировать
ArithmeticError {...}{.deprecated: "See corresponding Defect".} = ArithmeticDefect
Исходный код Редактировать
DivByZeroError {...}{.deprecated: "See corresponding Defect".} = DivByZeroDefect
Исходный код Редактировать
OverflowError {...}{.deprecated: "See corresponding Defect".} = OverflowDefect
Исходный код Редактировать
AccessViolationError {...}{.deprecated: "See corresponding Defect".} = AccessViolationDefect
Исходный код Редактировать
AssertionError {...}{.deprecated: "See corresponding Defect".} = AssertionDefect
Исходный код Редактировать
OutOfMemError {...}{.deprecated: "See corresponding Defect".} = OutOfMemDefect
Исходный код Редактировать
IndexError {...}{.deprecated: "See corresponding Defect".} = IndexDefect
Исходный код Редактировать
FieldError {...}{.deprecated: "See corresponding Defect".} = FieldDefect
Исходный код Редактировать
RangeError {...}{.deprecated: "See corresponding Defect".} = RangeDefect
Исходный код Редактировать
StackOverflowError {...}{.deprecated: "See corresponding Defect".} = StackOverflowDefect
Исходный код Редактировать
ReraiseError {...}{.deprecated: "See corresponding Defect".} = ReraiseDefect
Исходный код Редактировать
ObjectAssignmentError {...}{.deprecated: "See corresponding Defect".} = ObjectAssignmentDefect
Исходный код Редактировать
ObjectConversionError {...}{.deprecated: "See corresponding Defect".} = ObjectConversionDefect
Исходный код Редактировать
FloatingPointError {...}{.deprecated: "See corresponding Defect".} = FloatingPointDefect
Исходный код Редактировать
FloatInvalidOpError {...}{.deprecated: "See corresponding Defect".} = FloatInvalidOpDefect
Исходный код Редактировать
FloatDivByZeroError {...}{.deprecated: "See corresponding Defect".} = FloatDivByZeroDefect
Исходный код Редактировать
FloatOverflowError {...}{.deprecated: "See corresponding Defect".} = FloatOverflowDefect
Исходный код Редактировать
FloatUnderflowError {...}{.deprecated: "See corresponding Defect".} = FloatUnderflowDefect
Исходный код Редактировать
FloatInexactError {...}{.deprecated: "See corresponding Defect".} = FloatInexactDefect
Исходный код Редактировать
DeadThreadError {...}{.deprecated: "See corresponding Defect".} = DeadThreadDefect
Источник Изменить
NilAccessError {...}{.deprecated: "See corresponding Defect".} = NilAccessDefect
Источник Изменить
JsRoot = ref object of RootObj
Корневой тип иерархии JavaScript-объектов Источник Изменить
owned[T] {...}{.magic: "BuiltinType".}
Конструктор типа для маркировки ref/ptr или замыкания как owned. Источник Изменить
Endianness = enum
  littleEndian, bigEndian
Тип, описывающий порядок байтов процессора. Источник Изменить
TaintedString = string
Отличительный тип строки, который является загрязнённым, см. режим загрязнения для получения подробностей. Это псевдоним для string , если режим загрязнения не включён. Источник Изменить
ByteAddress = int
Это тип целого со знаком, который следует использовать для преобразования указателей в целочисленные адреса для удобочитаемости. Источник Изменить
BiggestFloat = float64
Это псевдоним для самого большого типа с плавающей запятой, поддерживаемого компилятором Nim. В настоящее время это float64, но в общем случае он зависит от платформы. Источник Изменить
BiggestUInt = uint64
Это псевдоним для самого большого целого типа без знака, поддерживаемого компилятором Nim. В настоящее время это uint32 для JS и uint64 для других целей. Источник Изменить
clong {...}{.importc: "long", nodecl.} = int
Это то же, что и тип long в C. Источник Изменить
culong {...}{.importc: "unsigned long", nodecl.} = uint
Это то же, что и тип unsigned long в C. Источник Изменить
cchar {...}{.importc: "char", nodecl.} = char
Это то же, что и тип char в C. Источник Изменить
cschar {...}{.importc: "signed char", nodecl.} = int8
Это то же, что и тип signed char в C. Источник Изменить
cshort {...}{.importc: "short", nodecl.} = int16
Это то же, что и тип short в C. Источник Изменить
cint {...}{.importc: "int", nodecl.} = int32
Это то же, что и тип int в C. Источник Изменить
csize {...}{.importc: "size_t", nodecl, deprecated: "use `csize_t` instead".} = int
Это не то же, что size_t в C. Не используйте его. Источник Изменить
csize_t {...}{.importc: "size_t", nodecl.} = uint
Это то же, что и тип size_t в C. Источник Изменить
clonglong {...}{.importc: "long long", nodecl.} = int64
Это то же, что и тип long long в C. Источник Изменить
cfloat {...}{.importc: "float", nodecl.} = float32
Это то же, что и тип float в C. Источник Изменить
cdouble {...}{.importc: "double", nodecl.} = float64
Это то же, что и тип double в C. Источник Изменить
clongdouble {...}{.importc: "long double", nodecl.} = BiggestFloat
Это то же, что и тип long double в C. Этот тип C не поддерживается генератором кода Nim. Источник Изменить
cuchar {...}{.importc: "unsigned char", nodecl.} = char
Это то же, что и тип unsigned char в C. Источник Изменить
cushort {...}{.importc: "unsigned short", nodecl.} = uint16
Это то же, что и тип unsigned short в C. Источник Изменить
cuint {...}{.importc: "unsigned int", nodecl.} = uint32
Это то же, что и тип unsigned int в C. Источник Изменить
culonglong {...}{.importc: "unsigned long long", nodecl.} = uint64
Это то же, что и тип unsigned long long в C. Источник Изменить
cstringArray {...}{.importc: "char**", nodecl.} = ptr UncheckedArray[cstring]
Это двоично совместимо с типом char** в C. Максимальное значение массива достаточно велико, чтобы фактически отключить проверку границ. Используйте процедуру cstringArrayToSeq для преобразования в seq[string]. Источник Изменить
PFloat32 = ptr float32
Псевдоним для ptr float32. Источник Изменить
PFloat64 = ptr float64
Псевдоним для ptr float64. Источник Изменить
PInt64 = ptr int64
Псевдоним для ptr int64. Источник Изменить
PInt32 = ptr int32
Псевдоним для ptr int32. Источник Изменить
AllocStats = object
  allocCount: int
  deallocCount: int
Источник Изменить
AtomType = SomeNumber | pointer | ptr | char | bool
Тип класса, представляющий допустимые типы для использования с атомными процедурами Источник Изменить
GC_Strategy = enum
  gcThroughput,             ## optimize for throughput
  gcResponsiveness,         ## optimize for responsiveness (default)
  gcOptimizeTime,           ## optimize for speed
  gcOptimizeSpace            ## optimize for memory footprint
Стратегия, которую GC должен использовать для приложения. Источник Изменить
PFrame = ptr TFrame
Представляет кадр выполнения стека вызовов; часть API отладчика. Источник Изменить
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.
Сам кадр. Источник Изменить
FileSeekPos = enum
  fspSet,                   ## Seek to absolute value
  fspCur,                   ## Seek relative to current position
  fspEnd                     ## Seek relative to end
Положение относительно которого должно произойти перемещение. Источник Изменить
ForeignCell = object
  data*: pointer
  owner: ptr GcHeap
Исходный код Редактировать
BackwardsIndex = distinct int
Тип, созданный ^ для обратного доступа к элементам массива. (См. шаблон ^) Исходный код Редактировать
NimNode {...}{.magic: "PNimrodNode".} = ref NimNodeObj
Представляет узел Nim AST. Макросы работают с этим типом. Исходный код Редактировать
ForLoopStmt {...}{.compilerproc.} = object
Специальный тип, отмечающий макрос как макрос цикла for. См. "Макрос цикла For". Исходный код Редактировать

Переменные

programResult: int
устарело, используйте quit или exitprocs.getProgramResult, exitprocs.setProgramResult. Исходный код Редактировать
globalRaiseHook: proc (e: ref Exception): bool {...}{.nimcall, gcsafe, locks: 0.}

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

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

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

Исходный код Редактировать
localRaiseHook: proc (e: ref Exception): bool {...}{.nimcall, gcsafe, locks: 0.}

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

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

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

Исходный код Редактировать
outOfMemHook: proc () {...}{.nimcall, tags: [], gcsafe, locks: 0, 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

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

Исходный код Редактировать
unhandledExceptionHook: proc (e: ref Exception) {...}{.nimcall, tags: [], gcsafe,
    locks: 0, raises: [].}
Установите эту переменную, чтобы предоставить процедуру, которая должна быть вызвана в случае события unhandle exception. Стандартный обработчик выводит сообщение об ошибке и завершает программу, за исключением использования --os:any. Исходный код Редактировать
errorMessageWriter: (proc (msg: string) {...}{.tags: [WriteIOEffect], gcsafe,
    locks: 0, nimcall.})
Функция, которая будет вызвана вместо stdmsg.write при печати стека вызовов. Нестабильный API. Исходный код Редактировать
onUnhandledException: (proc (errorMsg: string) {...}{.nimcall, gcsafe.})

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

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

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

Константы

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

Постоянные значения

on = true
Псевдоним для true. Исходный код Редактировать
off = false
Псевдоним для false. Исходный код Редактировать
appType: string = ""
Строка, описывающая тип приложения. Возможные значения: "console", "gui", "lib". Исходный код Редактировать
NoFakeVars = false
true, если бэкенд не поддерживает "фиктивные переменные", такие как var EBADF {.importc.}: cint. Исходный код Редактировать
isMainModule: bool = false
Истинно только при обращении в главном модуле. Работает благодаря магии компилятора. Полезно для встраивания кода тестирования в модуль. Исходный код Редактировать
CompileDate: string = "0000-00-00"
Дата компиляции (в UTC) в виде строки формата YYYY-MM-DD. Работает благодаря магии компилятора. Исходный код Редактировать
CompileTime: string = "00:00:00"
Время компиляции (в UTC) в виде строки формата HH:MM:SS. Работает благодаря магии компилятора. Исходный код Редактировать
cpuEndian: Endianness = littleEndian
Порядок байтов целевого процессора. Важная информация только для кода низкого уровня. Работает благодаря магии компилятора. Исходный код Редактировать
hostOS: string = ""

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

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

Исходный код Редактировать
hostCPU: string = ""

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

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

Исходный код Редактировать
nimEnableCovariance = false
Исходный код Редактировать
QuitSuccess = 0
значение, которое следует передать в quit, чтобы указать на успех. Исходный код Редактировать
QuitFailure = 1
значение, которое следует передать в quit, чтобы указать на неудачу. Исходный код Редактировать
Inf = 0x7FF0000000000000'f64
Содержит значение IEEE плавающей точки положительной бесконечности. Исходный код Редактировать
NegInf = 0xFFF0000000000000'f64
Содержит значение IEEE плавающей точки отрицательной бесконечности. Исходный код Редактировать
NaN = 0x7FF7FFFFFFFFFFFF'f64

Содержит значение IEEE плавающей точки Не число.

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

Исходный код Редактировать
nimCoroutines = false
Исходный код Редактировать
NimMajor: int = 1
Это основное число версии Nim. Пример:
when (NimMajor, NimMinor, NimPatch) >= (1, 3, 1): discard
Исходный код Редактировать
NimMinor: int = 4
Это второстепенное число версии Nim. Нечётное для devel, чётное для релизов. Исходный код Редактировать
NimPatch: int = 8
Это номер патча версии Nim. Нечётное для devel, чётное для релизов. Исходный код Редактировать
NimVersion: string = "1.4.8"
Это версия Nim в виде строки. Исходный код Редактировать
nativeStackTraceSupported = false
Исходный код Редактировать

Программы

proc `not`(x: bool): bool {...}{.magic: "Not", noSideEffect.}
Логическое отрицание; возвращает true, если x == false. Исходный код Редактировать
proc `and`(x, y: bool): bool {...}{.magic: "And", noSideEffect.}

Логическое and; возвращает true, если x == y == true (если оба аргумента истинны).

Вычисление ленивое: если x ложно, y даже не будет вычислено.

Исходный код Редактировать
proc `or`(x, y: bool): bool {...}{.magic: "Or", noSideEffect.}

Логическое or; возвращает true, если not (not x and not y) (если любой из аргументов истинен).

Вычисление ленивое: если x истинно, y даже не будет вычислено.

Исходный код Редактировать
proc `xor`(x, y: bool): bool {...}{.magic: "Xor", noSideEffect.}
Логическое exclusive or; возвращает true, если x != y (если один из аргументов истинен, а другой — ложен). Исходный код Редактировать
proc compileOption(option: string): bool {...}{.magic: "CompileOption", noSideEffect.}
Может использоваться для определения компиляционной опции on|off. Пример:
when compileOption("floatchecks"):
  echo "compiled with floating point NaN and Inf checks"
Исходный код Редактировать
proc compileOption(option, arg: string): bool {...}{.magic: "CompileOptionArg",
    noSideEffect.}
Может использоваться для определения компиляционной опции перечисления. Пример:
when compileOption("opt", "size") and compileOption("gc", "boehm"):
  echo "compiled with optimization for size and uses Boehm's GC"
Исходный код Редактировать
proc `or`(a, b: typedesc): typedesc {...}{.magic: "TypeTrait", noSideEffect.}
Создает метакласс or. Исходный код Редактировать
proc `and`(a, b: typedesc): typedesc {...}{.magic: "TypeTrait", noSideEffect.}
Создает метакласс and. Исходный код Редактировать
proc `not`(a: typedesc): typedesc {...}{.magic: "TypeTrait", noSideEffect.}
Создает метакласс not. Исходный код Редактировать
proc defined(x: untyped): bool {...}{.magic: "Defined", noSideEffect, compileTime.}

Специальная процедура компиляции, проверяющая, определено ли x.

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

when not defined(release):
  # Do here programmer friendly expensive sanity checks.
# Put here the normal code
Исходный код Редактировать
proc runnableExamples(rdoccmd = ""; body: untyped) {...}{.magic: "RunnableExamples".}
Раздел для выделения примера кода для исполнения.
  • В обычных дебажных и релизных сборках код в разделе runnableExamples игнорируется.
  • Генератор документации осознаёт эти примеры и считает их частью ## комментария документации. На последнем этапе генерации документации каждый runnableExample помещается в свой собственный файл $file_examples$i.nim, компилируется и тестируется. Собраные примеры помещаются в свой собственный модуль, чтобы избежать ссылок на неэкспортированные символы.

Использование:

proc double*(x: int): int =
  ## This proc doubles a number.
  runnableExamples:
    ## at module scope
    assert double(5) == 10
    block: ## at block scope
      defer: echo "done"
  result = 2 * x
  runnableExamples "-d:foo -b:cpp":
    import std/compilesettings
    doAssert querySetting(backend) == "cpp"
  runnableExamples "-r:off": ## this one is only compiled
     import std/browsers
     openDefaultBrowser "https://forum.nim-lang.org/"
Исходный код Редактировать
proc declared(x: untyped): bool {...}{.magic: "Declared", noSideEffect, compileTime.}

Специальная процедура компиляции, проверяющая, объявлено ли x. x должен быть идентификатором или квалифицированным идентификатором.

См. также:

  • declaredInScope

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

when not declared(strutils.toUpper):
  # provide our own toUpper proc here, because strutils is
  # missing it.
Исходный код Редактировать
proc declaredInScope(x: untyped): bool {...}{.magic: "DeclaredInScope", noSideEffect,
    compileTime.}
Специальная процедура компиляции, проверяющая, объявлено ли x в текущем области видимости. x должен быть идентификатором. Исходный код Редактировать
proc `addr`[T](x: var T): ptr T {...}{.magic: "Addr", noSideEffect.}

Встроенный addr оператор для получения адреса области памяти. Не перегружается.

См. также:

  • unsafeAddr
var
  buf: seq[char] = @['a','b','c']
  p = buf[1].addr
echo p.repr # ref 0x7faa35c40059 --> 'b'
echo p[]    # b
Исходный код Редактировать
proc unsafeAddr[T](x: T): ptr T {...}{.magic: "Addr", noSideEffect.}

Встроенный addr оператор для получения адреса области памяти. Он работает даже для let переменных или параметров для лучшей работы с C, поэтому он считается ещё более небезопасным, чем обычный addr.

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

Не перегружается.

Исходный код Редактировать
proc typeof(x: untyped; mode = typeOfIter): typedesc {...}{.magic: "TypeOf",
    noSideEffect, compileTime.}
Встроенная typeof операция для доступа к типу выражения. С версии 0.20.0. Исходный код Редактировать
proc internalNew[T](a: var ref T) {...}{.magic: "New", noSideEffect.}
Утечка реализации деталей. Не использовать. Исходный код Редактировать
proc new[T](a: var ref T; finalizer: proc (x: ref T) {...}{.nimcall.}) {...}{.
    magic: "NewFinalize", noSideEffect.}

Создаёт новый объект типа T и возвращает безопасную (отслеживаемую) ссылку на него в a.

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

Примечание: finalizer относится к типу T, а не к объекту! Это означает, что для каждого объекта типа T вызывается финализатор!

Исходный код Редактировать
proc wasMoved[T](obj: var T) {...}{.magic: "WasMoved", noSideEffect.}
Сбрасывает объект obj до его начального (бинарно-нулевого) значения, чтобы указать, что он был «перемещён», и что его деструктор не должен выполнять никаких действий и, желательно, быть оптимизирован. Исходный код Редактировать
proc move[T](x: var T): T {...}{.magic: "Move", noSideEffect.}
Исходный код Редактировать
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)`.".}
Устаревшее: Устаревшее с версии v1.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.}

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

high(int) — способ написания INT_MAX или MAX_INT в Ниме.

См. также:

  • low(typedesc)
high(int) # => 9223372036854775807
Исходный код Редактировать
proc high[T](x: openArray[T]): int {...}{.magic: "High", noSideEffect.}

Возвращает наибольший возможный индекс последовательности x.

См. также:

  • low(openArray)
var s = @[1, 2, 3, 4, 5, 6, 7]
high(s) # => 6
for i in low(s)..high(s):
  echo s[i]
Исходный код Редактировать
proc high[I, T](x: array[I, T]): I {...}{.magic: "High", noSideEffect.}

Возвращает наибольший возможный индекс массива x.

См. также:

  • low(array)
var arr = [1, 2, 3, 4, 5, 6, 7]
high(arr) # => 6
for i in low(arr)..high(arr):
  echo arr[i]
Исходный код Редактировать
proc high[I, T](x: typedesc[array[I, T]]): I {...}{.magic: "High", noSideEffect.}

Возвращает максимальный возможный индекс типа массива.

См. также:

  • low(typedesc[array])
high(array[7, int]) # => 6
Исходный код Редактировать
proc high(x: cstring): int {...}{.magic: "High", noSideEffect.}

Возвращает максимальный возможный индекс совместимой строки x. Иногда это операция O(n).

См. также:

  • low(cstring)
Исходный код Редактировать
proc high(x: string): int {...}{.magic: "High", noSideEffect.}

Возвращает максимальный возможный индекс строки x.

См. также:

  • low(string)
var str = "Hello world!"
high(str) # => 11
Исходный код Редактировать
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)`.".}
Устаревшее: Устарело начиная с 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.}

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

low(int) — это способ записи INT_MIN или MIN_INT в Nim.

См. также:

  • high(typedesc)
low(int) # => -9223372036854775808
Исходный код Редактировать
proc low[T](x: openArray[T]): int {...}{.magic: "Low", noSideEffect.}

Возвращает наименьший возможный индекс последовательности x.

См. также:

  • high(openArray)
var s = @[1, 2, 3, 4, 5, 6, 7]
low(s) # => 0
for i in low(s)..high(s):
  echo s[i]
Исходный код Редактировать
proc low[I, T](x: array[I, T]): I {...}{.magic: "Low", noSideEffect.}

Возвращает наименьший возможный индекс массива x.

См. также:

  • high(array)
var arr = [1, 2, 3, 4, 5, 6, 7]
low(arr) # => 0
for i in low(arr)..high(arr):
  echo arr[i]
Исходный код Редактировать
proc low[I, T](x: typedesc[array[I, T]]): I {...}{.magic: "Low", noSideEffect.}

Возвращает наименьший возможный индекс типа массива.

См. также:

  • high(typedesc[array])
low(array[7, int]) # => 0
Исходный код Редактировать
proc low(x: cstring): int {...}{.magic: "Low", noSideEffect.}

Возвращает наименьший возможный индекс совместимой строки x.

См. также:

  • high(cstring)
Исходный код Редактировать
proc low(x: string): int {...}{.magic: "Low", noSideEffect.}

Возвращает наименьший возможный индекс строки x.

См. также:

  • high(string)
var str = "Hello world!"
low(str) # => 0
Исходный код Редактировать
proc shallowCopy[T](x: var T; y: T) {...}{.noSideEffect, magic: "ShallowCopy".}

Используйте это вместо = для поверхностной копии.

Поверхностная копия изменяет семантику только для последовательностей и строк (и типов, которые содержат эти).

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

Исходный код Редактировать
proc `[]`[I: Ordinal; T](a: T; i: I): T {...}{.noSideEffect, magic: "ArrGet".}
Исходный код Редактировать
proc `[]=`[I: Ordinal; T, S](a: T; i: I; x: sink S) {...}{.noSideEffect,
    magic: "ArrPut".}
Исходный код Редактировать
proc `=`[T](dest: var T; src: T) {...}{.noSideEffect, magic: "Asgn".}
Исходный код Редактировать
proc `=destroy`[T](x: var T) {...}{.inline, magic: "Destroy".}
Реализация обобщённого деструктора, которую можно переопределить. Исходный код Редактировать
proc `=sink`[T](x: var T; y: T) {...}{.inline, magic: "Asgn".}
Реализация обобщённого синка, которую можно переопределить. Исходный код Редактировать
proc `..`[T, U](a: sink T; b: sink U): HSlice[T, U] {...}{.noSideEffect, inline,
    magic: "DotDot".}

Бинарный оператор срезов, который строит интервал [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".}
Унарный оператор срезов, который строит интервал [default(int), b].
let a = [10, 20, 30, 40, 50]
echo a[.. 2] # @[10, 20, 30]
Исходный код Редактировать
proc succ[T: Ordinal](x: T; y = 1): T {...}{.magic: "Succ", noSideEffect.}

Возвращает y-й преемник (по умолчанию: 1) значения x. T должен быть порядковым типом.

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

let x = 5
echo succ(5)    # => 6
echo succ(5, 3) # => 8
Исходный код Редактировать
proc pred[T: Ordinal](x: T; y = 1): T {...}{.magic: "Pred", noSideEffect.}

Возвращает y-й предшественник (по умолчанию: 1) значения x. T должен быть порядковым типом.

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

let x = 5
echo pred(5)    # => 4
echo pred(5, 3) # => 2
Исходный код Редактировать
proc inc[T: Ordinal](x: var T; y = 1) {...}{.magic: "Inc", noSideEffect.}

Увеличивает порядковый x на y.

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

var i = 2
inc(i)    # i <- 3
inc(i, 3) # i <- 6
Исходный код Редактировать
proc dec[T: Ordinal](x: var T; y = 1) {...}{.magic: "Dec", noSideEffect.}

Уменьшает порядковый x на y.

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

var i = 2
dec(i)    # i <- 1
dec(i, 3) # i <- -2
Исходный код Редактировать
proc ze(x: int8): int {...}{.deprecated, raises: [], tags: [].}
Устаревшее
нулевое расширение меньшего целочисленного типа до int. Это обрабатывает x как беззнаковый. Устарело начиная с версии 0.19.9: Используйте беззнаковые целые числа вместо этого. Исходный код Редактировать
proc ze(x: int16): int {...}{.deprecated, raises: [], tags: [].}
Устаревшее
нулевое расширение меньшего целочисленного типа до int. Это обрабатывает x как беззнаковый. Устарело начиная с версии 0.19.9: Используйте беззнаковые целые числа вместо этого. Исходный код Редактировать
proc ze64(x: int8): int64 {...}{.deprecated, raises: [], tags: [].}
Устаревшее
нулевое расширение меньшего целочисленного типа до int64. Это обрабатывает x как беззнаковый. Устарело начиная с версии 0.19.9: Используйте беззнаковые целые числа вместо этого. Исходный код Редактировать
proc ze64(x: int16): int64 {...}{.deprecated, raises: [], tags: [].}
Устаревшее
zero расширяет тип целого меньшего размера до int64. Это обрабатывает x как беззнаковое. Устарело начиная с версии 0.19.9: Используйте беззнаковые целые числа вместо этого. Исходный код Редактировать
proc ze64(x: int32): int64 {...}{.deprecated, raises: [], tags: [].}
Устаревшее
zero расширяет тип целого меньшего размера до int64. Это обрабатывает x как беззнаковое. Устарело начиная с версии 0.19.9: Используйте беззнаковые целые числа вместо этого. Исходный код Редактировать
proc ze64(x: int): int64 {...}{.deprecated, raises: [], tags: [].}
Устаревшее
zero расширяет тип целого меньшего размера до int64. Это обрабатывает x как беззнаковое. Ничего не делает, если размер int такой же, как у int64. (Это случай на 64-битных процессорах.) Устарело начиная с версии 0.19.9: Используйте беззнаковые целые числа вместо этого. Исходный код Редактировать
proc toU8(x: int): int8 {...}{.deprecated, raises: [], tags: [].}
Устаревшее
обрабатывает x как беззнаковое и преобразует его в байт, взяв последние 8 бит из x. Устарело начиная с версии 0.19.9: Используйте беззнаковые целые числа вместо этого. Исходный код Редактировать
proc toU16(x: int): int16 {...}{.deprecated, raises: [], tags: [].}
Устаревшее
обрабатывает x как беззнаковое и преобразует его в int16, взяв последние 16 бит из x. Устарело начиная с версии 0.19.9: Используйте беззнаковые целые числа вместо этого. Исходный код Редактировать
proc toU32(x: int64): int32 {...}{.deprecated, raises: [], tags: [].}
Устаревшее
обрабатывает x как беззнаковое и преобразует его в int32, взяв последние 32 бита из x. Устарело начиная с версии 0.19.9: Используйте беззнаковые целые числа вместо этого. Исходный код Редактировать
proc `+`(x: int): int {...}{.magic: "UnaryPlusI", noSideEffect.}
Унарный оператор + для целого числа. Не оказывает никакого эффекта. Исходный код Редактировать
proc `+`(x: int8): int8 {...}{.magic: "UnaryPlusI", noSideEffect.}
Исходный код Редактировать
proc `+`(x: int16): int16 {...}{.magic: "UnaryPlusI", noSideEffect.}
Исходный код Редактировать
proc `+`(x: int32): int32 {...}{.magic: "UnaryPlusI", noSideEffect.}
Исходный код Редактировать
proc `+`(x: int64): int64 {...}{.magic: "UnaryPlusI", noSideEffect.}
Исходный код Редактировать
proc `-`(x: int): int {...}{.magic: "UnaryMinusI", noSideEffect.}
Унарный оператор - для целого числа. Инвертирует x. Исходный код Редактировать
proc `-`(x: int8): int8 {...}{.magic: "UnaryMinusI", noSideEffect.}
Исходный код Редактировать
proc `-`(x: int16): int16 {...}{.magic: "UnaryMinusI", noSideEffect.}
Исходный код Редактировать
proc `-`(x: int32): int32 {...}{.magic: "UnaryMinusI", noSideEffect.}
Исходный код Редактировать
proc `-`(x: int64): int64 {...}{.magic: "UnaryMinusI64", noSideEffect.}
Исходный код Редактировать
proc `not`(x: int): int {...}{.magic: "BitnotI", noSideEffect.}
Вычисляет bitwise complement целого числа x.
var
  a = 0'u8
  b = 0'i8
  c = 1000'u16
  d = 1000'i16

echo not a # => 255
echo not b # => -1
echo not c # => 64535
echo not d # => -1001
Исходный код Редактировать
proc `not`(x: int8): int8 {...}{.magic: "BitnotI", noSideEffect.}
Исходный код Редактировать
proc `not`(x: int16): int16 {...}{.magic: "BitnotI", noSideEffect.}
Исходный код Редактировать
proc `not`(x: int32): int32 {...}{.magic: "BitnotI", noSideEffect.}
Исходный код Редактировать
proc `not`(x: int64): int64 {...}{.magic: "BitnotI", noSideEffect.}
Исходный код Редактировать
proc `+`(x, y: int): int {...}{.magic: "AddI", noSideEffect.}
Бинарный оператор + для целого числа. Исходный код Редактировать
proc `+`(x, y: int8): int8 {...}{.magic: "AddI", noSideEffect.}
Исходный код Редактировать
proc `+`(x, y: int16): int16 {...}{.magic: "AddI", noSideEffect.}
Исходный код Редактировать
proc `+`(x, y: int32): int32 {...}{.magic: "AddI", noSideEffect.}
Исходный код Редактировать
proc `+`(x, y: int64): int64 {...}{.magic: "AddI", noSideEffect.}
Исходный код Редактировать
proc `-`(x, y: int): int {...}{.magic: "SubI", noSideEffect.}
Бинарный оператор - для целого числа. Исходный код Редактировать
proc `-`(x, y: int8): int8 {...}{.magic: "SubI", noSideEffect.}
Исходный код Редактировать
proc `-`(x, y: int16): int16 {...}{.magic: "SubI", noSideEffect.}
Исходный код Редактировать
proc `-`(x, y: int32): int32 {...}{.magic: "SubI", noSideEffect.}
Исходный код Редактировать
proc `-`(x, y: int64): int64 {...}{.magic: "SubI", noSideEffect.}
Исходный код Редактировать
proc `*`(x, y: int): int {...}{.magic: "MulI", noSideEffect.}
Бинарный оператор * для целого числа. Исходный код Редактировать
proc `*`(x, y: int8): int8 {...}{.magic: "MulI", noSideEffect.}
Исходный код Редактировать
proc `*`(x, y: int16): int16 {...}{.magic: "MulI", noSideEffect.}
Исходный код Редактировать
proc `*`(x, y: int32): int32 {...}{.magic: "MulI", noSideEffect.}
Исходный код Редактировать
proc `*`(x, y: int64): int64 {...}{.magic: "MulI", noSideEffect.}
Источник Редактировать
proc `div`(x, y: int): int {...}{.magic: "DivI", noSideEffect.}

Вычисляет целочисленное деление.

Это примерно то же самое, что trunc(x/y).

( 1 div  2) ==  0
( 2 div  2) ==  1
( 3 div  2) ==  1
( 7 div  3) ==  2
(-7 div  3) == -2
( 7 div -3) == -2
(-7 div -3) ==  2
Источник Редактировать
proc `div`(x, y: int8): int8 {...}{.magic: "DivI", noSideEffect.}
Источник Редактировать
proc `div`(x, y: int16): int16 {...}{.magic: "DivI", noSideEffect.}
Источник Редактировать
proc `div`(x, y: int32): int32 {...}{.magic: "DivI", noSideEffect.}
Источник Редактировать
proc `div`(x, y: int64): int64 {...}{.magic: "DivI", noSideEffect.}
Источник Редактировать
proc `mod`(x, y: int): int {...}{.magic: "ModI", noSideEffect.}

Вычисляет операцию нахождения остатка от целочисленного деления (modulo).

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

( 7 mod  5) ==  2
(-7 mod  5) == -2
( 7 mod -5) ==  2
(-7 mod -5) == -2
Источник Редактировать
proc `mod`(x, y: int8): int8 {...}{.magic: "ModI", noSideEffect.}
Источник Редактировать
proc `mod`(x, y: int16): int16 {...}{.magic: "ModI", noSideEffect.}
Источник Редактировать
proc `mod`(x, y: int32): int32 {...}{.magic: "ModI", noSideEffect.}
Источник Редактировать
proc `mod`(x, y: int64): int64 {...}{.magic: "ModI", noSideEffect.}
Источник Редактировать
proc `shr`(x: int; y: SomeInteger): int {...}{.magic: "AshrI", noSideEffect.}

Вычисляет операцию shift right x и y, заполняя свободные битовые позиции знаковым битом.

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

См. также:

  • Функция ashr для арифметического сдвига вправо
0b0001_0000'i8 shr 2 == 0b0000_0100'i8
0b0000_0001'i8 shr 1 == 0b0000_0000'i8
0b1000_0000'i8 shr 4 == 0b1111_1000'i8
-1 shr 5 == -1
1 shr 5 == 0
16 shr 2 == 4
-16 shr 2 == -4
Источник Редактировать
proc `shr`(x: int8; y: SomeInteger): int8 {...}{.magic: "AshrI", noSideEffect.}
Источник Редактировать
proc `shr`(x: int16; y: SomeInteger): int16 {...}{.magic: "AshrI", noSideEffect.}
Источник Редактировать
proc `shr`(x: int32; y: SomeInteger): int32 {...}{.magic: "AshrI", noSideEffect.}
Источник Редактировать
proc `shr`(x: int64; y: SomeInteger): int64 {...}{.magic: "AshrI", noSideEffect.}
Источник Редактировать
proc `shl`(x: int; y: SomeInteger): int {...}{.magic: "ShlI", noSideEffect.}

Вычисляет операцию shift left x и y.

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

1'i32 shl 4 == 0x0000_0010
1'i64 shl 4 == 0x0000_0000_0000_0010
Источник Редактировать
proc `shl`(x: int8; y: SomeInteger): int8 {...}{.magic: "ShlI", noSideEffect.}
Источник Редактировать
proc `shl`(x: int16; y: SomeInteger): int16 {...}{.magic: "ShlI", noSideEffect.}
Источник Редактировать
proc `shl`(x: int32; y: SomeInteger): int32 {...}{.magic: "ShlI", noSideEffect.}
Источник Редактировать
proc `shl`(x: int64; y: SomeInteger): int64 {...}{.magic: "ShlI", noSideEffect.}
Источник Редактировать
proc ashr(x: int; y: SomeInteger): int {...}{.magic: "AshrI", noSideEffect.}

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

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

См. также:

  • Функция shr
ashr(0b0001_0000'i8, 2) == 0b0000_0100'i8
ashr(0b1000_0000'i8, 8) == 0b1111_1111'i8
ashr(0b1000_0000'i8, 1) == 0b1100_0000'i8
Источник Редактировать
proc ashr(x: int8; y: SomeInteger): int8 {...}{.magic: "AshrI", noSideEffect.}
Источник Редактировать
proc ashr(x: int16; y: SomeInteger): int16 {...}{.magic: "AshrI", noSideEffect.}
Источник Редактировать
proc ashr(x: int32; y: SomeInteger): int32 {...}{.magic: "AshrI", noSideEffect.}
Источник Редактировать
proc ashr(x: int64; y: SomeInteger): int64 {...}{.magic: "AshrI", noSideEffect.}
Источник Редактировать
proc `and`(x, y: int): int {...}{.magic: "BitandI", noSideEffect.}
Вычисляет bitwise and чисел x и y.
(0b0011 and 0b0101) == 0b0001
(0b0111 and 0b1100) == 0b0100
Источник Редактировать
proc `and`(x, y: int8): int8 {...}{.magic: "BitandI", noSideEffect.}
Источник Редактировать
proc `and`(x, y: int16): int16 {...}{.magic: "BitandI", noSideEffect.}
Источник Редактировать
proc `and`(x, y: int32): int32 {...}{.magic: "BitandI", noSideEffect.}
Источник Редактировать
proc `and`(x, y: int64): int64 {...}{.magic: "BitandI", noSideEffect.}
Источник Редактировать
proc `or`(x, y: int): int {...}{.magic: "BitorI", noSideEffect.}
Вычисляет bitwise or чисел x и y.
(0b0011 or 0b0101) == 0b0111
(0b0111 or 0b1100) == 0b1111
Источник Редактировать
proc `or`(x, y: int8): int8 {...}{.magic: "BitorI", noSideEffect.}
Источник Редактировать
proc `or`(x, y: int16): int16 {...}{.magic: "BitorI", noSideEffect.}
Источник Редактировать
proc `or`(x, y: int32): int32 {...}{.magic: "BitorI", noSideEffect.}
Источник Редактировать
proc `or`(x, y: int64): int64 {...}{.magic: "BitorI", noSideEffect.}
Источник Редактировать
proc `xor`(x, y: int): int {...}{.magic: "BitxorI", noSideEffect.}
Вычисляет bitwise xor чисел x и y.
(0b0011 xor 0b0101) == 0b0110
(0b0111 xor 0b1100) == 0b1011
Источник Редактировать
proc `xor`(x, y: int8): int8 {...}{.magic: "BitxorI", noSideEffect.}
Источник Изменить
proc `xor`(x, y: int16): int16 {...}{.magic: "BitxorI", noSideEffect.}
Источник Изменить
proc `xor`(x, y: int32): int32 {...}{.magic: "BitxorI", noSideEffect.}
Источник Изменить
proc `xor`(x, y: int64): int64 {...}{.magic: "BitxorI", noSideEffect.}
Источник Изменить
proc `not`(x: uint): uint {...}{.magic: "BitnotI", noSideEffect.}
Вычисляет bitwise complement целого числа x. Источник Изменить
proc `not`(x: uint8): uint8 {...}{.magic: "BitnotI", noSideEffect.}
Источник Изменить
proc `not`(x: uint16): uint16 {...}{.magic: "BitnotI", noSideEffect.}
Источник Изменить
proc `not`(x: uint32): uint32 {...}{.magic: "BitnotI", noSideEffect.}
Источник Изменить
proc `not`(x: uint64): uint64 {...}{.magic: "BitnotI", noSideEffect.}
Источник Изменить
proc `shr`(x: uint; y: SomeInteger): uint {...}{.magic: "ShrI", noSideEffect.}
Вычисляет операцию shift right для x и y. Источник Изменить
proc `shr`(x: uint8; y: SomeInteger): uint8 {...}{.magic: "ShrI", noSideEffect.}
Источник Изменить
proc `shr`(x: uint16; y: SomeInteger): uint16 {...}{.magic: "ShrI", noSideEffect.}
Источник Изменить
proc `shr`(x: uint32; y: SomeInteger): uint32 {...}{.magic: "ShrI", noSideEffect.}
Источник Изменить
proc `shr`(x: uint64; y: SomeInteger): uint64 {...}{.magic: "ShrI", noSideEffect.}
Источник Изменить
proc `shl`(x: uint; y: SomeInteger): uint {...}{.magic: "ShlI", noSideEffect.}
Вычисляет операцию shift left для x и y. Источник Изменить
proc `shl`(x: uint8; y: SomeInteger): uint8 {...}{.magic: "ShlI", noSideEffect.}
Источник Изменить
proc `shl`(x: uint16; y: SomeInteger): uint16 {...}{.magic: "ShlI", noSideEffect.}
Источник Изменить
proc `shl`(x: uint32; y: SomeInteger): uint32 {...}{.magic: "ShlI", noSideEffect.}
Источник Изменить
proc `shl`(x: uint64; y: SomeInteger): uint64 {...}{.magic: "ShlI", noSideEffect.}
Источник Изменить
proc `and`(x, y: uint): uint {...}{.magic: "BitandI", noSideEffect.}
Вычисляет bitwise and чисел x и y. Источник Изменить
proc `and`(x, y: uint8): uint8 {...}{.magic: "BitandI", noSideEffect.}
Источник Изменить
proc `and`(x, y: uint16): uint16 {...}{.magic: "BitandI", noSideEffect.}
Источник Изменить
proc `and`(x, y: uint32): uint32 {...}{.magic: "BitandI", noSideEffect.}
Источник Изменить
proc `and`(x, y: uint64): uint64 {...}{.magic: "BitandI", noSideEffect.}
Источник Изменить
proc `or`(x, y: uint): uint {...}{.magic: "BitorI", noSideEffect.}
Вычисляет bitwise or чисел x и y. Источник Изменить
proc `or`(x, y: uint8): uint8 {...}{.magic: "BitorI", noSideEffect.}
Источник Изменить
proc `or`(x, y: uint16): uint16 {...}{.magic: "BitorI", noSideEffect.}
Источник Изменить
proc `or`(x, y: uint32): uint32 {...}{.magic: "BitorI", noSideEffect.}
Источник Изменить
proc `or`(x, y: uint64): uint64 {...}{.magic: "BitorI", noSideEffect.}
Источник Изменить
proc `xor`(x, y: uint): uint {...}{.magic: "BitxorI", noSideEffect.}
Вычисляет bitwise xor чисел x и y. Источник Изменить
proc `xor`(x, y: uint8): uint8 {...}{.magic: "BitxorI", noSideEffect.}
Источник Изменить
proc `xor`(x, y: uint16): uint16 {...}{.magic: "BitxorI", noSideEffect.}
Источник Изменить
proc `xor`(x, y: uint32): uint32 {...}{.magic: "BitxorI", noSideEffect.}
Источник Изменить
proc `xor`(x, y: uint64): uint64 {...}{.magic: "BitxorI", noSideEffect.}
Источник Изменить
proc `+`(x, y: uint): uint {...}{.magic: "AddU", noSideEffect.}
Бинарный оператор + для беззнаковых целых чисел. Источник Изменить
proc `+`(x, y: uint8): uint8 {...}{.magic: "AddU", noSideEffect.}
Источник Изменить
proc `+`(x, y: uint16): uint16 {...}{.magic: "AddU", noSideEffect.}
Источник Изменить
proc `+`(x, y: uint32): uint32 {...}{.magic: "AddU", noSideEffect.}
Источник Изменить
proc `+`(x, y: uint64): uint64 {...}{.magic: "AddU", noSideEffect.}
Источник Изменить
proc `-`(x, y: uint): uint {...}{.magic: "SubU", noSideEffect.}
Бинарный оператор - для беззнаковых целых чисел. Источник Изменить
proc `-`(x, y: uint8): uint8 {...}{.magic: "SubU", noSideEffect.}
Исходный код Изменить
proc `-`(x, y: uint16): uint16 {...}{.magic: "SubU", noSideEffect.}
Исходный код Изменить
proc `-`(x, y: uint32): uint32 {...}{.magic: "SubU", noSideEffect.}
Исходный код Изменить
proc `-`(x, y: uint64): uint64 {...}{.magic: "SubU", noSideEffect.}
Исходный код Изменить
proc `*`(x, y: uint): uint {...}{.magic: "MulU", noSideEffect.}
Бинарный * оператор для беззнаковых целых чисел. Исходный код Изменить
proc `*`(x, y: uint8): uint8 {...}{.magic: "MulU", noSideEffect.}
Исходный код Изменить
proc `*`(x, y: uint16): uint16 {...}{.magic: "MulU", noSideEffect.}
Исходный код Изменить
proc `*`(x, y: uint32): uint32 {...}{.magic: "MulU", noSideEffect.}
Исходный код Изменить
proc `*`(x, y: uint64): uint64 {...}{.magic: "MulU", noSideEffect.}
Исходный код Изменить
proc `div`(x, y: uint): uint {...}{.magic: "DivU", noSideEffect.}
Вычисляет целочисленное деление для беззнаковых целых чисел. Это примерно то же самое, что и trunc(x/y). Исходный код Изменить
proc `div`(x, y: uint8): uint8 {...}{.magic: "DivU", noSideEffect.}
Исходный код Изменить
proc `div`(x, y: uint16): uint16 {...}{.magic: "DivU", noSideEffect.}
Исходный код Изменить
proc `div`(x, y: uint32): uint32 {...}{.magic: "DivU", noSideEffect.}
Исходный код Изменить
proc `div`(x, y: uint64): uint64 {...}{.magic: "DivU", noSideEffect.}
Исходный код Изменить
proc `mod`(x, y: uint): uint {...}{.magic: "ModU", noSideEffect.}
Вычисляет операцию взятия остатка от деления (остаток) для беззнаковых целых чисел. Это то же самое, что и x - (x div y) * y. Исходный код Изменить
proc `mod`(x, y: uint8): uint8 {...}{.magic: "ModU", noSideEffect.}
Исходный код Изменить
proc `mod`(x, y: uint16): uint16 {...}{.magic: "ModU", noSideEffect.}
Исходный код Изменить
proc `mod`(x, y: uint32): uint32 {...}{.magic: "ModU", noSideEffect.}
Исходный код Изменить
proc `mod`(x, y: uint64): uint64 {...}{.magic: "ModU", noSideEffect.}
Исходный код Изменить
proc `+%`(x, y: int): int {...}{.inline, raises: [], tags: [].}

Обращается с x и y как с беззнаковыми и складывает их.

Результат усекается до размера результата. Это реализует арифметику по модулю. Ошибки переполнения невозможны.

Исходный код Изменить
proc `+%`(x, y: int8): int8 {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `+%`(x, y: int16): int16 {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `+%`(x, y: int32): int32 {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `+%`(x, y: int64): int64 {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `-%`(x, y: int): int {...}{.inline, raises: [], tags: [].}

Обращается с x и y как с беззнаковыми и вычитает их.

Результат усекается до размера результата. Это реализует арифметику по модулю. Ошибки переполнения невозможны.

Исходный код Изменить
proc `-%`(x, y: int8): int8 {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `-%`(x, y: int16): int16 {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `-%`(x, y: int32): int32 {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `-%`(x, y: int64): int64 {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `*%`(x, y: int): int {...}{.inline, raises: [], tags: [].}

Обращается с x и y как с беззнаковыми и перемножает их.

Результат усекается до размера результата. Это реализует арифметику по модулю. Ошибки переполнения невозможны.

Исходный код Изменить
proc `*%`(x, y: int8): int8 {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `*%`(x, y: int16): int16 {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `*%`(x, y: int32): int32 {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `*%`(x, y: int64): int64 {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `/%`(x, y: int): int {...}{.inline, raises: [], tags: [].}

Обращается с x и y как с беззнаковыми и делит их.

Результат усекается до размера результата. Это реализует арифметику по модулю. Ошибки переполнения невозможны.

Исходный код Изменить
proc `/%`(x, y: int8): int8 {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `/%`(x, y: int16): int16 {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `/%`(x, y: int32): int32 {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `/%`(x, y: int64): int64 {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `%%`(x, y: int): int {...}{.inline, raises: [], tags: [].}
END_OF_DOCUMENT_MARKER

Обрабатывает x и y как беззнаковые и вычисляет остаток от деления x на y.

Результат усекается для соответствия результату. Это реализует арифметику по модулю. Ошибки переполнения невозможны.

Источник Редактировать
proc `%%`(x, y: int8): int8 {...}{.inline, raises: [], tags: [].}
Источник Редактировать
proc `%%`(x, y: int16): int16 {...}{.inline, raises: [], tags: [].}
Источник Редактировать
proc `%%`(x, y: int32): int32 {...}{.inline, raises: [], tags: [].}
Источник Редактировать
proc `%%`(x, y: int64): int64 {...}{.inline, raises: [], tags: [].}
Источник Редактировать
proc `+=`[T: SomeInteger](x: var T; y: T) {...}{.magic: "Inc", noSideEffect.}
Увеличивает целое число. Источник Редактировать
proc `-=`[T: SomeInteger](x: var T; y: T) {...}{.magic: "Dec", noSideEffect.}
Уменьшает целое число. Источник Редактировать
proc `*=`[T: SomeInteger](x: var T; y: T) {...}{.inline, noSideEffect.}
Бинарный *= оператор для целых чисел. Источник Редактировать
proc `==`[Enum: enum](x, y: Enum): bool {...}{.magic: "EqEnum", noSideEffect.}
Проверяет, имеют ли значения в одном перечислении одно и то же базовое значение.
type
  Enum1 = enum
    Field1 = 3, Field2
  Enum2 = enum
    Place1, Place2 = 3
var
  e1 = Field1
  e2 = Enum1(Place2)
echo (e1 == e2) # true
echo (e1 == Place2) # raises error
Источник Редактировать
proc `==`(x, y: pointer): bool {...}{.magic: "EqRef", noSideEffect.}
var # this is a wildly dangerous example
  a = cast[pointer](0)
  b = cast[pointer](nil)
echo (a == b) # true due to the special meaning of `nil`/0 as a pointer
Источник Редактировать
proc `==`(x, y: string): bool {...}{.magic: "EqStr", noSideEffect.}
Проверяет равенство двух string переменных. Источник Редактировать
proc `==`(x, y: char): bool {...}{.magic: "EqCh", noSideEffect.}
Проверяет равенство двух char переменных. Источник Редактировать
proc `==`(x, y: bool): bool {...}{.magic: "EqB", noSideEffect.}
Проверяет равенство двух bool переменных. Источник Редактировать
proc `==`[T](x, y: set[T]): bool {...}{.magic: "EqSet", noSideEffect.}
Проверяет равенство двух переменных типа set.
var a = {1, 2, 2, 3} # duplication in sets is ignored
var b = {1, 2, 3}
echo (a == b) # true
Источник Редактировать
proc `==`[T](x, y: ref T): bool {...}{.magic: "EqRef", noSideEffect.}
Проверяет, ссылаются ли две ref переменные на один и тот же элемент. Источник Редактировать
proc `==`[T](x, y: ptr T): bool {...}{.magic: "EqRef", noSideEffect.}
Проверяет, ссылаются ли две ptr переменные на один и тот же элемент. Источник Редактировать
proc `==`[T: proc](x, y: T): bool {...}{.magic: "EqProc", noSideEffect.}
Проверяет, ссылаются ли две proc переменные на одну и ту же процедуру. Источник Редактировать
proc `<=`[Enum: enum](x, y: Enum): bool {...}{.magic: "LeEnum", noSideEffect.}
Источник Редактировать
proc `<=`(x, y: string): bool {...}{.magic: "LeStr", noSideEffect.}
Сравнивает две строки и возвращает true, если x стоит лексикографически раньше y (заглавные буквы стоят раньше строчных).
let
  a = "abc"
  b = "abd"
  c = "ZZZ"
assert a <= b
assert a <= a
assert (a <= c) == false
Источник Редактировать
proc `<=`(x, y: char): bool {...}{.magic: "LeCh", noSideEffect.}
Сравнивает два символа и возвращает true, если x стоит лексикографически раньше y (заглавные буквы стоят раньше строчных).
let
  a = 'a'
  b = 'b'
  c = 'Z'
assert a <= b
assert a <= a
assert (a <= c) == false
Источник Редактировать
proc `<=`[T](x, y: set[T]): bool {...}{.magic: "LeSet", noSideEffect.}

Возвращает 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 (a <= c) == false
Источник Редактировать
proc `<=`(x, y: bool): bool {...}{.magic: "LeB", noSideEffect.}
Источник Редактировать
proc `<=`[T](x, y: ref T): bool {...}{.magic: "LePtr", noSideEffect.}
Источник Редактировать
proc `<=`(x, y: pointer): bool {...}{.magic: "LePtr", noSideEffect.}
Источник Редактировать
proc `<`[Enum: enum](x, y: Enum): bool {...}{.magic: "LtEnum", noSideEffect.}
Источник Редактировать
proc `<`(x, y: string): bool {...}{.magic: "LtStr", noSideEffect.}
Сравнивает две строки и возвращает true, если x стоит лексикографически раньше y (заглавные буквы стоят раньше строчных).
let
  a = "abc"
  b = "abd"
  c = "ZZZ"
assert a < b
assert (a < a) == false
assert (a < c) == false
Источник Редактировать
proc `<`(x, y: char): bool {...}{.magic: "LtCh", noSideEffect.}
Сравнивает два символа и возвращает true, если x стоит лексикографически раньше y (заглавные буквы стоят раньше строчных).
let
  a = 'a'
  b = 'b'
  c = 'Z'
assert a < b
assert (a < a) == false
assert (a < c) == false
Источник Редактировать
proc `<`[T](x, y: set[T]): bool {...}{.magic: "LtSet", noSideEffect.}

Возвращает true, если x является строгим или истинным подмножеством y.

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

let
  a = {3, 5}
  b = {1, 3, 5, 7}
  c = {2}
assert a < b
assert (a < a) == false
assert (a < c) == false
Источник Редактировать
proc `<`(x, y: bool): bool {...}{.magic: "LtB", noSideEffect.}
Источник Редактировать
proc `<`[T](x, y: ref T): bool {...}{.magic: "LtPtr", noSideEffect.}
Источник Редактировать
proc `<`[T](x, y: ptr T): bool {...}{.magic: "LtPtr", noSideEffect.}
Источник Редактировать
proc `<`(x, y: pointer): bool {...}{.magic: "LtPtr", noSideEffect.}
Источник Редактировать
proc `==`(x, y: int): bool {...}{.magic: "EqI", noSideEffect.}
Сравнивает два целых числа на равенство. Источник Редактировать
proc `==`(x, y: int8): bool {...}{.magic: "EqI", noSideEffect.}
Источник Редактировать
proc `==`(x, y: int16): bool {...}{.magic: "EqI", noSideEffect.}
Исходный код Изменить
proc `==`(x, y: int32): bool {...}{.magic: "EqI", noSideEffect.}
Исходный код Изменить
proc `==`(x, y: int64): bool {...}{.magic: "EqI", noSideEffect.}
Исходный код Изменить
proc `<=`(x, y: int): bool {...}{.magic: "LeI", noSideEffect.}
Возвращает true, если x меньше или равно y. Исходный код Изменить
proc `<=`(x, y: int8): bool {...}{.magic: "LeI", noSideEffect.}
Исходный код Изменить
proc `<=`(x, y: int16): bool {...}{.magic: "LeI", noSideEffect.}
Исходный код Изменить
proc `<=`(x, y: int32): bool {...}{.magic: "LeI", noSideEffect.}
Исходный код Изменить
proc `<=`(x, y: int64): bool {...}{.magic: "LeI", noSideEffect.}
Исходный код Изменить
proc `<`(x, y: int): bool {...}{.magic: "LtI", noSideEffect.}
Возвращает true, если x меньше y. Исходный код Изменить
proc `<`(x, y: int8): bool {...}{.magic: "LtI", noSideEffect.}
Исходный код Изменить
proc `<`(x, y: int16): bool {...}{.magic: "LtI", noSideEffect.}
Исходный код Изменить
proc `<`(x, y: int32): bool {...}{.magic: "LtI", noSideEffect.}
Исходный код Изменить
proc `<`(x, y: int64): bool {...}{.magic: "LtI", noSideEffect.}
Исходный код Изменить
proc `<=`(x, y: uint): bool {...}{.magic: "LeU", noSideEffect.}
Возвращает true, если x <= y. Исходный код Изменить
proc `<=`(x, y: uint8): bool {...}{.magic: "LeU", noSideEffect.}
Исходный код Изменить
proc `<=`(x, y: uint16): bool {...}{.magic: "LeU", noSideEffect.}
Исходный код Изменить
proc `<=`(x, y: uint32): bool {...}{.magic: "LeU", noSideEffect.}
Исходный код Изменить
proc `<=`(x, y: uint64): bool {...}{.magic: "LeU", noSideEffect.}
Исходный код Изменить
proc `<`(x, y: uint): bool {...}{.magic: "LtU", noSideEffect.}
Возвращает true, если x < y. Исходный код Изменить
proc `<`(x, y: uint8): bool {...}{.magic: "LtU", noSideEffect.}
Исходный код Изменить
proc `<`(x, y: uint16): bool {...}{.magic: "LtU", noSideEffect.}
Исходный код Изменить
proc `<`(x, y: uint32): bool {...}{.magic: "LtU", noSideEffect.}
Исходный код Изменить
proc `<`(x, y: uint64): bool {...}{.magic: "LtU", noSideEffect.}
Исходный код Изменить
proc `<=%`(x, y: int): bool {...}{.inline, raises: [], tags: [].}
Рассматривает x и y как беззнаковые и сравнивает их. Возвращает true, если unsigned(x) <= unsigned(y). Исходный код Изменить
proc `<=%`(x, y: int8): bool {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `<=%`(x, y: int16): bool {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `<=%`(x, y: int32): bool {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `<=%`(x, y: int64): bool {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `<%`(x, y: int): bool {...}{.inline, raises: [], tags: [].}
Рассматривает x и y как беззнаковые и сравнивает их. Возвращает true, если unsigned(x) < unsigned(y). Исходный код Изменить
proc `<%`(x, y: int8): bool {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `<%`(x, y: int16): bool {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `<%`(x, y: int32): bool {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `<%`(x, y: int64): bool {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `==`(x, y: uint): bool {...}{.magic: "EqI", noSideEffect.}
Сравнивает два беззнаковых целых числа на равенство. Исходный код Изменить
proc `==`(x, y: uint8): bool {...}{.magic: "EqI", noSideEffect.}
Исходный код Изменить
proc `==`(x, y: uint16): bool {...}{.magic: "EqI", noSideEffect.}
Исходный код Изменить
proc `==`(x, y: uint32): bool {...}{.magic: "EqI", noSideEffect.}
Исходный код Изменить
proc `==`(x, y: uint64): bool {...}{.magic: "EqI", noSideEffect.}
Исходный код Изменить
proc min(x, y: int): int {...}{.magic: "MinI", noSideEffect, raises: [], tags: [].}
Исходный код Изменить
proc min(x, y: int8): int8 {...}{.magic: "MinI", noSideEffect, raises: [], tags: [].}
Исходный код Изменить
proc min(x, y: int16): int16 {...}{.magic: "MinI", noSideEffect, raises: [], tags: [].}
Исходный код Изменить
proc min(x, y: int32): int32 {...}{.magic: "MinI", noSideEffect, raises: [], tags: [].}
Исходный код Редактировать
proc min(x, y: int64): int64 {...}{.magic: "MinI", noSideEffect, raises: [], tags: [].}
Минимальное значение двух целых чисел. Исходный код Редактировать
proc max(x, y: int): int {...}{.magic: "MaxI", noSideEffect, raises: [], tags: [].}
Исходный код Редактировать
proc max(x, y: int8): int8 {...}{.magic: "MaxI", noSideEffect, raises: [], tags: [].}
Исходный код Редактировать
proc max(x, y: int16): int16 {...}{.magic: "MaxI", noSideEffect, raises: [], tags: [].}
Исходный код Редактировать
proc max(x, y: int32): int32 {...}{.magic: "MaxI", noSideEffect, raises: [], tags: [].}
Исходный код Редактировать
proc max(x, y: int64): int64 {...}{.magic: "MaxI", noSideEffect, raises: [], tags: [].}
Максимальное значение двух целых чисел. Исходный код Редактировать
proc min[T](x: openArray[T]): T
Минимальное значение x. T должен иметь оператор <. Исходный код Редактировать
proc max[T](x: openArray[T]): T
Максимальное значение x. T должен иметь оператор <. Исходный код Редактировать
proc clamp[T](x, a, b: T): T
Ограничивает значение x в пределах интервала [a, b].
assert((1.4).clamp(0.0, 1.0) == 1.0)
assert((0.5).clamp(0.0, 1.0) == 0.5)
Исходный код Редактировать
proc `==`[I, T](x, y: array[I, T]): bool
Исходный код Редактировать
proc `==`[T](x, y: openArray[T]): bool
Исходный код Редактировать
proc `==`[T](x, y: seq[T]): bool {...}{.noSideEffect.}
Общий оператор равенства для последовательностей: опирается на оператор равенства для типа элементов T. Исходный код Редактировать
proc unsafeNew[T](a: var ref T; size: Natural) {...}{.magic: "New", noSideEffect.}

Создаёт новый объект типа T и возвращает безопасную (отслеживаемую) ссылку на него в a.

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

См. также:

  • new
Исходный код Редактировать
proc sizeof[T](x: T): int {...}{.magic: "SizeOf", noSideEffect.}

Возвращает размер x в байтах.

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

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

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

sizeof('A') # => 1
sizeof(2) # => 8
Исходный код Редактировать
proc alignof[T](x: T): int {...}{.magic: "AlignOf", noSideEffect.}
Исходный код Редактировать
proc alignof(x: typedesc): int {...}{.magic: "AlignOf", noSideEffect.}
Исходный код Редактировать
proc sizeof(x: typedesc): int {...}{.magic: "SizeOf", noSideEffect.}
Исходный код Редактировать
proc newSeq[T](s: var seq[T]; len: Natural) {...}{.magic: "NewSeq", noSideEffect.}

Создаёт новую последовательность типа 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 newSeq[T](len = 0.Natural): seq[T]

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

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

См. также:

  • newSeqOfCap
  • newSeqUninitialized
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"
Исходный код Редактировать
proc newSeqOfCap[T](cap: Natural): seq[T] {...}{.magic: "NewSeqOfCap", noSideEffect.}
Создаёт новую последовательность типа seq[T] длиной ноль и ёмкостью cap.
var x = newSeqOfCap[int](5)
assert len(x) == 0
x.add(10)
assert len(x) == 1
Исходный код Редактировать
proc newSeqUninitialized[T: SomeNumber](len: Natural): seq[T]

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

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

var x = newSeqUninitialized[int](3)
assert len(x) == 3
x[0] = 10
Исходный код Редактировать
proc len[TOpenArray: openArray | varargs](x: TOpenArray): int {...}{.
    magic: "LengthOpenArray", noSideEffect.}
Возвращает длину openArray.
var s = [1, 1, 1, 1, 1]
echo len(s) # => 5
Исходный код Редактировать
proc len(x: string): int {...}{.magic: "LengthStr", noSideEffect.}
Возвращает длину строки.
var str = "Hello world!"
echo len(str) # => 12
Исходный код Редактировать
proc len(x: cstring): int {...}{.magic: "LengthStr", noSideEffect.}

Возвращает длину совместимой строки. Иногда это операция O(n).

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

var str: cstring = "Hello world!"
len(str) # => 12
Исходный код Редактировать
proc len(x: (type array) | array): int {...}{.magic: "LengthArray", noSideEffect.}
Возвращает длину массива или типа массива. Это примерно то же самое, что и high(T)-low(T)+1.
var arr = [1, 1, 1, 1, 1]
echo len(arr) # => 5
echo len(array[3..8, int]) # => 6
Исходный код Редактировать
proc len[T](x: seq[T]): int {...}{.magic: "LengthSeq", noSideEffect.}
Возвращает длину последовательности.
var s = @[1, 1, 1, 1, 1]
echo len(s) # => 5
Исходный код Редактировать
proc ord[T: Ordinal | enum](x: T): int {...}{.magic: "Ord", noSideEffect.}
Возвращает внутреннее значение int порядкового значения x.
echo ord('A') # => 65
echo ord('a') # => 97
Исходный код Редактировать
proc chr(u: range[0 .. 255]): char {...}{.magic: "Chr", noSideEffect.}
Преобразует int в диапазоне 0..255 в символ.
echo chr(65) # => A
echo chr(97) # => a
Исходный код Редактировать
proc `+`(x: float32): float32 {...}{.magic: "UnaryPlusF64", noSideEffect.}
Исходный код Редактировать
proc `-`(x: float32): float32 {...}{.magic: "UnaryMinusF64", noSideEffect.}
Источник Изменить
proc `+`(x, y: float32): float32 {...}{.magic: "AddF64", noSideEffect.}
Источник Изменить
proc `-`(x, y: float32): float32 {...}{.magic: "SubF64", noSideEffect.}
Источник Изменить
proc `*`(x, y: float32): float32 {...}{.magic: "MulF64", noSideEffect.}
Источник Изменить
proc `/`(x, y: float32): float32 {...}{.magic: "DivF64", noSideEffect.}
Источник Изменить
proc `+`(x: float): float {...}{.magic: "UnaryPlusF64", noSideEffect.}
Источник Изменить
proc `-`(x: float): float {...}{.magic: "UnaryMinusF64", noSideEffect.}
Источник Изменить
proc `+`(x, y: float): float {...}{.magic: "AddF64", noSideEffect.}
Источник Изменить
proc `-`(x, y: float): float {...}{.magic: "SubF64", noSideEffect.}
Источник Изменить
proc `*`(x, y: float): float {...}{.magic: "MulF64", noSideEffect.}
Источник Изменить
proc `/`(x, y: float): float {...}{.magic: "DivF64", noSideEffect.}
Источник Изменить
proc `==`(x, y: float32): bool {...}{.magic: "EqF64", noSideEffect.}
Источник Изменить
proc `<=`(x, y: float32): bool {...}{.magic: "LeF64", noSideEffect.}
Источник Изменить
proc `<`(x, y: float32): bool {...}{.magic: "LtF64", noSideEffect.}
Источник Изменить
proc `==`(x, y: float): bool {...}{.magic: "EqF64", noSideEffect.}
Источник Изменить
proc `<=`(x, y: float): bool {...}{.magic: "LeF64", noSideEffect.}
Источник Изменить
proc `<`(x, y: float): bool {...}{.magic: "LtF64", noSideEffect.}
Источник Изменить
proc incl[T](x: var set[T]; y: T) {...}{.magic: "Incl", noSideEffect.}

Включает элемент y в множество x.

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

var a = {1, 3, 5}
a.incl(2) # a <- {1, 2, 3, 5}
a.incl(4) # a <- {1, 2, 3, 4, 5}
Источник Изменить
proc excl[T](x: var set[T]; y: T) {...}{.magic: "Excl", noSideEffect.}

Исключает элемент y из множества x.

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

var b = {2, 3, 5, 6, 12, 545}
b.excl(5)  # b <- {2, 3, 6, 12, 545}
Источник Изменить
proc card[T](x: set[T]): int {...}{.magic: "Card", noSideEffect.}
Возвращает мощность множества x, т.е. количество элементов в множестве.
var a = {1, 3, 5, 7}
echo card(a) # => 4
Источник Изменить
proc len[T](x: set[T]): int {...}{.magic: "Card", noSideEffect.}
Псевдоним для card(x). Источник Изменить
proc `*`[T](x, y: set[T]): set[T] {...}{.magic: "MulSet", noSideEffect.}
Данный оператор вычисляет пересечение двух множеств.
let
  a = {1, 2, 3}
  b = {2, 3, 4}
echo a * b # => {2, 3}
Источник Изменить
proc `+`[T](x, y: set[T]): set[T] {...}{.magic: "PlusSet", noSideEffect.}
Данный оператор вычисляет объединение двух множеств.
let
  a = {1, 2, 3}
  b = {2, 3, 4}
echo a + b # => {1, 2, 3, 4}
Источник Изменить
proc `-`[T](x, y: set[T]): set[T] {...}{.magic: "MinusSet", noSideEffect.}
Данный оператор вычисляет разность двух множеств.
let
  a = {1, 2, 3}
  b = {2, 3, 4}
echo a - b # => {1}
Источник Изменить
proc contains[T](x: set[T]; y: T): bool {...}{.magic: "InSet", noSideEffect.}

Следует переопределять эту процедуру, если нужно переопределить оператор 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

Если 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 `is`[T, S](x: T; y: S): bool {...}{.magic: "Is", noSideEffect.}

Проверяет, имеет ли 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 new[T](a: var ref T) {...}{.magic: "New", noSideEffect.}
Создаёт новый объект типа T и возвращает безопасную (отслеживаемую) ссылку на него в a. Источник Изменить
proc new(t: typedesc): auto

Создаёт новый объект типа T и возвращает безопасную (отслеживаемую) ссылку на него как значение результата.

Если T является типом ref, то возвращаемый тип будет T, в противном случае ref T.

Источник Изменить
proc `of`[T, S](x: typedesc[T]; y: typedesc[S]): bool {...}{.magic: "Of",
    noSideEffect.}
Источник Изменить
proc `of`[T, S](x: T; y: typedesc[S]): bool {...}{.magic: "Of", noSideEffect.}
Источник Изменить
proc `of`[T, S](x: T; y: S): bool {...}{.magic: "Of", noSideEffect.}
Проверяет, имеет ли x тип y.
assert(FloatingPointDefect of Exception)
assert(DivByZeroDefect of Exception)
Источник Изменить
proc cmp[T](x, y: T): int

Обобщенная процедура сравнения.

Возвращает:

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

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

import algorithm
echo sorted(@[4, 2, 6, 5, 8, 7], cmp[int])
Источник Изменить
proc `@`[IDX, T](a: sink array[IDX, T]): seq[T] {...}{.magic: "ArrToSeq",
    noSideEffect.}

Преобразует массив в последовательность.

Это чаще всего полезно для создания последовательностей с конструктором массива: @[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 default(T: typedesc): T:type {...}{.magic: "Default", noSideEffect.}
возвращает значение по умолчанию типа T. Исходный код Редактировать
proc reset[T](obj: var T) {...}{.noSideEffect.}
Сбрасывает объект obj до значения по умолчанию. Исходный код Редактировать
proc setLen[T](s: var seq[T]; newlen: Natural) {...}{.magic: "SetLengthSeq",
    noSideEffect.}

Устанавливает длину последовательности 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]
Исходный код Редактировать
proc setLen(s: var string; newlen: Natural) {...}{.magic: "SetLengthStr",
    noSideEffect.}

Устанавливает длину строки s в newlen.

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

var myS = "Nim is great!!"
myS.setLen(3) # myS <- "Nim"
echo myS, " is fantastic!!"
Исходный код Редактировать
proc newString(len: Natural): string {...}{.magic: "NewString",
                                       importc: "mnewString", noSideEffect.}

Возвращает новую строку длиной len, но с незаполненным содержимым. Необходимо заполнить строку посимвольно с помощью оператора индекса s[i].

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

Исходный код Редактировать
proc newStringOfCap(cap: Natural): string {...}{.magic: "NewStringOfCap",
    importc: "rawNewString", noSideEffect.}

Возвращает новую строку длиной 0 с емкостью cap.

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

Исходный код Редактировать
proc `&`(x: string; y: char): string {...}{.magic: "ConStrStr", noSideEffect, merge.}
Объединяет x с y.
assert("ab" & 'c' == "abc")
Исходный код Редактировать
proc `&`(x, y: char): string {...}{.magic: "ConStrStr", noSideEffect, merge.}
Объединяет символы x и y в строку.
assert('a' & 'b' == "ab")
Исходный код Редактировать
proc `&`(x, y: string): string {...}{.magic: "ConStrStr", noSideEffect, merge.}
Объединяет строки x и y.
assert("ab" & "cd" == "abcd")
Исходный код Редактировать
proc `&`(x: char; y: string): string {...}{.magic: "ConStrStr", noSideEffect, merge.}
Объединяет x с y.
assert('a' & "bc" == "abc")
Исходный код Редактировать
proc add(x: var string; y: char) {...}{.magic: "AppendStrCh", noSideEffect.}
Добавляет y к x на месте.
var tmp = ""
tmp.add('a')
tmp.add('b')
assert(tmp == "ab")
Исходный код Редактировать
proc add(x: var string; y: string) {...}{.magic: "AppendStrStr", noSideEffect.}
Объединяет x и y на месте.
var tmp = ""
tmp.add("ab")
tmp.add("cd")
assert(tmp == "abcd")
Исходный код Редактировать
proc quit(errorcode: int = QuitSuccess) {...}{.magic: "Exit", noreturn.}

Немедленно останавливает программу с кодом выхода.

Перед остановкой программы вызываются «процедуры выхода» в обратном порядке, в котором они были добавлены с помощью addExitProc. quit никогда не возвращается и игнорирует любые исключения, которые могут быть вызваны процедурами выхода. Он не вызывает сборщик мусора для освобождения всей памяти, если процедура выхода не вызовет GC_fullCollect.

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

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

Исходный код Редактировать
proc add[T](x: var seq[T]; y: sink T) {...}{.magic: "AppendSeqElem", noSideEffect.}

Обобщённая процедура для добавления элемента данных y в контейнер x.

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

Исходный код Редактировать
proc add[T](x: var seq[T]; y: openArray[T]) {...}{.noSideEffect.}

Обобщённая процедура для добавления контейнера y в контейнер x.

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

См. также:

  • & процедура
var s: seq[string] = @["test2","test2"]
s.add("test") # s <- @[test2, test2, test]
Исходный код Редактировать
proc del[T](x: var seq[T]; i: Natural) {...}{.noSideEffect.}

Удаляет элемент по индексу i, помещая x[high(x)] в позицию i.

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

См. также:

  • delete для сохранения порядка
var i = @[1, 2, 3, 4, 5]
i.del(2) # => @[1, 2, 5, 4]
Исходный код Редактировать
proc delete[T](x: var seq[T]; i: Natural) {...}{.noSideEffect.}

Удаляет элемент по индексу i путём перемещения всех x[i+1..] элементов на одну позицию вперёд.

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

См. также:

  • del для операции O(1)
var i = @[1, 2, 3, 4, 5]
i.delete(2) # => @[1, 2, 4, 5]
Исходный код Редактировать
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 repr[T](x: T): string {...}{.magic: "Repr", noSideEffect.}

Принимает любую переменную Nim и возвращает её строковое представление.

Работает даже для сложных графов данных с циклами. Это отличный инструмент отладки.

var s: seq[string] = @["test2", "test2"]
var i = @[1, 2, 3, 4, 5]
echo repr(s) # => 0x1055eb050[0x1055ec050"test2", 0x1055ec078"test2"]
echo repr(i) # => 0x1055ed050[1, 2, 3, 4, 5]
Исходный код Редактировать
proc toFloat(i: int): float {...}{.noSideEffect, inline, raises: [], tags: [].}

Преобразует целое число i в float.

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

let
  a = 2
  b = 3.7

echo a.toFloat + b # => 5.7
Исходный код Редактировать
proc toBiggestFloat(i: BiggestInt): BiggestFloat {...}{.noSideEffect, inline,
    raises: [], tags: [].}
То же, что и toFloat, но для BiggestInt до BiggestFloat. Исходный код Редактировать
proc toInt(f: float): int {...}{.noSideEffect, raises: [], tags: [].}

Преобразует число с плавающей точкой f в int.

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

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

doAssert toInt(0.49) == 0
doAssert toInt(0.5) == 1
doAssert toInt(-0.5) == -1 # rounding is symmetrical
Исходный код Редактировать
proc toBiggestInt(f: BiggestFloat): BiggestInt {...}{.noSideEffect, raises: [],
    tags: [].}
То же, что и toInt, но для BiggestFloat до BiggestInt. Исходный код Редактировать
proc addQuitProc(quitProc: proc () {...}{.noconv.}) {...}{.importc: "atexit",
    header: "<stdlib.h>", deprecated: "use exitprocs.addExitProc".}
Устарело: используйте exitprocs.addExitProc

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

Каждый вызов addQuitProc регистрирует ещё одну процедуру завершения. До 30 процедур могут быть зарегистрированы. Они выполняются по принципу LIFO (последним записанным первым исполняется). addQuitProc генерирует исключение EOutOfIndex, если quitProc не может быть зарегистрирована.

Исходный код Редактировать
proc swap[T](a, b: var T) {...}{.magic: "Swap", noSideEffect.}

Меняет значения a и b.

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

var
  a = 5
  b = 9

swap(a, b)

assert a == 9
assert b == 5
Исходный код Редактировать
proc `-`(a, b: AllocStats): AllocStats {...}{.raises: [], tags: [].}
Исходный код Редактировать
proc getAllocStats(): AllocStats {...}{.raises: [], tags: [].}
Исходный код Редактировать
proc createU(T: typedesc; size = 1.Positive): ptr T:type {...}{.inline, gcsafe,
    locks: 0, raises: [].}

Выделяет новый блок памяти размером не менее T.sizeof * size байт.

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

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

См. также:

  • create
Исходный код Редактировать
proc create(T: typedesc; size = 1.Positive): ptr T:type {...}{.inline, gcsafe,
    locks: 0, raises: [].}

Выделяет новый блок памяти размером не менее T.sizeof * size байт.

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

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

Исходный код Редактировать
proc resize[T](p: ptr T; newSize: Natural): ptr T {...}{.inline, gcsafe, locks: 0,
    raises: [].}

Изменяет размер заданного блока памяти.

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

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

Исходный код Редактировать
proc dealloc(p: pointer) {...}{.noconv, compilerproc, gcsafe, gcsafe, locks: 0,
                           raises: [], tags: [].}

Освобождает память, выделенную с помощью alloc, alloc0 или realloc.

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

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

Исходный код Редактировать
proc createSharedU(T: typedesc; size = 1.Positive): ptr T:type {...}{.inline,
    tags: [], gcsafe, locks: 0, raises: [].}

Выделяет новый блок памяти в общей куче размером не менее T.sizeof * size байт.

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

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

См. также:

  • createShared
Исходный код Редактировать
proc createShared(T: typedesc; size = 1.Positive): ptr T:type {...}{.inline.}

Выделяет новый блок памяти в общей куче размером не менее T.sizeof * size байт.

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

Блок инициализируется нулями, поэтому он немного безопаснее, чем createSharedU.

Исходный код Редактировать
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 deallocShared(p: pointer) {...}{.noconv, compilerproc, gcsafe, gcsafe, locks: 0,
                                 raises: [], tags: [].}

Освобождает память, выделенную с помощью allocShared, allocShared0 или reallocShared.

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

Исходный код Редактировать
proc freeShared[T](p: ptr T) {...}{.inline, gcsafe, locks: 0, raises: [].}

Освобождает память, выделенную с помощью createShared, createSharedU или resizeShared.

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

Исходный код Редактировать
proc `|`(a, b: typedesc): typedesc
Исходный код Редактировать
proc abs(x: float64): float64 {...}{.noSideEffect, inline, raises: [], tags: [].}
Исходный код Редактировать
proc abs(x: float32): float32 {...}{.noSideEffect, inline, raises: [], tags: [].}
Исходный код Редактировать
proc min(x, y: float32): float32 {...}{.noSideEffect, inline, raises: [], tags: [].}
Исходный код Редактировать
proc min(x, y: float64): float64 {...}{.noSideEffect, inline, raises: [], tags: [].}
Исходный код Редактировать
proc max(x, y: float32): float32 {...}{.noSideEffect, inline, raises: [], tags: [].}
Исходный код Редактировать
proc max(x, y: float64): float64 {...}{.noSideEffect, inline, raises: [], tags: [].}
Исходный код Редактировать
proc min[T: not SomeFloat](x, y: T): T {...}{.inline.}
Исходный код Редактировать
proc max[T: not SomeFloat](x, y: T): T {...}{.inline.}
Исходный код Редактировать
proc high(T: typedesc[SomeFloat]): T:type
Исходный код Редактировать
proc low(T: typedesc[SomeFloat]): T:type
Исходный код Редактировать
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 isNil[T](x: seq[T]): bool {...}{.noSideEffect, magic: "IsNil", error.}

Требует --nilseqs:on начиная с версии 0.19.

Массивы больше не являются nil по умолчанию, а устанавливаются в пустые. Проверьте длину на ноль вместо проверки на nil.

См. также:

  • isNil(string)
Исходный код Редактировать
END_OF_DOCUMENT_MARKER
proc isNil[T](x: ref T): bool {...}{.noSideEffect, magic: "IsNil".}
Исходный код Изменить
proc isNil(x: string): bool {...}{.noSideEffect, magic: "IsNil", error.}

Требуется --nilseqs:on.

См. также:

  • isNil(seq[T])
Исходный код Изменить
proc isNil[T](x: ptr T): bool {...}{.noSideEffect, magic: "IsNil".}
Исходный код Изменить
proc isNil(x: pointer): bool {...}{.noSideEffect, magic: "IsNil".}
Исходный код Изменить
proc isNil(x: cstring): bool {...}{.noSideEffect, magic: "IsNil".}
Исходный код Изменить
proc isNil[T: proc](x: T): bool {...}{.noSideEffect, magic: "IsNil".}
Быстрая проверка, является ли x нулевым. Иногда это более эффективно, чем == nil. Исходный код Изменить
proc `@`[T](a: openArray[T]): seq[T]

Преобразует openArray в последовательность.

Это не так эффективно, как преобразование массива фиксированной длины в последовательность, поскольку всегда копирует каждый элемент a.

Исходный код Изменить
proc `&`[T](x, y: seq[T]): seq[T] {...}{.noSideEffect.}

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

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

См. также:

  • add(var seq[T], openArray[T])
assert(@[1, 2, 3, 4] & @[5, 6] == @[1, 2, 3, 4, 5, 6])
Исходный код Изменить
proc `&`[T](x: seq[T]; y: T): seq[T] {...}{.noSideEffect.}

Добавляет элемент y в конец последовательности.

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

См. также:

  • add(var seq[T], T)
assert(@[1, 2, 3] & 4 == @[1, 2, 3, 4])
Исходный код Изменить
proc `&`[T](x: T; y: seq[T]): seq[T] {...}{.noSideEffect.}

Добавляет элемент x в начало последовательности.

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

assert(1 & @[2, 3, 4] == @[1, 2, 3, 4])
Исходный код Изменить
proc astToStr[T](x: T): string {...}{.magic: "AstToStr", noSideEffect.}
Преобразует AST x в строковое представление. Это очень полезно для отладки. Исходный код Изменить
proc instantiationInfo(index = -1; fullPaths = false): tuple[filename: string,
    line: int, column: int] {...}{.magic: "InstantiationInfo", noSideEffect.}

Предоставляет доступ к информации о строке стека экземпляров компилятора шаблона.

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

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

import 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 compiles(x: untyped): bool {...}{.magic: "Compiles", noSideEffect, compileTime,
                                  raises: [], tags: [].}
Специальная процедура времени компиляции, проверяющая, можно ли скомпилировать x без каких-либо семантических ошибок. Это можно использовать для проверки того, поддерживает ли тип какую-либо операцию:
when compiles(3 + 4):
  echo "'+' for integers is available"
Исходный код Изменить
proc atomicInc(memLoc: var int; x: int = 1): int {...}{.inline, discardable, gcsafe,
    locks: 0, raises: [], tags: [].}
Атомарное увеличение memLoc. Возвращает значение после операции. Исходный код Изменить
proc atomicDec(memLoc: var int; x: int = 1): int {...}{.inline, discardable, gcsafe,
    locks: 0, raises: [], tags: [].}
Атомарное уменьшение memLoc. Возвращает значение после операции. Исходный код Изменить
proc addAndFetch(p: ptr int; val: int): int {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc cas[T: bool | int | ptr](p: ptr T; oldValue, newValue: T): bool {...}{.
    importc: "__sync_bool_compare_and_swap", nodecl.}
Исходный код Изменить
proc cpuRelax() {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc find[T, S](a: T; item: S): int {...}{.inline.}
Возвращает первый индекс item в a или -1, если не найден. Для работы требуются соответствующие операции items и ==. Исходный код Изменить
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
Исходный код Изменить
proc pop[T](s: var seq[T]): T {...}{.inline, noSideEffect.}
Возвращает последний элемент s и уменьшает s.len на единицу. Это рассматривает s как стек и реализует общую операцию pop.

Пример:

var a = @[1, 3, 5, 7]
let b = pop(a)
assert b == 7
assert a == @[1, 3, 5]
Исходный код Изменить
proc `==`[T: tuple | object](x, y: T): bool
Общий оператор == для кортежей, который поднимается из компонентов x и y. Исходный код Изменить
proc `<=`[T: tuple](x, y: T): bool
Общий лексикографический оператор <= для кортежей, который поднимается из компонентов x и y. Эта реализация использует cmp. Исходный код Изменить
proc `<`[T: tuple](x, y: T): bool
Общий лексикографический оператор < для кортежей, который поднимается из компонентов x и y. Эта реализация использует cmp. Исходный код Изменить
proc GC_ref[T](x: ref T) {...}{.magic: "GCref", gcsafe, locks: 0.}
Исходный код Изменить
proc GC_ref[T](x: seq[T]) {...}{.magic: "GCref", gcsafe, locks: 0.}
Исходный код Изменить
proc GC_ref(x: string) {...}{.magic: "GCref", gcsafe, locks: 0.}
Помечает объект x как ссылочный, чтобы он не был освобождён до тех пор, пока он не будет помечен как нессылочный с помощью GC_unref. Если вызваны n раз для одного и того же объекта x, для разметки x нужно n вызовов GC_unref . Исходный код Изменить
proc GC_unref[T](x: ref T) {...}{.magic: "GCunref", gcsafe, locks: 0.}
Исходный код Изменить
proc GC_unref[T](x: seq[T]) {...}{.magic: "GCunref", gcsafe, locks: 0.}
Исходный код Изменить
proc GC_unref(x: string) {...}{.magic: "GCunref", gcsafe, locks: 0.}
См. документацию по GC_ref. Исходный код Изменить
proc add(x: var string; y: cstring) {...}{.asmNoStackFrame, raises: [], tags: [].}
END_OF_DOCUMENT_MARKER
Добавляет y к x на месте.

Пример:

var tmp = ""
tmp.add(cstring("ab"))
tmp.add(cstring("cd"))
doAssert tmp == "abcd"
Исходный код Изменить
proc add(x: var cstring; y: cstring) {...}{.magic: "AppendStrStr", raises: [],
                                       tags: [].}
Добавляет y к x на месте. Реализовано только для JS бэкенда.

Пример:

when defined(js):
  var tmp: cstring = ""
  tmp.add(cstring("ab"))
  tmp.add(cstring("cd"))
  doAssert tmp == cstring("abcd")
Исходный код Изменить
proc echo(x: varargs[typed, `$`]) {...}{.magic: "Echo", tags: [WriteIOEffect],
                                    gcsafe, locks: 0, sideEffect.}

Записывает и сбрасывает параметры в стандартный вывод.

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

В отличие от других операций ввода-вывода, эта функция гарантированно потокобезопасна, так как echo часто используется для удобства отладки. Если вы хотите использовать echo внутри процедуры без побочных эффектов, вы можете использовать debugEcho вместо этого.

Исходный код Изменить
proc debugEcho(x: varargs[typed, `$`]) {...}{.magic: "Echo", noSideEffect, tags: [],
    raises: [].}
То же, что и echo, но, согласно специальному правилу семантики, debugEcho имитирует отсутствие побочных эффектов, чтобы его можно было использовать в отладочных процедурах, помеченных как noSideEffect. Исходный код Изменить
proc getTypeInfo[T](x: T): pointer {...}{.magic: "GetTypeInfo", gcsafe, locks: 0.}

Получить информацию о типе для x.

Обычный код не должен использовать это, а вместо этого — модуль typeinfo.

Исходный код Изменить
proc abs(x: int): int {...}{.magic: "AbsI", noSideEffect, raises: [], tags: [].}
Исходный код Изменить
proc abs(x: int8): int8 {...}{.magic: "AbsI", noSideEffect, raises: [], tags: [].}
Исходный код Изменить
proc abs(x: int16): int16 {...}{.magic: "AbsI", noSideEffect, raises: [], tags: [].}
Исходный код Изменить
proc abs(x: int32): int32 {...}{.magic: "AbsI", noSideEffect, raises: [], tags: [].}
Исходный код Изменить
proc abs(x: int64): int64 {...}{.magic: "AbsI", noSideEffect, raises: [], tags: [].}

Возвращает абсолютное значение x.

Если x равно low(x) (то есть -MININT для своего типа), генерируется исключение переполнения (если проверка на переполнение включена).

Исходный код Изменить
proc zeroMem(p: pointer; size: Natural) {...}{.inline, noSideEffect, tags: [],
    locks: 0, raises: [].}

Перезаписывает содержимое памяти по адресу p значением 0.

Будет перезаписано ровно size байт. Как любая процедура, работающая с сырой памятью, эта операция является небезопасной.

Исходный код Изменить
proc copyMem(dest, source: pointer; size: Natural) {...}{.inline, gcsafe, locks: 0,
    tags: [], locks: 0, raises: [].}
Копирует содержимое из памяти по адресу source в память по адресу dest. Будет скопировано ровно size байт. Области памяти не должны перекрываться. Как любая процедура, работающая с сырой памятью, эта операция является небезопасной. Исходный код Изменить
proc moveMem(dest, source: pointer; size: Natural) {...}{.inline, gcsafe, locks: 0,
    tags: [], locks: 0, raises: [].}

Копирует содержимое из памяти по адресу source в память по адресу dest.

Будет скопировано ровно size байт. Области памяти могут перекрываться, moveMem обрабатывает этот случай должным образом, и, таким образом, немного безопаснее, чем copyMem. Тем не менее, как любая процедура, работающая с сырой памятью, эта операция всё ещё является небезопасной.

Исходный код Изменить
proc equalMem(a, b: pointer; size: Natural): bool {...}{.inline, noSideEffect,
    tags: [], locks: 0, raises: [].}

Сравнивает блоки памяти a и b. Будет сравнено size байт.

Если блоки равны, возвращается true, в противном случае false. Как любая процедура, работающая с сырой памятью, эта операция является небезопасной.

Исходный код Изменить
proc cmp(x, y: string): int {...}{.noSideEffect, raises: [], tags: [].}

Процедура сравнения для строк. Более эффективна, чем общая версия.

Примечание: точные значения результатов зависят от используемой библиотеки C-времени выполнения и могут отличаться в разных операционных системах!

Исходный код Изменить
proc cstringArrayToSeq(a: cstringArray; len: Natural): seq[string] {...}{.raises: [],
    tags: [].}
Преобразует cstringArray в seq[string] . a должна иметь длину len. Исходный код Изменить
proc cstringArrayToSeq(a: cstringArray): seq[string] {...}{.raises: [], tags: [].}
Преобразует cstringArray в seq[string] . a должна быть завершена nil. Исходный код Изменить
proc allocCStringArray(a: openArray[string]): cstringArray {...}{.raises: [],
    tags: [].}
Создаёт массив cstring с нулевым завершением из a. Результат нужно освободить с помощью deallocCStringArray после того, как он больше не нужен. Исходный код Изменить
proc deallocCStringArray(a: cstringArray) {...}{.raises: [], tags: [].}
Освобождает массив cstring с нулевым завершением. Исходный код Изменить
proc setControlCHook(hook: proc () {...}{.noconv.}) {...}{.raises: [], tags: [].}
Позволяет переопределить поведение приложения при нажатии CTRL+C. Поддерживается только один такой обработчик. Исходный код Изменить
proc unsetControlCHook() {...}{.raises: [], tags: [RootEffect, WriteIOEffect].}
Отменяет вызов setControlCHook. Исходный код Изменить
proc getStackTrace(): string {...}{.gcsafe, raises: [], tags: [].}
Получает текущий стек отслеживания. Это работает только для отладочных сборок. Исходный код Изменить
proc getStackTrace(e: ref Exception): string {...}{.gcsafe, raises: [], tags: [].}
Получает стек отслеживания, связанный с e, который является стеком, приведшим к заявлению raise. Это работает только для отладочных сборок. Исходный код Изменить
proc getFrameState(): FrameState {...}{.compilerproc, inline, raises: [], tags: [].}
Исходный код Изменить
proc setFrameState(state: FrameState) {...}{.compilerproc, inline, raises: [],
                                        tags: [].}
Исходный код Изменить
proc getFrame(): PFrame {...}{.compilerproc, inline, raises: [], tags: [].}
Исходный код Изменить
proc setFrame(s: PFrame) {...}{.compilerproc, inline, raises: [], tags: [].}
Исходный код Изменить
proc getGcFrame(): GcFrame {...}{.compilerproc, inline, raises: [], tags: [].}
Исходный код Изменить
proc popGcFrame() {...}{.compilerproc, inline, raises: [], tags: [].}
Исходный код Изменить
proc setGcFrame(s: GcFrame) {...}{.compilerproc, inline, raises: [], tags: [].}
Исходный код Изменить
proc pushGcFrame(s: GcFrame) {...}{.compilerproc, inline, raises: [], tags: [].}
Источник Изменить
proc stackTraceAvailable(): bool {...}{.raises: [], tags: [].}
Источник Изменить
proc writeStackTrace() {...}{.tags: [], gcsafe, raises: [].}
Выводит текущий стек отслеживания ошибок в stderr. Это работает только для отладочных сборок. Поскольку это обычно используется для отладки, считается, что это не имеет побочных эффектов ввода-вывода! Источник Изменить
proc getStackTraceEntries(e: ref Exception): seq[StackTraceEntry] {...}{.raises: [],
    tags: [].}
Возвращает прикреплённый стек отслеживания ошибок к исключению e в виде seq. Это пока недоступно для JS-бекенда. Источник Изменить
proc getStackTraceEntries(): seq[StackTraceEntry] {...}{.raises: [], tags: [].}
Возвращает записи стека отслеживания ошибок для текущего стека отслеживания. Это пока недоступно для JS-бекенда. Источник Изменить
proc iterToProc(iter: typed; envType: typedesc; procName: untyped) {...}{.
    magic: "Plugin", compileTime.}
Источник Изменить
proc allocImpl(size: Natural): pointer {...}{.noconv, gcsafe, tags: [], gcsafe,
    locks: 0, raises: [].}
Источник Изменить
proc alloc0Impl(size: Natural): pointer {...}{.noconv, gcsafe, tags: [], gcsafe,
    locks: 0, raises: [].}
Источник Изменить
proc deallocImpl(p: pointer) {...}{.noconv, gcsafe, tags: [], gcsafe, locks: 0,
                               raises: [].}
Источник Изменить
proc reallocImpl(p: pointer; newSize: Natural): pointer {...}{.noconv, gcsafe,
    tags: [], gcsafe, locks: 0, raises: [].}
Источник Изменить
proc realloc0Impl(p: pointer; oldSize, newSize: Natural): pointer {...}{.noconv,
    gcsafe, tags: [], gcsafe, locks: 0, raises: [].}
Источник Изменить
proc getFreeMem(): int {...}{.gcsafe, raises: [], tags: [].}
Возвращает количество байтов, принадлежащих процессу, но не содержащих значимых данных. Источник Изменить
proc getTotalMem(): int {...}{.gcsafe, raises: [], tags: [].}
Возвращает количество байтов, принадлежащих процессу. Источник Изменить
proc getOccupiedMem(): int {...}{.gcsafe, raises: [], tags: [].}
Возвращает количество байтов, принадлежащих процессу и содержащих данные. Источник Изменить
proc getMaxMem(): int {...}{.raises: [], tags: [].}
Источник Изменить
proc allocSharedImpl(size: Natural): pointer {...}{.noconv, compilerproc, gcsafe,
    gcsafe, locks: 0, raises: [], tags: [].}
Источник Изменить
proc allocShared0Impl(size: Natural): pointer {...}{.noconv, gcsafe, gcsafe,
    locks: 0, raises: [], tags: [].}
Источник Изменить
proc deallocSharedImpl(p: pointer) {...}{.noconv, gcsafe, gcsafe, locks: 0,
                                     raises: [], tags: [].}
Источник Изменить
proc reallocSharedImpl(p: pointer; newSize: Natural): pointer {...}{.noconv, gcsafe,
    tags: [], gcsafe, locks: 0, raises: [].}
Источник Изменить
proc reallocShared0Impl(p: pointer; oldSize, newSize: Natural): pointer {...}{.
    noconv, gcsafe, tags: [], gcsafe, locks: 0, raises: [].}
Источник Изменить
proc protect(x: pointer): ForeignCell {...}{.raises: [], tags: [].}
Источник Изменить
proc dispose(x: ForeignCell) {...}{.raises: [], tags: [].}
Источник Изменить
proc isNotForeign(x: ForeignCell): bool {...}{.raises: [], tags: [].}
возвращает true, если 'x' принадлежит вызывающей нити. Тогда не нужно выполнять глубокое копирование. Источник Изменить
proc setupForeignThreadGc() {...}{.gcsafe, raises: [], tags: [].}
Вызовите эту функцию, если вы зарегистрировали обратный вызов, который будет выполнен из потока, не находящегося под вашим контролем. Эта функция имеет защитный механизм на уровне потока, поэтому сборщик мусора для этого потока будет инициализирован только один раз на поток, независимо от того, как часто она вызывается.

Эта функция доступна только при включенных ключах --threads:on и --tlsEmulation:off

Источник Изменить
proc tearDownForeignThreadGc() {...}{.gcsafe, raises: [], tags: [].}
Вызовите эту функцию, чтобы разрушить сборщик мусора, ранее инициализированный setupForeignThreadGc. Если сборщик мусора не был ранее инициализирован или уже был разрушен, вызов ничего не сделает.

Эта функция доступна только при включенных ключах --threads:on и --tlsEmulation:off

Источник Изменить
proc nimGC_setStackBottom(theStackBottom: pointer) {...}{.compilerproc, noinline,
    gcsafe, locks: 0, raises: [], tags: [].}
Расширяет диапазон стека операционной системы для сборки мусора до theStackBottom. Ничего не делает, если текущий нижний предел стека уже ниже theStackBottom. Источник Изменить
proc deallocHeap(runFinalizers = true; allowGcAfterwards = true) {...}{.
    raises: [Exception], tags: [RootEffect].}
Освобождает локальный кусок памяти потока. Выполняет все финализаторы, если runFinalizers равно true. Если allowGcAfterwards равно true, происходит минимальное выделение памяти, чтобы гарантировать, что сборщик мусора может продолжать работать после вызова deallocHeap. Источник Изменить
proc gcInvariant() {...}{.raises: [], tags: [].}
Источник Изменить
proc GC_collectZct() {...}{.raises: [Exception], tags: [RootEffect].}
Собрать ZCT (нулевой счётчик таблицы). Нестабильный, экспериментальный API для тестирования. НЕ ИСПОЛЬЗОВАТЬ! Источник Изменить
proc GC_disable() {...}{.gcsafe, inline, gcsafe, locks: 0, raises: [], tags: [].}

Отключает сборщик мусора. Если вызвана n раз, необходимо n вызовов GC_enable, чтобы активировать сборщик мусора снова.

Обратите внимание, что в большинстве случаев следует отключать только фазу маркировки и очистки с помощью GC_disableMarkAndSweep.

Источник Изменить
proc GC_enable() {...}{.gcsafe, inline, gcsafe, locks: 0, raises: [], tags: [].}
Включает сборщик мусора снова. Источник Изменить
proc GC_enableMarkAndSweep() {...}{.gcsafe, gcsafe, locks: 0, raises: [], tags: [].}
Источник Изменить
proc GC_disableMarkAndSweep() {...}{.gcsafe, gcsafe, locks: 0, raises: [], tags: [].}
Текущая реализация использует сборщик мусора со счётом ссылок и фазой маркировки и очистки, которая запускается редко, чтобы освободить циклы. Фаза маркировки и очистки может занимать много времени и не нужна, если приложение не создаёт циклы. Таким образом, фаза маркировки и очистки может быть отключена и включена отдельно от остальной части сборщика мусора. Источник Изменить
proc GC_fullCollect() {...}{.gcsafe, gcsafe, locks: 0, raises: [Exception],
                        tags: [RootEffect].}
Вынуждает выполнение полного прохода сборщика мусора. Обычному коду нет необходимости вызывать эту функцию (и не следует). Источник Изменить
proc GC_getStatistics(): string {...}{.gcsafe, gcsafe, locks: 0, raises: [], tags: [].}
Возвращает информационную строку об активности сборщика мусора. Это может быть полезно для настройки. Исходный код Изменить
proc addInt(result: var string; x: int64) {...}{.raises: [], tags: [].}
Преобразует целое число в его строковое представление и добавляет его к result.
var
  a = "123"
  b = 45
a.addInt(b) # a <- "12345"
Исходный код Изменить
proc addFloat(result: var string; x: float) {...}{.raises: [], tags: [].}
Преобразует число с плавающей точкой в его строковое представление и добавляет его к result.
var
  a = "123"
  b = 45.67
a.addFloat(b) # a <- "12345.67"
Исходный код Изменить
proc getCurrentException(): ref Exception {...}{.compilerproc, inline, gcsafe,
    locks: 0, raises: [], tags: [].}
Возвращает текущее исключение; если его нет, возвращается nil. Исходный код Изменить
proc getCurrentExceptionMsg(): string {...}{.inline, gcsafe, locks: 0, raises: [],
                                        tags: [].}
Возвращает сообщение об ошибке, прикрепленное к текущему исключению; если его нет, возвращается "". Исходный код Изменить
proc setCurrentException(exc: ref Exception) {...}{.inline, gcsafe, locks: 0,
    raises: [], tags: [].}

Устанавливает текущее исключение.

Предупреждение: Используйте только в том случае, если вы понимаете, что делаете.

Исходный код Изменить
proc rawProc[T: proc](x: T): pointer {...}{.noSideEffect, inline.}
Возвращает сырой указатель на процедуру замыкания x. Это полезно для взаимодействия замыканий с C. Исходный код Изменить
proc rawEnv[T: proc](x: T): pointer {...}{.noSideEffect, inline.}
Возвращает сырой указатель на среду замыкания x. Это полезно для взаимодействия замыканий с C. Исходный код Изменить
proc finished[T: proc](x: T): bool {...}{.noSideEffect, inline.}
Может использоваться для определения завершения итератора первого класса. Исходный код Изменить
proc quit(errormsg: string; errorcode = QuitFailure) {...}{.noreturn, raises: [],
    tags: [].}
Краткая запись для echo(errormsg); quit(errorcode). Исходный код Изменить
proc `/`(x, y: int): float {...}{.inline, noSideEffect, raises: [], tags: [].}

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

См. также:

  • div
  • mod
echo 7 / 5 # => 1.4
Исходный код Изменить
proc `[]`[T, U](s: string; x: HSlice[T, U]): string {...}{.inline.}
Операция среза для строк. Возвращает включающий диапазон [s[x.a], s[x.b]]:
var s = "abcdef"
assert s[1..3] == "bcd"
Исходный код Изменить
proc `[]=`[T, U](s: var string; x: HSlice[T, U]; b: string)

Присваивание среза для строк.

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

Пример:

var s = "abcdefgh"
s[1 .. ^2] = "xyz"
assert s == "axyzh"
Исходный код Изменить
proc `[]`[Idx, T, U, V](a: array[Idx, T]; x: HSlice[U, V]): seq[T]
Операция среза для массивов. Возвращает включающий диапазон [a[x.a], a[x.b]]:
var a = [1, 2, 3, 4]
assert a[0..2] == @[1, 2, 3]
Исходный код Изменить
proc `[]=`[Idx, T, U, V](a: var array[Idx, T]; x: HSlice[U, V]; b: openArray[T])
Присваивание среза для массивов.
var a = [10, 20, 30, 40, 50]
a[1..2] = @[99, 88]
assert a == [10, 99, 88, 40, 50]
Исходный код Изменить
proc `[]`[T, U, V](s: openArray[T]; x: HSlice[U, V]): seq[T]
Операция среза для последовательностей. Возвращает включающий диапазон [s[x.a], s[x.b]]:
var s = @[1, 2, 3, 4]
assert s[0..2] == @[1, 2, 3]
Исходный код Изменить
proc `[]=`[T, U, V](s: var seq[T]; x: HSlice[U, V]; b: openArray[T])

Присваивание среза для последовательностей.

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

Пример:

var s = @"abcdefgh"
s[1 .. ^2] = @"xyz"
assert s == @"axyzh"
Исходный код Изменить
proc `[]`[T](s: openArray[T]; i: BackwardsIndex): T {...}{.inline.}
Исходный код Изменить
proc `[]`[Idx, T](a: array[Idx, T]; i: BackwardsIndex): T {...}{.inline.}
Исходный код Изменить
proc `[]`(s: string; i: BackwardsIndex): char {...}{.inline, raises: [], tags: [].}
Исходный код Изменить
proc `[]`[T](s: var openArray[T]; i: BackwardsIndex): var T {...}{.inline.}
Исходный код Изменить
proc `[]`[Idx, T](a: var array[Idx, T]; i: BackwardsIndex): var T {...}{.inline.}
Исходный код Изменить
proc `[]=`[T](s: var openArray[T]; i: BackwardsIndex; x: T) {...}{.inline.}
Исходный код Изменить
proc `[]=`[Idx, T](a: var array[Idx, T]; i: BackwardsIndex; x: T) {...}{.inline.}
Исходный код Изменить
proc `[]=`(s: var string; i: BackwardsIndex; x: char) {...}{.inline, raises: [],
    tags: [].}
Исходный код Изменить
proc slurp(filename: string): string {...}{.magic: "Slurp".}
Это псевдоним для staticRead. Исходный код Изменить
proc staticRead(filename: string): string {...}{.magic: "Slurp".}

Процедура readFile времени компиляции для удобного встраивания ресурсов:

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

const myResource = staticRead"mydatafile.bin"

slurp — это псевдоним для staticRead.

Исходный код Изменить
proc gorge(command: string; input = ""; cache = ""): string {...}{.
    magic: "StaticExec", raises: [], tags: [].}
Это псевдоним для staticExec. Исходный код Изменить
proc staticExec(command: string; input = ""; cache = ""): string {...}{.
    magic: "StaticExec", raises: [], tags: [].}

Выполняет внешнюю программу во время компиляции и возвращает текстовый вывод (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 gorgeEx(command: string; input = ""; cache = ""): tuple[output: string,
    exitCode: int] {...}{.raises: [], tags: [].}
Аналогично gorge, но также возвращает код завершения. Исходный код Изменить
proc `+=`[T: float | float32 | float64](x: var T; y: T) {...}{.inline, noSideEffect.}
Увеличивает число с плавающей точкой на месте. Исходный код Изменить
proc `-=`[T: float | float32 | float64](x: var T; y: T) {...}{.inline, noSideEffect.}
Уменьшает значение числа с плавающей точкой на месте. Источник Изменить
proc `*=`[T: float | float32 | float64](x: var T; y: T) {...}{.inline, noSideEffect.}
Умножает число с плавающей точкой на месте. Источник Изменить
proc `/=`(x: var float64; y: float64) {...}{.inline, noSideEffect, raises: [],
                                        tags: [].}
Делит число с плавающей точкой на месте. Источник Изменить
proc `/=`[T: float | float32](x: var T; y: T) {...}{.inline, noSideEffect.}
Делит число с плавающей точкой на месте. Источник Изменить
proc `&=`(x: var string; y: string) {...}{.magic: "AppendStrStr", noSideEffect.}
Добавляет строку на месте.
var a = "abc"
a &= "de" # a <- "abcde"
Источник Изменить
proc shallow[T](s: var seq[T]) {...}{.noSideEffect, inline.}

Помечает последовательность s как поверхностная. Последующие присваивания не будут выполнять глубокие копии s.

Это полезно только для оптимизации.

Источник Изменить
proc shallow(s: var string) {...}{.noSideEffect, inline, raises: [], tags: [].}

Помечает строку s как поверхностная. Последующие присваивания не будут выполнять глубокие копии s.

Это полезно только для оптимизации.

Источник Изменить
proc insert(x: var string; item: string; i = 0.Natural) {...}{.noSideEffect,
    raises: [], tags: [].}
Вставляет item в x на позиции i.
var a = "abc"
a.insert("zz", 0) # a <- "zzabc"
Источник Изменить
proc addEscapedChar(s: var string; c: char) {...}{.noSideEffect, inline, raises: [],
    tags: [].}
Добавляет символ в строку s и применяет следующие экранирования:
  • заменяет все \ на \\
  • заменяет все ' на \'
  • заменяет все " на \"
  • заменяет все \a на \\a
  • заменяет все \b на \\b
  • заменяет все \t на \\t
  • заменяет все \n на \\n
  • заменяет все \v на \\v
  • заменяет все \f на \\f
  • заменяет все \c на \\c
  • заменяет все \e на \\e
  • заменяет любой другой символ, не входящий в набор {'\21..'\126'} by ``\xHH где HH - его шестнадцатеричное значение.

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

Примечание: Это неверно для создания кода Ansi C!

Источник Изменить
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 locals(): RootObj {...}{.magic: "Plugin", noSideEffect, raises: [], tags: [].}

Генерирует выражение конструктора кортежа, перечисляя все локальные переменные в текущем области видимости.

Это довольно быстро, так как не полагается на информацию о отладке или выполнении. Обратите внимание, что в отличие от того, что говорит официальная подпись, возвращаемый тип не 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 deepCopy[T](x: var T; y: T) {...}{.noSideEffect, magic: "DeepCopy".}

Выполняет глубокую копию y и копирует ее в x.

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

Для --gc:arc или --gc:orc поддержка deep copy должна быть включена через --deepcopy:on.

Источник Изменить
proc deepCopy[T](y: T): T
Обёртка для перегрузки deepCopy. Источник Изменить
proc procCall(x: untyped) {...}{.magic: "ProcCall", compileTime, raises: [], tags: [].}
Специальная магия, чтобы запретить динамическое связывание для вызовов метода. Это похоже на super в обычных языках ООП.
# 'someMethod' will be resolved fully statically:
procCall someMethod(a, b)
Источник Изменить
proc `==`(x, y: cstring): bool {...}{.magic: "EqCString", noSideEffect, inline,
                                 raises: [], tags: [].}
Проверяет равенство между двумя переменными cstring. Источник Изменить
proc `==`(x: string; y: type(nil) | type(nil)): bool {...}{.error: "\'nil\' is now invalid for \'string\'; compile with --nilseqs:on for a migration period".}
Источник Изменить
proc `==`(x: type(nil) | type(nil); y: string): bool {...}{.error: "\'nil\' is now invalid for \'string\'; compile with --nilseqs:on for a migration period".}
Источник Изменить
proc substr(s: string; first, last: int): string {...}{.raises: [], tags: [].}

Копирует срез 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 substr(s: string; first = 0): string {...}{.raises: [], tags: [].}
Источник Изменить
proc toOpenArray[T](x: ptr UncheckedArray[T]; first, last: int): openArray[T] {...}{.
    magic: "Slice".}
Источник Изменить
proc toOpenArray(x: cstring; first, last: int): openArray[char] {...}{.magic: "Slice".}
Источник Изменить
proc toOpenArrayByte(x: cstring; first, last: int): openArray[byte] {...}{.
    magic: "Slice".}
Источник Изменить
proc toOpenArray[T](x: seq[T]; first, last: int): openArray[T] {...}{.magic: "Slice".}
Источник Изменить
proc toOpenArray[T](x: openArray[T]; first, last: int): openArray[T] {...}{.
    magic: "Slice".}
Источник Изменить
proc toOpenArray[I, T](x: array[I, T]; first, last: I): openArray[T] {...}{.
    magic: "Slice".}
Источник Изменить
proc toOpenArray(x: string; first, last: int): openArray[char] {...}{.magic: "Slice".}
Источник Изменить
proc toOpenArrayByte(x: string; first, last: int): openArray[byte] {...}{.
    magic: "Slice".}
Источник Изменить
proc toOpenArrayByte(x: openArray[char]; first, last: int): openArray[byte] {...}{.
    magic: "Slice".}
Источник Изменить
proc toOpenArrayByte(x: seq[char]; first, last: int): openArray[byte] {...}{.
    magic: "Slice".}
END_OF_DOCUMENT_MARKER
Исходный код Редактировать

Итераторы

iterator countdown[T](a, b: T; step: Positive = 1): T {...}{.inline.}

Счёт от порядкового значения a вниз до b (включительно) с заданным шагом.

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

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

for i in countdown(7, 3):
  echo i # => 7; 6; 5; 4; 3

for i in countdown(9, 2, 3):
  echo i # => 9; 6; 3
Исходный код Редактировать
iterator countup[T](a, b: T; step: Positive = 1): T {...}{.inline.}

Счёт от порядкового значения a до b (включительно) с заданным шагом.

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

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

for i in countup(3, 7):
  echo i # => 3; 4; 5; 6; 7

for i in countup(2, 9, 3):
  echo i # => 2; 5; 8
Исходный код Редактировать
iterator `..`[T](a, b: T): T {...}{.inline.}

Псевдоним для countup(a, b, 1).

См. также:

  • ..<
for i in 3 .. 7:
  echo i # => 3; 4; 5; 6; 7
Исходный код Редактировать
iterator `..`(a, b: int64): int64 {...}{.inline, raises: [], tags: [].}

Специализированная версия типа .. для удобства, чтобы смешивание целочисленных типов работало лучше.

См. также:

  • ..<
Исходный код Редактировать
iterator `..`(a, b: int32): int32 {...}{.inline, raises: [], tags: [].}

Специализированная версия типа .. для удобства, чтобы смешивание целочисленных типов работало лучше.

См. также:

  • ..<
Исходный код Редактировать
iterator `..`(a, b: uint64): uint64 {...}{.inline, raises: [], tags: [].}

Специализированная версия типа .. для удобства, чтобы смешивание целочисленных типов работало лучше.

См. также:

  • ..<
Исходный код Редактировать
iterator `..`(a, b: uint32): uint32 {...}{.inline, raises: [], tags: [].}

Специализированная версия типа .. для удобства, чтобы смешивание целочисленных типов работало лучше.

См. также:

  • ..<
Исходный код Редактировать
iterator `..<`[T](a, b: T): T {...}{.inline.}
Исходный код Редактировать
iterator `..<`(a, b: int64): int64 {...}{.inline, raises: [], tags: [].}
Специализированная версия типа ..< для удобства, чтобы смешивание целочисленных типов работало лучше. Исходный код Редактировать
iterator `..<`(a, b: int32): int32 {...}{.inline, raises: [], tags: [].}
Специализированная версия типа ..< для удобства, чтобы смешивание целочисленных типов работало лучше. Исходный код Редактировать
iterator `||`[S, T](a: S; b: T; step: Positive;
                    annotation: static string = "parallel for"): T {...}{.inline,
    magic: "OmpParFor", sideEffect.}

Итератор параллельного цикла OpenMP. Такой же, как countup, но цикл может выполняться параллельно.

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.}

Итератор параллельного цикла OpenMP с шагом. Такой же, как countup, но цикл может выполняться параллельно.

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

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

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

Макросы

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

Шаблоны

template `!=`(x, y: untyped): untyped
Оператор неравенства. Это сокращённая запись для not (x == y). Исходный код Изменить
template `>=`(x, y: untyped): untyped
Оператор "больше или равно". Это то же самое, что и y <= x. Исходный код Изменить
template `>`(x, y: untyped): untyped
Оператор "больше". Это то же самое, что и y < x. Исходный код Изменить
template `>=%`(x, y: untyped): untyped
Обрабатывает x и y как беззнаковые и сравнивает их. Возвращает true, если unsigned(x) >= unsigned(y). Исходный код Изменить
template `>%`(x, y: untyped): untyped
Обрабатывает x и y как беззнаковые и сравнивает их. Возвращает true, если unsigned(x) > unsigned(y). Исходный код Изменить
template offsetOf[T; ](t: typedesc[T]; member: untyped): int
Исходный код Изменить
template offsetOf[T](value: T; member: untyped): int
Исходный код Изменить
template incl[T](x: var set[T]; y: set[T])
Включает множество y в множество x.
var a = {1, 3, 5, 7}
var b = {4, 5, 6}
a.incl(b)  # a <- {1, 3, 4, 5, 6, 7}
Исходный код Изменить
template excl[T](x: var set[T]; y: set[T])
Исключает множество y из множества x.
var a = {1, 3, 5, 7}
var b = {3, 4, 5}
a.excl(b)  # a <- {1, 7}
Исходный код Изменить
template `in`(x, y: untyped): untyped {...}{.dirty.}
Синоним для contains.
assert(1 in (1..3) == true)
assert(5 in (1..3) == false)
Исходный код Изменить
template `notin`(x, y: untyped): untyped {...}{.dirty.}
Синоним для not contains.
assert(1 notin (1..3) == false)
assert(5 notin (1..3) == true)
Исходный код Изменить
template `isnot`(x, y: untyped): untyped
Отрицание is. Эквивалентно not(x is y).
assert 42 isnot float
assert @[1, 2] isnot enum
Исходный код Изменить
template unown(x: typed): untyped
Исходный код Изменить
template `<//>`(t: untyped): untyped
Исходный код Изменить
template disarm(x: typed)
Полезно для disarming висячих указателей явно для
--newruntime. Независимо от того, используется ли --newruntime или нет

Это устанавливает указатель или обратный вызов x в nil. Это экспериментальный API!

Исходный код Изменить
template dumpAllocstats(code: untyped)
Исходный код Изменить
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 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 allocShared(size: Natural): pointer

Выделяет новый блок памяти в общей куче объёмом не менее size байт.

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

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

См. также: allocShared0.

Исходный код Изменить
template allocShared0(size: Natural): pointer

Выделяет новый блок памяти в общей куче объёмом не менее size байт.

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

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

Исходный код Изменить
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 newException(exceptn: typedesc; message: string;
                      parentException: ref Exception = nil): untyped
Создаёт объект исключения типа exceptn и устанавливает его поле msg в message. Возвращает новый объект исключения. Исходный код Редактировать
template likely(val: bool): bool

Подсказывает оптимизатору, что val, вероятно, будет истинным.

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

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

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

Исходный код Редактировать
template unlikely(val: bool): bool

Подсказывает оптимизатору, что val, вероятно, будет ложным.

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

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

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

Исходный код Редактировать
template formatErrorIndexBound[T](i, a, b: T): string
Исходный код Редактировать
template formatErrorIndexBound[T](i, n: T): string
Исходный код Редактировать
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 `..^`(a, b: untyped): untyped
Сокращение для .. ^, чтобы избежать распространённой проблемы, требующей пробела между '..' и '^'. Исходный код Редактировать
template `..<`(a, b: untyped): untyped
Сокращение для a .. pred(b).
for i in 5 ..< 9:
  echo i # => 5; 6; 7; 8
Исходный код Редактировать
template `[]`(s: string; i: int): char
Исходный код Редактировать
template `[]=`(s: string; i: int; val: char)
Исходный код Редактировать
template `&=`(x, y: typed)

Общий оператор "слива" для Nim.

Для файлов это псевдоним для write. Если не специализирован дальше, то псевдоним для add.

Исходный код Редактировать
template currentSourcePath(): string

Возвращает полный путь к файловой системе текущего источника.

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

Возвращаемый путь устанавливается во время компиляции.

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

См. также:

  • getCurrentDir proc
Исходный код Редактировать
template rangeCheck(cond)
Помощник для выполнения пользовательских проверок диапазона. Такие проверки будут выполняться только при включённом флаге компиляции rangechecks. Исходный код Редактировать
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 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)
Исходный код Редактировать

Экспорт

doAssertRaises, raiseAssert, failedAssertImpl, doAssert, assert, onFailedAssert, items, mpairs, items, fieldPairs, items, pairs, fieldPairs, mitems, fields, mpairs, pairs, mitems, items, items, fields, mitems, items, mpairs, mpairs, items, mpairs, pairs, pairs, items, mitems, items, pairs, mitems, $, $, $, $, $, $, $, $, $, $, $, $, $, $, $, $, len, $, newWideCString, Utf16Char, WideCStringObj, $, newWideCString, WideCString, newWideCString, writeFile, write, File, write, writeChars, endOfFile, getFilePos, readChars, readLines, write, readLine, open, reopen, readChar, writeBuffer, stdmsg, getFileHandle, close, write, getOsFileHandle, readFile, setFilePos, write, setStdIoUnbuffered, writeFile, lines, stdout, readLines, getFileSize, FileHandle, write, write, readBytes, writeLine, write, setInheritable, readLine, open, flushFile, readAll, FileMode, write, readBuffer, stderr, stdin, open, writeBytes, lines

© 2006–2021 Andreas Rumpf
Licensed under the MIT License.
https://nim-lang.org/docs/system.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API