Учебное пособие по языку Nim (Часть I)

• Автор: Andreas Rumpf
• Версия: 2.1.1
• Исходный перевод: Morthan
• Правки, обновление, порт на nimib: janAkali

Введение

"Der Mensch ist doch ein Augentier -- Schöne Dinge wünsch' ich mir."

(Цитата из песни «Morgenstern» группы «Rammstein». Примерный перевод: «Но человек – глазастый зверь. Мне нужно множество красивых вещей».)

Документ является учебником по языку программирования Nim.

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

Вот несколько других ресурсов для изучения Nim (на английском языке):

• Азы Nim - нежное введение в упомянутые выше концепции

• Выучи Nim за 5 минут - быстрое введение в Nim длительностью 5 минут

• Руководство по Nim - еще больше примеров продвинутых возможностей языка

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

Содержание:

1. Твоя первая программа
2. Лексические Элементы
   • Строковые и символьные литералы
   • Комментарии
   • Числа
3. Переменные var
4. Переменные let
5. Константы
6. Команда присваивания
7. Команды управления потоком
   • Команда if
   • Команда case
   • Команда while
   • Команда for
8. Области видимости и команда block
   • Команда break
   • Команда continue
   • Команда when
9. Команды и отступы
10. Процедуры
    • Переменная result
    • Параметры
    • Команда discard
    • Именованные аргументы
    • Значения по умолчанию
    • Перегруженные процедуры
    • Операторы
    • Предварительные объявления
11. Функции и методы
12. Итераторы
13. Базовые типы
    • Логические значения bool
    • Символы char
    • Строки string
    • Целые числа int
    • Числа с плавающей запятой float
    • Преобразование типов
14. Внутреннее представление типов
15. Дополнительные типы
    • Перечислениe enum
    • Перечислимые типы Ordinal
    • Диапазоны range
    • Множества set
    • Поля битов
    • Массив array
    • Последовательности seq
    • Открытые массивы openarray
    • Параметры с произвольным количеством аргументов varargs
    • Срезы Slice
    • Объекты object
    • Кортежи tuple
    • Ссылочные и указательные типы ref и ptr
    • Процедурный тип proc
    • Отличный тип distinct
16. Модули
    • Исключение символов except
    • Команда from
    • Команда include

Твоя первая программа

Начнём с интерактивной программы "Hello World":

# это коментарий
echo "Как тебя зовут? "
var name: string = readLine(stdin)
echo "Привет, ", name, "!"

Сохраните этот код в файл greetings.nim. Теперь скомпилируйте и запустите его:

$ nim compile --run greetings.nim

С ключом --run Nim автоматически выполняет файл после его компиляции. Вы можете передать аргументы командной строки вашей программе, добавив их после имени файла:

$ nim compile --run greetings.nim аргумент1 аргумент2

У часто используемых команд и ключей есть сокращения, так что вы можете написать один из этих вариантов:

$ nim c greetings.nim # компилирует и сохраняет программу в текущую папку
$ nim c -r greetings.nim # компилирует программу в текущую папку и запускает её

Eсли вам нужно запустить программу, но исполняемый файл не нужен (например, при запуске тестов и коротких скриптов) используйте:

$ nim r greetings.nim # компилирует программу в системную кеш папку и запускает её

Все доступные комманды, ключи и сокращения можно посмотреть в выводе комманды:

$ nim --fullhelp

По умолчанию, Nim компилирует код в режиме отладки (debug), чтобы собрать релизную версию - используйте ключ -d:release, который включает оптимизацию:

$ nim compile -d:release --run greetings.nim

Для бенчмаркинга и кода в продакшене используйте ключ -d:release. Для сравнения производительности с "небезопасными" языками, такими как C, используйте переключатель -d:danger, чтобы получить значимые, сопоставимые результаты. В противном случае, производительность Nim кода может быть ограничена проверками выполнения, которые даже не доступны для C.

Что делает наша программа, должно быть довольно очевидно, но я объясню синтаксис: команды, написанные без отступа, выполняются при старте программы. Nim группирует команды с помощью отступов. Отступы делаются только пробелами, табуляция не допускается.

Строковые литералы обрамляются двойными кавычками. Команда var объявляет новую переменную с именем name и типом string, после чего ей присваивается значение, которое вернула процедура readLine. Поскольку компилятор знает, что readLine возвращает строку, тип можно опустить (это называется локальным выведением типов). Поэтому следующий вариант также будет работать:

var name = readLine(stdin)

Обратите внимание – это почти единственная форма выведения типов, присутствующая в Nim: это хороший компромисс между краткостью и читаемостью.

Наша программа "hello world" содержит некоторые идентификаторы, которые уже известны компилятору: echo, readLine и т.д. Эти встроенные команды объявлены в модуле std/system, который неявно импортируется любым другим модулем. Команды из этого модуля всегда доступны.

Лексические Элементы

Рассмотрим лексические элементы Nim подробнее. Как и другие языки программирования, Nim состоит из литералов, идентификаторов, ключевых слов, комментариев, операторов и знаков пунктуации.

Строковые и символьные литералы

Строковые литералы заключаются в двойные кавычки "; символьные – в одинарные '. Специальные символы экранируются обратным слэшем \; \n означает перевод строки, \t – табуляцию и так далее.

Также бывают сырые (raw) строковые литералы:

r"C:\program files\nim"

В сырых литералах обратный слэш не является экранирующим символом.

Третий и последний способ записи строковых литералов, это длинные строковые литералы. Они обрамляются тройными кавычками: """...""", могут содержать перевод строки, и \ в них не является экранирующим символом. Они очень полезны, например, для включения в код HTML-фрагментов.

Комментарии

Комментарий может находиться где угодно за пределами строкового или символьного литерала и начинается с символа решётки #. Документирующие комментарии начинаются с ##:

# Комментарий.
var myVariable: int ## документирующий комментарий

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

Многострочные комментарии начинаются с #[ и завершаются ]#. Многострочные комментарии также могут быть вложенными:

##[ Многострочный документирующий комментарий ]##
#[
  Вы можете писать любой текст внутри этого блока
  без ограничений по отступам.
     yes("Можно ли задать бессмысленный вопрос?")
  #[
     Заметка: этот комментарий вложенный!
  ]#
]#
discard """Старый стиль комментариев, не рекомендуется использовать."""

Числа

Численные литералы пишутся так же, как и в большинстве других языков. Для повышения читабельности разрешается разделять разряды подчёркиваниями: 1_000_000 (один миллион).

Числа, содержащие точку (или e, или E) считаются литералами чисел с плавающей запятой: 1.0e9 (один миллиард).

Шестнадцатеричные литералы начинаются с префикса 0x, двоичные – с 0b, а восьмеричные – с 0o. Ведущий ноль без 'о' не превращает число в восьмеричное.

Переменные var

Команда var объявляет новую локальную или глобальную переменную:

var x, y: int # объявляет x и y, имеющие тип `int`

Переменные let

