Предисловие

Стандартные типы, классы и связанные функции

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

data Bool :: * Исходный код

(&&) :: Bool -> Bool -> Bool infixr 3 Исходный код

Булево "и"

(||) :: Bool -> Bool -> Bool infixr 2 Исходный код

Булево "или"

not :: Bool -> Bool Исходный код

Булево "не"

otherwise :: Bool Исходный код

otherwise определяется как значение True. Оно помогает сделать условия более читаемыми. Например:

 f x | x < 0     = ...
     | otherwise = ...

data Maybe a Исходный код

Тип Maybe инкапсулирует необязательное значение. Значение типа Maybe a содержит значение типа a (представленное как Just a) или пустое (представленное как Nothing). Использование Maybe – хороший способ справиться с ошибками или исключительными случаями, не прибегая к радикальным мерам, таким как error.

Тип Maybe также является монадой. Это простой вид монад ошибок, где все ошибки представлены как Nothing. Более богатая монада ошибок может быть построена с помощью типа Either.

maybe :: b -> (a -> b) -> Maybe a -> b Source

Функция maybe принимает значение по умолчанию, функцию и значение Maybe. Если значение Maybe равно Nothing, функция возвращает значение по умолчанию. В противном случае она применяет функцию к значению внутри Just и возвращает результат.

Примеры

>>> maybe False odd (Just 3)
True

>>> maybe False odd Nothing
False

>>> import Text.Read ( readMaybe )
>>> maybe 0 (*2) (readMaybe "5")
10
>>> maybe 0 (*2) (readMaybe "")
0

>>> maybe "" show (Just 5)
"5"
>>> maybe "" show Nothing
""

data Either a b Source

Тип Either представляет значения с двумя возможностями: значение типа Either a b является либо Left a, либо Right b.

Тип Either иногда используется для представления значения, которое либо правильное, либо ошибка; по соглашению, конструктор Left используется для хранения значения ошибки, а конструктор Right используется для хранения правильного значения (мнемоника: «right» также означает «правильно»).

Примеры

>>> let s = Left "foo" :: Either String Int
>>> s
Left "foo"
>>> let n = Right 3 :: Either String Int
>>> n
Right 3
>>> :type s
s :: Either String Int
>>> :type n
n :: Either String Int

>>> let s = Left "foo" :: Either String Int
>>> let n = Right 3 :: Either String Int
>>> fmap (*2) s
Left "foo"
>>> fmap (*2) n
Right 6

>>> import Data.Char ( digitToInt, isDigit )
>>> :{
    let parseEither :: Char -> Either String Int
        parseEither c
          | isDigit c = Right (digitToInt c)
          | otherwise = Left "parse error"
>>> :}

>>> :{
    let parseMultiple :: Either String Int
        parseMultiple = do
          x <- parseEither '1'
          y <- parseEither '2'
          return (x + y)
>>> :}

>>> parseMultiple
Right 3

>>> :{
    let parseMultiple :: Either String Int
        parseMultiple = do
          x <- parseEither 'm'
          y <- parseEither '2'
          return (x + y)
>>> :}

>>> parseMultiple
Left "parse error"

either :: (a -> c) -> (b -> c) -> Either a b -> c Source

Анализ вариантов для типа Either. Если значение Left a, примените первую функцию к a; если Right b, примените вторую функцию к b.

Примеры

>>> let s = Left "foo" :: Either String Int
>>> let n = Right 3 :: Either String Int
>>> either length (*2) s
3
>>> either length (*2) n
6

data Ordering :: * Source

data Char :: * Source

