Главная » Haskell » Prelude: Функции – ЧАСТЬ 2

0

id  ::  a  ->  a id  x  =  x

Функция: init

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

Определение:

init  ::  [a]  ->  [a] init  [x]        =  []

init  (x:xs) =  x  : init xs

Функция: interact

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

Определение:

interact :: (String ->  String)  ->  IO () interact f =  getContents >>= (putStr . f)

Функция: intToDigit

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

Определение:

intToDigit ::  Int ->  Char

intToDigit i | i >= 0   &&  i <=   9 = toEnum  (fromEnum ’0’ + i)

| i >= 10 &&  i <= 15 = toEnum (fromEnum ’a’ + i 10)

| otherwise                 = error "Char.intToDigit: not  a digit"

Функция: intToRatio

Описание: функция для преобразования целого числа в рациональное. В качестве числителя  берется заданное число, в качестве знаменателя — 1.

Определение:

intToRatio :: Integral a =>  Int  ->  Ratio   a intToRatio x  =  fromInt x  :% 1

Функция: ioError

Описание:  функция  для  обработки ошибок,  связанных  с   действиями ввода/вывода.

Определение:

ioError ::  IOError ->  IO  a

Функция определена в виде примитива.

Функция: isAlpha

Описание: принимает на вход некоторый символ. Возвращает True, если это алфавитный символ, и False в противном случае.

Определение:

isAlpha :: Char ->  Bool

isAlpha c  = isUpper  c  || isLower  c

Функция: isAlphaNum

Описание: предикат для определения, является ли заданный символ цифрой или алфавитным символом. Возвращает True, если таковым является.

Определение:

isAlphaNum :: Char ->  Bool

isAlphaNum c  = isAlpha c  || isDigit  c

Функция: isAscii

Описание: предикат для определения, является ли заданный символ стандартным символом кодировки ASCII. Возвращает True, если таковым является. Определение:

isAscii :: Char ->  Bool isAscii c  =  fromEnum  c  < 128

Функция: isControl

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

Определение:

isControl :: Char ->  Bool

isControl c  = c  < ’ ’ || c  == ’\DEL’

Функция: isDigit

Описание: принимает на вход некоторый символ. Возвращает True, если это символьное представление цифры, и False в противном случае.

Определение:

isDigit ::  Char ->  Bool

isDigit c  = c  >= ’0’  &&  c  <= ’9’

Функция: isHexDigit

Описание: предикат для определения, является ли заданный символ шестнадцатеричной цифрой. Возвращает True, если таковым является.

Определение:

isHexDigit ::  Char ->  Bool isHexDigit c  =  isDigit c  ||

c  >= ’A’ &&  c  <= ’F’ || c  >= ’a’ &&  c  <= ’f’

Функция: isLower

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

Определение:

isLower  ::  Char ->  Bool

isLower  c  = c  >= ’a’  &&  c  <= ’z’

Функция: isOctDigit

Описание: предикат для определения, является ли заданный символ восьмеричной цифрой. Возвращает True, если таковым является.

Определение:

isOctDigit :: Char ->  Bool isOctDigit c  = c  >=  ’0’ &&  c  <= ’7’

Функция: isPrint

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

Возвращает True, если таковым является.

Определение:

isPrint ::  Char ->  Bool

isPrint c  = c  >= ’ ’  &&    c  <= ’~’

Функция: isSpace

Описание: принимает на вход некоторый символ. Возвращает True,  если этот символ является пробельным (пустым), и False в противном случае. Определение:

isSpace  :: Char  ->  Bool isSpace  c  = c  == ’ ’ ||

c  == ’\t’ ||

c  == ’\n’ ||

c  == ’\r’ ||

c  ==  ’\f’  || c  ==  ’\v’

Функция: isUpper

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

Определение:

isUpper  :: Char ->  Bool

isUpper  c  = c  >= ’A’ &&  c  <= ’Z’

Функция: iterate

Описание: применяет заданную функцию ко второму аргументу и  возвращает бесконечный список таких применений: [x, f x, f (f x),  …].

Определение:

iterate :: (a  ->  a)  ->  a  ->  [a] iterate f x  = x  :  iterate f (f x)

Функция: last

Описание: применяется к непустому списку, возвращает последний элемент заданного списка.

Определение:

last ::  [a] ->  a last [x]        = x

last (_:xs) = last  xs

Функция: lex

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

Определение:

lex   ::  ReadS  String

lex   ""                                  =  [("", "")]

lex   (c:s) | isSpace  c     = lex   (dropWhile  isSpace  s) lex   (’’:s)               =  [(’’:ch ++ "’", t) |

(ch, ’’:t) < lexLitChar s, ch  /=  "’"]

lex   (’"’:s)               =  [(’"’:str, t) |

(str,t) < lexString s] where lexString (’"’:s) =  [("\"", s)]

lexString s             = [(ch ++ str, u)  |

(ch, t) < lexStrItem  s, (str, u)  < lexString  t]

lexStrItem (’\:’&’:s)             =  [("\\&", s)] lexStrItem (’\:c:s) |  isSpace  c  = [("", t) |

’\:t < [dropWhile  isSpace  s]] lexStrItem s  =  lexLitChar  s

lex   (c:s) | isSingle c  =  [([c], s)]

| isSym c       = [(c:sym, t) |

(sym,  t) < [span  isSym s]]

| isAlpha c   = [(c:nam, t) |

(nam,  t) < [span  isIdChar s]]

| isDigit c   = [(c:ds ++ fe, t) |

(ds, s) < [span  isDigit s], (fe,  t) < lexFracExp  s]

| otherwise     = []

where isSingle c  =   c  ‘elem‘ ",;()[]{}_‘"

isSym c       =   c  ‘elem‘  "!@#$%&*+./<=>?\\^|:-~" isIdChar  c  =    isAlphaNum c  || c  ‘elem‘ "_’" lexFracExp  (’.’:s) = [(’.’:ds ++  e,  u)  |

(ds, t) < lexDigits  s, (e, u)  < lexExp  t]

lexFracExp  s  = [("", s)]

lexExp  (e:s) | e ‘elem‘ "eE"  =  [(e:c:ds,  u)  | (c:t)  < [s],

c  ‘elem‘  "+-",

(ds, u)  < lexDigits t] ++

lexExp  s  = [("", s)]

[(e:ds, t) |

(ds, t) < lexDigits s]

Функция: lexDigits

Описание: лексический анализатор для чисел. Возвращает, как и функция lex, пару строк — первым  элементом пары является найденная лексема (число), вторым — остаток строки.

Определение:

lexDigits :: ReadS  String lexDigits =  nonnull isDigit

Функция: lexLitChar

Описание: лексический анализатор для печатаемых символов. Возвращает, как и функция lex,  пару строк — первым  элементом  пары является найденная лексема (символ), вторым — остаток строки.

Определение:

lexLitChar ::  ReadS  String

lexLitChar (’\:s) = [(’\:esc, t) | (esc, t) < lexEsc  s]

where lexEsc  (c:s)       | c  ‘elem‘ "abfnrtv\\\"’" = [([c],  s)] lexEsc  (’^’:c:s) | c  >= ’@’  &&  c  <= ’_’    =  [([’^’, c], s)] lexEsc  s@(d:_)  | isDigit d =  lexDigits s

lexEsc  s@(c:_)  | isUpper  c  =

let table = (’\DEL’,"DEL") :  asciiTab

in case [(mne, s’)  | (c, mne) < table,

([], s’) < [lexmatch mne  s]]

of (pr:_)  ->  [pr] []          ->  []

lexEsc  _ = []

lexLitChar (c:s)  = [([c], s)] lexLitChar ""        = []

Функция: lexmatch

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

Определение:

lexmatch  :: (Eq  a)  => [a] ->  [a] ->  ([a], [a]) lexmatch  (x:xs) (y:ys) | x  == y   = lexmatch  xs  ys lexmatch  xs  ys                                    =  (xs, ys)

Функция: lcm

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

Определение:

lcm  :: Integral a =>  a ->  a ->  a lcm  _ 0 =  0

lcm  0 _ = 0

lcm  x  y  = abs ((x ‘quot‘ gcd x  y) * y)

Функция: length

Описание: возвращает число элементов в ограниченном списке.

Определение:

length  ::  [a]  ->  Int length  []          =  0

length (x:xs)  = 1 + length  xs

Функция: lines

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

lines :: String  ->  [String] lines []     =  []

lines (x:xs) = l : ls

where (l, xs’) = break  (==  ’\n’) (x:xs) ls | xs’  == [] = []

| otherwise = lines (tail  xs’)

Функция: log

Описание: возвращает натуральный логарифм своего аргумента.