Команда let работает примерно как var, но объявляет переменные однократного присваивания: после инициализации их значение не может быть изменено:

let x = "abc" # вводит новую переменную `x` и присваивает ей значение
x = "xyz"     # не сработает: второе присваивание `x`

С помощью отступов после ключевого слова можно перечислить целую секцию переменных или констант:

let # также работают `var` и `const`
  x, y: int
  # здесь также может быть комментарий
  m, n, o: string

Константы

Константы - это символы, связанные со значением. Значение константы не может меняться. Выражение в объявлении константы обязано быть вычисляемым на этапе компиляции! :

var a = 5
const
  x = "abc" # константа x содержит строку "abc"
  b = 1
  c = b + 5 # результат вычисления известен на этапе компиляции
  d = a + 3 # не сработает: на этапе компиляции не возможно знать значение переменных

Различие между let и const следующее: let вводит переменную, которая не может быть переприсвоена, а const означает «принудительно вычислить во время компиляции и поместить результат в секцию данных»:

const input = readLine(stdin) # Ошибка: предполагается константное выражение
let input = readLine(stdin)   # а это сработает

Команда присваивания

Команда присваивания задает новое значение переменной или, в общем случае, месту хранения:

var x = "abc" # вводит новую переменную `x` и присваивает ей значение
x = "xyz"     # присваивает новое значение `x`

= - это оператор присваивания.

Оператор = нельзя перегрузить, перезаписать или запретить, но это может измениться в будущих версиях Nim.

В одном операторе присваивания можно объявить несколько переменных — все они получат одинаковое значение:

var x, y = 3 # присваивает переменным `x` и `y` значение 3
echo "x имеет значение ", x
echo "y имеет значение ", y
x = 42       # изменяет значение `x` на 42, не меняя `y`
echo "x имеет значение ", x
echo "y имеет значение ", y

x имеет значение 3
y имеет значение 3
x имеет значение 42
y имеет значение 3

Команды управления потоком

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

Но так работать могут лишь самые примитивные программы, более сложным нужны ещё циклы и ветвления.

Команда if

Команда if – один из способов организовать ветвление потока выполнения:

let name = readLine(stdin)
if name == "":
  echo "Бедняга, ты потерял своё имя?"
elif name == "имя":
  echo "Очень смешно, тебя зовут имя."
else:
  echo "Привет, ", name, "!"

Веток elif может быть ноль и более, ветка else не обязательна.

Ключевое слово elif является сокращением else if, чтобы не делать излишних отступов. ("" это пустая строка, она не содержит символов.)

Команда case

Другой способ ветвления реализуется командой case. Она разделяет поток выполнения на несколько веток:

let name = readLine(stdin)
case name
of "":
  echo "Бедняга, ты потерял своё имя?"
of "name":
  echo "Очень смешно, тебя зовут имя."
of "Dave", "Frank":
  echo "Крутое имя!"
else:
  echo "Привет, ", name, "!"

Как видите, в качестве аргумента для of можно использовать список значений, разделённых запятыми.

Команда case может работать с целыми числами, другими перечислимыми типами и строками. (Что такое перечислимые типы будет рассказано позже.) Для целых чисел и перечислимых типов можно использовать диапазоны значений:

# этa командa будет объяснена позже:
from strutils import parseInt

echo("Назови число: ")
let n = parseInt(readLine(stdin))
case n
of 0..2, 4..7: echo("Это число из множества: {0, 1, 2, 4, 5, 6, 7}")
of 3, 8: echo("Это число либо 3, либо 8")

Впрочем, код выше не будет компилироваться. Причина в том, что вам надо покрыть все значения, которые может принимать n, а код обрабатывает только значения 0..8.

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

case n
of 0..2, 4..7: echo("Это число из множества: {0, 1, 2, 4, 5, 6, 7}")
of 3, 8: echo("Это число либо 3, либо 8")
else: discard

Пустая команда discard это команда ничего не делать.

Компилятор знает, что команда case с секцией else охватывает все возможные варианты и, таким образом,ошибка исчезает. Обратите внимание, что все строковые значения покрыть невозможно: вот почему в случае строк, ветка else обязательна.

В целом, команда case используется для диапазонов типов и перечислений. То что компилятор проверяет охват всех возможных значений - очень полезная вещь.

Команда while

Команда while представляет собой простой цикл:

echo "Как тебя зовут? "
var name = readLine(stdin)
while name == "":
  echo "Пожалуйста, назови своё имя: "
  name = readLine(stdin) # `var` отсутствует, поскольку
                         # здесь не объявляется новая переменная

В примере, цикл while использован, чтобы спрашивать у пользователя его имя до тех пор, пока он не нажмёт Enter (т.е. не введёт пустую строку).

Команда for

Команда for реализует цикл по всем элементам итератора. Вот пример использования встроенного итератора countup:

echo "Считаем до 5: "
for i in countup(1, 5):
  echo i

Считаем до 5: 
1
2
3
4
5

Встроенный оператор $ преобразует целое число (int) и многие другие типы в строку.

Переменная i неявно объявляется циклом for и имеет тип int, поскольку countup возвращает именно этот тип. i проходит по значениям 1, 2, .., 5.

Каждое значение выводится с помощью echo. Этот код делает то же самое:

echo "Считаем до 5: "
var i = 1
while i <= 5:
  echo i
  inc i # увеличиваем i на 1

Считаем до 5: 
1
2
3
4
5

Поскольку отсчёт с увеличением используется настолько часто в программах, в Nim также есть .. итератор который делает тоже самое что и countup:

for i in 1 .. 5:
  echo i

Обратный отсчёт реализуется столь же просто (хотя он не так часто нужен):

echo "Считаем от 5 до 1: "
for i in countdown(5, 1):
  echo i

Считаем от 5 до 1: 
5
4
3
2
1

0-индексированный счёт имеет 2 удобных сокращения ..< и .. ^1 (оператор обратного индекса) чтобы упростить счёт до индекса на один меньше чем верхний предел:

for i in 0 ..< 3: # то же самое что и 0 .. 2
  echo i

0
1
2

var s = "Hello"
for i in 0 ..< s.len:
  echo i

0
1
2
3
4

var s = "Hello"
for idx, c in s[0 .. ^1]: # ^1 это последний элемент, ^2 - предпоследний, и так далее
  echo idx, ": ", c

0: H
1: e
2: l
3: l
4: o

Другие полезныe итераторы для коллекций (такие как массивы и последовательности): * items and mitems, которые возвращают неизменяемые и изменяемые элементы * соответственно, и * pairs and mpairs которые возвращают индекс каждого элемента и сам элемент * (неизменяемые и изменяемые, соответственно)

for index, item in ["a","b"].pairs:
  echo item, " на позиции ", index

a на позиции 0
b на позиции 1

Области видимости и команда block

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

while false:
  var x = "hi"
echo(x) # не работает

Команда while создаёт неявный блок. Идентификаторы видимы только внутри того блока, в котором они были объявлены. Команду block можно использовать, чтобы открыть новый блок явно:

block myblock:
  var x = "hi"