Тип символов Char — это перечисление, чьи значения представляют собой символы Юникода (или, что эквивалентно, ISO/IEC 10646) (см. http://www.unicode.org/ для получения подробностей). Этот набор расширяет набор символов ISO 8859-1 (Latin-1) (первые 256 символов), который сам по себе является расширением набора символов ASCII (первые 128 символов). Символьная литерал в Haskell имеет тип Char.

Для преобразования Char в соответствующее значение Int Юникода используйте toEnum и fromEnum соответственно из класса Enum (или, что эквивалентно, ord и chr).

type Строка = [Символ] Источник

A String представляет собой список символов. Константы строк в Haskell — это значения типа String.

Кортежи

fst :: (a, b) -> a Источник

Извлечение первого компонента пары.

snd :: (a, b) -> b Источник

Извлечение второго компонента пары.

curry :: ((a, b) -> c) -> a -> b -> c Источник

curry преобразует некаррированную функцию в каррированную.

uncurry :: (a -> b -> c) -> (a, b) -> c Источник

uncurry преобразует каррированную функцию в функцию над парами.

Базовые типы классов

class Eq a where Источник

Класс Eq определяет равенство (==) и неравенство (/=). Все основные типы данных, экспортируемые Prelude, являются экземплярами Eq, а Eq можно вывести для любого типа данных, чьи составляющие также являются экземплярами Eq.

Минимальное полное определение: либо == или /=.

class Eq a => Ord a where Source

Класс Ord используется для типов данных с полным порядком.

Экземпляры Ord могут быть получены для любого пользовательского типа данных, составные типы которого принадлежат к Ord. Заявленный порядок конструкторов в объявлении данных определяет порядок в полученных экземплярах Ord. Тип Ordering позволяет определить точный порядок двух объектов с помощью одного сравнения.

Минимальное полное определение: либо compare либо <=. Использование compare может быть более эффективным для сложных типов.

class Enum a where Source

Класс Enum определяет операции над последовательно упорядоченными типами.

Методы enumFrom... используются в Haskell для перевода арифметических последовательностей.

Экземпляры Enum могут быть выведены для любого типа перечисления (типы, у конструкторов которых нет полей). Предполагается, что нулевые конструкторы пронумерованы слева направо fromEnum с 0 по n-1. Дополнительные подробности см. в главе 10 документации Haskell.

Для любого типа, который является экземпляром класса Bounded а также Enum, должны выполняться следующие условия:

• Вызовы succ maxBound и pred minBound должны привести к ошибке времени выполнения.
• fromEnum и toEnum должны выдавать ошибку времени выполнения, если значение результата не представимо в типе результата. Например, toEnum 7 :: Bool - это ошибка.
• enumFrom и enumFromThen должны быть определены с явным ограничением, таким образом:

   enumFrom     x   = enumFromTo     x maxBound
   enumFromThen x y = enumFromThenTo x y bound
     where
       bound | fromEnum y >= fromEnum x = maxBound
             | otherwise                = minBound

class Ограниченный a where Источник

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

Класс Bounded может быть выведен для любого типа перечисления; minBound — это первый конструктор, указанный в объявлении data, а maxBound — последний. Bounded также может быть выведен для типов данных с одним конструктором, составные типы которых находятся в Bounded.

Числа

Числовые типы

data Int :: * Source

Целочисленный тип с фиксированной точностью, имеющий по крайней мере диапазон [-2^29 .. 2^29-1]. Точный диапазон для данной реализации можно определить с помощью minBound и maxBound из класса Bounded.

data Integer :: * Source

Инвариант: Jn# и Jp# используются, если значение не помещается в S#

Полезные свойства, вытекающие из инвариантов:

• abs (S# _) <= abs (Jp# _)

• abs (S# _) <  abs (Jn# _)

data Float :: * Source

Числа с плавающей точкой одинарной точности. Желательно, чтобы этот тип был по крайней мере равен по диапазону и точности типу IEEE одинарной точности.

data Double :: * Источник

Числа с плавающей запятой двойной точности. Желательно, чтобы этот тип был по крайней мере равен по диапазону и точности типу IEEE двойной точности.

type Рациональное число = Ratio Целое число Источник

Рациональные числа произвольной точности, представленные как отношение двух Integer значений. Рациональное число можно построить, используя оператор %.

data Целочисленное беззнаковое слово :: * Источник

Беззнаковое целочисленное значение с размером, совпадающим с размером Int.

Числовые классы

class Числовой a где Источник

Базовый числовой класс.

abs x * signum x == x

класс (Num a, Ord a) => Real a где Источник

class (Real a, Enum a) => Целочисленный a где Источник

Целые числа, поддерживающие целочисленное деление.

(x `quot` y)*y + (x `rem` y) == x

(x `div` y)*y + (x `mod` y) == x

класс Num a => Дробный a где Источник

Дробные числа, поддерживающие действительное деление.

класс Дробный a => Плавающий a где Источник

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

class (Real a, Fractional a) => RealFrac a where Источник

Извлечение компонентов дробей.

class (RealFrac a, Floating a) => RealFloat a where Источник

Эффективный, независимый от машины доступ к компонентам числа с плавающей запятой.

Числовые функции

subtract :: Num a => a -> a -> a Source

то же самое, что и flip (-).

Поскольку - обрабатывается специально в грамматике Haskell, (- e) — это не секция, а применение префиксного отрицания. Однако (subtract exp) эквивалентно запрещённой секции.

even :: Integral a => a -> Bool Source

odd :: Integral a => a -> Bool Source

gcd :: Integral a => a -> a -> a Source

gcd x y — это наибольший неотрицательный общий делитель x и y, то есть такой общий делитель x и y, который сам делится на любой их общий делитель; например, gcd 4 2 = 2, gcd (-4) 6 = 2, gcd 0 4 = 4. gcd 0 0 = 0. (То есть наибольший общий делитель в порядке делимости.)

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

lcm :: Integral a => a -> a -> a Source

lcm x y — наименьшее положительное целое число, которое делит как x, так и y.

(^) :: (Num a, Integral b) => a -> b -> a infixr 8 Source

возведение числа в неотрицательную целую степень

(^^) :: (Fractional a, Integral b) => a -> b -> a infixr 8 Source

возведение числа в целую степень

fromIntegral :: (Integral a, Num b) => a -> b Source

общее приведение из целочисленных типов

realToFrac :: (Real a, Fractional b) => a -> b Source

общее приведение к типам с плавающей точкой

Моноиды

class Monoid a where Source

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

• mappend mempty x = x

• mappend x mempty = x

• mappend x (mappend y z) = mappend (mappend x y) z

• mconcat = foldr mappend mempty

Названия методов относятся к моноиду списков при конкатенации, но существует много других экземпляров.

Некоторые типы могут рассматриваться как моноид более чем одним способом, например, как сложение, так и умножение чисел. В таких случаях мы часто определяем newtypes и делаем эти экземпляры Monoid, например Sum и Product.

Моноиды и функторы

class Functor f where Source

Класс Functor используется для типов, по которым можно выполнять отображение. Экземпляры Functor должны удовлетворять следующим законам:

fmap id  ==  id
fmap (f . g)  ==  fmap f . fmap g

Экземпляры Functor для списков, Maybe и IO удовлетворяют этим законам.

(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4 Источник

Инфиксный синоним для fmap.

Примеры

>>> show <$> Nothing
Nothing
>>> show <$> Just 3
Just "3"

>>> show <$> Left 17
Left 17
>>> show <$> Right 17
Right "17"

>>> (*2) <$> [1,2,3]
[2,4,6]

>>> even <$> (2,2)
(2,True)

class Functor f => Applicative f where Источник

Функтор с применением, предоставляющий операции для

• встраивания чистых выражений (pure), и
• последовательного выполнения вычислений и объединения их результатов (<*>).

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

тождество

pure id <*> v = v

композиция

pure (.) <*> u <*> v <*> w = u <*> (v <*> w)

гомоморфизм

pure f <*> pure x = pure (f x)

перестановка

u <*> pure y = pure ($ y) <*> u

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

• u *> v = pure (const id) <*> u <*> v

• u <* v = pure const <*> u <*> v

Вследствие этих законов, Functor экземпляр для f будет удовлетворять

• fmap f x = pure f <*> x

Если f также является Monad, оно должно удовлетворять

• pure = return

• (<*>) = ap

(что подразумевает, что pure и <*> удовлетворяют законам функтора с применением).

класс Applicative m => Monad m где Источник

Класс Monad определяет основные операции над монадой, концепцией из области математики, известной как теория категорий. Однако с точки зрения программиста Haskell лучше рассматривать монаду как абстрактный тип данных действий. Выражения Haskell's do предоставляют удобный синтаксис для записи монадных выражений.

Примеры Monad должны удовлетворять следующим законам:

• return a >>= k  =  k a

• m >>= return  =  m

• m >>= (x -> k x >>= h)  =  (m >>= k) >>= h

Кроме того, операции Monad и Applicative должны быть связаны следующим образом:

• pure = return

• (<*>) = ap

Вышеупомянутые законы подразумевают:

• fmap f xs  =  xs >>= return . f

• (>>) = (*>)

и что pure и (<*>) удовлетворяют законам функционального аппликативного типа.

Примеры Monad для списков, Maybe и IO определённые в Prelude удовлетворяют этим законам.

mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m () Источник

Применяет каждое элементу структуры монадное действие, оценивает эти действия слева направо и игнорирует результаты. Для версии, которая не игнорирует результаты, см. mapM.

Начиная с версии base 4.8.0.0, mapM_ это просто traverse_, специализированная для Monad.

sequence_ :: (Foldable t, Monad m) => t (m a) -> m () Источник

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

Начиная с версии base 4.8.0.0, sequence_ это просто sequenceA_, специализированная для Monad.

(=<<) :: Monad m => (a -> m b) -> m a -> m b infixr 1 Источник

То же, что и >>=, но с переставленными аргументами.

Склады и обходы

class Foldable t where Source

Структуры данных, которые можно сложить.

Например, задан тип данных

data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

подходящий экземпляр будет

instance Foldable Tree where
   foldMap f Empty = mempty
   foldMap f (Leaf x) = f x
   foldMap f (Node l k r) = foldMap f l `mappend` f k `mappend` foldMap f r

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

instance Foldable Tree where
   foldr f z Empty = z
   foldr f z (Leaf x) = f x z
   foldr f z (Node l k r) = foldr f (f k (foldr f z r)) l

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

foldr f z t = appEndo (foldMap (Endo . f) t ) z

foldl f z t = appEndo (getDual (foldMap (Dual . Endo . flip f) t)) z

fold = foldMap id

sum, product, maximum, и minimum должны быть в сущности эквивалентны foldMap формам, таким как

sum = getSum . foldMap Sum

но могут быть менее определёнными.

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

foldMap f = fold . fmap f

что подразумевает, что

foldMap f . fmap g = foldMap (f . g)

foldr f z = foldr f z . toList

foldl f z = foldl f z . toList

foldr1 f = foldr1 f . toList

foldl1 f = foldl1 f . toList

class (Functor t, Foldable t) => Traversable t where Source

Функторы, представляющие структуры данных, которые можно пройти слева направо.

Определение traverse должно удовлетворять следующим законам:

естественность

t . traverse f = traverse (t . f) для каждой аппликативной трансформации t

тождество

traverse Identity = Identity

составление

traverse (Compose . fmap g . f) = Compose . fmap (traverse g) . traverse f

Определение sequenceA должно удовлетворять следующим законам:

естественность

t . sequenceA = sequenceA . fmap t для каждой аппликативной трансформации t

тождество

sequenceA . fmap Identity = Identity

составление

sequenceA . fmap Compose = Compose . fmap sequenceA . sequenceA

где аппликативная трансформация — это функция

t :: (Applicative f, Applicative g) => f a -> g a

сохраняющая операции Applicative, т.е.

• t (pure x) = pure x

• t (x <*> y) = t x <*> t y

и тождественный функтор Identity и композиция функторов Compose определяются как

  newtype Identity a = Identity a

  instance Functor Identity where
    fmap f (Identity x) = Identity (f x)

  instance Applicative Indentity where
    pure x = Identity x
    Identity f <*> Identity x = Identity (f x)

  newtype Compose f g a = Compose (f (g a))

  instance (Functor f, Functor g) => Functor (Compose f g) where
    fmap f (Compose x) = Compose (fmap (fmap f) x)

  instance (Applicative f, Applicative g) => Applicative (Compose f g) where
    pure x = Compose (pure (pure x))
    Compose f <*> Compose x = Compose ((<*>) <$> f <*> x)

(Закон естественности подразумевается параметричностью.)

Экземпляры аналогичны Functor, например, задан тип данных

data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

подходящий экземпляр будет

instance Traversable Tree where
   traverse f Empty = pure Empty
   traverse f (Leaf x) = Leaf <$> f x
   traverse f (Node l k r) = Node <$> traverse f l <*> f k <*> traverse f r

Это подходит даже для абстрактных типов, так как законы для <*> подразумевают форму ассоциативности.

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

• В экземпляре Functor, fmap должен быть эквивалентен обходу с тождественным аппликативным функтором (fmapDefault).
• В экземпляре Foldable, foldMap должен быть эквивалентен обходу с постоянным аппликативным функтором (foldMapDefault).

Разные функции

id :: a -> a Источник

Функция тождества.

const :: a -> b -> a Источник

Функция константы.

(.) :: (b -> c) -> (a -> b) -> a -> c infixr 9 Источник

Композиция функций.

flip :: (a -> b -> c) -> b -> a -> c Источник

Меняет порядок первых двух аргументов функции.

($) :: (a -> b) -> a -> b infixr 0 Источник

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

    f $ g $ h x  =  f (g (h x))

Он также полезен в ситуациях с высшим порядком функций, таких как map ($ 0) xs, или zipWith ($) fs xs.

until :: (a -> Bool) -> (a -> a) -> a -> a Источник

until p f возвращает результат применения f до тех пор, пока p не станет истинным.

asTypeOf :: a -> a -> a Источник

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

error :: [Char] -> a Источник

error останавливает выполнение и отображает сообщение об ошибке.

undefined :: a Источник

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

seq :: a -> b -> b Источник

Значение seq a b — неопределённо, если a — неопределённо, а в противном случае равно b . Обычно seq используется для повышения производительности, избегая ненужной лени.

Замечание по порядку вычислений: выражение seq a b не гарантирует, что a будет вычислено до b. Единственная гарантия, предоставляемая seq, заключается в том, что a и b будут вычислены до того, как seq вернёт значение. В частности, это означает, что b может быть вычислено до a . Если вам нужно гарантировать определённый порядок вычислений, используйте функцию pseq из пакета "parallel".

($!) :: (a -> b) -> a -> b infixr 0 Источник

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

Операции со списками

map :: (a -> b) -> [a] -> [b] Источник

map f xs — это список, полученный путём применения f к каждому элементу xs, т.е.,

map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn]
map f [x1, x2, ...] == [f x1, f x2, ...]

(++) :: [a] -> [a] -> [a] infixr 5 Источник

Присоединение двух списков, т.е.,

[x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
[x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]

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

filter :: (a -> Bool) -> [a] -> [a] Источник

filter, применённая к предикату и списку, возвращает список элементов, удовлетворяющих предикату; т.е.,

filter p xs = [ x | x <- xs, p x]

head :: [a] -> a Источник

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

last :: [a] -> a Источник

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

tail :: [a] -> [a] Источник

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

init :: [a] -> [a] Источник

Возвращение всех элементов списка, кроме последнего. Список должен быть непустым.

(!!) :: [a] -> Int -> a infixl 9 Источник

Оператор индексации списка (индекс), начиная с 0. Он является примером более общей функции genericIndex, которая принимает индекс любого целочисленного типа.

reverse :: [a] -> [a] Источник

reverse xs возвращает элементы xs в обратном порядке. xs должен быть конечным.

Специальные свертки

and :: Foldable t => t Bool -> Bool Источник

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

or :: Foldable t => t Bool -> Bool Источник

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

any :: Foldable t => (a -> Bool) -> t a -> Bool Источник

Определяет, удовлетворяет ли какой-либо элемент структуры предикату.

all :: Foldable t => (a -> Bool) -> t a -> Bool Источник

Определяет, удовлетворяют ли все элементы структуры предикату.

concat :: Foldable t => t [a] -> [a] Source

Конкатенация всех элементов контейнера списков.

concatMap :: Foldable t => (a -> [b]) -> t a -> [b] Source

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

Создание списков

Сканирование

scanl :: (b -> a -> b) -> b -> [a] -> [b] Source

scanl аналогично foldl, но возвращает список последовательных результирующих значений слева направо:

scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]

Обратите внимание, что

last (scanl f z xs) == foldl f z xs.

scanl1 :: (a -> a -> a) -> [a] -> [a] Source

scanl1 является вариантом scanl, у которого нет аргумента начального значения:

scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]

scanr :: (a -> b -> b) -> b -> [a] -> [b] Source

scanr — это правая версия scanl. Обратите внимание, что

head (scanr f z xs) == foldr f z xs.

scanr1 :: (a -> a -> a) -> [a] -> [a] Source

scanr1 является вариантом scanr, у которого нет аргумента начального значения.

Бесконечные списки

iterate :: (a -> a) -> a -> [a] Source

iterate f x возвращает бесконечный список повторных применений f к x:

iterate f x == [x, f x, f (f x), ...]

repeat :: a -> [a] Source

repeat x — это бесконечный список, где значение каждого элемента — x.

replicate :: Int -> a -> [a] Source

replicate n x — это список длиной n со значением x каждого элемента. Он является примером более общей genericReplicate, в которой n может быть любого целочисленного типа.

cycle :: [a] -> [a] Source

cycle преобразует конечный список в циклический, или эквивалентно, в бесконечное повторение исходного списка. Это тождественная функция для бесконечных списков.

Подсписки

take :: Int -> [a] -> [a] Source

take n, применённое к списку xs, возвращает префикс xs длины n, или сам список xs , если n > length xs:

take 5 "Hello World!" == "Hello"
take 3 [1,2,3,4,5] == [1,2,3]
take 3 [1,2] == [1,2]
take 3 [] == []
take (-1) [1,2] == []
take 0 [1,2] == []

Это пример более общей функции genericTake, в которой n может быть любого целочисленного типа.

drop :: Int -> [a] -> [a] Source

drop n xs возвращает суффикс xs после первых n элементов, или сам список [] если n > length xs:

drop 6 "Hello World!" == "World!"
drop 3 [1,2,3,4,5] == [4,5]
drop 3 [1,2] == []
drop 3 [] == []
drop (-1) [1,2] == [1,2]
drop 0 [1,2] == [1,2]

Это пример более общей функции genericDrop, в которой n может быть любого целочисленного типа.

splitAt :: Int -> [a] -> ([a], [a]) Source

splitAt n xs возвращает кортеж, где первым элементом является префикс xs длины n, а вторым — остаток списка:

splitAt 6 "Hello World!" == ("Hello ","World!")
splitAt 3 [1,2,3,4,5] == ([1,2,3],[4,5])
splitAt 1 [1,2,3] == ([1],[2,3])
splitAt 3 [1,2,3] == ([1,2,3],[])
splitAt 4 [1,2,3] == ([1,2,3],[])
splitAt 0 [1,2,3] == ([],[1,2,3])
splitAt (-1) [1,2,3] == ([],[1,2,3])

Это эквивалентно (take n xs, drop n xs) , когда n не _|_ (splitAt _|_ xs = _|_). splitAt является примером более общей функции genericSplitAt, в которой n может быть любого целочисленного типа.

takeWhile :: (a -> Bool) -> [a] -> [a] Source

takeWhile, применённое к предикату p и списку xs, возвращает самый длинный префикс (возможно пустой) xs элементов, удовлетворяющих p:

takeWhile (< 3) [1,2,3,4,1,2,3,4] == [1,2]
takeWhile (< 9) [1,2,3] == [1,2,3]
takeWhile (< 0) [1,2,3] == []

dropWhile :: (a -> Bool) -> [a] -> [a] Source

dropWhile p xs возвращает суффикс, оставшийся после takeWhile p xs:

dropWhile (< 3) [1,2,3,4,5,1,2,3] == [3,4,5,1,2,3]
dropWhile (< 9) [1,2,3] == []
dropWhile (< 0) [1,2,3] == [1,2,3]

span :: (a -> Bool) -> [a] -> ([a], [a]) Source

span, применённое к предикату p и списку xs, возвращает кортеж, где первым элементом является самый длинный префикс (возможно пустой) xs элементов, удовлетворяющих p, а вторым — остаток списка:

span (< 3) [1,2,3,4,1,2,3,4] == ([1,2],[3,4,1,2,3,4])
span (< 9) [1,2,3] == ([1,2,3],[])
span (< 0) [1,2,3] == ([],[1,2,3])

span p xs эквивалентно (takeWhile p xs, dropWhile p xs)

break :: (a -> Bool) -> [a] -> ([a], [a]) Source

break, применённое к предикату p и списку xs, возвращает кортеж, где первым элементом является самый длинный префикс (возможно пустой) xs элементов, не удовлетворяющих p, а вторым — остаток списка:

break (> 3) [1,2,3,4,1,2,3,4] == ([1,2,3],[4,1,2,3,4])
break (< 9) [1,2,3] == ([],[1,2,3])
break (> 9) [1,2,3] == ([1,2,3],[])

break p эквивалентно span (not . p).

Поиск в списках

notElem :: (Foldable t, Eq a) => a -> t a -> Bool infix 4 Source

notElem — это отрицание elem.

lookup :: Eq a => a -> [(a, b)] -> Maybe b Source

lookup key assocs выполняет поиск ключа в списке ассоциаций.

Объединение и разделение списков

zip :: [a] -> [b] -> [(a, b)] Source

zip принимает два списка и возвращает список соответствующих пар. Если один из входных списков короче, избыточные элементы более длинного списка отбрасываются.

zip — правая ленивая функция:

zip [] _|_ = []

zip3 :: [a] -> [b] -> [c] -> [(a, b, c)] Source

zip3 принимает три списка и возвращает список троек, аналогично zip.

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] Source

zipWith обобщает zip путём объединения с функцией, указанной в качестве первого аргумента, вместо функции построения кортежей. Например, zipWith (+) применяется к двум спискам для получения списка соответствующих сумм.

zipWith — правая ленивая функция:

zipWith f [] _|_ = []

zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d] Source