Определение:

log  :: Floating a  => a ->  a

Функция определена в виде примитива.

Функция: lookup

Описание: функция для поиска ассоциированного значения с заданным в отображении. Отображение  задается списком вида (значение, ассоциированное значение). Результат возвращается в виде значения типа Maybe. Значение  Nothing возвращается, когда поиск неуспешен.

Определение:

lookup  :: Eq a => a ->  [(a, b)] ->  Maybe b lookup  k  []                                            =  Nothing lookup  k  ((x,  y):xys)  | k  == x       = Just  y

| otherwise = lookup  k  xys

Функция: maybe

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

Определение:

maybe :: b ->  (a  ->  b)  ->  Maybe a ->  b maybe n f Nothing    = n

maybe n f (Just  x) = f x

Функция: map

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

Определение:

map  :: (a  ->  b)  ->  [a]  ->  [b] map  f xs  =  [f x  | x  < xs]

Функция: mapM

Описание: функция для применения заданной функции ко всем элементам монады, в которую упакован исходный список. Заданная первым элементом функция

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

mapM  :: Monad  m   => (a  ->  m   b)  ->  [a] ->  m   [b] mapM  f = sequence .  map  f

Функция: mapM-

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

Определение:

mapM_  :: Monad  m   => (a  ->  m   b)  ->  [a] ->  m   () mapM_  f = sequence_ .  map  f

Функция: max

Описание: принимает на вход два значения одного типа, значения которого можно сравнивать. Возвращает максимальное значение из двух заданных в соответствии с действием оператора (>=).

Определение:

max :: Ord a =>  a ->  a ->  a max  x  y  | x  >= y        =  x

| otherwise = y

Функция: maximum

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

maximum  :: Ord a  => [a] ->  a maximum  xs  =  foldl1 max xs

Функция: min

Описание: принимает на вход два значения одного типа, значения которого можно сравнивать. Возвращает минимальное значение из двух заданных в соответствии с действием оператора (<=).

Определение:

min :: Ord a => a  ->  a ->  a min x  y  |  x  <= y       = x

|  otherwise  = y

Функция: minimum

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

minimum  :: Ord a =>  [a] ->  a minimum  xs  =  foldl1 min xs

Функция: mod

Описание: возвращает остаток от  деления одного целочисленного  аргумента на другой.

Определение:

mod  :: Integral a => a ->  a ->  a

Функция определена в виде примитива.

Функция: nonnull

Описание: функция для получения пары, состоящей из начала заданной строки (второй аргумент функции), удовлетворяющей заданному предикату (первый аргумент), и остатка строки. Используется в функциях для лексического анализа серии lex.

Определение:

nonnull :: (Char  ->  Bool)   ->  ReadS  String

nonnull p s  = [(cs, t) | (cs@(_:_), t) < [span  p s]]

Функция: not

Описание: возвращает логическое отрицание от булевского аргумента.

Определение:

not  :: Bool  ->  Bool not  True   =  False not  False  =  True

Функция: null

Описание: предикат для определения того, является ли заданный список пустым или нет. Возвращает True на пустых списках.

Определение:

null ::  [a] ->  Bool null []        =  True null  (_:_) =  False

Функция: numerator

Описание: функция для получения числителя из дробного  значения.  Работает в паре с функцией denominator.

Определение:

numerator  :: Integral a =>  Ratio   a ->  a numerator  (x :%  y) = x

Функция: numericEnumFrom

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

Определение:

numericEnumFrom  :: Real  a => a ->  [a]

numericEnumFrom  n = n : (numericEnumFrom  $! (n  + 1))

Функция: numericEnumFromThen

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

numericEnumFromThen  :: Real  a => a  -> a ->  [a] numericEnumFromThen  n m  =  iterate ((m  n)  +)  n

Функция: numericEnumFromTo

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

numericEnumFromTo  :: Real  a => a ->  a ->  [a] numericEnumFromTo  n m   = takeWhile (<=  m)  (numericEnumFrom  n)

Функция: numericEnumFromThenTo

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

Определение:

numericEnumFromThenTo  :: Real  a => a ->  a ->  a ->  [a] numericEnumFromThenTo  n n’ m      = takeWhile p  (numericEnumFromThen  n n’)

where p | n’ >= n     =  (<=  m)

| otherwise =  (>=  m)

Функция: or