echo(x) # тоже не работает

Метка блока (myblock в примере) не обязательна.

Команда break

Из блока можно досрочно выйти командой break. Эта команда может прерывать блоки команд while, for или block. Она выходит из ближайшей внутренней конструкции, если не задана метка блока, из которого надо выйти:

block myblock:
  echo "входим в блок"
  while true:
    echo "цикл"
    break # покидаем цикл, но не блок
  echo "мы всё ещё в блоке"
echo "уже вне блока"

входим в блок
цикл
мы всё ещё в блоке
уже вне блока

block myblock2:
  echo "входим в блок"
  while true:
    echo "цикл"
    break myblock2 # покидаем названный блок (и цикл)
  echo "мы всё ещё в блоке"
echo "уже вне блока"

входим в блок
цикл
уже вне блока

Команда continue

Как и во многих других языках программирования, команда continue немедленно переходит к следующей итерации:

for i in 1 .. 5:
  if i <= 3: continue
  echo i

4
5

Команда when

Пример:

when system.hostOS == "windows":
  echo("это Windows компьютер!")
elif system.hostOS == "linux":
  echo("это Linux компьютер!")
elif system.hostOS == "macosx":
  echo("это Mac OS X!")
else:
  echo("неизвестная операционная система")

Команда when почти идентична команде if, но есть некоторые различия:

• каждое условие должно быть константным выражением, поскольку вычисляется компилятором;
• команды внутри ветки не открывают новую область видимости;
• компилятор проверяет синтаксис и генерирует код только для команд, принадлежащих ветке по первому условию, которое вернуло true.

Команда when полезна для написания платформенно-зависимого кода, по аналогии с конструкцией #ifdef языка C.

Команды и отступы

Теперь, когда мы рассмотрели базовые команды управления потоком, давайте вернёмся к правилам отступов Nim.

В Nim есть различие между простыми и сложными командами:

Простые команды, такие как присваивание, вызов процедур или команда return, не могут содержать других команд.

Сложные команды, такие как if, when, for, while могут содержать другие команды. Чтобы избежать неоднозначности сложные команды всегда пишутся с отступом, а простые – нет:

var x, y = true

# для одиночного присваивания отступ не нужен:"
if x: x = false

# нужен отступ для вложенного if:
if x:
  if y:
    y = false
  else:
    y = true

# нужен отступ, потому что две команды соответствуют условию:
if x:
  x = false
  y = false

Части команд, которые обычно дают в результате некое значение, называются выражениями. Для улучшения читаемости они могут содержать отступы в определённых местах:

if thisIsaLongCondition() and
    thisIsAnotherLongCondition(1,
       2, 3, 4):
  x = true

Как правило, отступы в выражениях, разрешены после операторов, после открытия скобок и после запятых.

С помощью скобок и точек с запятой (;) вы можете использовать команды там, где разрешены только выражения:

# вычисляем fac(4) на этапе компиляции:
const fac4 = (var x = 1; for i in 1..4: x *= i; x)
echo "факториал числа 4 равен ", fac4

факториал числа 4 равен 24

Процедуры

Чтобы создавать новые команды, такие как echo и readLine из примеров, нам понадобятся процедуры. (В некоторых языках они называются методами или функциями.) В Nim новые процедуры определяются с помощью ключевого слова proc:

proc yes(question: string): bool =
  echo(question, " (д/н)")
  while true:
    case readLine(stdin)
    of "д", "Д", "да", "Да": return true
    of "н", "Н", "нет", "Нет": return false
    else: echo("Пожалуйста, будьте яснее: да или нет?")

if yes("Удалить все важные данные?"):
  echo("Извини, Дейв, я боюсь, я не могу этого сделать.")
else:
  echo("Я думаю ты знаешь в чем проблема не хуже меня.")

В этом примере показана процедура с названием yes, которая задаёт пользователю вопрос и возвращает true, если он ответил «Да», и false, если он ответил «Нет».

Команда return приводит к немедленному выходу из процедуры (и, соответственно, цикла while).

Синтаксис (question: string): bool означает, что процедура ожидает получить параметр с именем question, типом string и вернёт значение типа bool.

bool это встроенный тип, единственные значения, которые он может принимать, это true и false. Условия в командах if или while должны иметь тип bool.

Немного терминологии: в примере, question формально называется параметром, а "Удалить все..." – это аргумент, который передаётся в этому параметру.

Переменная result

В любой процедуре, возвращающей значение, неявно объявляется переменная result, которая представляет собой возвращаемое значение.

Команда return без аргументов это просто сокращение для return result.

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

proc sumTillNegative(x: varargs[int]): int =
  for i in x:
    if i < 0:
      return
    result = result + i

echo sumTillNegative() # выведет 0
echo sumTillNegative(3, 4, 5) # выведет 12
echo sumTillNegative(3, 4 , -1 , 6) # выведет 7

На момент старта функции переменная result всегда уже объявлена, так что попытка объявить её снова, например, с помощью var result, приведёт к её затенению обычной переменной с тем же именем.

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

Процедуры которые не используют команду return и не используют специальную result переменную - возвращают значение своего последнего выражения. Например, эта процедура:

proc helloWorld(): string =
  "Hello, World!"

возвращает строку "Hello, World!":

echo helloWorld()

Hello, World!

Параметры

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

Если внутри процедуры нужна изменяемая переменная, её следует объявить в теле процедуры с помощью var. Затенение имени параметра возможно и является идиоматичным:

proc printSeq(s: seq, nprinted: int = -1) =
  var nprinted = if nprinted == -1: s.len else: min(nprinted, s.len)
  for i in 0 .. <nprinted:
    echo s[i]

Если процедуре нужно модифицировать аргумент для передачи вызвавшему, можно использовать var параметр:

proc divmod(a, b: int; res, remainder: var int) =
  res = a div b        # целочисленное деление
  remainder = a mod b  # целочисленное взятие остатка

var
  x, y: int
echo "до:    x = ", x, "; y = ", y
divmod(8, 5, x, y) # модифицирует x и y
echo "после: x = ", x, "; y = ", y

до:    x = 0; y = 0
после: x = 1; y = 3

В примере, res и remainder являются var параметрами. Такие параметры могут модифицироваться процедурой и изменения станут видимы вызвавшему.

Отметим, что в примере выше вместо var параметров лучше было бы вернуть кортеж (tuple).

Команда discard

В Nim нельзя просто игнорировать возвращённое значение. Чтобы вызвать процедуру, возвращающую значение, и проигнорировать результат её вызова, необходимо использовать команду discard:

discard yes("Можно мне задать бесполезный вопрос?")

Возвращённое значение можно проигнорировать неявно, если вызываемая процедура или итератор были объявлены с прагмой discardable:

proc p(x, y: int): int {.discardable.} =
  return x + y

p(3, 4) # теперь работает

Именованные аргументы

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

proc createWindow(x, y, width, height: int; title: string;
                  show: bool): Window

var w = createWindow(show = true, title = "My Application",
                     x = 0, y = 0, height = 600, width = 800)

