Главная » Haskell » Prelude: Классы и их экземпляры

0

Класс:  Bounded

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

class Bounded a  where minBound,  maxBound  :: a

Экземпляры: (), Bool, Char, Ordering,  Int.

Класс:  Enum

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

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

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

class  Enum  a  where

succ,   pred         :: a  ->  a toEnum                 ::  Int ->  a fromEnum             :: a ->  Int enumFrom           :: a  ->  [a] enumFromThen      :: a ->  a ->  [a] enumFromTo      :: a  ->  a ->  [a]

enumFromThenTo  :: a ->  a ->  a ->  [a]

succ                                = toEnum . (1  +)           .  fromEnum pred                                = toEnum  .  subtract 1 . fromEnum enumFrom x                     =  map  toEnum [fromEnum x  ..] enumFromThen  x  y         = map  toEnum  [fromEnum x,

fromEnum  y  ..]

enumFromTo  x  y             = map  toEnum [fromEnum x  ..  fromEnum  y] enumFromThenTo  x  y  z  = map  toEnum  [fromEnum x,

fromEnum  y  .. fromEnum  z]

Экземпляры:  (),   Bool,   Char,  Ordering,   Int,   Integer,  Float,   Double,

Enum  (Ratio  a).

Для  работы с типами данных, являющимися экземплярами  класса Enum, в языке Haskell имеется возможность получения различных перечислений при помощи синтаксиса с двумя точками (..). Любой тип данных класса Enum поддер живает такой синтаксис. Например,  если имеется такое определение типа Digits:

data  Digits =  Zero   | One

|  Two      |  Three

|  Four    |  Five

|  Six      |  Seven

|  Eight | Nine deriving  Enum

то вполне можно использовать значения этого перечисления в генераторах:

evens  ::  [Digits]

evens = [Zero,  Two..Eight]

odds :: [Digits]

odds = [One,  Three..Nine]

Класс:  Eq

Описание: определяет класс типов, над которыми определены отношения равенства. Это означает, что элементы таких типов можно сравнивать друг с другом, получая значения истинности булевского типа («ИСТИНА» или «ЛОЖЬ»). Определение:

class Eq a where

(==), (/=) :: a ->  a  ->  Bool

x  == y  = not  (x /=  y) x  /=  y  = not  (x  ==  y)

Экземпляры: (),  Bool,  Char, Maybe, Either, Ordering,   [a],  (a,  b),  Int,

Integer, Float, Double, Ratio  a.

Класс:  Floating

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

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

class (Fractional  a)  => Floating  a where pi                         ::  a

exp,  log, sqrt           ::  a ->  a

(**), logBase             :: a  ->  a ->  a sin, cos,  tan             ::  a ->  a

asin, acos,  atan        ::  a ->  a sinh,  cosh,  tanh        :: a ->  a asinh, acosh,  atanh  ::  a ->  a

pi              = 4 * atan  1

x  ** y           = exp  (log x  * y) logBase  x  y  = log  y  / log  x sqrt x           =  x  ** 0.5

tan  x             = sin   x  / cos  x

sinh  x           = (exp  x   exp (-x)) / 2 cosh x           =  (exp  x  + exp (-x)) / 2 tanh  x           = sinh  x  /  cosh x

asinh  x         = log  (x + sqrt  (x * x  + 1)) acosh x         =  log  (x + sqrt (x * x  1))

atanh  x         = (log (1  + x) log  (1  x)) / 2

Экземпляры: Float, Double.

Класс:  Fractional

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

class (Num a)  =>  Fractional a where (/)                   :: a ->  a ->  a

recip            :: a  ->  a fromRational  :: Rational ->  a fromDouble      ::  Double ->  a

recip x       = 1 / x

fromDouble  = fromRational  .  toRational x  / y           = x  * recip y

Экземпляры: Float, Double, Ratio  a.

Класс:  Functor

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

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

class Functor   f where

fmap :: (a  ->  b)  ->  (f a  ->  f b)

Экземпляры: Maybe, [a], IO.

Класс:  Integral

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

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

class (Real  a, Enum  a)  => Integral  a where quot, rem,  div, mod  :: a  ->  a ->  a quotRem, divMod         ::  a ->  a ->  (a, a) even,  odd                     ::  a ->  Bool toInteger                     ::  a ->  Integer

toInt                     ::  a  ->  Int

n ‘quot‘ d = q where (q, r) =  quotRem  n d n ‘rem‘ d   = r where  (q, r) = quotRem  n d n ‘div‘ d   =  q where (q, r) = divMod n d

n ‘mod‘  d   = r where (q, r) =  divMod n d

divMod n d = if (signum  r == signum d)  then  (q   1,  r + d) else  qr

where qr@(q,  r) = quotRem  n d

even n = n  ‘rem‘  2 == 0 odd       = not  .  even

toInt  = toInt . toInteger

Экземпляры: Int, Integer, Ratio  a.

Класс:  Ix

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

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

class (Ord  a)  =>  Ix a where range         ::  (a, a)  ->  [a]

index          :: (a, a)  ->  a ->  Int inRange      ::  (a, a)  ->  a ->  Bool rangeSize  :: (a,  a)  ->  Int

rangeSize  r@(l, u)  | l > u         = 0

| otherwise = index  r u + 1

Экземпляры: (), Bool, Char, Ordering,  (a, b), Int, Integer.

Класс:  Monad

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

class  Monad  m  where return  :: a  ->  m   a

(>>=)    :: m   a ->  (a  ->  m   b)  ->  m   b (>>)      :: m  a ->  m   b ->  m   b

fail  :: String ->  m   a

p >> q = p  >>= \_ ->  q fail s  =  error  s