Описание: применяется к списку булевских значений, возвращает их дизъюнкцию (см. также описание функции and).

Определение:

or  :: [Bool]  ->  Bool

or  xs  = foldr  (||)  False  xs

Функция: ord

Описание: применяется к символу, возвращает его код ASCII как значение типа

Integer.

Определение:

ord  ::  Char  ->  Int

Функция определена в виде примитива.

Функция: otherwise

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

Определение:

otherwise  ::  Bool otherwise  =  True

Функция: pi

Описание: возвращает отношение длины окружности к её диаметру (число ?).

Определение:

pi ::  Floating  a  => a

Функция определена в виде примитива.

Функция: putChar

Описание: функция для вывода в стандартный поток вывода заданного символа.

Определение:

putChar  ::  Char ->  IO  ()

Функция определена в виде примитива.

Функция: putStr

Описание: принимает строку в качестве аргумента и возвращает действие ввода/вывода в качестве  результата. Побочным  эффектом применения функции putStr является вывод заданной строки на экран.

Определение:

putStr ::  String ->  IO  ()

Функция определена в виде примитива.

Функция: putStrLn

Описание: функция, выводящая на экран заданную строку и  завершающая её вывод символом  перевода строки. По своему эффекту  тождественна функции putStr, за исключением описанного нюанса.

Определение:

putStrLn :: String  ->  IO () putStrLn  s  = do putStr  s

putChar  ’\n’

Функция: print

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

Определение:

print :: Show  a => a  ->  IO () print =  putStrLn . show

Функция: product

Описание: применяется к списку чисел, возвращает  произведение всех  чисел, входящих в список.

Определение:

product :: Num  a =>  [a] ->  a product xs  =  foldl (*) 1 xs

Функция: protectEsc

Описание: функция для «защиты» символов, выраженных при помощи escapeпоследовательностей.  Заменяет  символ (\) на два таких символа.

Определение:

protectEsc :: (Char  ->  Bool)   ->  ([Char] ->  a)  ->  [Char] ->  a protectEsc p f = f . cont

where cont  s@(c:_)  | p c  =  "\\&" ++ s cont  s                         =  s

Функция: rationalToDouble

Описание: функция для преобразования заданного рационального числа в действительное двойной точности (тип Double).

Определение:

rationalToDouble ::  Rational ->  Double

Функция определена в виде примитива.

Функция: rationalToFloat

Описание: функция для преобразования заданного рационального числа в действительное одинарной точности (тип Float).

Определение:

rationalToFloat ::  Rational ->  Float

Функция определена в виде примитива.

Функция: rationalToRealFloat

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

Определение:

rationalToRealFloat :: RealFloat a => Ratio  Integer ->  a rationalToRealFloat x  = x’

where x’      = f e

f e       =  if  (e’  ==  e) then  y

else  f e’

where y             = encodeFloat  (round  (x * (1  %   b)^^e)) e (_, e’) = decodeFloat  y

(_, e)  = decodeFloat  (fromInteger  (numerator x)  ‘asTypeOf‘ x’  / fromInteger  (denominator x))

b           =  floatRadix  x’

Функция: read

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

Определение:

read  :: Read a => String ->  a

read  s  =   case [x | (x, t) < reads  s, ("",  "") < lex  t]  of

[x] ->  x

[] ->  error "Prelude.read: no parse"

_     ->  error "Prelude.read: ambiguous parse"

Функция: readDec

Описание: функция для получения из заданной строки беззнакового числа в десятичном представлении.

Определение:

readDec :: Integral a => ReadS  a

readDec = readInt 10 isDigit (\d ->  fromEnum  d fromEnum  ’0’)

Функция: readHex

Описание: функция  для  получения из  заданной строки  беззнакового  числа в шестнадцатеричном представлении.

Определение:

readHex :: Integral a =>  ReadS  a readHex = readInt  16  isHexDigit hex

where hex d = fromEnum  d (if (isDigit  d)

then  fromEnum  ’0’

else  fromEnum  (if  (isUpper  d) then  ’A’

else  ’a’) 10)

Функция: readField

Описание: функция для получения из строки определённых полей данных в зависимости от их типов.

Определение:

readField :: Read a => String ->  ReadS  a readField m   s0 = [r |  (t,  s1)  < lex   s0,

t == m,

("=", s2)  < lex   s1,  r < reads  s2]

Функция: readFile

Описание: функция для полного чтения содержимого файла.