Теперь, когда мы использовали именованные аргументы для вызова createWindow, порядок аргументов больше не имеет значения. Можно смешивать именованные аргументы с неименованными, но это ухудшает читаемость:

var w = createWindow(0, 0, title = "My Application",
                     height = 600, width = 800, true)

Компилятор проверяет, что каждый параметр получает ровно один аргумент.

Значения по умолчанию

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

proc createWindow(x = 0, y = 0, width = 500, height = 700,
                  title = "unknown",
                  show = true): Window =
  discard

var w = createWindow(title = "My Application", height = 600, width = 800)

Теперь при вызове createWindow нужно указать лишь те значения, которые отличаются от значений по умолчанию.

Отметим, что для параметров со значениями по умолчанию работает вывод типов, так что нет необходимости писать title: string = "unknown".

Перегруженные процедуры

Nim даёт возможность перегружать процедуры по аналогии с C++:

proc toString(x: int): string =
  result =
    if x < 0: "положительное"
    elif x > 0: "отрицательное"
    else: "ноль"

proc toString(x: bool): string =
  if x: result = "true"
  else: result = "false"

echo toString(13)    # вызывается процедура toString(x: int)
echo toString(true)  # вызывается процедура toString(x: bool)

отрицательное
true

Примечание: toString в Nim обычно реализуется оператором $

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

Операторы

Стандартная библиотека Nim интенсивно пользуется перегрузкой – одна из причин этого в том, что каждый оператор наподобие + это просто перегруженная процедура. Парсер позволяет использовать операторы в инфиксной a + b или префиксной нотации +a. Инфиксный оператор всегда получает два аргумента, а префиксный – всегда один.

Постфиксные операторы запрещены, поскольку могут привести к неоднозначности: a @ @ b означает (a) @ (@b) или (a@) @ (b)? Поскольку постфиксных операторов в Nim нет, это выражение всегда будет означать (a) @ (@b).

Кроме нескольких встроенных операторов-ключевых слов, таких как and, or и not, операторы всегда состоят из таких символов: + - * \ / < > = @ $ ~ & % ! ? ^ . |

Созданные пользователем операторы - разрешены. Ничто не помешает вам создать свой собственный оператор @!?+~, но читаемость может пострадать.

Приоритет оператора определяется по его первому символу. Подробности можно найти в руководстве.

Чтобы создать оператор, заключите его в апострофы:

proc `$` (x: myDataType): string = discard
# теперь оператор $ также работает и с myDataType, перекрывая поведение $,
# реализованное ранее только для встроенных типов

Эта нотация также может использоваться для вызова оператора как процедуры:

if `==`( `+`(3, 4), 7): echo("Истина")

Истина

Предварительные объявления

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

# предварительное объявление:
proc even(n: int): bool

proc odd(n: int): bool =
  assert(n >= 0) # гарантирует, что мы не свалимся в отрицательную рекурсию
  if n == 0: false
  else:
    n == 1 or even(n-1)

proc even(n: int): bool =
  assert(n >= 0) # гарантирует, что мы не свалимся в отрицательную рекурсию
  if n == 1: false
  else:
    n == 0 or odd(n-1)

Здесь odd зависит от even и наоборот. Таким образом, even должна встретиться компилятору до того, как будет полностью определена. Синтаксис для такого предварительного объявления несложен: просто пропустите = и тело процедуры. assert добавляет граничные условия и будет описан позднее в разделе Модули.

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

Пример также показывает, как тело оператора может состоять из единственного выражения, чьё значение возвращается неявно.

Функции и методы

Как упоминалось в введении, Nim различает процедуры, функции и методы, определенные соответственно ключевыми словами proc, func и method. В некоторых аспектах Nim немного более строг в своих определениях, чем другие языки.

Функции ближе к понятию чистой математической функции, что может быть знакомым, если вы когда-либо занимались функциональным программированием. В сущности они являются процедурами с дополнительными ограничениями: они не могут обращаться к глобальному состоянию (за исключением const) и не могут производить побочные эффекты.

Ключевое слово func в основном является псевдонимом для proc, помеченного как {.noSideEffects.}. Но функции всё же могут изменять свои изменяемые аргументы, которые помечены как var, а также любые объекты ref. В отличие от процедур, методы вызываются динамически. Это звучит довольно сложно, но этот концепт, тесно связан с наследованием и объектно-ориентированным программированием. Если вы перегружаете процедуру (две процедуры с одинаковым именем, но разными типами или наборами аргументов считаются перегруженными), какя процедура будет использована определяется на этапе компиляции. Методы, с другой стороны, зависят от объектов, которые наследуются от RootObj. Это тема, которая рассматривается гораздо более подробно во второй части учебника.

Итераторы

Давайте вернёмся к простому примеру с подсчётом:

echo("Считаем до десяти: ")
for i in countup(1, 10):
  echo($i)

Считаем до десяти: 
1
2
3
4
5
6
7
8
9
10

Можно ли самим написать процедуру countup для использования в таком цикле? Давайте попробуем:

proc countup(a, b: int): int =
  var res = a
  while res <= b:
    return res
    inc(res)

Увы, это не работает. Проблема в том, что процедура должна не просто вернуть значение, а вернуть и продолжить работу на следующей итерации. Вот это «вернуть и продолжить» называется командой yield. Теперь осталось лишь заменить ключевое слово proc на iterator и вот он – наш первый итератор:

iterator countup(a, b: int): int =
  var res = a
  while res <= b:
    yield res
    inc(res)

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

• итераторы могут быть вызваны только из циклов for;
• итераторы не могут содержать команду return, а процедуры не могут содержать команду yield;
• у итераторов нет неявной переменной result;
• итераторы не поддерживают рекурсию;
• итераторы не могут быть объявлены предварительно, поскольку компилятор должен иметь возможность встроить inline итератор (это ограничение будет убрано в будущих версиях компилятора).

Однако, вы можете также использовать итератор closure, имеющий другой набор ограничений. Подробности смотрите в разделе документации «Итераторы первого класса». Итераторы могут иметь те же имена и параметры, что и процедуры: у них своё собственное пространство имён. Поэтому есть общепринятая практика оборачивания итераторов в процедуры с теми же именами, которые накапливают результат итератора и возвращают его в виде последовательности, как split из модуля std/strutils.

Базовые типы

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

Логические значения bool

Логический тип в Nim называется bool и состоит из двух предопределённых значений true и false. Условия в командах while```,`` if, elifиwhenдолжны иметь типbool`.

Для типа bool определены операторы not, and, or, xor, <, <=, >, >=, != и ==. Операторы and и or выполняют сокращённые вычисления. Пример:

while p != nil and p.name != "xyz":
  # p.name не вычисляется, если p == nil
  p = p.next

Символы char

Символьный тип в Nim называется char. Его размер равен одному байту. Таким образом, он не может представлять собой символ UTF-8, только его часть. Причина этого в эффективности: в подавляющем большинстве случаев готовые программы будут правильно обрабатывать данные в UTF-8, так как UTF-8 был разработан специально для этого. Символьные литералы заключаются в одиночные кавычки.

