Учебник по Haskell - [11]

попытаемся построить бессмысленное предложение, компилятор языка автоматически найдёт такое предло-

жение и сообщит нам об этом. Этот процесс заключается в проверке типов, к примеру если у нас есть функция

сложения чисел, и мы попытаемся передать в неё строку или список, компилятор заметит это и скажет нам

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

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

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

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

Time January True 23

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

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

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

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

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

Отметим, что такой подход с разделением вычисления на две стадии и проверкой типов называется

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

Типы | 15

вычисляться, если есть какие-то несоответствия, об ошибке программисту сообщит вычислитель, причём

только тогда, когда вычисление дойдёт до ошибки. Такой подход называют динамической типизацией.

Типы требуют серьёзных размышлений на начальном этапе, этапе определения базовых терминов и спо-

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

общий характер и допускают ненужные нам предложения? Приходится задумываться. Но если типы подо-

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

1.3 Значения

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

слов. Например в логических выражениях всего лишь два слова. Можем ли мы на что либо рассчитывать с

таким словарным запасом? Оказывается, что да. Здесь на помощь приходят синонимы. Сейчас у нас в активе

лишь два слова:

data Bool = True | False

И мы можем определить два синонима:

true :: Bool

true = True

false :: Bool

false = False

В Haskell синонимы пишутся с маленькой буквы. Синоним определяется через знак =. Обратите внимание

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

Теперь мы имеем целых четыре слова! Тем не менее, ушли мы не далеко, и два новых слова, в сущности,

не делают язык выразительнее. Такие синонимы называют константами. Это значит, что одним словом мы

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

Но наши синонимы могут определять одни слова через другие. Синонимы могут принимать параметры.

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

not :: Bool -> Bool

not True

= False

not False = True

Мы определили новое имя not с типом Bool -> Bool. Оно определяется двумя уравнениями (clause). Слева

от знака равно левая часть уравнения, а справа – правая. В первом уравнении мы говорим, что сочетание (not

True) означает False, а сочетание (not False) означает True. Опять же, мы ничего не вычисляем, мы даём

новые имена нашим константам True и False. Только в этом случае имена составные.

Если вычислителю нужно узнать, что кроется за составным именем not False он последовательно про-

анализирует уравнения сверху вниз, до тех пор, пока левая часть уравнения не совпадёт со значением not

False. Сначала мы сверим с первым:

not True

== not False

-- нет, пошли дальше

not False

== not False

-- эврика, вернём правую часть

=> True

Определим ещё два составных имени

and :: Bool -> Bool -> Bool

and False

_

= False

and True

x

= x

or

:: Bool -> Bool -> Bool

or True

_ = True

or False

x = x

Эти синонимы определяют логические операции “и” и “или”. Здесь несколько новых конструкций, но вы

не пугайтесь, они не так трудны для понимания. Начнём с _:

and False

_

= False

16 | Глава 1: Основы

Здесь cимвол _ означает, что в этом уравнении, если первый параметр равен False, то второй нам уже не

важен, мы знаем ответ. Так, если в логическом “и” один из аргументов равен False, то всё выражение равно

False. Так же и в случае с or.

Теперь другая новая конструкция:

and True

x

= x

В этом случае параметр x служит для того, чтобы перетащить значение из аргумента в результат. Кон-

кретное значение нам также не важно, но в этом случае мы полагаем, что слева и справа от =, x имеет одно

и то же значение.

Итак у нас уже целых семь имён: True, False, true, false, not, and, or. Или не семь? На самом деле, их

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

комбинации:

not (and true False)

or (and true true) (or False False)

not (not true)

not (or (or True True) (or False (not True)))

...

Обратите внимание на использование скобок, они группируют значения. Так, если бы мы написали not