Определение:

readFile :: FilePath ->  IO String

Функция определена в виде примитива.

Функция: readFloat

Описание: функция для получения из заданной строки числового значения с плавающей точкой.

Определение:

readFloat :: RealFloat a => ReadS  a

readFloat r = [(fromRational ((n %   1)  * 10^^(k   d)), t) | (n, d, s) < readFix  r,

(k, t) < readExp  s]

where readFix r = [(read (ds  ++ ds’),  length ds’, t) | (ds,  s)  < lexDigits r,

(ds’, t)  < lexFrac s] lexFrac  (’.’:s) = lexDigits  s

lexFrac s             = [("", s)]

readExp (e:s) | e ‘elem‘ "eE"  =  readExp’  s readExp s                                        =  [(0, s)]

readExp’  (’-’:s) = [(-k, t) | (k, t) < readDec s] readExp’  (’+’:s) = readDec  s

readExp’  s             = readDec s

Функция: readInt

Описание: функция для получения из заданной строки целочисленного значения в заданном базисе.

Определение:

readInt :: Integral a => a ->  (Char  ->  Bool)   ->  (Char  ->  Int)  ->  ReadS  a readInt radix isDig digToInt s  = [(foldl1 (\n d  ->  n * radix + d)

(map (fromIntegral  . digToInt) ds), r)  |

(ds, r) < nonnull isDig s]

Функция: readIO

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

Определение:

readIO  :: Read a => String ->  IO  a readIO  s  = case [x | (x, t)  < reads  s,

("", "") < lex   t] of

[x] ->  return  x

[] ->  ioError  (userError "PreludeIO.readIO: no parse")

_     ->  ioError  (userError "PreludeIO.readIO: ambiguous parse")

Функция: readLitChar

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

Определение:

readLitChar :: ReadS  Char readLitChar  (’\:s)  = readEsc s

where readEsc (’a’:s)  =  [(’\a’, s)] readEsc  (’b’:s)  = [(’\b’, s)] readEsc (’f’:s)  =  [(’\f’, s)] readEsc  (’n’:s)  = [(’\n’, s)] readEsc (’r’:s)  =  [(’\r’, s)] readEsc  (’t’:s)  = [(’\t’, s)] readEsc (’v’:s)  =  [(’\v’, s)] readEsc  (’\:s) = [(’\, s)] readEsc (’"’:s)  =  [(’"’, s)] readEsc  (’’:s) = [(’’, s)]

readEsc (’^’:c:s) | c  >= ’@’  &&  c  <= ’_’

= [(toEnum  (fromEnum c  fromEnum  ’@’), s)] readEsc s@(d:_)  | isDigit d =  [(toEnum  n, t) |

(n,t)  < readDec s] readEsc (’o’:s)  = [(toEnum  n,  t)  |

(n, t) < readOct  s] readEsc (’x’:s)  =  [(toEnum  n, t) |

(n, t) < readHex s] readEsc s@(c:_)  |  isUpper  c

= let table = (’\DEL’,"DEL") :  asciiTab in  case [(c, s’) |  (c,  mne) < table,

([], s’) < [lexmatch  mne  s]] of (pr:_) ->  [pr]

[]          ->  [] readEsc  _                 =  []

readLitChar (c:s)        =  [(c, s)]

Функция: readLn

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

Определение:

readLn  ::  Read a => IO  a readLn  = do  l < getLine

r  < readIO  l return  r

Функция: readOct

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

Определение:

readOct  :: Integral  a  => ReadS  a

readOct  = readInt 8 isOctDigit (\d ->  fromEnum  d  fromEnum  ’0’)

Функция: readParen

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

Определение:

readParen  :: Bool  ->  ReadS  a  ->  ReadS  a readParen  b g =  if (b) then  mandatory

else  optional where optional r    =  g r ++ mandatory r

mandatory r = [(x, u)  | ("(",  s) < lex   r,

(x, t) < optional  s, (")",  u)  < lex  t]

Функция: reads

Описание: функция для чтения некоторого значения из заданной строки символов. Является синонимом метода readsPrec класса Read.

Определение:

reads  :: Read a =>  ReadS  a reads  =  readsPrec  0

Функция: readSigned

Описание: функция для получения из заданной строки знакового числового значения.

Определение:

readSigned  :: Real  a => ReadS  a ->  ReadS  a readSigned  readPos =  readParen  False  read’