Символы могут сравниваться с помощью операторов ==, <, <=, > и >=. Оператор $ преобразует char в string. Символы не могут смешиваться с целыми числами; для получения численного значения символа используйте процедуру ord. Конвертирование из численного значения в символ выполняется с помощью процедуры chr.

Строки string

Строковые значения в Nim изменяемые, так что операция добавления подстроки к строке довольно эффективна. Строки в Nim одновременно заканчиваются нулём и содержат поле длины. Длину строки можно получить встроенной процедурой len; длина никогда не учитывает завершающий ноль. Попытка получить доступ к завершающему нулю - ошибка, он существует только чтобы Nim строки могли быть конвертированы в cstring без создания копии.

Оператор присвоения для строк копирует строку. Вы можете использовать оператор & для конкатенации строк и add для добавления к строке.

Сравнение строк производится в лексикографическом порядке. Допустимы любые операторы сравнения. Как правило, все строки являются строками UTF-8, но это не обязательно. Например, при чтении строк из бинарных файлов, они, скорее, представляют собой последовательность байтов. Операция s[i] означает i-й char строки, а не i-й юникод символ unichar.

Строковые переменные инициализируются пустой строкой "".

Целые числа int

Nim имеет следующие встроенные целочисленные типы: int, int8, int16, int32, int64, uint, uint8, uint16, uint32 и uint64.

По умолчанию используется целочисленный тип int. Целочисленные литералы могут иметь суффикс, обозначающий их принадлежность к тому или иному целочисленному типу:

let
  x = 0     # int
  y = 0'i8  # int8
  z = 0'i64 # int64
  u = 0'u   # uint

echo "x имеет тип ", typeof(x)
echo "y имеет тип ", typeof(y)
echo "z имеет тип ", typeof(z)
echo "u имеет тип ", typeof(u)

x имеет тип int
y имеет тип int8
z имеет тип int64
u имеет тип uint

Чаще всего целые числа используются для подсчёта объектов, размещённых в памяти, так что размер int равен размеру указателя.

Основные операторы +, -, *, div, mod, <, <=, ==, !=, > и >= определены для целых чисел. Операторы and, or, xor и not также определены для целых чисел и выполняют побитовые операции. Битовый сдвиг влево делается с помощью оператора shl, а сдвиг вправо – с помощью оператора shr. Операторы битового сдвига всегда трактуют свой аргумент как беззнаковое число. Они могут использоваться для умножения или деления.

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

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

Числа с плавающей запятой float

Nim имеет следующие встроенные типы чисел с плавающей запятой: float, float32 и float64.

По умолчанию используется тип float. В текущей реализации float всегда имеет размер 64 бита.

Литералы чисел с плавающей запятой могут иметь суффикс, обозначающий их принадлежность к тому или иному типу чисел с плавающей запятой:

var
  x = 0.0      # float
  y = 0.0'f32  # float32
  z = 0.0'f64  # float64

echo "x имеет тип ", typeof(x)
echo "y имеет тип ", typeof(y)
echo "z имеет тип ", typeof(z)

x имеет тип float64
y имеет тип float32
z имеет тип float64

Основные операторы +, -, *, /, <, <=, ==, !=, > и >= определены для чисел с плавающей запятой и соответствуют стандарту IEEE-754.

Автоматическое преобразование типов в выражениях с различными видами типов с плавающей запятой выполняется: меньшие типы конвертируются в большие. Целочисленные типы не конвертируются автоматически в типы с плавающей запятой и наоборот. Для таких преобразований могут использоваться процедуры toInt и toFloat.

Преобразование типов

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

var
  x: int32 = 1.int32   #  то же, что вызов int32(1)
  y: int8  = int8('a') # 'a' == 97'i8
  z: float = 2.5       # int(2.5) округляется до 2
  sum: int = int(x) + int(y) + int(z)

echo "x = ", x, "; y = ", y, "; z = ", z
echo "int(x) + int(y) + int(z) = ", sum

x = 1; y = 97; z = 2.5
int(x) + int(y) + int(z) = 100

Внутреннее представление типов

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

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

var
  myBool = true
  myCharacter = 'n'
  myString = "nim"
  myInteger = 42
  myFloat = 3.14

echo "bool   ", $myBool, ":", repr(myBool)
echo "char   ", $myCharacter, ":", repr(myCharacter)
echo "string ", $myString, ":", repr(myString)
echo "int    ", $myInteger, ":", repr(myInteger)
echo "float  ", $myFloat, ":", repr(myFloat)

bool   true:true
char   n:'n'
string nim:"nim"
int    42:42
float  3.14:3.14

Дополнительные типы

Новые типы в Nim можно определять с помощью команды type:

type
  biggestInt = int64      # целочисленный тип, самый большой из доступных
  biggestFloat = float64  # тип с плавающей запятой, самый большой из доступных

Перечисления и объектные типы могут обьявлены только внутри type выражения.

Перечислениe enum

Переменная, относящаяся к типу перечислений, может принимать лишь ограниченное множество значений. Это множество состоит из упорядоченных символов. Каждый символ внутренне отображается на целочисленное значение. Первый символ соответствует числу 0, второй – числу 1 и так далее. Пример:

type
  Direction = enum
    north, east, south, west

var x = south
echo typeof(x) # `x` имеет тип `Direction`
echo $x        # a его значение `south`

Direction
south

Для перечислений могут использоваться любые операторы сравнения.

Во избежание неоднозначности символы перечислений могут быть квалифицированы: Direction.south.

Оператор $ может конвертировать любое значение перечисления в его имя, а процедура ord – в соответствующее целочисленное значение.

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

Явно пронумерованные перечисления могут содержать пропуски:

type
  MyEnum = enum
    a = 2, b = 4, c = 89

Перечислимые типы Ordinal

Перечисления, целочисленные типы, char, bool (и поддиапазоны) – все они называются перечислимыми типами. Для перечислимых типов есть несколько специальных операций:

Операции inc, dec, succ и pred могут выполниться с ошибкой, вызвав исключение RangeDefect или OverflowDefect. (Если, конечно, код скомпилирован со включенными подходящими проверками.)

Диапазоны range

Этот тип представляет собой диапазон значений целочисленного типа или перечисления (базового типа). Пример:

type
  MySubrange = range[0..5]

MySubrange это диапазон int, который может содержать значения от 0 до 5. Назначение любых других значений переменной типа MySubrange приведёт к ошибке при компиляции или во время выполнения. Назначение базового типа одному из его диапазонов (и наоборот) разрешается.

Модуль system имеет важный тип Natural, определённый как range[0..high(int)] (high возвращает максимально допустимое значение коллекции). Другие языки программирования, для работы с натуральными числами, принуждают использовать беззнаковые целые числа. Это часто бывает неправильно: вас не должны заставлять использовать беззнаковую арифметику лишь по той причине, что числа не могут быть отрицательными. Тип Natural языка Nim позволяет избежать этой распространённой ошибки в программировании.

