Язык Nemerle

Автор: Владислав Юрьевич Чистяков
The RSDN Group
Источник: RSDN Magazine #2-2009

Опубликовано: 24.09.2009
Версия текста: 1.0

Отвлеченное введение О языке Почему Nemerle? Как использовать язык? Инсталлятор ncc.exe Упрощенное введение Первый пример – «Hello, World!» Пространства имен и типы Арифметика Локальные функции Встроенные типы данных Вывод типов и их явное описание Макросы Промежуточный итог Ссылки

Эта статья открывает цикл статей, посвященных обучению языку программирования Nemerle. Имеющиеся статьи об этом языке предполагают, что программист хорошо знаком с Microsoft .NET Framework и языком программирования C#. Данный же цикл статей, напротив, рассчитан на людей, не знакомых ни с тем, ни с другим, и может быть даже применен для изучения программирования как такового. Новичкам в программировании может потребоваться помощь опытного товарища.

Отвлеченное введение

На данную работу меня вдохновила книга Кернигана и Ричи – «Язык С». Много лет назад я учился программировать по этой книге. Мне очень понравилась концепция изложения использованная в этой книге. В этой книге, вместо того чтобы взять одну тему и разобрать ее по косточкам, попутно заостряя внимание на мелких деталях, давался минимум, необходимый человеку, чтобы начать программировать на «C», а затем приоткрывался аспект за аспектом. Причем изложение давалось не на абстрактных примерах, которыми так увлекаются проповедники функционального программирования, а на примерах простых, но все же из этой жизни. Понимая, что прыгнуть выше Кернигана и Ричи очень тяжело, я решил не соревноваться с ними в креативности, а просто повторить их методологию, но с расчетом на Nemerle.

Nemerle – это совсем другой язык. Он многим отличается от C, но это никак не мешает применить тот же подход, и даже те же примеры, что и в знаменитой книге «Язык С». Надеюсь, что у меня что-то получилось :).

О языке

Язык Nemerle задумывался как язык программирования высокого уровня, поддерживающий объектно-ориентированное программирование, функциональное программирование и метапрограммирование.

Прародителями языка являются C#, ML и LISP. Пожалуй, Nemerle ближе всего к C#. Хорошо знакомый с C# программист может, прочитав пару вводных статей и потратив два-три дня на эксперименты, начать писать код на Nemerle. Конечно, чтобы освоить все возможности языка, придется потратить минимум месяц, но и этот срок вряд ли можно назвать очень большим для изучения мощного современного языка программирования.

Если вы не знакомы с C# и платформой .Net, то на изучение Nemerle вам придется потратить больше времени. Но все же это не так сложно. Язык проектировался так, чтобы на нем можно было быстро и просто начать программировать. Не обязательно знать все о языке, чтобы писать полезные для себя и окружающих программы.

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

Почему Nemerle?

«Зачем изучать именно этот язык, если вокруг есть масса других (в том числе и для платформы .Net)?» - можете спросить вы. Ответ очень прост. Это один из самых лучших и интересных языков программирование, созданных на сегодняшний день, который легко и приятно изучать. Могу сказать без сомнения, что это лучший язык, созданный для платформы .Net на сегодняшний день. Этот язык поддерживает практически все возможности, которые имеются в других языках программирования (пожалуй, кроме логического программирования, в основном представленное языком Prolog), так что изучив этот язык, вам будет проще освоить другие языки.

Как использовать язык?

Самым удобным способом писать на Nemerle является использование «Интеграции с Microsoft Visual Studio» (далее VS). Однако VS, как и любая IDE (интегрированная среда разработки), скрывает большинство особенностей работы с проектом, которые следует знать новичку. Поэтому в начале я буду использовать компилятор командной строки.

Инсталлятор

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

Если вы используете инсталлятор, то лучше всего располагать файлы в предложенном по умолчанию каталоге (%ProgramFiles%\Nemerle).

ncc.exe

Компилятор командной строки Nemerle называется ncc.exe. По умолчанию он находится в %ProgramFiles%\Nemerle (например, на моей машине это «c:\Program Files\Nemerle»).

Там же находятся библиотеки, относящиеся к «Интеграции с Microsoft VS» и библиотеке времени выполнения Nemerle.dll, которая требуется для запуска программ, получаемых с помощью компилятора Nemerle. Для упрощения использования ncc добавьте путь %ProgramFiles%\Nemerle в переменную среды окружения PATH (о том, как это сделать, см. здесь). Тогда вы сможете вызывать ncc из любого каталога на вашей машине.

Ncc принимает в качестве аргументов список файлов, которые требуется скомпилировать, и набор ключей. Ключи нужно предварять символом «-» (минус) или «/» (обратный слеш). Полный список ключей компиляции можно получить, введя в командной строке

ncc -h

У ncc есть много ключей, но для нас сейчас важны только следующие:

Упрощенное введение

В данном разделе мне не хочется заострять внимание на всех особенностях языка, увязая при этом в деталях и формальных правилах. Напротив, хочется продемонстрировать наиболее существенные элементы языка (его базу) на реальных программах.

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

Естественно, начальные примеры могут оказаться не столь краткими и элегантными, как если бы мы писали их, используя всю мощь Nemerle. Не обращайте на это внимания! По мере изучения мы будем переписывать их, делая каждый раз все более краткими и выразительными.

