Skip to content

← Späť na FP

Haskel - Cheat Sheet

Zdroj: pages.kpi.fei.tuke.sk/kpi/fp/lecture-notes/cheat-sheet.html

  1. 1.1 Základy
  2. 1.1.1 Komentáre
  3. 1.1.2 Konštanty
  4. 1.1.3 Použitie operátorov a funkcií
  5. 1.1.4 Základné operátory a funkcie
  6. 1.1.5 Importy modulov
  7. 1.2 Definícia funkcie
  8. 1.2.1 Definícia funkcie viacerými rovnicami
  9. 1.2.2 Podmienené výrazy (strážcovia)
  10. 1.2.3 Lokálne funkcie
  11. 1.2.4 Viac rovníc vs. strážcovia
  12. 1.2.5 Pomocná funkcia go
  13. 1.2.6 Výraz case
  14. 1.3 Typy
  15. 1.4 Funkcie pre prácu so znakmi
  16. 1.5 N-tice
  17. 1.6 Zoznamy
  18. 1.6.1 Základné funkcie pre prácu s zoznamami
  19. 1.7 Porovnávanie vzorov (pattern matching)
  20. 1.8 Funkcie vyššieho rádu
  21. 1.8.1 Anonymne funkcie
  22. 1.8.2 Kompozícia funkcií
  23. 1.8.3 Funkcie vyššieho rádu pre prácu s zoznamami
  24. 1.8.4 Generovanie zoznamu: unfoldr
  25. 1.9 Ďalšie operácie nad zoznamami
  26. 1.10 Množinové abstrakcie
  27. 1.11 Vlastné údajové typy
    1. 1.11.1 Algebraický údajový typ
    2. 1.11.2 Rekurzívne typy
    3. 1.11.3 Parametrizované údajové typy
    4. 1.11.4 Typ Maybe (hodnota, ktorá nemusí existovať)
    5. 1.11.5 Typ Either (výsledok alebo chyba)
  28. 1.12 Typové synonyma
  29. 1.13 Typové triedy
    1. 1.13.1 Automatické odvodenie inštancie
  30. 1.14 Vstupno-výstupné operácie
    1. 1.14.1 Funkcia main
    2. 1.14.2 Vstup od používateľa
  31. 1.15 Spracovanie chýb
    1. 1.15.1 Okamžitý pád programu: error
    2. 1.15.2 Chyba v návratovom type: Maybe / Either
    3. 1.15.3 Výnimky v IO
  32. 1.16 Príklad: sumDigits tromi spôsobmi

1.1 Základy

1.1.1 Komentáre

-- Do konca riadku

{-
  Blok
-}

1.1.2 Konštanty

Čísla: 1``3.14``-42

Znaky: 'a'

Reťazce: "Hello\n"

Pravdivostné hodnoty: True``False

1.1.3 Použitie operátorov a funkcií

Infixné operátory:

1 + 2
(17 + 3) * 4 / 2 * (-1)

Aplikácia funkcie je zapisovaná v prefixnom tváre pričom argumenty sú oddelené len medzerami. Ak sú argumenty tiež výrazmi, môže byť potrebné uzavrieť ich do zátvoriek.

min 1 2               -- Minimum
max (5 - 3) (min 1 2) -- Maximum

Aplikácia funkcie má vyššiu prioritu ako operátory, takže:

1 + min 2 3  ==  1 + (min 2 3)

Funkciu s dvoma argumentmi je možné zapísať infixne, ak jej názov uzavrieme do spätných apostrofov (backtickov):

div 7 2   ==  7 `div` 2   -- 3
mod 7 2   ==  7 `mod` 2   -- 1

Záporné číslo ako argument funkcie musí byť v zátvorkách, inak ho Haskell chápe ako odčítanie:

abs (-5)        -- 5
sumDigits (-123)
abs -5          -- CHYBA: chápe sa ako  abs - 5

1.1.4 Základné operátory a funkcie

Aritmetické: +``-``*``/``div (celočíselné delenie) mod (modulo) abs (absolútna hodnota) signum (znamienko)

Reláčne: >``<``==``>=``<=``/= (nerovnosť) min``max

Logické: &&``||``not

Ďalšie: even``odd``truncate``round``sqrt

Podiel a zvyšok naraz – výsledkom je dvojica (podiel, zvyšok):

