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должен быть идентификатором или квалифицированным идентификатором.См. также:
Это можно использовать для проверки наличия определённой функции в библиотеке:
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оператор для получения адреса области памяти. Не перегружается.См. также:
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)`.".}-
Возвращает наибольшее возможное значение порядкового значения
x.В качестве специального семантического правила,
xможет также быть идентификатором типа.Эта процедура устарела, используйте эту вместо неё:
high(2) # => 9223372036854775807
Исходный код Редактировать proc high[T: Ordinal | enum | range](x: typedesc[T]): T {...}{.magic: "High", noSideEffect.}-
Возвращает наибольшее возможное значение порядкового или перечислимого типа.
high(int)— способ написания INT_MAX или MAX_INT в Ниме.См. также:
high(int) # => 9223372036854775807
Исходный код Редактировать proc high[T](x: openArray[T]): int {...}{.magic: "High", noSideEffect.}-
Возвращает наибольший возможный индекс последовательности
x.См. также:
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.См. также:
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.}
-
Возвращает максимальный возможный индекс типа массива.
См. также:
high(array[7, int]) # => 6
Исходный код Редактировать proc high(x: cstring): int {...}{.magic: "High", noSideEffect.}-
Возвращает максимальный возможный индекс совместимой строки
x. Иногда это операция O(n).См. также:
Исходный код Редактировать proc high(x: string): int {...}{.magic: "High", noSideEffect.}-
Возвращает максимальный возможный индекс строки
x.См. также:
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)`.".}-
Возвращает наименьшее возможное значение порядкового значения
x. В качестве специального семантического правила,xтакже может быть идентификатором типа.Эта процедура устарела, используйте вместо неё эту:
low(2) # => -9223372036854775808
Исходный код Редактировать proc low[T: Ordinal | enum | range](x: typedesc[T]): T {...}{.magic: "Low", noSideEffect.}-
Возвращает наименьшее возможное значение порядкового или перечисления типа.
low(int)— это способ записи INT_MIN или MIN_INT в Nim.См. также:
low(int) # => -9223372036854775808
Исходный код Редактировать proc low[T](x: openArray[T]): int {...}{.magic: "Low", noSideEffect.}-
Возвращает наименьший возможный индекс последовательности
x.См. также:
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.См. также:
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.}-
Возвращает наименьший возможный индекс типа массива.
См. также:
low(array[7, int]) # => 0
Исходный код Редактировать proc low(x: cstring): int {...}{.magic: "Low", noSideEffect.}-
Возвращает наименьший возможный индекс совместимой строки
x.См. также:
Исходный код Редактировать proc low(x: string): int {...}{.magic: "Low", noSideEffect.}-
Возвращает наименьший возможный индекс строки
x.См. также:
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 rightxи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 leftxи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не является оператором, поэтому используйте обычную синтаксис вызова функции для него.См. также:
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: [].}
-
Обрабатывает
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. Это следует использовать только в оптимизационных целях, когда вы знаете, что делаете!См. также:
Исходный код Редактировать 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.Обратите внимание, что последовательность будет заполнена нулевыми значениями. После создания последовательности необходимо присваивать элементы, а не добавлять их.
См. также:
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.bassert((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".}
-
Добавляет/регистрирует процедуру завершения.
Каждый вызов
Исходный код Редактировать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 для выделения из общей кучи.
См. также:
Исходный код Редактировать 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).
Блок не инициализируется, поэтому чтение из него до записи является неопределённым поведением!
См. также:
Исходный код Редактировать 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.
См. также:
Исходный код Редактировать
proc isNil[T](x: ref T): bool {...}{.noSideEffect, magic: "IsNil".}- Исходный код Изменить
proc isNil(x: string): bool {...}{.noSideEffect, magic: "IsNil", error.}-
Требуется
--nilseqs:on.См. также:
Исходный код Изменить 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.}-
Конкатенирует две последовательности.
Требует копирования последовательностей.
См. также:
assert(@[1, 2, 3, 4] & @[5, 6] == @[1, 2, 3, 4, 5, 6])
Исходный код Изменить proc `&`[T](x: seq[T]; y: T): seq[T] {...}{.noSideEffect.}-
Добавляет элемент y в конец последовательности.
Требует копирования последовательности.
См. также:
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: [].}
- Добавляет
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: [].}-
Деление целых чисел, результатом которого является число с плавающей точкой.
См. также:
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".}
- Исходный код Редактировать
Итераторы
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 для выделения из общей кучи.
См. также:
Исходный код Изменить 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.См. также:
Исходный код Редактировать 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