where read’ r   = read’’ r ++ [(-x, t) | ("-", s) < lex   r, (x,  t) < read’’  s]

read’’ r = [(n, s) | (str, s) < lex   r,

(n, "") < readPos str]

Функция: realFloatToRational

Описание: функция для получения реального дробного значения действительного числа.

Определение:

realFloatToRational :: Real  a => ReadS  a ->  ReadS  a realFloatToRational x  = (m %   1)  *  (b  %   1)^^n

where (m,  n)  =  decodeFloat  x b           =  floatRadix  x

Функция: realToFrac

Описание: функция для перевода заданного действительного  числа в рациональное представление.

Определение:

realToFrac :: (Real  a, Fractional b)  =>  a ->  b realToFrac = fromRational .  toRational

Функция: reduce

Описание: функция для сокращения дроби. Возвращает дробь, которую нельзя сократить.

Определение:

reduce  :: Integral a => a ->  a  ->  Ratio   a

reduce  x  y  | y  == 0       = error  "Ratio.%: zero  denominator"

| otherwise = (x ‘quot‘ d)  :%  (y  ‘quot‘ d) where d = gcd x  y

Функция: repeat

Описание: принимает на вход некоторое значение, возвращает неограниченный список, составленный только из этого значения.

Определение:

repeat  :: a  ->  [a] repeat  x  = xs

where  xs  =  x:xs

Функция: replicate

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

Определение:

replicate :: Int ->  a  ->  [a] replicate n x  =  take  n (repeat x)

Функция: reverse

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

Определение:

reverse  ::  [a] ->  [a]

reverse xs  = foldl  (flip  (:)) [] xs

Функция: round

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

Определение:

round  :: (RealFrac a, Integral  b)  => a ->  b

Функция определена в виде примитива.

Функция: scanl

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

Определение:

scanl   :: (a  ->  b ->  a)  ->  a ->  [b]  ->  [a] scanl   f q xs  = q :  (case  xs  of

[]   ->  []

x:xs ->  scanl   f (f q x) xs)

Функция: scanl1

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

Определение:

scanl1  :: (a  ->  a ->  a)  ->  [a]  ->  [a] scanl1  f (x:xs) =  scanl   f x  xs

Функция: scanr

Описание: функция, осуществляющая правоассоциативное сканирование заданного списка (по аналогии с функцией scanl).

Определение:

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

scanr  f q0 []     = [q0] scanr  f q0 (x:xs) = f  x  q : qs where qs@(q:_)  = scanr  f q0 xs

Функция: scanr1

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

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

scanr1  f [x]    = [x] scanr1  f (x:xs) = f  x  q : qs where qs@(q:_)  = scanr1  f xs

Функция: sequence

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

Определение:

sequence :: Monad  m   => [m  a] ->  m   [a] sequence []          =  return []

sequence (c:cs) = do x   < c

xs  < sequence  cs return  (x:xs)

Функция: sequence-

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

sequence_ :: Monad  m   =>  [m  a] ->  m   () sequence_ =  foldr (>>)  (return ())

Функция: show

Описание: преобразует значение, тип которого должен быть из класса Show, в его строковое представление.

Определение:

show :: Show  a => a ->  String

Функция определена в виде примитива.

Функция: showChar

Описание: функция для преобразования заданного символа в строку. Используется в функции show для отображения символов.

Определение:

showChar ::  Char ->  ShowS showChar =  (:)

Функция: showField

Описание: функция для преобразования в строку определённого значения поля.

Используется в функции show для отображения полей.

Определение:

showField  :: Show  a => String ->  a  ->  ShowS

showField  m   v  = showString  m   . showChar ’=’ .  shows v

Функция: showInt

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

Определение:

showInt  :: Integral a => a  ->  ShowS

showInt  n r | n < 0 = error  "Numeric.showInt: can’t  show negative  numbers"

| otherwise = let (n’, d)  = quotRem  n 10

r’      = toEnum (fromEnum  ’0’ + fromIntegral  d)  : r

in if (n’ == 0)  then  r’

else  showInt  n’ r’

Функция: showLitChar

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

Определение:

showLitChar  :: Char  ->  ShowS

showLitChar  c  | c  > ’\DEL’ =  showChar ’\ .

protectEsc isDigit (shows  (fromEnum c)) showLitChar  ’\DEL’              =  showString  "\\DEL" showLitChar  ’\           =  showString  "\\\\" showLitChar  c  | c  >= ’ ’  =  showChar c