Множества set

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

• int8-int16
• uint8/byte-uint16
• char
• enum
• поддиапазоны перечислимых типов, например range[-10..10]

или эквивалентным. Когда вы создаёте множество с помощью литералов целых чисел со знаком, базовый тип сета определяется как находящийся в диапазоне от 0 до DefaultSetElements-1, где DefaultSetElements в настоящее время всегда равно (2^8). Максимальная длина диапазона для базового типа множества - это MaxSetElements, которая в настоящее время всегда равна (2^16). Типы с большей длиной диапазона принудительно преобразуются в диапазон от 0 до MaxSetElements-1.

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

var s: set[int64] # Error: set is too large; используй `std/sets` для перечислимых типов
                  # с больше чем 2^16 возможных элементов

Примечание: в Nim также есть хеш множества - std/sets, у которых нет ограничений.

Множества могут быть сконструированы с помощью конструктора множества: {} это пустое множество. Пустое множество совместимо по типу с любым конкретным типом множества. Конструктор также может быть использован для включения элементов (и диапазонов элементов):

type
  CharSet = set[char]
var
  x: CharSet
x = {'a'..'z', '0'..'9'} # Множество, содержащее буквы от 'a' до 'z'
                         # и цифры от '0' до '9'

Модуль std/setutils предоставляет утилиты для создания множества из итерабельных типов:

import std/setutils

let uniqueChars = myString.toSet

Для множеств поддерживаются следующие операции:

Поля битов

Множества часто используются для флагов процедуры. Это более прозрачное (и типобезопасное) решение, чем определение целочисленных констант, которые надо объединять операцией or.

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

type
  MyFlag* {.size: sizeof(cint).} = enum
    A
    B
    C
    D
  MyFlags = set[MyFlag]

proc toNum(f: MyFlags): int = cast[cint](f)
proc toFlags(v: int): MyFlags = cast[MyFlags](v)

assert toNum({}) == 0
assert toNum({A}) == 1
assert toNum({D}) == 8
assert toNum({A, C}) == 5
assert toFlags(0) == {}
assert toFlags(7) == {A, B, C}

Заметьте как множества превращают перечисления в степени числа 2.

Когда используете перечисления и множества с C, используйте отличный cint (distinct cint).

Для совместимогог кода с C, смотри - bitsize pragma.

Массив array

Массив представляет собой простой контейнер фиксированного размера. Все его элементы имеют один и тот же тип. В качестве индекса массива может использоваться любой перечислимый тип.

Массив может быть создан с помощью []:

type
  IntArray = array[0..5, int] # массив целых чисел, индексированный от 0 до 5
var
  x: IntArray
x = [1, 2, 3, 4, 5, 6]
for i in low(x)..high(x):
  echo x[i], " на позиции ", i

1 на позиции 0
2 на позиции 1
3 на позиции 2
4 на позиции 3
5 на позиции 4
6 на позиции 5

Нотация x[i] используется для получения доступа к i-му элементу x. При доступе к элементам массива всегда производится проверка границ (либо во время компиляции, либо во время выполнения). Эту проверку можно отключить прагмами или вызовом компилятора с ключом --bound_checks:off.

Массивы являются типами-значениями, как и другие типы Nim. Оператор присваивания копирует содержимое массива целиком.

Встроенная процедура len возвращает длину массива. low(a) возвращает наименьший возможный индекс массива a, а high(a) – наибольший возможный индекс.

type
  Direction = enum
    north, east, south, west
  BlinkLights = enum
    Off, On, slowBlink, mediumBlink, fastBlink
  LevelSetting = array[north..west, BlinkLights]
var
  level: LevelSetting
level[north] = On
level[south] = slowBlink
level[east] = fastBlink
echo "repr(level) = ", repr(level)
echo "low(level) = ", low(level)
echo "len(level) = ", len(level)
echo "high(level) = ", high(level)

repr(level) = [On, fastBlink, slowBlink, Off]
low(level) = north
len(level) = 4
high(level) = west

Синтаксис для вложенных массивов (множественная размерность) в других языках сводится к добавлению дополнительных квадратных скобок, поскольку обычно каждое измерение должно быть того же типа, что и остальные. В Nim вы можете использовать разные измерения с различными индексными типами, так что синтаксис вложенности несколько другой. Основываясь на предыдущем примере, где level определён как массив перечислений, индексированный другим перечислением, мы можем добавить следующие строки, чтобы дать возможность типу маяка разделяться по уровням, доступ к которым можно получить через их целочисленный индекс:

type
  LightTower = array[1..3, LevelSetting]
var
  tower: LightTower
tower[1][north] = slowBlink
tower[1][east] = mediumBlink
echo "len(tower)    = ", len(tower)
echo "len(tower[1]) = ", len(tower[1])
echo "repr(tower)   = ", repr(tower)
# Следующие строки не компилируются из-за несовпадения типов
#tower[north][east] = on
#tower[0][1] = on

len(tower)    = 3
len(tower[1]) = 4
repr(tower)   = [[slowBlink, mediumBlink, Off, Off], [Off, Off, Off, Off], [Off, Off, Off, Off]]

Обратите внимание, что встроенная процедура len вернёт длину только массива первого уровня. Чтобы ещё лучше показать вложенную природу LightTower, можно было бы не писать предыдущее определение типа LevelSetting, а вместо этого включить его непосредственно в тип первого измерения:

type
  LightTower = array[1..10, array[north..west, BlinkLights]]

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

type
  IntArray = array[0..5, int] # массив, индексированный от 0 до 5
  QuickArray = array[6, int]  # массив, индексированный от 0 до 5
var
  x: IntArray
  y: QuickArray
x = [1, 2, 3, 4, 5, 6]
y = x
for i in low(x)..high(x):
  echo "i = ", i, "; ", "x[i] = ", x[i], "; y[i] = ", y[i]

i = 0; x[i] = 1; y[i] = 1
i = 1; x[i] = 2; y[i] = 2
i = 2; x[i] = 3; y[i] = 3
i = 3; x[i] = 4; y[i] = 4
i = 4; x[i] = 5; y[i] = 5
i = 5; x[i] = 6; y[i] = 6

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

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

Последовательности всегда индексируются int, начинающимся с 0. Операции len, low и high применимы для последовательностей. Нотация x[i] может использоваться для доступа к i-му элементу x.

Последовательности могут конструироваться с помощью конструктора массива [], соединённого с оператором преобразования массива в последовательность @. Другой способ выделить память для последовательности состоит в вызове встроенной процедуры newSeq.

Последовательность может передаваться в параметре openarray.

Пример:

var
  x: seq[int] # ссылка на последовательность целых чисел
x = @[1, 2, 3, 4, 5, 6] # @ превращает массив в последовательность, размещённую в куче

Последовательности инициализируются значениет @[].