Первый пример – «Hello, World!»

Как метко подмечено в книге «Язык C» (которая в немалой степени вдохновила меня на данную работу и послужила прототипом), «Единственный способ освоить новый язык программирования – писать на нем программы. Первая программа, которая должна быть написана, одна для всех языков: напечатать предложение "Hello, World!"».

Вам потребуется где-то завести файл с расширением «.n» (без кавычек) и подходящим именем (например, «HelloWorld.n»). Поместить в него следующий код (текст программ называют кодом или исходным кодом):

        using System.Console;

WriteLine("Hello, World!");

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

ncc -no-color HelloWorld.n -out:HelloWorld.exe

И вызвать получившуюся программу «HelloWorld.exe».

Если вы нигде не ошибетесь, то после запуска «HelloWorld.exe» на консоль (т.е. на экран компьютера) будет выведено:

Hello, World!

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

Что же демонстрирует этот пример? Как ни странно, немало. Во первых он демонстрирует, что Nemerle, как и большинство современных компилируемых языков, не имеет встроенных средств для ввода/вывода и вообще для чего бы то ни было (кроме, пожалуй базового набора арифметических операторов).

Функции

Все, что вы можете сделать в Nemerle, делается посредством вызова функций (или методов, но об этом чуть позже). В данном случае мы используем системную функцию WriteLine (объявленную в .Net), выводящую на консоль одну строку и символ перевода (разрыва) строки (что приводит к тому, что следующий вывод текста осуществляется уже с новой строки). Если перевод строки не требуется, то для вывода строки можно воспользоваться функцией Write.

Вызов функции выглядит как ее имя, за которым идет список аргументов, заключенных в круглые скобки. Если функция не имеет аргументов, то в скобках ничего не указывается (они остаются пустыми).

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