Экземпляры: Maybe, [a], IO.

Класс:  Num

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

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

class (Eq  a, Show  a)  => Num  a where (+), (-), (*) ::  a  ->  a ->  a negate               ::  a ->  a

abs,  signum     :: a ->  a fromInteger     ::  Integer ->  a fromInt             :: Int ->  a

x  y       = x  +  negate  y fromInt    =  fromIntegral negate  x  = 0  x

Экземпляры: (), Bool, Char, Ordering,  Int, Integer, Float, Double.

Класс:  Ord

Описание: шаблон для типов, над экземплярами которых определён порядок следования.

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

class (Eq  a)  => Ord a where

compare                         :: a ->  a ->  Ordering  (<), (<=), (>=), (>) :: a  ->  a ->  Bool

max, min                        :: a  ->  a ->  a

compare x  y  | x  == y        = EQ

| x  <= y       = LT

| otherwise = GT

x  <= y  = compare x  y  /=  GT x  <   y  =  compare x  y  == LT x  >= y  = compare x  y  /=  LT x  >   y  =  compare x  y  == GT

max x  y  | x  >=  y        = x

|  otherwise  = y

min x  y  | x  <=  y        = x

|  otherwise  = y

Экземпляры: (),  Bool,  Char, Maybe, Either, Ordering,   [a],  (a,  b),  Int,

Integer, Float, Double, Ratio  a.

Класс:  Read

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

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

type  ReadS  a = String ->  [(a, String)]

class Read a where

readsPrec  ::  Int  ->  ReadS  a readList   ::  ReadS  [a]

readList = readParen  False  (\r ->  [pr | ("[",  s)  < lex   r, pr  < readl  s  ])

where readl   s  = [([], t)   | ("]", t)  < lex   s] ++ [(x:xs,  u)  | (x, t)   < reads  s,

(xs, u)    < readl’ t] readl’ s  = [([], t)      |  ("]", t) < lex   s] ++

[(x:xs, v) | (",", t)  < lex   s, (x, u)      < reads  t, (xs,  v)    < readl’ u]

Экземпляры: (),  Bool,  Char, Maybe, Either, Ordering,   [a],  (a,  b),  Int,

Integer, Float, Double, Ratio  a.

Класс:  Real

Описание: этот класс покрывает все числовые типы, элементы  которых могут быть представлены как отношения (типичный пример — рациональные  числа). Определение:

class (Num a, Ord a)  =>  Real  a where toRational  :: a ->  Rational

Экземпляры: Int, Integer, Float, Double.

Класс:  RealFloat

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

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

class (RealFrac a, Floating a)  => RealFloat  a where floatRadix        :: a ->  Integer

floatDigits  :: a ->  Int floatRange        :: a ->  (Int,  Int) decodeFloat        :: a ->  (Integer, Int) encodeFloat        ::  Integer ->  Int ->  a exponent             :: a ->  Int

significand      :: a ->  a scaleFloat        :: Int  ->  a ->  a isNaN                   ::  a ->  Bool isInfinite          :: a ->  Bool isDenormalized ::  a  ->  Bool isNegativeZero  :: a ->  Bool isIEEE                 ::  a  ->  Bool atan2                   ::  a ->  a ->  a

exponent  x  = if (m == 0)  then  0

else  n +  floatDigits x where (m,  n)  =  decodeFloat  x

significand x  = encodeFloat  m   ( floatDigits x) where (m,  _)  =  decodeFloat  x

scaleFloat k  x  = encodeFloat  m  (n  + k) where (m,  n)  =  decodeFloat  x

atan2  y  x  | x  > 0                    = atan  (y / x)

| x  == 0 &&  y  > 0 = pi/2

| x  < 0 &&  y  > 0   = pi + atan  (y / x)

| (x <= 0 &&  y  < 0)  ||

(x < 0 &&  isNegativeZero y) || (isNegativeZero x  &&

isNegativeZero y)                  = atan2  (-y)  x

| y  == 0 &&  (x < 0 ||

isNegativeZero  x) = pi

| x  == 0 &&  y  == 0                        = y

| otherwise                                  = x  + y

Экземпляры: Float, Double.

Класс: RealFrac

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

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

class (Real  a, Fractional a)  =>  RealFrac  a where properFraction   ::  (Integral b)  => a ->  (b, a) truncate, round  :: (Integral b)  =>  a ->  b ceiling, floor  :: (Integral  b)  => a ->  b

truncate x  = m   where (m,  _)  =  properFraction x round  x  = let (n,  r) = properFraction  x

m                  = if (r < 0)  then  n 1

else  n  +  1 in  case  (signum  (abs  r   0.5))  of

-1  ->  n

0   ->  if  (even  n)  then  n else  m

1    ->  m

ceiling x  = if (r >  0)  then  n  +  1 else  n

where (n, r) = properFraction  x

floor x  = if (r <  0)  then  n   1 else  n

where (n, r) = properFraction  x

Экземпляры: Float, Double, Ratio  a.

Класс: Show

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

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

type  ShowS      =  String ->  String

class Show  a where

show          :: a ->  String showsPrec ::  Int  ->  a ->  ShowS showList    :: [a] ->  ShowS

show x                   =  showsPrec 0 x  "" showsPrec  _ x  s  = show x  ++ s showList   []     =  showString  "[]"

showList   (x:xs) = showChar ’[’ . shows x  .  showl  xs where showl  []     = showChar  ’]’

showl  (x:xs) = showChar ’,’ . shows x  . showl  xs

Экземпляры: (),  Bool,  Char, Maybe, Either, Ordering,   [a],  (a,  b),  Int,

Integer, Float, Double, Ratio  a, IO, IOError.

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

По теме:

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