quotRem :: Integral a => a -> a -> (a, a)
divMod  :: Integral a => a -> a -> (a, a)

(q, r) = 123 `quotRem` 10   -- q = 12 (číslo bez poslednej cifry)
                            -- r = 3  (posledná cifra)

Rozdiel sa prejaví iba pri záporných číslach: quot/rem zaokrúhľujú k nule, div/mod smerom dole.

(-7) `div` 2   -- -4        (-7) `quot` 2   -- -3
(-7) `mod` 2   --  1        (-7) `rem`  2   -- -1

1.1.5 Importy modulov

Funkcie mimo štandardného Prelude je potrebné importovať. Všetky import musia byť na začiatku súboru, pred akoukoľvek definíciou (inak parse error on input 'import').

import Data.Char (digitToInt, toUpper)  -- len vybrané funkcie
import Data.List (unfoldr)
import Control.Exception (throwIO)
import Data.List                        -- celý modul

1.2 Definícia funkcie

Vo všeobecnosti:

meno parametre = výraz

Názvy parametrov sú oddelené iba medzerami. Príklad:

add x y = x + y

Názvy funkcií, premenných a parametrov musia začínať malými písmenami.

1.2.1 Definícia funkcie viacerými rovnicami

Funkcia môže byť definovaná viacerými rovnicami. Pritom ak namiesto mena parametra dáme konkrétnu hodnotu, daná rovnica sa použije iba pre zadanú hodnotu parametra. Rovnice sa prechádzajú zhora dole až kým sa nenájde taká, ktoré sa môže použiť (teda buď je tam rovnaká hodnota alebo meno premennej).

isOne 1 = True
isOne n = False

1.2.2 Podmienené výrazy (strážcovia)

Rôzny spôsob výpočtu hodnoty funkcie v závislosti od splnenia podmienky. Podmienky sú vyhodnocované zhora dole a výraz, ktorý zodpovedá prvej splnenej podmienke sa použije na výpočet výsledku. Špeciálna konštanta otherwise má hodnotu True a predstavuje podmienku, ktorá je vždy splnená.

positive x | x > 0     = True
           | x == 0    = True
           | otherwise = False

1.2.3 Lokálne funkcie

Lokálne funkcie môžu byť definované vo vnútri inej funkcie a môžu byť použité pre rozdelenie výpočtu na časti.

addSquares x y = sqx + sqy
    where sqx = x * x
          sqy = y * y

Pomocou let je možné definovať lokálne funkcie aj vo výraze.

addSquares x y = let sqx = x * x
                     sqy = y * y
                 in sqx + sqy

1.2.4 Viac rovníc vs. strážcovia

Oba zápisy môžu robiť to isté, ale fungujú inak:

-- Viac rovníc (pattern matching) – porovnáva priamo hodnotu/štruktúru argumentu
safeDivide :: Int -> Int -> Maybe Int
safeDivide _ 0 = Nothing
safeDivide x y = Just (x `div` y)

-- Strážcovia (|) – vyhodnocujú logické podmienky (True/False)
safeDivide :: Int -> Int -> Maybe Int
safeDivide x y
  | y == 0    = Nothing
  | otherwise = Just (x `div` y)
  • Viac rovníc – keď testuješ konkrétne hodnoty (0, [], Nothing, Just x) alebo rozkladáš štruktúru.
  • Strážcovia – keď potrebuješ zložitejšie podmienky (y < 0, x > y, even x).

Pozor na pokrytie všetkých prípadov – napr. pri | n > 0 = ... | otherwise = 0 padnú aj záporné čísla do otherwise:

sumDigits :: Int -> Int
sumDigits n | n < 0     = sumDigits (-n)
            | n > 0     = n `mod` 10 + sumDigits (n `div` 10)
            | otherwise = 0

1.2.5 Pomocná funkcia go

go nie je kľúčové slovo, ale zaužívaný názov lokálnej (väčšinou rekurzívnej) pomocnej funkcie. Hlavná funkcia pripraví vstup a go robí samotnú rekurziu.

sumDigits :: Int -> Int
sumDigits n = go (abs n)
  where
    go 0 = 0
    go x = x `mod` 10 + go (x `div` 10)

1.2.6 Výraz case

Pattern matching priamo vo výraze (nie len v hlavičke funkcie).

