Kihagyás

2. előadás

Ismétlés

λ maxBound :: Int
9223372036854775807

λ (maxBound :: Int) + 1 --> Túlcsordulás
-9223372036854775808

λ minBound :: Int
-9223372036854775808

λ (minBound :: Int) - 1
9223372036854775807
  • Int - megadott pontosságú egész szám
  • Integer - tetszőleges pontosságú egész szám
  • Float/Double - racionális számok

Típusosztályok

Valamilyen tulajdonság szerinti csoportosítása a típusoknak

λ :t (+)
(+) :: Num a => a -> a -> a
  • Num: bármilyen szám
  • Fractional: (Num) Tört számok (Float, Double)
  • Integral (Num) Egész szám
  • Floating (Fractional, így Num is) Lebegőpontos törtszám

Ad-hoc polimorfizmus Több típus is tartozhat egy függvényhez, elég annak a családját megadni (hasonlóan a metódus túlterheléshez imperatív nyelveken)

Típusmegszorítások

f :: Fractional a => a -> a -> a

a itt bármilyen számtípus lehet, ami a Fractional-ből származik le

Note: Ha csak a van megszorírva, akkor mondjuk b lehet bármilyen típus

λ :i Fractional
type Fractional :: * -> Constraint
class Num a => Fractional a where
  (/) :: a -> a -> a
  recip :: a -> a
  fromRational :: Rational -> a
  {-# MINIMAL fromRational, (recip | (/)) #-}
    -- Defined in ‘GHC.Real’
instance Fractional Float -- Defined in ‘GHC.Float’
instance Fractional Double -- Defined in ‘GHC.Float’

A Fractional típusosztály a Num-ból származik.

λ :t 3
3 :: Num p => p

A 3, mint konstans, a Num típusosztályt használja

Ebből következően a fordító tetszőlegesen bármalyik szám függvényben fogja tudni használni (típuskényszerítve már nem)

λ :t (+)
(+) :: Num p => p -> p -> p

A (+) függvény például össze tud adni bármilyen két tetszőleges azonos típusú számot.

A Num típusosztály szűkíthető például az Int, Integer típusokkal, de ez fordítva már nem igaz.

Osztás

Egészeket osztani lehet?

λ :t (/)
(/) :: Fractional a => a -> a -> a

Így nem, csak Fractional-re van implementálva.

Egész számokra az Integral osztálytípus érvényes.

λ :i Integral
type Integral :: * -> Constraint
class (Real a, Enum a) => Integral a where
  quot :: a -> a -> a
  rem :: a -> a -> a
  div :: a -> a -> a
  mod :: a -> a -> a
  quotRem :: a -> a -> (a, a)
  divMod :: a -> a -> (a, a)
  toInteger :: a -> Integer
  {-# MINIMAL quotRem, toInteger #-}
    -- Defined in ‘GHC.Real’
instance Integral Word -- Defined in ‘GHC.Real’
instance Integral Integer -- Defined in ‘GHC.Real’
instance Integral Int -- Defined in ‘GHC.Real’

Itt láthatóak az implementált függvények.

div: egész számok osztása

divMod : egész számok osztása, és moduló művelete egy rendezett párként visszaadva

-- g' :: Int -> Int -> Int
-- g'' :: Integer -> Integer -> Integer
-- ^--> ez a kettő együtt --v
g :: Integral a => a -> a -> a

Note:

= - Hozzárendelés

== - Egyenlőségvizsgálat

/= - Egyenlőtlenségvizsgálat

Prelude> :i Floating
type Floating :: * -> Constraint
class Fractional a => Floating a where
  pi :: a
  exp :: a -> a
  log :: a -> a
  sqrt :: a -> a
  (**) :: a -> a -> a
  logBase :: a -> a -> a
  sin :: a -> a
  cos :: a -> a
  tan :: a -> a
  asin :: a -> a
  acos :: a -> a
  atan :: a -> a
  sinh :: a -> a
  cosh :: a -> a
  tanh :: a -> a
  asinh :: a -> a
  acosh :: a -> a
  atanh :: a -> a
  GHC.Float.log1p :: a -> a
  GHC.Float.expm1 :: a -> a
  GHC.Float.log1pexp :: a -> a
  GHC.Float.log1mexp :: a -> a
  {-# MINIMAL pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh,
              asinh, acosh, atanh #-}
        -- Defined in `GHC.Float'
instance Floating Float -- Defined in `GHC.Float'
instance Floating Double -- Defined in `GHC.Float'

iSqrt :: Integral a => a -> a
--iSqrt i = sqrt i
iSqrt i = round (sqrt (fromIntegral i))

Függvénykompozíció

-- f (g x) -> (f ∘ g) x
-- h (f (g x)) -> (h ∘ f ∘ g) x
iSqrt :: Integral a => a -> a
iSqrt i = (round . sqrt . fromIntegral) i

-- Egyszerűsítve:
iSqrt :: Integral a => (a -> a)
iSqrt = round . sqrt . fromIntegral
  • fromIntegral: (Integral a, Num b) => a -> b
  • round: (RealFrac a, Integral b) => a -> b
add :: Int -> Int -> Int
add x y = x + y
add x y = (+) x y

add :: Int -> (Int -> Int)
add x = (+) x -- ez is ugyanaz