showLitChar  ’\a’            =  showString  "\\a" showLitChar  ’\b’                     =  showString  "\\b" showLitChar  ’\f’                     = showString  "\\f" showLitChar  ’\n’            =  showString  "\\n" showLitChar  ’\r’                     =  showString  "\\r" showLitChar  ’\t’                     = showString  "\\t" showLitChar  ’\v’            =  showString  "\\v"

showLitChar  ’\SO’               = protectEsc (’H’  ==)  (showString  "\\SO") showLitChar  c  = showString  (’\ : snd (asciiTab !!  fromEnum  c))

Функция: showParen

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

Определение:

showParen :: Bool  ->  ShowS  ->  ShowS

showParen b p = if (b) then  showChar ’(’ . p .  showChar ’)’ else  p

Функция: shows

Описание: функция для преобразования в строку некоторого заданного значения.

Является синонимом метода showsPrec класса Show.

Определение:

shows :: Show  a  =>  a ->  ShowS shows = showsPrec  0

Функция: showSigned

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

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

Определение:

showSigned :: Real  a => (a  ->  ShowS) ->  Int  ->  a ->  ShowS showSigned showPos  p x  = if (x <  0)

then  showParen (p  > 6)

(showChar ’-’ . showPos  (-x))

else  showPos  x

Функция: showString

Описание: функция для преобразования заданной строки в строку. Используется в функции show для отображения строк.

Определение:

showString  ::  String ->  ShowS showString  = (++)

Функция: sin

Описание: тригонометрическая функция для вычисления синуса. Аргумент принимается в радианах.

Определение:

sin   :: Floating a  => a ->  a

Функция определена в виде примитива.

Функция: signumReal

Описание: функция для получения знака заданного числа.

Определение:

signumReal :: (Num a, Num  b, Ord a)  => a ->  b signumReal x  | x  == 0       =    0

| x  > 0         =   1

| otherwise = -1

Функция: snd

Описание: возвращает второй элемент кортежа из двух элементов. См.  также описание функции fst.

Определение:

snd :: (a,  b)  ->  b snd  (_, y)  = y

Функция: sort

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

Определение:

sort :: Ord a =>  [a] ->  [a] sort []          =  []

sort (x:xs) = sort [y | y  < xs,   y  < x] ++ [x] ++

sort [y | y  < xs,   y  >= x]

Функция: span

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

Определение:

span :: (a  ->  Bool)   ->  [a]  ->  ([a], [a]) span p [] =  ([],  [])

span p xs@(x:xs’) | p x             = (x:ys,  zs)

| otherwise  = ([], xs)  where (ys, zs)  =  span p xs’

Функция: splitAt

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

splitAt :: Int ->  [a]  ->  ([a], [a]) splitAt 0  xs  = ([], xs)

splitAt _ [] = ([], [])

splitAt n (x:xs) | n > 0 =  (x:xs’, xs>>) where (xs’,  xs>>)  = splitAt (n  1)  xs

splitAt _ _ = error "PreludeList.splitAt:  negative  argument"

Функция: sqrt

Описание: возвращает квадратный корень из заданного числа.

Определение:

sqrt :: Floating a => a ->  a

Функция определена в виде примитива.

Функция: subtract

Описание: вычитает первый аргумент из второго.

Определение:

subtract :: Num  a =>  a ->  a ->  a subtract  =  flip (-)

Функция: sum

Описание: складывает элементы ограниченного списка чисел.

Определение:

sum :: Num  a =>  [a] ->  a sum xs  =  foldl (+) 0 xs

Функция: tail

Описание: применяется к непустому списку, возвращает список без его первого элемента.

Определение:

tail ::  [a]  ->  [a] tail  (_:xs)  =  xs

Функция: take

Описание: применяется к целому числу (положительному или 0) и списку, возвращает указанное количество элементов из начала списка.

Определение:

take  :: Int ->  [a]  ->  [a] take  0  _   = []

take  _ [] = []

take  n (x:xs) | n > 0 = x  : take  (n  1)  xs

take  _ _   = error  "PreludeList.take:  negative argument"

Функция: takeWhile

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

Определение:

takeWhile :: (a  ->  Bool)   ->  [a]  ->  [a]  takeWhile p [] = []

takeWhile p (x:xs) | p x             = x  : takeWhile p xs