case výraz of
  vzor1 -> výsledok1
  vzor2 -> výsledok2
describe :: Maybe Int -> String
describe m = case m of
  Nothing -> "nic"
  Just x  -> "hodnota " ++ show x

1.3 Typy

Každá hodnota a funkcia má priradený typ, ktorý sa používa pri kontrole správnosti programu. Pritom typ väčšinou nie je nutné zadávať explicitne v kóde, lebo prekladač Haskellu ho dokáže odvodiť automaticky.

Na zistenie typu hodnoty alebo funkcie je možné použiť špeciálny príkaz v interaktívnom interpretátore (typy jednotlivých parametrov funkcie a výsledku sú oddelené operátorom ->).

ghci> :t 'a'
'a' :: Char

ghci> :t not
not :: Bool -> Bool

ghci> :t (&&)
(&&) :: Bool -> Bool -> Bool

Typová definícia funkcie má tvar názov :: typ a uvádza sa zvyčajne pred definíciou hodnoty funkcie:

add :: Int -> Int -> Int
add x y = x + y

Názvy typov vždy začínajú veľkými písmenami.

Typ funkcie môže tiež obsahovať typové premenné, ktoré môžu zodpovedať ľubovoľnému typu. Napríklad výsledkom funkcie id je jej argument, pričom typ výsledku je rovnaký ako typ argumentu.

id :: a -> a

Názvy typových premenných musia začínať malými písmenami. Definícia môže tiež obsahovať obmedzenie určujúce, že typová premenná môže zodpovedať len typom z určitej triedy, napríklad numerickým typom (trieda Num), typom, pre ktoré je definovaná rovnosť (trieda Eq), alebo usporiadanie (trieda Ord).

ghci> :t (+)
(+) :: Num a => a -> a -> a

ghci> :t min
min :: Ord a => a -> a -> a

ghci> :t (==)
(==) :: Eq a => a -> a -> Bool

1.4 Funkcie pre prácu so znakmi

import Data.Char
ord :: Char -> Int  -- ASCII kód
chr :: Int -> Char
isSpace, isAlpha, isDigit :: Char -> Bool
isUpper, isLower :: Char -> Bool
digitToInt :: Char -> Int
intToDigit :: Int -> Char
toUpper, toLower :: Char -> Char

1.5 N-tice

Jednoduchá údajová štruktúra spájajúca n hodnôt, ktoré môžu byť rôznych typov. Hodnoty sú uvedené v zátvorkách a oddelené čiarkami.

(1, 'a')

Typ n-tice má podobný zápis:

ghci> :t (1, 'a')
(1, 'a') :: Num t => (t, Char)

Pre 𝑛=2, teda pre dvojice, existujú funkcie pre prístup k jednotlivým hodnotám:

fst :: (a, b) -> a
snd :: (a, b) -> b

1.6 Zoznamy

Zoznam môže obsahovať ľubovoľný počet prvkov rovnakého typu. Syntax: [1, 2, 3]. Zoznam je možné skonštruovať pomocou prázdneho zoznamu ( nil) [] a operátoru cons:, ktorý slúži na pripojenie prvku k zoznamu:

[1, 2, 3]  ==  1 : 2 : 3 : []

Tieto dva výrazy ([] a :) sú dvoma konštruktormi typu zoznam.

1.6.1 Základné funkcie pre prácu s zoznamami

head :: [a] -> a            -- Prvý prvok zoznamu
tail :: [a] -> [a]          -- Všetko okrem prvého
length :: [a] -> Int        -- Dlžka zoznamu
null :: [a] -> Bool         -- Je zoznam prázdny?
(++) :: [a] -> [a] -> [a]   -- Spájanie
(!!) :: [a] -> Int -> a     -- n-tý prvok
take :: Int -> [a] -> [a]
drop :: Int -> [a] -> [a]
elem :: Eq a => a -> [a] -> Bool
last :: [a] -> a
init :: [a] -> [a]
reverse :: [a] -> [a]

1.7 Porovnávanie vzorov (pattern matching)

Namiesto názvu parametra funkcie môže byť uvedený jeho konštruktor, kde jednotlivé zložky sú označené premennými alebo sú znovu konštruktormi.

middle :: (a, b, c) -> b
middle (x, y, z) = y

