SQL-волшебник
0,0
рейтинг
13 октября 2013 в 20:49

Разработка → Erlang для самых маленьких. Глава 2: Модули и функции tutorial

imageДоброго вечера, дорогие Хабровчане. Мы продолжаем изучение Erlang для самых маленьких.

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

В этой главе мы поднимемся на следующую ступень и рассмотрим модули и функции.



Исходники примеров к главе лежат здесь.

В Erlang все функции разбиты на модули. Ни одна функция не может быть исключением. Стандартные функции языка, которые мы вызываем как «глобальные» (например length, hd, tl), на самом деле тоже находятся внутри модуля. Это «встроенные функции»(Их называют BIF — Built-In Functions) и принадлежат они модулю erlang. Данный модуль импортируется по умолчанию, поэтому с ними можно работать как с отдельными функциями(об импортировании модулей смотрите дальше).

Модули


Модуль — это группа логически связанных функций, объединенных под одним именем. Грубо говоря, модули в Erlang — это аналог пространств имен из императивных языков. Они используются для того, что бы объединить функции имеющие сходное назначение. Например, функции для работы со списками находятся в модуле lists, а функции ввода-вывода в модуле io.

Для того, что бы вызвать функцию, необходимо воспользоваться следующей конструкцией: ModuleName:FunctionName(Arg1, Arg2, ..., ArgN). Для примера вызовем функцию, которая возвращает элемент переданного кортежа с указанным номером. Эта функция называется element и находится в модуле erlang.
1> erlang:element(3, {23,54,34,95}).
34

Так же есть возможность вызывать функции без явного указания модуля. Об этом написано немного дальше.

Модули содержат в себе функции и атрибуты.

Атрибуты модуля


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

Атрибуты указываются в самом начале файла с модулем и имеют следующий вид: -Name(Arg).. Название модуля должно быть атомом. Каждый атрибут указывается на отдельной строке.

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

-module(Name).
Название модуля — это единственный обязательный атрибут и он обязательно должен быть указан первым. Без него ваш модуль просто-напросто не скомпилируется. В качестве аргумента принимает атом — название модуля. Назовем наш модуль mySuperModule.
-module(mySuperModule).

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

-export([Fnct1/Arity, Fnct2/Arity, ..., FnctN/Arity])
Список экспортируемых функций — список функций модуля, которые будут доступны извне. Принимаемый атрибут — список функций. Здесь Fnct — название функции, а Arity — количество аргументов, принимаемых ей(арность). Наш модуль будет экспортировать четыре функции: add, subtr, mult, divis (сложение, вычитание, умножение, деление). Каждая функция будет принимать по два аргумента.
-export([add/2, subtr/2, mult/2, divis/2]).

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

-import(ModuleName, [Fnct1/Arite, Fnct2/Arity, ..., FnckN/Arity]).
Этот атрибут указывает, что мы хотим импортировать из модуля ModuleName функции указанные в списке, который передается вторым аргументом. Каждый импортируемый модуль указывается в отдельном атрибуте.

Зачем импортировать функции? Как упоминалось выше, для обращения к функции из другого модуля необходимо указать ее полное имя вида ModuleName:FunctionName(). Если вы не хотите каждый раз указывать имя модуля, его нужно импортировать. Этот атрибут — аналог директивы #using из языка C++. Но не стоит злоупотреблять импортированием. Полное имя функции гораздо нагляднее. Увидев его можно сразу сказать к какому модулю принадлежит вызываемая функция. В случае короткого имени, вам придется запоминать из какого модуля была импортированна эта функция.

Мы будем использовать полные имена функций, но если бы мы хотели использовать короткие имена, мы могли бы написать что то вроде следующего:
-import(io, [format/2]).

Ну и для примера давайте укажем какой-нибудь произвольный атрибут. Пусть это будет имя автора.
-author("Haru Atari").

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

Если сейчас вы попробуете скомпилировать наш модуль, то получите ошибку:
1> c(mySuperModule).
./mySuperModule.erl:2: function add/2 undefined
./mySuperModule.erl:2: function divis/2 undefined
./mySuperModule.erl:2: function mult/2 undefined
./mySuperModule.erl:2: function subtr/2 undefined

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

Функции


В базовом случае, функции в Erlang имеют следующий вид: FnctName(Arg1, Arg2, ..., ArgN) -> FunctionBody. Имя функции — атом, а ее тело — это одно или несколько выражений, разделенных запятыми. В конце тела функции ставится точка. Если функция cодержит всего одно выражение, нагляднее будет записать ее в одну строку.
add(X, Y) -> X + Y.

Наша функция принимает два аргумента и возвращает их сумму. Обратите внимание на отсутствие слова return. Дело в том, что в Erlang функция всегда возвращает результат последнего выражения. В нашем случае — это результат сложения. Поэтому слово return просто-напросто не нужно.

Но далеко не всегда функция состоит из одного выражения. В таком случае, тело функции выделяется отступом слева от остального кода. В таком случае наша функция будет выглядеть так:
add(X, Y) ->
    doSomthing(),
    X + Y.

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

Компиляция


Программы, написанные на Erlang, компилируются в промежуточный байт код, который потом выполняется в виртуальной машине. Благодаря этому приложения написанные на Erlang кроссплатформенны.