Функция zipWith3 принимает функцию, которая объединяет три элемента, а также три списка, и возвращает список их точечного объединения, аналогично zipWith.

unzip :: [(a, b)] -> ([a], [b]) Source

unzip преобразует список пар в список первых компонентов и список вторых компонентов.

unzip3 :: [(a, b, c)] -> ([a], [b], [c]) Source

Функция unzip3 принимает список троек и возвращает три списка, аналогично unzip.

Функции для строк

lines :: String -> [String] Source

lines разбивает строку на список строк по символам новой строки. Результирующие строки не содержат символы новой строки.

words :: String -> [String] Source

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

unlines :: [String] -> String Source

unlines — обратная операция к lines. Она объединяет строки, добавляя символ новой строки в конец каждой.

unwords :: [String] -> String Source

unwords — обратная операция к words. Она объединяет слова, разделяя их пробелами.

Преобразование в строку и из строки

Преобразование в String

type ShowS = String -> String Source

Функции shows возвращают функцию, которая добавляет результат String к существующей String. Это позволяет выполнять конкатенацию результатов с использованием композиции функций за постоянное время.

class Show a where Source

Преобразование значений в удобочитаемые String.

Производные экземпляры Show имеют следующие свойства, совместимые с производными экземплярами Read.

• Результат show — это синтаксически корректное выражение Haskell, содержащее только константы, учитывая директивы фиксы, действующие в момент объявления типа. Оно содержит только имена конструкторов, определённые в типе данных, скобки и пробелы. При использовании помеченных полей конструктора также используются фигурные скобки, запятые, имена полей и знаки равенства.
• Если конструктор определён как инфиксный оператор, то showsPrec создаст инфиксное применение конструктора.
• Представление будет заключено в скобки, если приоритет конструктора верхнего уровня в x меньше d (ассоциативность игнорируется). Таким образом, если d — 0, то результат никогда не будет заключён в скобки; если d — 11, он всегда будет заключён в скобки, если не является атомарным выражением.
• Если конструктор определён с помощью синтаксиса записей, то show создаст форму синтаксиса записей, с полями в том же порядке, что и в исходном объявлении.

Например, при объявлениях

infixr 5 :^:
data Tree a =  Leaf a  |  Tree a :^: Tree a

производный экземпляр Show эквивалентен

instance (Show a) => Show (Tree a) where

       showsPrec d (Leaf m) = showParen (d > app_prec) $
            showString "Leaf " . showsPrec (app_prec+1) m
         where app_prec = 10

       showsPrec d (u :^: v) = showParen (d > up_prec) $
            showsPrec (up_prec+1) u .
            showString " :^: "      .
            showsPrec (up_prec+1) v
         where up_prec = 5

Обратите внимание, что правоассоциативность :^: игнорируется. Например,

• show (Leaf 1 :^: Leaf 2 :^: Leaf 3) создаёт строку "Leaf 1 :^: (Leaf 2 :^: Leaf 3)".

showsPrec d x r ++ s  ==  showsPrec d x (r ++ s)