To znamená, že rovnaký zápis má na pravej strane rovnice význam konštrukcie štruktúry z jednotlivých hodnôt alebo výrazov a na ľavej strane naopak rozloženie štruktúry na jednotlivé zložky. Zároveň sa kontroluje či štruktúra aktuálneho argumentu funkcie zodpovedá vzoru štruktúry v zozname parametrov. Ak štruktúra nezodpovedá, prejde sa na ďalšiu rovnicu.

Napríklad zoznam má dva konštruktory, takže funkcie spracovávajúce zoznamy je prirodzené definovať pomocou dvoch rovníc.

mySum :: Num a => [a] -> a
mySum []     = 0
mySum (x:xs) = x + mySum xs

Zložky štruktúry, ktoré nie sú používané na pravej strane rovnice je možné označiť pomocou _.

sndOfFive :: (a, b, c, d, e) -> b
sndOfFive (_, x, _, _, _) = x

1.8 Funkcie vyššieho rádu

Funkcia vyššieho rádu je funkcia, ktorej parameter alebo výsledok je iná funkcia. V typovej definícii sa typ funkcie parameteru zapisuje v zátvorkách. V zozname parametrov sa zapisuje jednoducho meno parametra, ktoré je možne na pravej strane definície používať ako funkciu.

forEach :: [a] -> (a -> b) -> [b]
forEach (x:xs) op = op x : forEach xs op
forEach [] _      = []

Pri aplikácií sa názov funkcie použije ako argument.

forEach toUpper 'ahoj'

1.8.1 Anonymne funkcie

Anonymná funkcia (nazývaná tiež lambda) je funkcia definovaná ako súčasť výrazu. Všeobecná tvar:

\ zoznam argumentov -> výraz

Napríklad:

\ x y -> x + y

Použitie vo výraze:

forEach (\x -> x + 2) [1,2,3]

1.8.2 Kompozícia funkcií

Operátor kompozície funkcií:

(f . g) x  ==  f (g x)

Kompozícia sa číta sprava doľava a umožňuje point-free zápis – bez uvedenia parametra:

-- s parametrom
sumDigits n = sum (map digitToInt (show (abs n)))

-- point-free: abs -> show -> map digitToInt -> sum
sumDigits = sum . map digitToInt . show . abs
-- -123 -> 123 -> "123" -> [1,2,3] -> 6

1.8.3 Funkcie vyššieho rádu pre prácu s zoznamami

map :: (a -> b) -> [a] -> [b]
filter :: (a -> Bool) -> [a] -> [a]
foldr :: (a -> b -> b) -> b -> [a] -> b
foldl :: (a -> b -> a) -> a -> [b] -> a
takeWhile :: (a -> Bool) -> [a] -> [a]
dropWhile :: (a -> Bool) -> [a] -> [a]
zip :: [a] -> [b] -> [(a,b)]
zipWith :: (a -> b -> c) -> [a] -> [b]
           -> [c]

1.8.4 Generovanie zoznamu: unfoldr

Opak foldr – z počiatočného stavu vygeneruje zoznam. Funkcia kroku vracia Just (prvok, novýStav) (pokračuj) alebo Nothing (koniec).

import Data.List (unfoldr)

unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
digits :: Int -> [Int]
digits = unfoldr step
  where
    step 0 = Nothing                 -- STOP
    step x = Just (r, q)             -- pridaj r, pokračuj s q
      where (q, r) = x `quotRem` 10

-- digits 123  ==  [3, 2, 1]

1.9 Ďalšie operácie nad zoznamami

-- Logické
and, or :: [Bool] -> Bool
any, all :: (a -> Bool) -> [a] -> Bool
-- Aritmetické
sum, product :: Num a => [a] -> a
-- Spájanie
concat :: [[a]] -> [a]
-- Reťazce
lines, words :: String -> [String]
unlines, unwords :: [String] -> String

1.10 Množinové abstrakcie

Jazyková konštrukcia pre definovanie zoznamov vychádzajúca z matematického zápisu pre zoznamy, napríklad:

{𝑥|𝑥∈ℕ,𝑥>1,𝑥≤20}

Všeobecný tvár:

[ výraz | generátory, filtre ]

Príklady:

[x | x <- [1..], x > 1, x <= 20]
[x + y | x <- [1..5], y <- [1..5]]

Výsledkom použitia viacerých generátorov je vygenerovanie všetkých kombinácií.

1.11 Vlastné údajové typy