Функции и другие действия можно выполнять последовательно. При этом отдельные действия (выражения или вызовы функций) нужно отделять знаком «;» (точка с запятой). Это поведение аналогично тому, как это было принято в языке Pascal. Впрочем, знак «;» можно просто ставить в конце каждого отдельного действия (как это принято в C-подобных языках, таких как C#, Java и C++).

Следующий пример:

          using System.Console;

WriteLine("Hello, World!");
WriteLine("Привет, Мир!");
WriteLine("Мир! Привет!");

выведет:

Hello, World!
Привет, Мир!
Мир! Привет!

Последнюю точку с запятой можно смело не указывать.

Заодно давайте познакомимся с еще одной консольной функций Write. Ее отличие заключается только в том, что она не выводит символ новой строки, что приводит к тому, что следующий вывод на консоль начинается на том месте, где закончился предыдущий. Следующий пример демонстрирует это:

          using System.Console;

Write("Hello");
Write(", World");
WriteLine("!");

выведет, как и исходный пример, строку:

Hello, World!

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

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

Для представления заранее известного (статического) текста используются строковые литералы (или, как еще их иногда называют, «строковые константы»). Nemerle поддерживает три типа строковых литералов, но на данный момент нам будет достаточно одного типа – обычного строкового литерала (regular string literals).

Обычный строковый литерал – это просто строка символов, которая заключается в пару двойных кавычек (то есть в пару символов «"»). Такие строки должны располагаться на одной строке (не могут содержать символ новой строки) и не могут содержать в себе символ двойной кавычки «"». Чтобы вписать эти символы в строку, нужно воспользоваться так называемой эскейп-нотацией. Это мудреное словосочетание означает, что перед такими символами нужно поставить символ «\» (экскейп-символ). Естественно, что сам символ «\» тоже не может встречаться в строке самостоятельно (так как компилятор воспримет его как управляющую конструкцию), так что если вам нужно написать в строке этот символ, то его нужно удвоить.

Этот тип строкового литерала часто называют C-строкой (си-строкой), так как впервые он появился в языке «C».

Остальные виды строковых литералов вы освоите позже. Если они вас интересуют уже сейчас, обратитесь к подразделу «Строковые литералы» из раздела «Расширенное описание».

Пространства имен и типы

Думаю, что в этом примере ясно все, за исключением строки:

        using System.Console;

Если вы удалите эту строку, то компилятор выдаст сообщение об ошибке:

HelloWorld.n:3:1:3:10: error: unbound name `WriteLine'

Это означат, что компилятор не нашел имя функции.

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

Чтобы можно было использовать одинаковые имена и при этом не происходило путаницы, были придуманы пространства имен и модули (точнее типы, но об этом позже).

Функции могут объявляться только в типах (таких, как модуль) и внутри других функций. Типы могут объявляться в пространствах имен, в других типах или в глобальном пространстве имен (безымянном). Например, функция WriteLine объявлена в модуле Console, который объявлен в пространстве имен System. Модуль Console объединяет все функции, связанные с консольным вводом/выводом, а System объединяет все системные типы (то есть базовые для системы). Например, тип «строка» также объявлен в пространстве имен System.

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

Строка «using System.Console;», так сказать, открывает тип «System.Console». После этого содержимое данного типа можно использовать напрямую. В принципе, и не открывая типы и/или пространства имен можно дотянуться до нужных функций. Наш исходный пример можно переписать следующим образом:

System.Console.WriteLine("Hello, World!");

Такой способ задания имен называется полностью квалифицированным.

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

        using System;

Console.WriteLine("Hello, World!");

Два последних варианта выведут на консоль то же самое, что и самый первый вариант.

Арифметика

Nemerle позволяет производить арифметические вычисления почти так же, как вы записывали их в свои школьные тетради.

Например, чтобы пересчитать (по формуле «C = 5 / 9 * (F - 32)») 40 градусов по Фаренгейту в эквивалент по шкале Цельсия можно написать следующую программу:

        using System.Console;

WriteLine(5.0 / 9.0 * (40.0 - 32.0));

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

Этот код выводит на консоль:

4,44444444444444

Странным здесь выглядит то, что к числам дописаны «.0». Это необходимо потому, что в Nemerle, как и во всех C-подобных языках, целые числа и числа с плавающей точкой (или запятой, как ее принято называть в России) записываются по-разному. Более того! Деление и умножение с ними также выполняется по-разному. При делении целого числа на целое же число в результате также получается целое число. Дробная часть при этом отбрасывается. Так что если попытаться поделить 5 / 9:

        using System.Console;

WriteLine(5 / 9);

то мы получим не 0.555555, а 0!

Если же хотя бы один из аргументов (операндов) выражения будет числом с плавающей точкой, то второй операнд операции деления будет автоматически приведен к типу другого операнда. Другими словами, будет произведено неявное приведение типов к большему типу (типу, который может содержать значения из большего диапазона). Приведение типов констант осуществляет компилятор. Так что в итоге мы получаем максимально эффективный код. Таким образом, благодаря автоматическому приведению типов, вместо выражения «5.0 / 9.0 * (40.0 - 32.0)» мы могли бы написать «5.0 / 9 * (40 - 32)» или «5 / 9.0 * (40 - 32)». Все остальные типы компилятор привел бы сам. Но чем более явно выражено намерение, тем меньше места остается для домыслов. А чем меньше домыслов (при прочих равных), тем проще программисту понять, что написано в коде, а стало быть, тем сложнее сделать ошибку. Кстати, если бы мы написали «5 / 9 * (40.0 - 32)», то компилятор привел бы к типу числа с плавающей точкой уже результат целочисленного деления, что в итого дало бы неверный (для нас) результат.

Локальные функции

Функции дают удобный способ заключения некоторой части вычислений в «черный ящик», который в дальнейшем можно использовать, не интересуясь его внутренним содержанием. Использование функций в Nemerle (да и в остальных языках) является одним из важнейших механизмов, позволяющих справляться с потенциальной сложностью больших программ. Если функции организованы должным образом, то можно игнорировать, как делается работа; достаточно знания того, что делается. Nemerle недаром называется функциональным языком. В нем использование функций доведено до совершенства. Функции не только легко и удобно создавать (как в C), но ими еще точно так же легко манипулировать. Их можно передавать в другие функции, хранить в переменных и даже динамически создавать новые функции из нескольких других. Вам будут часто встречаться функции длиной всего в несколько строчек, вызываемые только один раз. Они создаются, чтобы прояснять некоторую часть программы. Ведь даже само имя функции может сказать о многом. В сочетании же со списком параметров функция является незаменимым источником информации о программе.

Так, писать в программе формулы прямо там, где требуется произвести вычисления – это не очень хорошая идея. Намного лучше вынести формулу в функцию. Следующая программа именно это и делает:

        using System.Console;

def fahrenheitToCelsius(fahrenheit)
{
  5.0 / 9 * (fahrenheit - 32)
}

WriteLine(fahrenheitToCelsius(40));

Этот код также выведет на консоль:

4,44444444444444

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

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

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

f2c.n:4:3:4:6: error: parse error near double literal: expected `{' 
at the beginning of function body

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

В Nemerle функции, описываемые в типах, в отличие от локальных функций (продемонстрированной выше), могут быть перегруженными. Это означает, что может существовать более одной функции с одним и тем же именем. Компилятор сможет отличить их по количеству и типам параметров. У метода WriteLine есть множество перегрузок. В том числе есть перегрузка, принимающая первым параметром строку форматирования, а вторым (и возможно третьим, четвертым и т.д.) – параметры, на которые можно ссылаться в строке формата.

Выведем информацию таким образом:

Fahrenheit:   40 Celsius:   4,4

Следующий пример делает это:

        using System.Console;

def fahrenheitToCelsius(fahrenheit)
{
  5.0 / 9 * (fahrenheit - 32)
}

WriteLine("Fahrenheit: {0, 4} Celsius: {1, 5:##0.0}", 40, 
  fahrenheitToCelsius(40));

Усложним задачу. Вместо одного значения выведем 16, с шагом в «20» градусов:

Fahrenheit:    0 Celsius: -17,8
Fahrenheit:   20 Celsius:  -6,7
Fahrenheit:   40 Celsius:   4,4
Fahrenheit:   60 Celsius:  15,6
Fahrenheit:   80 Celsius:  26,7
Fahrenheit:  100 Celsius:  37,8
Fahrenheit:  120 Celsius:  48,9
Fahrenheit:  140 Celsius:  60,0
Fahrenheit:  160 Celsius:  71,1
Fahrenheit:  180 Celsius:  82,2
Fahrenheit:  200 Celsius:  93,3
Fahrenheit:  220 Celsius: 104,4
Fahrenheit:  240 Celsius: 115,6
Fahrenheit:  260 Celsius: 126,7
Fahrenheit:  280 Celsius: 137,8
Fahrenheit:  300 Celsius: 148,9

Конечно, можно просто шестнадцать раз скопировать строку:

WriteLine("Fahrenheit: {0, 4} Celsius: {1, 5:##0.0}", 40, 
  fahrenheitToCelsius(40));

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

        using System.Console;

def fahrenheitToCelsius(fahrenheit)
{
  5.0 / 9 * (fahrenheit - 32)
}

def loop(fahrenheit)
{
  WriteLine("Fahrenheit: {0, 4} Celsius: {1, 5:##0.0}", 
    fahrenheit, fahrenheitToCelsius(fahrenheit));

  loop(fahrenheit + 20);
}

loop(0);

Обратите внимание на выделение. Это рекурсивный вызов функции (т.е. вызов функцией самой себя).

Наверно, многие из вас уже догадались, что данный код выведет не совсем то, что было запланировано. Более того, данный код попросту не завершится! Вам придется нажать Ctrl+C, чтобы прервать работу программы. Иначе она еще долго будет прокручивать консольное окно, выводя все новые и новые значения.

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

Если вы знаете какие-то другие языки программирования, то наверняка догадались, что таким средством обычно является оператор if/else. Все правильно, но в Nemerle такого оператора также нет. :)

Зато в Nemerle есть оператор match. Это так называемый оператор сопоставления с образцом. Он позволяет сравнить значение с одним или несколькими образцами и выполнить некоторые действия, если некоторый образец совпал с проверяемым значением.

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

        using System.Console;

def fahrenheitToCelsius(fahrenheit)
{
  5.0 / 9 * (fahrenheit - 32)
}

def loop(fahrenheit)
{
  WriteLine("Fahrenheit: {0, 4} Celsius: {1, 5:##0.0}", 
    fahrenheit, fahrenheitToCelsius(fahrenheit));

  match (fahrenheit)
  {
    | 300 => ()
    | _   => loop(fahrenheit + 20);
  }
}

loop(0);

Суть оператора match очень проста. В качестве единственного параметра ему передается некоторое значение, а в теле (состоящем из блока) размещается список образцов. Каждый образец начинается со знака «|» и состоит из одного выражения, которое и является образцом. Далее может идти еще один образец или «=>». За «=>» идут выражения/действия (одно или более) которое вычисляется, если один из образцов, перечисленных перед «=>», совпал с переданным значением (со значением в скобках, идущих сразу за ключевым словом «match»).

В нашей программе в качестве сопоставляемого значения используется текущее значение параметра fahrenheit, а в качестве образцов – выражение «300», и выражение «_». Подчеркивание – «_» – это особая штука в Nemerle. Она называется подстановочным символом (wildcard). Когда wildcard используется в качестве образца, то оно сопоставляется с любым значением. Таким образом, если первым в списке образцов поставить образец «| _ », то всегда будет сопоставляться только он, а остальные ветви никогда не получат управления (никогда не будут вычислены). Но компилятор Nemerle не так глуп, чтобы допустить такую ситуацию. Компилятор поймет, что все образцы, кроме первого, не имеют смысла, и выдаст предупреждение об этом. Если же такой образец расположен в конце списка образцов, то он будет использоваться, если никакие другие образцы не совпали (не сопоставились) со значением. Таким образом, порядок следования образцов в операторе match может быть важен (о случаях, когда он не важен, мы поговорим позднее).

В нашем случае образец «_» – это как раз то, что нужно! Ведь если значение fahrenheit не равно тремстам, то нам нужно рекурсивно вызвать текущую функцию еще раз. Если же значение равно тремстам, то следует остановить рекурсию.

Однако есть одна загвоздка! Все вхождения оператора match должны возвращать значения некоторого типа (это позволяет использовать match внутри выражений). Причем типы, возвращаемые всеми вхождениями match, должны совпадать. Но нам нужно попросту ничего не делать в первом вхождении! А ничего не делать в программировании означает отсутствие операторов, которые что-то делают. Налицо конфликт! Мы должны что-то вернуть, но не можем выполнять никаких действий.

К счастью, есть выражение «()» которое означает «ничто». Это выражение также не осуществляет никаких действий. Вписав его после «=>», мы говорим компилятору, что намеренно хотим, чтобы компилятор ничего не сделал. Кроме того, компилятор делает вывод о том, что результат оператора match также является «ничем», а так как оператор match является последним оператором функции, то и возвращаемым значением функции тоже будет «ничто». Это как раз то, что нам нужно, так как функция «loop» и не должна ничего возвращать. Ее задача – вывод информации на консоль.

Задача выполнена, но есть нюансы. Код нашей функции loop рассчитывает на то, что в качестве параметра этой функции будет передано верное значение (лежащее в диапазоне между 0 и 300). Если мы ошибемся и, например, передадим в loop не «0», а, скажем, «400», то наша функцию снова никогда не завершится. Как же исправить ситуацию?

Для этого можно воспользоваться операторами сравнения «больше»/«меньше» и еще одним оператором match:

        using System.Console;

def fahrenheitToCelsius(fahrenheit)
{
  5.0 / 9 * (fahrenheit - 32)
}

def loop(fahrenheit)
{
  WriteLine("Fahrenheit: {0, 4} Celsius: {1, 5:##0.0}", 
    fahrenheit, fahrenheitToCelsius(fahrenheit));

  match (match (fahrenheit >= 0) { | true  => fahrenheit < 300 | false => false })
  {
    | true  => loop(fahrenheit + 20);
    | false => ()
  }
}

loop(400);

Разберем вложенный оператор match:

        match (fahrenheit >= 0) { | true  => fahrenheit < 300 | false => false }

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

Вторая особенность – это использование операторов «>=» и «<» – это «операторы сравнения» (изучите таблицу, приведенную ниже, чтобы понять, как работают операторы сравнения).

Если fahrenheit больше или равен нулю, оператор сравнения «>=» возвращает значение «истина» (true), которое сопоставляется с образцом «| true», что приводит к выполнению выражения «fahrenheit < 300». Оно, в свою очередь, становится равным true, если fahrenheit меньше трехсот, и false в обратном случае. Если же значение fahrenheit меньше нуля, то оператор «>=» вернет значение false, которое сопоставится с образцом «| false». В этом случае возвращаемым значением оператора match будет «false» (так как за «=>» у этого вхождения match идет выражение «false»).

Таким образом, если значение fahrenheit больше или равно нулю и меньше трехсот, match вернет true, иначе он вернет false.

Кому-то данное выражение может показаться громоздким. Охотно соглашусь с этим мнением! Как сейчас любят говорить представители молодежи – «слишком много букв». Ведь нам всего лишь нужно было связать два оператора сравнения союзом «и». В нашем коде было логично использовать оператор, аналогичный этому союзу – принимающий два логических значения и возвращающий true, если оба значения равны true, и false в противном случае. Такой оператор – «&&» – встроен во все C-подобные языки (C, C#, Java и C++). Но в Nemerle его нет. Сравните:

        match (fahrenheit >= 0)
{
  | true  => fahrenheit < 300
  | false => false
}

и

fahrenheit >= 0 && fahrenheit < 300

Несомненно, код Nemerle более громоздкий, а стало быть, менее выразительный!

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

Но такое преимущество может порадовать только на первых порах. В дальнейшем это будет серьезным недостатком! Если язык нельзя было бы расширить, то многие (и я в том числе) сочли бы такой примитивизм серьезным недостатком языка (так и происходит на практике с поздними творениями Вирта, языками Oberon и Oberon 2). К счастью, Nemerle – расширяемый язык. И основное средство его расширения – это макросы! Они позволяют убить двух зайцев сразу: оставить простой и краткой базу языка и все же позволить программистам, пишущим на Nemerle, использовать более удобные (для конкретного применения) конструкции. Но всему свое время. Скоро я покажу вам, как повысить выразительность с помощью макросов. А пока что продолжим рассмотрение кода.

Если в результате вычисления значения вложенного оператора match будет получено значение true, то управление перейдет к вхождению:

    | true  => loop(fahrenheit + 20);

внешнего оператора match. Это приводит к рекурсивному вызову функции loop.

Если же значение вложенного оператора – false, то выполняется вхождение:

    | false => ()

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

Таким образом, ошибка в аргументе (значение 400 вместо нуля) не приведет к зацикливанию. Вместо этого просто один раз будет выдано значение:

Fahrenheit  400 Celsius 204,4

Обратите также внимание на то, что в коде не использован образец «_», и на то, что изменился тип образца. В прошлом варианте образцом служило целочисленное значение. А в этом – булево (логическое). Это еще один встроенный тип данных Nemerle (и заодно .Net). Он может принимать только два значения true и false. Данный тип несовместим ни с какими другими, кроме себя. Так что если попытаться передать в оператор match выражение, тип которого не булев, например:

...
  match (fahrenheit)
  {
    | true  => loop(fahrenheit + 20);
    | false => ()
  }
...

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

f2c.n:15:7:15:11: error: expected bool, got int+ in matched value: 
System.Boolean is not a subtype of System.Int32 [simple require]

(в переводе: ожидается булево значение, а получено целое число)

Встроенные типы данных

В сообщении компилятора из предыдущего раздела:

f2c.n:15:7:15:11: error: expected bool, got int+ in matched value: 
System.Boolean is not a subtype of System.Int32 [simple require]

есть слова «bool», «System.Boolean», «int» и «System.Int32». Если до этого вы не программировали на статически типизированных языках, то сообщаю вам, что это типы данных. Откуда они взялись? Их вывел компилятор. Компилятор Nemerle довольно умен, чтобы угадывать тип параметров (и переменных, о которых речь пойдет дальше) на основании того, чем эти параметры инициализируются, и даже от того, в каком контексте они используются. Компилятор видит, что параметр fahrenheit подставляется в оператор match, все вхождения в котором имеют булев тип (булев тип в Nemerle имеет имя «bool»). Также он видит, что параметр складывается с «20», и делает вывод, что параметр также должен быть целочисленным значением (32-битное целочисленное значение в Nemerle имеет тип «int»). Компилятор пытается унифицировать эти типы, но так как это не удается, он выдает сообщение об ошибке, гласящее, что «ожидается bool, а получен int+».

Про «+» я все расскажу позже, когда дойдет время. А сейчас я лучше поясню, что такое System.Boolean, System.Int32 и откуда они здесь взялись. System.Boolean и System.Int32 – это название типов «bool» и «int» соответственно, принятые в .Net. Точнее сказать, что в Nemerle для типов System.Boolean и System.Int32 созданы соответствующие псевдонимы. Так что это одни и те же типы, просто какая-то часть компилятора использует имена псевдонимов, а какая-то – имена типов, принятых в .Net.

Вот список базовых типов .Net и их Nemerle-псевдонимы:

Числа с плавающей точкой (или с плавающей запятой, как принято говорить в России) – это числа способные хранить не только целую, но и дробную часть числа (десятичную), например, 4.555 или 123.1. При этом дробная часть имеет не фиксированную длину, например, 4 знака после точки, а может изменяться, «плавать». Отсюда и название: «число с плавающей точкой».

Тип void – это особый тип, который, по существу, типом и не является. Он используется, когда требуется показать, что функция или выражение не возвращает никакого значения, или как уже говорилось выше, возвращает «ничто». Этот тип не может быть назначен параметрам или переменным. Однако выражение может иметь тип void. Приведенное в предыдущем разделе выражение () как раз и имеет этот тип. Кроме того, тип void имеет и функция loop.

Также в Nemerle есть типы, определяемые пользователями (типы, которые можно описать в исходном файле), и функциональный тип. Но это уже более высокие материи, о которых речь пойдет немного позже.

Сейчас важно понимать, что у любого значения в Nemerle есть тип.

Вывод типов и их явное описание

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

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

        using System.Console;

def fahrenheitToCelsius(fahrenheit : int) : double
{
  5.0 / 9 * (fahrenheit - 32)
}

def loop(fahrenheit : int) : void
{
  WriteLine("Fahrenheit: {0, 4} Celsius: {1, 5:##0.0}", 
    fahrenheit, fahrenheitToCelsius(fahrenheit));

  match (match (fahrenheit >= 0)
         {
           | true  => fahrenheit < 300
           | false => false
         })
  {
    | true  => loop(fahrenheit + 20);
    | false => ()
  }
}

loop(0);

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

Кроме того, в Nemerle можно указывать не только типы параметров функций и переменных, но и типы вообще любых выражений. Например, вместо того, чтобы использовать константу с плавающей точкой «5.0», можно явно указать тип в нужной части выражения:

        def fahrenheitToCelsius(fahrenheit : int) : double
{
  (5 : double) / 9 * (fahrenheit - 32)
}

Синтаксис уточнения типа (а именно так называется данная операция) является «выражение : тип».

Макросы

Первый макрос

В начале повествования я говорил, что первые примеры могут быть не очень выразительны, и что по ходу дела мы будем их улучшать. В примере, выводящем список соответствий температур, я использовал вложенный оператор match. При этом я заметил, что с точки зрения выразительности приведенный код уступает аналогичному коду на C-подобных языках, и обещал повысить выразительность. Самое время это сделать.

Для начала давайте скомпилируем нашу программу, выводящую список соответствий температур, принудительно отключив макросы, входящие в стандартную библиотеку. Для этого нам потребуется добавить еще один ключ компиляции – «-nostdmacros». Проделайте это и запустите программу на выполнение. Командная строка для компиляции теперь должна выглядеть примерно так:

ncc -nostdmacros -no-color f2c.n -out: f2c.exe

@echo off
ncc -nostdmacros -no-color %1.n -out:%1.exe
if %errorlevel% == 0 %1.exe

Программа перестала работать корректно? Не пугайтесь. Всему виной приоритеты операторов, которые размещаются в стандартной библиотеке. Чтобы исправить ошибку, всего лишь нужно окружить скобками выражение «5.0 / 9»:

(5.0 / 9) * (fahrenheit - 32)

Сделайте это и попытайтесь скомпилировать код еще раз. Получилось? Тогда двинемся дальше.

Теперь нужно создать еще один исходный файл, в котором будут находиться макросы, которые мы будем писать. Назовем его MyMacroses.n.

Макрос, реализующий оператор «&&», имеющийся в C-подобных языках, будет выглядеть так:

          macro @&& (e1, e2) 
{
  <[ 
    match ($e1)
 {
      | true  => $e2
      | false => false
    }
  ]>
}

Поместите этот код в файл MyMacroses.n и скомпилируйте его в библиотеку. Командная строка для этого должна быть примерно такой:

ncc -no-color -target:library MyMacroses.n -ref:Nemerle.Compiler.dll -out:MyMacroses.dll

Что же изменилось в командной строке, за исключением имени исходного файла (MyMacroses.n)?

Во-первых, добавился ключ «-target:library». Он приказывает компилятору генерировать библиотеку, а не исполняемый файл. Во-вторых, изменилось расширение выходного файла (на dll, что расшифровывается как Dynamic Link Library, т.е. динамически подключаемая библиотека). И, в-третьих, был добавлен ключ «-ref:Nemerle.Compiler.dll» которые приказывает компилятору добавить ссылку на библиотеку «Nemerle.Compiler.dll». Nemerle.Compiler.dll – это библиотека, в которой реализован компилятор Nemerle. Утилита ncc.exe, которой мы все это время пользовались для сборки наших программ, на самом деле всего лишь предоставляет интерфейс командной строки. Вся же логика компилятора реализована в Nemerle.Compiler.dll, которую и использует ncc.exe.

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

Итак, если вы сделали все верно, то после выполнения приведенной выше команды в текущем каталоге появится файл MyMacroses.dll. Это сборка, содержащая наш первый макрос.

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

Для этого в командную строку, собирающую эту программу, нужно добавить ключ «-macros:MyMacroses.dll». В итоге командная строка должна выглядеть примерно так:

ncc -nostdmacros -no-color f2c.n -macros:MyMacroses.dll -out: f2c.exe

          @echo off
set PATH=%ProgramFiles%\Nemerle;%PATH%

rem %1 - имя файла программы
rem %2 - имя файла библиотеки маросов
if "%1" == "" goto usage
if "%2" == "" goto usage

rem Компилируем библиотеку макросов
ncc -no-color -target:library %2.n -ref:Nemerle.Compiler.dll -out:%2.dll
rem Завершаем пакетный файл в случае неудачи компиляции
if NOT %errorlevel% == 0 exit /B %errorlevel%

rem Компилируем программу
ncc -nostdmacros -no-color %1.n  -macros:%2.dll -out:%1.exe
rem Завершаем пакетный файл в случае неудачи компиляции
if NOT %errorlevel% == 0 exit /B %errorlevel%


rem Запускаем программу на исполнение
%1.exe
rem Завершаем командный файл
exit /B 0

rem Вывод описания использования командного файла
:usage
echo usage: c.cmd ProgramFileName MacrosesFileName

c f2c MyMacroses

Теперь мы можем воспользоваться макросом «&&» в нашей программе. Заменим вложенный match следующим образом:

          using System.Console;

def fahrenheitToCelsius(fahrenheit)
{
  (5.0 / 9) * (fahrenheit - 32)
}

def loop(fahrenheit)
{
  WriteLine("Fahrenheit: {0, 4} Celsius: {1, 5:##0.0}", 
    fahrenheit, fahrenheitToCelsius(fahrenheit));

  match (fahrenheit >= 0 && fahrenheit < 300)
  {
    | true  => loop(fahrenheit + 20);
    | false => ()
  }
}

loop(0);

Теперь скомпилируем программу. Не забудьте перед этим скомпилировать макро-сборку, в которой находится код макроса «&&». Сборка MyMacroses.dll должна находиться в том же каталоге, что и исходный файл f2c.n. Проще всего для этого воспользоваться приведенным выше командным файлом.

К сожалению, во время компиляции вы получите сообщение об ошибке:

f2c.n:13:10:13:59: error: in argument #1 of <.s, needed a int, got bool-: 
System.Boolean is not a subtype of System.Int32 [simple require]

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

          match ((fahrenheit >= 0) && (fahrenheit < 300))

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

Проблему с приоритетами можно решить, добавив в начало файла файл MyMacroses.n следующие строки:

          using Nemerle.Internal;

[assembly: OperatorAttribute("Nemerle.Core", "*",  false, 260, 261)]
[assembly: OperatorAttribute("Nemerle.Core", "/",  false, 260, 261)]
[assembly: OperatorAttribute("Nemerle.Core", "+",  false, 240, 241)]
[assembly: OperatorAttribute("Nemerle.Core", "-",  false, 240, 241)]
[assembly: OperatorAttribute("Nemerle.Core", "<",  false, 210, 211)]
[assembly: OperatorAttribute("Nemerle.Core", ">",  false, 210, 211)]
[assembly: OperatorAttribute("Nemerle.Core", "<=", false, 210, 211)]
[assembly: OperatorAttribute("Nemerle.Core", ">=", false, 210, 211)]
[assembly: OperatorAttribute("Nemerle.Core", "==", false, 165, 166)]
[assembly: OperatorAttribute("Nemerle.Core", "!=", false, 165, 166)]
[assembly: OperatorAttribute("Nemerle.Core", "&&", false, 160, 161)]
[assembly: OperatorAttribute("Nemerle.Core", "||", false, 150, 151)]

macro @&& (e1, e2) 
{
  <[ 
    match ($e1)
 {
      | true  => $e2
      | false => false
    }
  ]>
} 

Это описание приоритетов операторов, задаваемое с помощью глобального атрибута OperatorAttribute. Об атрибутах речь пойдет в следующих главах. Сейчас это не важно. Сейчас важно понимать, что означают параметры этого атрибута. Первый параметр задает пространство имен, в котором объявлены операторы. "Nemerle.Core" – это системное пространство имен, которое считается открытым по умолчанию (т.е. оно открыто автоматически, и его не надо открывать вручную). Второй параметр – это имя оператора. Третий сообщает, является ли оператор унарным (true) или бинарным (false). Унарный оператор имеет один аргумент. Например, если нам нужно изменить знак числа, то мы пишем «-x». Минус в данном случае – это унарный оператор. А если мы из одного числа вычитаем другое («2 – 1»), то применяем бинарный оператор. Следующие два параметра задают приоритет операторов (справа и слева соответственно). Чем ниже число, тем ниже приоритет. Так, для оператора «||» мы задали самый низкий приоритет (150), а для «*» и «/» – самый высокий. При этом у знаков «*» и «/» приоритет одинаковый.

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

Разбор первого макроса

Теперь давайте разберемся с нашим первым макросом:

          macro @&& (e1, e2) 
{
  <[ 
    match ($e1)
 {
      | true  => $e2
      | false => false
    }
  ]>
}

Что это такое – макрос? Из чего же он состоит? И что он делает?

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

Единственное внешнее отличие макроса от функции заключается в том, что он предваряется ключевым словом «macro».

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

В нашем случае тело макроса состоит из выражения:

  <[ 
    match ($e1)
 {
      | true  => $e2
      | false => false
    }
  ]>

В этом выражении заключена определенная магия! Дело в том, что код (в данном случае оператор match), заключенный в скобки вида «<[ ]>» рассматривается компилятором не как текст программы, который нужно преобразовать в исполняемый код, а как некий шаблон фрагмента кода, который требуется преобразовать в специальное внутреннее представление, используемое в компиляторе. Такое представление называется AST (Abstract Syntax Tree, Абстрактное синтаксическое дерево). Именно такой тип имеют параметры макроса и именно такой тип нужно возвратить из макроса.

Такой шаблон в Nemerle называется квази-цитатой. С цитатой, думаю, все понятно. Мы как бы цитируем код. А что значит приставка «квази»? Вы, наверно, обратили внимание, что внутри приведенной выше цитаты есть выражения «$e1» и «$e2». Это ссылки на соответствующие параметры макроса («e1» и «e2»). Знак «$» нужен, чтобы указать компилятору, что это не код внутри цитаты, а именно ссылки на выражения, объявленные вне цитаты. Эти выражения подставляются в цитату (в том месте, где на них ссылаются) и тем самым формируют результирующий код.

В коде программы в макрос передаются два выражения:

fahrenheit >= 0 

и

fahrenheit < 300

Они подставляются вместо «$e1» и «$e2», и в результате формируется код:

          match (fahrenheit >= 0)
 {
      | true  => fahrenheit < 300
      | false => false
    }

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

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

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

Внимательный читатель мог заметить, что осталось два неясных момента:

1. Что означает знак «@» перед «&&»?

2. Как компилятор догадывается, что макрос описывает оператор?

Знак «@» – это специальный символ, используемый в языке для указания того, что некоторое имя является просто обычным именем (идентификатором), а не специальным именем (именем оператора или ключевым словом).

Например, мы не можем в программе дать чему-нибудь (например, функции или ее параметру) имя def или match. Но если мы в начало такого имени добавим знак «@», то компилятор поймет, что это именно имя, а не ключевое слово, и позволит нам его использовать. Причем в метаинформации программы данное имя будет храниться так, как будто у него нет префикса «@».

Что касается операторов то, во-первых, компилятор рассматривает все последовательности символов состоящие из символов: '=', '<', '>', '@', '^', '&', '-', '+', '|', '*', '/', '$', '%', '!', '?', '~', '.', ':' и '#' именами операторов. А во-вторых, компилятор позволяет использовать макросы, имеющие один или два параметра, как операторы. Таким образом, можно создать операторы с буквенными именами (например, «and» и «or»).

К любому макросу можно обратиться как к функции (через синтаксис вызова функции). Так что в нашей программе можно использовать макрос «&&» следующим образом:

...
  match (@&&(fahrenheit >= 0,  fahrenheit < 300))
...

Компилятор понял бы нас.

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

На этом мы завершим первое знакомство с макросами. Nemerle поддерживает несколько видов макросов и предоставляет мощные средства для обработки кода в них. Но чтобы понять, зачем они нужны и как они работают, нам придется поближе познакомиться с самим Nemerle.

Промежуточный итог

Вас это может удивить, но описанных возможностей языка уже хватает, чтобы написать весьма нетривиальную программу. Конечно, без знания библиотек и с довольно ограниченным арсеналом операторов, который я продемонстрировал вам, будет непросто написать сложную программу. В следующих главах мы устраним этот недостаток. Так что не думайте, что Nemerle – ограниченный язык. Мы просто только в самом начале пути.

Ссылки

• http://nemerle.org – Сайт языка.
• http://nemerle.org/Download – здесь можно загрузить инсталлятор компилятор и интеграцию с Microsoft Visual Studio.
• http://rsdn.ru/forum/nemerle – русскоязычный форум по языку программирования Nemerle.
• http://groups.google.com/group/nemerle-en – англоязычный форум по языку программирования Nemerle.
• http://rsdn.ru/summary/3766.xml – статьи по языку программирования Nemerle на русском языке.
• http://nikovs-blog.blogspot.com/2007/02/nemerle.html - интересный блог, описывающий первые впечатления о языке.
• http://habrahabr.ru/blogs/nemerle/ - блоги о Nemerle на habrahabr.ru.