Команда for, использованная для последовательности, может работать с одной или двумя переменными. Если вы используете форму с одной переменной, то переменная будет содержать значение, предоставляемое последовательностью. Команда for проходит по результатам, полученным из итератора items() модуля std/system.

Но если вы используете форму с двумя переменными, тогда первая переменная содержит индекс позиции, а вторая – значение. В этом случае команда for проходит по результатам итератора pairs() из модуля system. Примеры:

for i in @[3, 4, 5]:
  echo($i)

3
4
5

for i, value in @[3, 4, 5]:
  echo "позиция: ", $i, ", значение:", $value

позиция: 0, значение:3
позиция: 1, значение:4
позиция: 2, значение:5

Открытые массивы openarray

Примечание: Открытые массивы могут использоваться только в качестве параметров.

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

Открытые массивы всегда индексируются целыми числами и нумерация начинается с 0. Для них доступны операции len, low и high. Любой массив с совместимым базовым типом может быть передан в качестве параметра открытого массива, тип индекса не имеет значения.

var
  fruits:   seq[string]       # ссылка на последовательность строк, которая
                              # инициализирована значением 'nil'
  capitals: array[3, string]  # массив строк с фиксированным размером

fruits = @[]                  # создаёт в куче пустую последовательность, на
                              # которую будет ссылаться 'fruits'

capitals = ["New York", "London", "Berlin"]   # массив 'capitals' позволяет
                                              # присвоить лишь три элемента
fruits.add("Banana")          # последовательность 'fruits' динамически
                              # расширяется в ходе выполнения
fruits.add("Mango")

proc openArraySize(oa: openArray[string]): int =
  oa.len

assert openArraySize(fruits) == 2     # процедура принимает последовательность
                                      # в качестве параметра
assert openArraySize(capitals) == 3   # но и массив тоже

Тип открытого массива не может быть вложенным: многомерные открытые массивы не поддерживаются, поскольку нужда в них возникает редко и их нельзя реализовать эффективно.

Параметры с произвольным количеством аргументов varargs

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

proc myWriteln(f: File, a: varargs[string]) =
  for s in items(a):
    write(f, s)
  write(f, "\n")

myWriteln(stdout, "abc", "def", "xyz")
# превращается компилятором в:
myWriteln(stdout, ["abc", "def", "xyz"])

Это преобразование делается только в том случае, если параметр varargs последний в заголовке процедуры. Также можно выполнить преобразование типов в этом контексте:

proc myWriteln(f: File, a: varargs[string, `$`]) =
  for s in items(a):
    write(f, s)
  write(f, "\n")

myWriteln(stdout, 123, "abc", 4.0)
# превращается компилятором в:
myWriteln(stdout, [$123, $"abc", $4.0])

В данном примере $ применяется к каждому аргументу, переданному через параметр a. Заметьте, что $, применённый к строкам, не делает ничего.

Срезы Slice

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

var
  a = "Nim is a programming language"
  b = "Slices are useless."

echo a[7 .. 12] # --> 'a prog'
b[11 .. ^2] = "useful"
echo b # --> 'Slices are useful.'

a prog
Slices are useful.

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

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

Таким образом, строка b имеет длину 19, и два разных способа указания индексов выглядят так:

"Slices are useless." | | | 0 11 17 использование индексов ^19 ^8 ^2 использование синтаксиса с ^

где b[0 .. ^1] эквивалентно b[0 .. b.len-1] и b[0 ..< b.len], и видно, что ^1 предоставляет сокращённый способ указания b.len-1. См. оператор обратного индекса.

В приведённом примере, из-за того что строка заканчивается точкой, если мы хотим получить часть строки "useless" и заменить её на "useful":

b[11 .. ^2] — выбирает "useless", а b[11 .. ^2] = "useful" заменяет "useless" на "useful", давая результат "Slices are useful.".

Примечание 1: альтернативные способы записи: b[^8 .. ^2] = "useful" или b[11 .. b.len-2] = "useful", или b[11 ..< b.len-1] = "useful".

Примечание 2: Поскольку шаблон ^ возвращает уникальный int типа BackwardsIndex, мы можем определить константу lastIndex как const lastIndex = ^1 и затем использовать её как b[0 .. lastIndex].

Объекты object

Стандартным типом для объединения различных значений в единую именованную структуру является тип object. Объект — это тип-значение, что означает: при присваивании объекта новой переменной все его компоненты копируются.

Каждый тип объекта Foo имеет конструктор Foo(поле: значение, ...), в котором можно инициализировать все его поля. Неуказанные поля получат значения по умолчанию.

type
  Person = object
    name: string
    age: int

var person1 = Person(name: "Peter", age: 30)

echo person1.name # "Peter"
echo person1.age  # 30

var person2 = person1 # копия person1

person2.age += 14

echo person1.age # 30
echo person2.age # 44


# порядок можно менять
let person3 = Person(age: 12, name: "Quentin")
doAssert person3.age == 12

# не все поля обязательны
let person4 = Person(age: 3)
# неуказанные поля инициализируются значениями по умолчанию.
# В данном случае это пустая строка.
doAssert person4.name == ""

Peter
30
30
44

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

type
  Person* = object # тип виден из других модулей
    name*: string  # поле этого типа видно из других модулей
    age*: int

Кортежи tuple

Кортежи во многом похожи на уже знакомые вам объекты. Они являются типами-значениями, и оператор присваивания копирует каждое поле. Однако, в отличие от типов-объектов, типы кортежей являются структурными — это означает, что разные типы кортежей считаются эквивалентными, если они содержат поля одинакового типа, с одинаковыми именами и в том же порядке.

Конструктор () используется для создания кортежей. Порядок полей в конструкторе должен соответствовать порядку в определении кортежа. Но, в отличие от объектов, здесь нельзя использовать имя типа кортежа.

Как и у объектов, доступ к полям кортежа осуществляется через запись t.поле. Однако у кортежей есть дополнительная возможность — обращение по индексу: t[i], где i должно быть целочисленной константой.

type
  # Тип, представляющий человека:
  # состоит из имени (name) и возраста (age).
  Person = tuple
    name: string
    age: int

  # Альтернативный синтаксис для эквивалентного типа.
  PersonX = tuple[name: string, age: int]

  # Синтаксис с анонимными полями
  PersonY = (string, int)

var
  person: Person
  personX: PersonX
  personY: PersonY

person = (name: "Peter", age: 30)
# Person и PersonX эквивалентны
personX = person

# Создание кортежа с анонимными полями:
personY = ("Peter", 30)

# Кортеж с анонимными полями совместим с кортежем,
# у которого есть имена полей.
person = personY
personY = person

# Часто используется сокращённый синтаксис инициализации
person = ("Peter", 30)

echo person.name  # "Peter"
echo person.age   # 30

echo person[0]    # "Peter"
echo person[1]    # 30

# Кортежи можно использовать без объявления отдельного типа.
var building: tuple[street: string, number: int]
building = ("Rue del Percebe", 13)
echo building.street

# Эта строка не скомпилируется — кортежи разных типов!
# person = building
# --> Error: type mismatch: got (tuple[street: string, number: int])
#     but expected 'Person'