Štruktúra

data Point =               -- Názov typu
        Point Float Float  -- Konštruktor

Konštruktor sa môže používať na ľavej strane rovností pre získanie zložiek štruktúry a tiež na pravej strane pre konštruovanie štruktúry.

distance :: Point -> Point -> Float
distance (Point x1 y1) (Point x2 y2) = sqrt (abs (x2-x1) + abs (y2-y1))

1.11.1 Algebraický údajový typ

Údajový typ môže mať niekoľko konštruktorov.

data Bool = True | False

data Shape = Rectangle Double Double
           | Square Double
           | RTriangle Double Double
           | Circle Double

1.11.2 Rekurzívne typy

-- Binárny strom
data Btree = Leaf Int
           | Branch Btree Btree

1.11.3 Parametrizované údajové typy

-- Binárny strom s hodnotami ľubovoľného (rovnakého) typu
data Btree a = Leaf a
             | Branch (Btree a) (Btree a)

1.11.4 Typ Maybe (hodnota, ktorá nemusí existovať)

V Haskelli neexistuje null. Namiesto toho sa používa štandardný typ:

data Maybe a = Nothing | Just a
  • Just x – výsledok existuje a je to x
  • Nothing – výsledok neexistuje
safeDivide :: Int -> Int -> Maybe Int
safeDivide _ 0 = Nothing
safeDivide x y = Just (x `div` y)

-- safeDivide 10 2  ==  Just 5
-- safeDivide 10 0  ==  Nothing

1.11.5 Typ Either (výsledok alebo chyba)

Podobné ako Maybe, ale namiesto Nothing nesie informáciu o chybe.

data Either a b = Left a | Right b
  • Left chyba – zlyhanie (napr. chybová správa)
  • Right výsledok – úspech
divideSafe :: Int -> Int -> Either String Int
divideSafe _ 0 = Left "Delenie nulou!"
divideSafe x y = Right (x `div` y)

1.12 Typové synonyma

Zavedenie nového názvu pre typ.

type String = [Char]
type Point3D = (Double, Double, Double)
type Year = Int
type Amount = Int
type Record = (Year, Amount)

1.13 Typové triedy

Typová trieda definujú množinu funkcií, ktoré musia byť realizované pre typ, ak daný typ je inštanciou triedy. To umožňuje vytvárať funkcie, ktoré nie sú obmedzené na konkrétne typy, ale pracujú s celou triedou typov.

Definícia typovej triedy obsahuje typové definície funkcií. Môže tiež obsahovať aj štandardné realizácie týchto funkcií.

class Eq a where
    -- Ak typ a je inštanciou triedy Eq
    -- musia preň byť definované funkcie
    (==) :: a -> a -> Bool
    (/=) :: a -> a -> Bool
    x /= y =  not (x == y)
    x == y =  not (x /= y)

Inštancia typovej triedy je realizácia funkcií triedy pre konkrétny typ.