|  otherwise  = []

Функция: tan

Описание: тригонометрическая функция тангенс, аргумент принимается в радианах.

Определение:

tan  :: Floating a => a ->  a

Функция определена в виде примитива.

Функция: toLower

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

Определение:

toLower  ::  Char ->  Char

toLower  c  | isUpper  c  = toEnum  (fromEnum  c  fromEnum  ’A’  + fromEnum  ’a’)

| otherwise = c

Функция: toUpper

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

Определение:

toUpper  ::  Char ->  Char

toUpper  c  | isLower  c  = toEnum  (fromEnum  c  fromEnum  ’a’  + fromEnum  ’A’)

| otherwise = c

Функция: truncate

Описание: удаляет дробную часть числа с плавающей точкой, оставляя только целую часть.

Определение:

truncate :: (RealFrac a, Integral  b)  => a ->  b

Функция определена в виде примитива.

Функция: uncurry

Описание: функция для преобразования каррированной функции в некаррированную. Действует обратно эффекту функции curry.

Определение:

uncurry :: (a  ->  b ->  c) ->  ((a,  b)  ->  c) uncurry f p = f (fst  p)  (snd  p)

Функция: undefined

Описание: функция для представления неопределенных вычислений (?).

Определение:

undefined  ::  a

undefined | False  =  undefined

Функция: unlines

Описание: преобразует список строк в единую строку, вставляя символ переноса строки между ними. Это функция является обратной к функции lines. Определение:

unlines :: [String]  ->  String

unlines xs  = concat  (map  addNewLine xs)  where  addNewLine l = l ++ "\n"

Функция: until

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

Определение:

until :: (a  ->  Bool)   ->  (a  ->  a)  ->  a ->  a until p f x  = if (p  x)  then  x

else  until p f (f x)

Функция: unwords

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

Определение:

unwords ::  [String] ->  String

unwords [] = [] unwords ws = foldr1  addSpace ws where addSpace w  s  = w  ++ (’ ’:s)

Функция: unzip

Описание: функция для преобразования списка пар в пару списков.

Определение:

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

unzip  = foldr (\(a, b)  ~(as, bs)  ->  (a:as,  b:bs)) ([], [])

Функция: unzip3

Описание: функция для преобразования списка троек в тройку списков.

Определение:

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

unzip3  = foldr (\(a,  b, c) ~(as, bs,  cs)  ->  (a:as,  b:bs, c:cs)) ([], [], [])

Функция: userError

Описание: функция, определяющая пользовательское сообщение об ошибке, возникающей в процессе выполнения действий ввода/вывода.

Определение:

userError ::  String  ->  IOError

Функция определена в виде примитива.

Функция: words

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

words :: String ->  [String] words s  |  findSpace   == [] =  []

| otherwise            = w  :  words s>> where (w,  s>>)    =  break  isSpace  findSpace

findSpace   = dropWhile  isSpace  s

Функция: writeFile

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

Определение:

writeFile :: FilePath ->  String  ->  IO ()

Функция определена в виде примитива.

Функция: zip

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

Определение:

zip   :: [a] ->  [b] ->  [(a, b)] zip   xs  ys  =  zipWith pair xs  ys

where pair x  y  = (x, y)

Функция: zip3

Описание: функция, осуществляющая те же  действия, что и функция  zip,  но упаковывающая три значения в тройку.

Определение:

zip3  :: [a] ->  [b] ->  [c] ->  [(a,  b, c)] zip3  = zipWith3 (\a  b  c  ->  (a, b, c))

Функция: zipWith

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

Определение:

zipWith :: (a  ->  b ->  c) ->  [a] ->  [b] ->  [c]  zipWith z  (a:as) (b:bs) = z  a b :  zipWith z  as bs zipWith _ _ _                    =  []

Функция: zipWith3

Описание: функция, осуществляющая те же действия, что и функция zip3,  но упаковывающая три значения в тройку при помощи заданной функции. Определение:

zipWith3 :: (a  ->  b ->  c  ->  d)  ->  [a] ->  [b] ->  [c]  ->  [d] zipWith3 z  (a:as) (b:bs) (c:cs) = z  a b c  :  zipWith3 z  as bs cs zipWith3 _ _ _ _                              =  []

Источник: Душкин Р. В., Справочник по языку Haskell. М.: ДМК Пресс, 2008. 544 с., ил.

По теме:

  • Комментарии