Существует несколько виртуальных машин для Erlang. Но самая распространенная — это BEAM(Bogdan/Björn's Erlang Abstract Machine). Существует еще ряд виртуальных машин (JAM и WAM), но они почти не используются и рассматривать их мы не будем.

Есть два способа компиляции: из терминала или командной строки Erlang. Давайте рассмотри оба варианта.

Для компиляции из терминала необходимо перейти в директорию с файлом и вызвать команду erlc FileName.erl. Для нашего модуля это будет выглядеть так (путь у вас будет свой).
cd ~/Erlang-for-the-little-ones/02/sources
erlc mySuperModule.erl

Для того, что бы сделать это из командной строки Erlang необходимо так же перейти в необходимую директорию командой cd("DirName"), а затем вызвать команду c(ModuleName). Обратите внимание, мы передаем название модуля, а не файла. Расширение указывать не надо.
1> cd("~/Erlang-for-the-little-ones/02/sources/").
/home/haru/Erlang-for-the-little-ones/02/sources
ok
2> c(mySuperModule).
{ok,mySuperModule}

В результате компиляции рядом с файлом mySuperModule.erl появиться файл mySuperModule.beam. Это и есть скомпилированный модуль. Теперь его можно использовать. Давайте попробуем:
1> mySuperModule:add(2, 4).
6
2> mySuperModule:divis(6,4).
1.5

Стоит упомянуть о том, что есть возможность передавать компилятору «флаги компиляции». Для этого в функцию c() необходимо передать второй аргумент — список флагов. Для примера давайте скомпилируем наш модуль в дебаг режиме:
c(mySuperModule, [debug_info]).

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

Заключение


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

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

Спасибо, что дочитали. Хорошего вам настроения и слабой связанности.

P.S. Об опечатках и ошибках прошу сообщать в личку. Спасибо за понимание.
@HaruAtari
карма
38,7
рейтинг 0,0
SQL-волшебник
Реклама помогает поддерживать и развивать наши сервисы

Подробнее
Реклама

Самое читаемое Разработка

Комментарии (15)

  • +1
    Автор, хрошее дело делаете, спасибо.
    Народ, поделитесь опытом, для каких задач кто применяет Erlang (желательно поподробней, с примерами кода)?
    • +2
      На сколько я знаю, серверная часть Яндекс диска на Erlang ездит. Хотя могу ошибаться.
      • 0
        На Erlange сделан webDAV интерфейс Яндекс.Диска. А остальная серверная часть — в основном на Питоне
    • +2
      В телекоме используется для роутинга пакетов (как я понял, для этого Эрланг и разработали), в серверах приложений (слышал, что кое-где на эрланге пишут сервер для онлайн игры). В общем, везде, где нужно что-то быстро обработать поточно, причём массово, высокопараллельно и супернадёжно.
      • +2
        И где текста мало.
    • +1
      Пишем процессинг платежных транзакций (и кучу вспомогательных вещей). Но мы не одни такие. Шведская Klarna пока еще тоже на эрланге сидит. Кроме того (из того, что еще не отметили), эрланг применяют в hft (Exante), в чем-то связаном с рекламой (насколько я понимаю, Campanja), играми (MochiMedia), интерактивным Web (Echo), видеостриммингом (Flussonic, бывший erlyvideo, код, например, тут можно посмотреть).
      • 0
        Почему Klarna «пока ещё»? Известны какие-то планы?
        • 0
          Да, у них там смутное время сейчас. Есть противоречивые сведения, но не мне рассказывать о положении вещей у них. Лучше поинтересоваться непосредственно у инсайдеров. dmitriid например.
    • 0
      Эти ребята используют его для игры.
      Pikko Server — для мультиплеерных игровых серверов.
      И даже для веб-приложений.
  • +3
    Единственное — посоветовал бы в примерах писать не ModuleName:FunctionName(Arg1, Arg2, ..., ArgN) а module_name:function_name(Arg1, Arg2, ..., ArgN).
    Первый вариант обычно понимается, как динамически вызываемая функция, типа:
    call_function(ModuleName, FunctionName) ->
        ModuleName:FunctionName().
    


    Я лично с Erlang начал знакомство тут www.rsdn.ru/article/erlang/GettingStartedWithErlang.xml — перевод официального tutorial.
    • 0
      Я тоже с этой статьи начинал — буквально за день въехал в синтаксис. Потом Армстронга и вперед.
  • 0
    А есть ли возможность сделать «return» в середине функции?
    • +1
      Именно return нет. Но, если требуется прервать выполнение из за ошибки (и при этом не выпустить ошибку наружу), можно слепить конструкцию из catch и begin… end например (но это плохой пример, потому что можно и нужно обойтись и без этого трюка, но идея должна быть ясна).
      foo(Bar) ->
          catch begin
              Zoo = do_some_very_necessary_work(),
              if 
                Bar < 5 -> throw({error, invalid_bar});
                true -> ok
              end,
              Result = do_bar(Bar, Zoo),
              {ok, Result}
          end.
      


      А насчет return из середины при happy path я не припомню, чтобы это пригождалось. Всегда находится способ (матч в голове клоза, вынести логику в лямбду или отдельную функцию) не прибегать к этому. Получается элегантнее.
    • +1
      Можно разбить тело функции на две логические ветви (как раз будет рассмотрено в следующей главе). Тогда перед выполнением функции производится проверка и выполняется та часть, которая нужна. И результат возвращается из нее.
    • 0
      Нет, нельзя. Можно бросить эксепшен, а в вызывающей функции его поймать, но как-то это не очень красиво получается, и вообще не erlang-way

      На практике этот приводит к разбиению кода на множество функций по 2-3 строки, что бы не вылезать за 2 уровня в дереве case'ов

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