data Color = RGB Int Int Int
instance Eq Color where
    (RGB r g b) == (RGB r' g' b') =
        (r == r') && (g == g') && (b == b')

Dedičnosť inštancií:

data BStree a = Tip
              | Bin a (BStree a) (BStree a)
-- Ak a je v triede Eq, potom (BStree a) je v Eq
instance Eq a => Eq (BStree a) where
    Tip == Tip = True
    (Bin x1 l1 r1) == (Bin x2 l2 r2) =
      (x1 == x2) && (l1 == l2) && (r1 == r2)

Dedičnosť typových tried:

-- Typ a musí byť v Eq aby mohol byť v Ord
class  Eq a => Ord a  where
    compare :: a -> a -> Ordering
    (<), (<=), (>=), (>) :: a -> a -> Bool
    max, min :: a -> a -> a

Uvedené príklady typových tried sú definované v štandardnej knižnici. Ďalšie štandardné typové triedy:

  • Num (aritmetické operácie +, -, *, …)
  • Integral (celé čísla Int, Integer; operácie div, mod, quotRem, …)
  • Show (funkcia show pre prevod hodnoty na reťazec)

1.13.1 Automatické odvodenie inštancie

Pre niektoré štandardné typové triedy je možné inštanciu triedy odvodiť automaticky.

data Color = RGB Int Int Int
    deriving (Eq, Show)

1.14 Vstupno-výstupné operácie

Vstupno výstupné operácie majú špeciálny typ IO a, ktorý znemožňuje ich miešanie s čisto funkcionálnym kódom.

putChar :: Char -> IO ()
putStr :: String -> IO ()
putStrLn :: String -> IO ()
print :: Show a => a -> IO ()   -- vypíše ľubovoľnú hodnotu (== putStrLn . show)

1.14.1 Funkcia main

Vstupný bod programu. Pomocou do sa píše viac IO operácií za sebou, let v do bloku definuje premenné (bez in).

main :: IO ()
main = do
  let a = 3
      b = 4
  print (hypotenuse a b)
  putStrLn ("Sucet cifier: " ++ show (sumDigits 123))

Spustenie (mimo GHCi, v termináli): runghc subor.hs

1.14.2 Vstup od používateľa

getLine :: IO String              -- načíta jeden riadok ako text
read    :: Read a => String -> a  -- prevedie text na hodnotu (Int, Double, ...)
readLn  :: Read a => IO a         -- getLine + read v jednom
  • x <- akcia – vyberie výsledok z IO akcie (napr. to, čo používateľ napísal)
  • let x = výraz – obyčajná (čistá) hodnota, bez IO
  • pri read/readLn treba povedať typ (:: Int), inak Haskell nevie, na čo prevádzať
main :: IO ()
main = do
  -- text
  putStrLn "Zadaj meno:"
  meno <- getLine
  putStrLn ("Ahoj " ++ meno)

  -- jedno číslo: getLine + read
  putStrLn "Zadaj cislo:"
  riadok <- getLine
  let n = read riadok :: Int
  print (sumDigits n)

  -- jedno číslo: readLn (kratšie)
  putStrLn "Zadaj rok:"
  rok <- readLn :: IO Int
  print (isLeapYear rok)

  -- viac čísel na jednom riadku, napr. "3 4"
  putStrLn "Zadaj dve cisla oddelene medzerou:"
  riadok2 <- getLine
  let [a, b] = map read (words riadok2) :: [Double]
  print (hypotenuse a b)

Ak chceš výzvu a vstup na tom istom riadku (putStr namiesto putStrLn), treba vypísať buffer, inak sa text zobrazí až po zadaní vstupu:

import System.IO (hFlush, stdout)

main = do
  putStr "Zadaj cislo: "
  hFlush stdout
  n <- readLn :: IO Int
  print (n * 2)

1.15 Spracovanie chýb

1.15.1 Okamžitý pád programu: error

Ekvivalent throw new Error(...) bez try/catch. Kompilátor o chybe nevie, preto sa v čistom kóde používa len výnimočne.

divide :: Int -> Int -> Int
divide _ 0 = error "Delenie nulou nie je povolene!"
divide x y = x `div` y

-- divide 10 0  =>  *** Exception: Delenie nulou nie je povolene!

1.15.2 Chyba v návratovom type: Maybe / Either

Idiomatický spôsob – volajúci je nútený ošetriť oba prípady (pozri 1.11.4, 1.11.5):

main :: IO ()
main = case divideSafe 10 0 of
  Left err  -> putStrLn ("Chyba: " ++ err)
  Right res -> putStrLn ("Vysledok: " ++ show res)

1.15.3 Výnimky v IO

Pri práci so súbormi, sieťou a pod. Výnimku je možné neskôr odchytiť cez catch alebo try.

import Control.Exception (throwIO)

loadData :: FilePath -> IO String
loadData path =
  if null path
    then throwIO (userError "Cesta nesmie byt prazdna!")
    else readFile path

1.16 Príklad: sumDigits tromi spôsobmi

-- 1. Explicitná rekurzia (div / mod)
sumDigits :: Int -> Int
sumDigits n = go (abs n)
  where
    go 0 = 0
    go x = x `mod` 10 + go (x `div` 10)

-- 2. Cez reťazec (show + digitToInt), point-free
import Data.Char (digitToInt)

sumDigits :: Int -> Int
sumDigits = sum . map digitToInt . show . abs

-- 3. Cez unfoldr + quotRem (bez prevodu na reťazec)
import Data.List (unfoldr)

sumDigits :: Int -> Int
sumDigits = sum . unfoldr step . abs
  where
    step 0 = Nothing
    step x = Just (r, q)
      where (q, r) = x `quotRem` 10

Top