Peter
30
Peter
30
Rue del Percebe

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

Распаковка кортежей

При присваивании кортежи можно распаковывать — это удобно, чтобы сразу присвоить поля кортежа отдельным переменным. Например, процедура splitFile из модуля os возвращает каталог, имя и расширение файла в виде кортежа.

Для распаковки кортежа необходимо использовать скобки, иначе все переменные получат одно и то же значение (весь кортеж)! Например:

import std/os

let
  path = "usr/local/nimc.html"
  (dir, name, ext) = splitFile(path)  # ✅ Правильная распаковка
  baddir, badname, badext = splitFile(path)  # ❌ Неправильно!

echo dir      # выведет "usr/local"
echo name     # выведет "nimc"
echo ext      # выведет ".html"

# Все следующие переменные содержат один и тот же кортеж:
echo baddir   # (dir: "usr/local", name: "nimc", ext: ".html")
echo badname  # (то же самое)
echo badext   # (то же самое)

usr/local
nimc
.html
(dir: "usr/local", name: "nimc", ext: ".html")
(dir: "usr/local", name: "nimc", ext: ".html")
(dir: "usr/local", name: "nimc", ext: ".html")

Распаковка кортежей также работает в циклах for:

let points = [(10, 'a'), (20, 'b'), (30, 'c')]

for (x, c) in points:
  echo x
# Выведет: 10; 20; 30

# Можно также получить индекс:
for i, (x, c) in points:
  echo i, c
# Выведет: 0a; 1b; 2c

10
20
30
0a
1b
2c

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

Ссылочные и указательные типы ref и ptr

Ссылки (то же, что и указатели в других языках программирования) это способ организовать отношения «многие-к-одному». Это значит, что разные ссылки могут указывать на одно и то же место в памяти и модифицировать его.

Nim различает отслеживаемые (traced) и неотслеживаемые (untraced) ссылки. Неотслеживаемые ссылки также называют указателями. Отслеживаемые ссылки указывают на объекты в куче со сборкой мусора, неотслеживаемые – на объекты, память под которые была выделена вручную или на объекты в других местах памяти. Таким образом, неотслеживаемые ссылки небезопасны. Однако для некоторых низкоуровневых операций (доступа к «железу») обойтись без них нельзя.

Отслеживаемые ссылки объявляются ключевым словом ref, неотслеживаемые – ключевым словом ptr.

Пустая subscript-нотация [] может использоваться для разыменования ссылки, то есть для получения элемента, на который указывает ссылка. Операторы . (доступ к полю кортежа/объекта) и [] (оператор индексирования массива/строки/последовательности) выполняют неявное разыменование для ссылочных типов:

type
  Node = ref NodeObj
  NodeObj = object
    le, ri: Node
    data: int
var
  n: Node
new(n)
n.data = 9
# не надо писать n[].data, это сильно сбивает с толку!

Для выделения памяти под новый отслеживаемый объект используется встроенная процедура new:

var n: Node
new(n)

Для работы с неотслеживаемой памятью могут использоваться процедуры alloc, dealloc и realloc. Документация модуля std/system содержит дополнительную информацию по этим вопросам.

Если ссылка ни на что не указывает, она имеет значение nil.

Процедурный тип proc

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

Пример:

proc greet(name: string): string =
  "Привет, " & name & "!"

proc bye(name: string): string =
  "Пока, " & name & "."

proc communicate(greeting: proc (x: string): string, name: string) =
  echo greeting(name)

communicate(greet, "Джон")
communicate(bye, "Мэри")

Привет, Джон!
Пока, Мэри.

Неочевидная проблема с процедурными типами состоит в том, что форма вызова процедуры влияет на совместимость типов: процедурные типы совместимы только тогда, когда используют одинаковые формы вызова. Различные формы вызова перечислены в руководстве.

Отличный тип distinct

Отличный тип позволяет создать новый тип, который не подразумевает подтипового отношения между ним и его базовым типом. Вам явно необходимо определить все поведение для отличного типа. Для помощи в этом, как отличный тип, так и его базовый тип могут перенимать тип друг друга (type casting).

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

Модули

Nim поддерживает разбиение программы на части согласно концепту модулей. Каждый модуль находится в отдельном файле. Модули позволяют выполнять сокрытие информации и раздельную компиляцию. Они могут получать доступ к символам других модулей с помощью команды import. Экспортироваться будут только символы верхнего уровня, отмеченные звёздочкой (*):

# Модуль A
var
  x*, y: int

proc `*` *(a, b: seq[int]): seq[int] =
  # создать новую последовательность:
  newSeq(result, len(a))
  # перемножить две целочисленных последовательности:
  for i in 0..len(a)-1: result[i] = a[i] * b[i]

when isMainModule:
  # проверить новый оператор ``*`` для последовательностей:
  assert(@[1, 2, 3] * @[1, 2, 3] == @[1, 4, 9])

Модуль A экспортирует x и *, но не y.

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

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

Символы модуля могут быть квалифицированы с помощью синтаксиса module.symbol. Если символ неоднозначен, он должен квалифицироваться. Символ является неоднозначным, если он определён в двух (или более) разных модулях и оба модуля импортируются третьим:

# Модуль A
var x*: string

# Модуль B
var x*: int

# Модуль C
import A, B
write(stdout, x) # ошибка: x неоднозначен
write(stdout, A.x) # ошибки нет: используется квалификатор

var x = 4
write(stdout, x) # неоднозначности нет: используется x модуля C

Но это правило неприменимо к процедурам или итераторам. Здесь применяются правила перегрузки:

# Модуль A
proc x*(a: int): string = $a

# Модуль B
proc x*(a: string): string = $a

# Модуль C
import A, B
write(stdout, x(3))   # ошибки нет: вызывается A.x
write(stdout, x(""))  # ошибки нет: вызывается B.x

proc x*(a: int): string = nil
write(stdout, x(3))   # неоднозначность: какой `x` вызывать?

Исключение символов except

Обычно, команда import забирает все экспортируемые символы. Это можно изменить, указав исключаемые символы с квалификатором except.

import mymodule except y

Команда from

Мы уже видели простую команду import, импортирующую все экспортированные символы. С помощью команды from import - возможно импортировать исключительно перечисленные символы:

from mymodule import x, y, z

Команда from также может принудительно задавать пространства имён для символов, в результате чего, символы будут доступны, но для их использования потребуется указать квалификатор.

from mymodule import x, y, z

x()           # использyeм x без квалификации

from mymodule import nil

mymodule.x()  # нужно квалифицировать x, указав имя модуля в качестве префикса

x()           # Ошибка: использование x без квалификации приведёт к ошибке компиляции

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

from mymodule as m import nil

m.x()         # m это псевдоним для mymodule

Команда include

Команда include делает нечто, фундаментально отличающееся от импортирования модуля: она вставляет на своё место содержимое файла. Эта команда весьма полезна для разбиения большого модуля на несколько файлов:

include fileA, fileB, fileC