Funkcionalno programiranje - lightgrayÄ udno izdanjepoincare.math.rs/~ivan/files/fp/presentation.pdf · Funkcionalnoprogramiranje Čudnoizdanje January6,2020 drIvanČukić [email protected]

Funkcionalno programiranjeČudno izdanje

January 6, 2020

dr Ivan Čukić

[email protected]/~ivan

UVOD

Uvod Sadržaj kursa Haskell -- osnove, tipovi podataka Haskell -- osnovne funkcije, testiranje Sakupljači otpadaka Parcijalna aplikacija i karijevanje ADT Teorija kategorija Zaključivanje tipova -- Haskell Zaključivanje tipova -- C++ Meta-funkcije Meta-funkcije Meta-funkcije Meta-funkcije Meta-funkcije Meta-funkcije Tipovi Koncepti Koncepti

O kursu

Predavanja: Ivan Čukić

e-pošta: [email protected]

stranica kursa: www.math.rs/~ivan/?content=fp

stranica asistenta:https://ivan-ristovic.github.io/courses/fp/

ako poincare ne radi: cukic.co/to/matf/fp

Vežbe: Ivan Čukić i Ivan Ristović

3


Funkcionalno programiranje

Šta je funkcionalno programiranje?

4


Osobine FP jezika

funkcije višeg reda

čistoća

lenjost

stroga tipiziranost

Ako uzmemo sve ovo kao preduslov da jezik bude funkcionalan, većina jezikaće otpasti.

5


Jezici

Lisp -- prvi funkcionalni jezik

Haskell -- današnji sinonim za FP

Scala -- mešavina OO i FP paradigmi

Erlang -- jezik za distribuirane sisteme

Elm -- jezik za pisanje veb aplikacija

C++ -- najpopularniji funkcionalni programski jezik :)

6


Literatura

Ova prezentacija nije namenjena za učenje

Literatura će biti okačena na mojoj stranici (sve knjige se mogu naćibesplatno na internetu)

Primeri sa vežbi

7

SADRŽAJ KURSA


Zašto uzeti ovaj kurs?

FP u svakodnevnom životu

Istorijski, FP i Haskell su bili prvenstveno namenjeni akademskimkrugovima, i često se predaju kao da su i daljeSvrha ovog kursa je da prikaže praktične koncepte FP-a, i njihovu primenu ivan jezika koji se tradicionalno smatraju funkcionalnim

Ako volite da programirate

FP daje novi način razmišljanja o programerskim problemimacould have been one line in Haskell

Ako vam smeta spora evolucija vašeg omiljenog programskog jezika

9


Uslovnost

Haskell

Kreće se od nule, uvod prve dve nedeljeI oni koji su imali Haskell na nekom drugom kursu bi trebalo da prisustvujuuvoduPosle uvoda se prelazi na ozbiljnije teme

Druga polovina semestra

FP tehnike u jeziku C++Osnovno predznanje C++-a je neophodno

10


Obaveze tokom godine

Kolokvijum (30%)

Ispit (70%)

11


Uvod u Haskell

lenjost

karijevanje i parcijalna aplikacija

funkcije višeg reda

map, filter, fold

pattern matching

…

12


C++

Razlike izmedju normalnih FP jezika i C++-a

Intervali, transformacije intervala

Monade, optional/maybe, ...

Primena monada u parsiranju, …

Dizajn softvera kroz reaktivne tokove

13

HASKELL -- OSNOVE, TIPOVI PODATAKA


Implementacije Haskella

Postoje mnoge implementacije jezika Haskell:

GHC -- Glasgow Haskell Compiler

UHC -- Ultrecht Haskell Compiler

LHC -- LLVM Haskell Compiler

...

Hugs

15


Ekstenzije jezika

Prirodna evolucija jezika -- kompajleri implementiraju ekstenzije koje, ako sepokažu korisnim, mogu kasnije da postanu deo samog jezika.

Neke od interesantnih ekstenzija

OverloadedStrings

LambdaCase

...

16


Kompilacija Haskell programa

ghc program.hs # kompajlira program,

# fajl mora da ima main funkciju

Flegovi:

-Wall # upozorenja na potencijalne greške

-Werror # sva upozorenja postaju greške

--make # kompajlira projekat koji ima više modula

-o # izlazni fajl

-XEkstenzija # uključuje ekstenziju jezika

17


REPL -- read–eval–print loop

ghci # pokreće haskell REPL

ghci program.hs # pokreće REPL i učitava funkcije

# iz datog fajla

:module Modul # učitava modul (biblioteku f-ja)

:set +t # za svaki rezultat ispisuje i tip

:set +m # višelinijske definicije

:set -XEkstenzija # uključuje navedenu ekstenziju

Podešavanja se nalaze u ~/.ghci

18


Cabal -- sistem za kompilaciju projekata

cabal sandbox init # inicijalizuje ”igralište”

cabal init # pravi haskell projekat

cabal configure # priprema projekat za kompilaciju

cabal build # kompajlira projekat

19


Stack -- moderniji sistem za kompilaciju projekata

stack setup # inicijalizacija

stack new # kreiranje novog projekta

stack build # kompajlira projekat

stack ghci # pokrece GHCI

stack exec CMD # pokrece zadatu komandu

20


Liste

[] -- prazna lista

(x: xs) -- definisanje liste

-- x je glava, xs je 'rep'

[ 1, 2, 3 ] -- sintaksa za 1 : 2 : 3 : []

[ True, False ] -- lista logičkih vrednosti

21


Liste brojeva

[ 1 .. 5 ] -- [ 1, 2, 3, 4, 5 ]

[ 1, 3 .. 10 ] -- [ 1, 3, 5, 7, 9 ]

[ 5, 4 .. 1 ] -- [ 5, 4, 3, 2, 1 ]

[ 1 .. ] -- beskonačna lista

22


Stringovi

data String = [Char]

”Fun” -- [ 'F', 'u', 'n' ]

'f' : ”un” -- ”Fun”

”f” ++ ”un” -- ”Fun”

U ozbiljnijim projektima, koristiti Data.Text ili Data.ByteString tipove uz-XOverloadedStrings ekstenziju jezika.

23


Izrazi i imena

imena počinju malim slovom

cifre, velika i mala slova, _ i '

number = 6

answer = 42

f = sin

f' = cos

24


Izrazi i imena

Bilo koji izraz može da dobije ime

Između definicija se stavljaju ”;”

main = print ”You are number 6”

main' = print (”You are number” ++ ”6”)

main'' = print (”You are number” ++ show 6)

25


Lokalna imena

Listu definicija imena okružujemo vitičastim zagradama

Između definicija, kao ranije ”;”

main = let number = 6

stringified = show number

in print (”You are number” ++ stringified)

26


Lokalna imena

Listu definicija imena okružujemo vitičastim zagradama

Između definicija, kao ranije ”;”

main = print answer

where answer = 42

27


Tačke, zapete i zagrade

answer = 42; number = 6;

main = let { number = 6

; stringified = show number

}

in print (”You are number” ++ stringified)

main = print (”You are number” ++ stringified)

where { number = 6

; stringified = show number

}

28


Osobine imenovanih izraza

Promenljive nisu promenljive

x = 5

x = 6 -- greška

redosled definicija nije bitan

lenj

fakeDiv x y =

let result = div x y

in if y == 0 then 0 else q

29


Osobine imenovanih izraza

rekurzivni -- promenlive su vidljive u svojoj definiciji

answer = 42

main = let answer = answer + 1 -- beskonacna petlja

in print answer -- program se ne završava

30


Petlje

Imerativni kod

int fact(int n)

{

int result = 1;

while (n > 1) { result *= n; n--; }

return result;

}

Rekurzivni kod

fact n = if n <= 1 then 1

else n * fact (n - 1)

31


Repna rekurzija

Obična rekurzija

fact n = if n <= 1 then 1

else n * fact (n - 1)

Repna rekurzija

fact n = let helper acc n = if n <= 1

then acc

else helper (acc * n) (n - 1)

in helper 1 n

32


Funkcije

Novu funkciju definišemo na sledeći način:

add x y = x + y

add2 x = add 2 x

Ponekad možemo da preskočimo promenljive:

add2 = add 2

33


Funkcije

Ako infiksne operatore želimo da koristimo kao da su normalne funkcije:

add x y = (+) x y

add = (+)

Ako normalne funkcije želimo da koristimo kao operator

add2 x = 2 `add` x

34


Funkcije

Poziv funkcije

print add 2 3 -- error

-- ovo je poziv kao da print ima

-- tri argumenta

print (add 2 3) -- grupišemo izraz da bi Haskell znao

-- da su 2 i 3 argumenti za funkciju add

print $ add 2 3 -- alternativa je operator `$`

35


Primer: Ciklična lista

Implementirati funkcije za baratanje cikličnom listom:

insert -- dodaje element kao trenutni

swap -- zamenjuje trenutni element sledećim

remove -- uklanja trenutni element

toNext -- pomera glavu na sledeći element

toPrev -- pomera glavu na prethodni element

36


Ciklična lista -- pokušaj 1

Koristimo [Int] da reprezentujemo listu

insert :: Int -> [Int] -> [Int]

insert value list = (???)

37



swap :: [Int] -> [Int]

swap = (???)

38




swap [] = []

swap [x] = [x] -- šta ako uklonimo ovaj red?

swap (x1:x2:xs) = x2:x1:xs

39




swap (x1:x2:xs) = x2:x1:xs

swap xs = xs

40




swap xs = case xs of

[] -> []

[x] -> [x]

(x1:x2:xs) -> x2:x1:xs

41


Tipovi

Šta su tipovi sledećih vrednosti?

[True, False]

[1, 2, 3]

[]

42


Korisnički tipovi

Ako želimo da imenujemo neki postojeći tip, koristimo type ključnu reč:

-- Imena tipova počinju velikim slovom

type Ring = [Int]

insert :: Int -> Ring -> Ring

swap :: Ring -> Ring

Na ovaj način krijemo internu implementaciju od korisnika naše biblioteke.

43


Generički tipovi

Do sada smo imali samo ciklične liste celih brojeva.

Šta ako želimo da dozvolimo korisniku da pravi ciklične liste proizvoljnog tipa?(kao što bi u C++-u i Javi bio Ring<T>)

-- Tipske promenljive počinju malim slovom

type Ring t = [t]

insert :: t -> Ring t -> Ring t

swap :: Ring t -> Ring t

44


Rotiramo listu

type Ring t = [t]

focusNext :: Ring t -> Ring t

focusNext = (???)

45


Operacije kontrukcije i konkatenacije

:t (:)

:t (++)

46


Implementacija konkatenacije

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

[] ++ ys = ys

(x:xs) ++ ys = x : (xs ++ ys)

Rekli smo da ne želimo više da vidimo rekurziju. Kako ovo implementiratikoristeći fold?

47


Rotiramo listu na drugu stranu

type Ring t = [t]

focusPrev :: Ring t -> Ring t

focusPrev = (???)

48


Rotiramo listu na drugu stranu

type Ring t = [t]

focusPrev :: Ring t -> Ring t

focusPrev ts = reverse (focusNext (reverse ts))

Nije efikasno, ali je dobro za razmišljanje.

49


Kompozicija funkcija

(.) :: (b->c) -> (a->b) -> (a->c)

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

Alternativno, preko lambda funkcije.

50


Operator aplikacije funkcije

($) :: (a -> b) -> a -> b

f $ x = f x

51


Efikasnost operacija nad listama

Liste u Haskelu su jednostruko povezane -- glava i rep -- tako da pate od svihproblema koje imaju liste u drugim jezicima.

Alternativne strukture podataka: Data.Sequence, Data.Vector.

52


Efikasnost operacija nad listama

Brze operacije:

(:) -- O(1)

head -- O(1)

tail -- O(1)

Sporije operacije:

xs !! n -- O(n)

take n, drop n, splitAt n -- O(n)

xs ++ yz -- O(length xs)

53


Osnovne operacije sa listama

null -- da li je lista prazna?

head last -- prvi, odnosno poslednji element

tail init -- svi osim prvog, odnosno poslednjeg

length ”Hello world” -- 11

reverse ”Hello world” -- ”dlrow olleH”

”Hello world” !! 4 -- 'o'

54


Primeri

Ekstraktovanje prve reči iz rečenice

Ekstraktovanje prve dve reči iz rečenice

Obrnuta varijanta mapiranja

55

HASKELL -- OSNOVNE FUNKCIJE, TESTIRANJE


zip

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

zip ”Hello” ”World”

Primeri:

-- Indeksiranje elemenata liste

withIndex = zip [0..]

-- Računanje parova

pairs xs = zip xs $ tail xs

-- Provera da li je lista sortirana

isSorted xs = and [ x <= y | (x, y) <- pairs xs ]

57


zipWith

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

zipWith (+) [1..5] [5..]

58


map

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

map length $ words ”The silent old pond a mirror of ancient...”

let ws = words ”The silent old pond a mirror of ancient...”

in zip ws $ map length ws

59


filter

filter :: (a -> Bool) -> [a] -> [a]

let ws = words ”The silent old pond a mirror of ancient...”

in filter ((>5) . snd) (zip ws $ map length ws)

60


Fold

foldl

foldl1

foldr

foldr1

61


Fold - implementirati naredne funkcije

and :: [Bool] -> Bool

concat :: [[a]] -> [a]

all :: (a -> Bool) -> [a] -> Bool

any :: (a -> Bool) -> [a] -> Bool

length :: [a] -> Int

(!!) :: [a] -> Int -> a

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

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

filter :: (a -> Bool) -> [a] -> [a]

62


Generatori lista (List comprehension)

Lista svih neparnih brojeva od 1 do 42

[ x | x <- [1..42], odd x ]

63


Testiranje čistih funkcija

Čiste funkcije su lake za testiranje -- jedino što treba da uradimo je dakonstruišemo argumente koje moramo da prosledimo funkciji.

U OOP stilu programiranja, moramo da simuliramo sve potrebne delovespoljašnjeg stanja.

64


Testiranje fiksnih tačaka

prop_swap s = s == swap (swap s)

import Test.QuickCheck

quickCheck prop_swap

65

SAKUPLJAČI OTPADAKA


Baratanje memorijom

Nizak nivo

Ručno baratanje memorijom vodi ka greškama

Alokacija memorije na hipu

67


Brojanje referenci

Svako kopiranje objekta je samo povećanje brojača referenci na tajobjekat

Kad brojač postane nula, objekat je moguće uništiti

Prednosti:

Determinizam

Efikasnost

Memorijska lokalnost (koliko je i sam program)

68


Brojanje referenci

Mane:

Ciklične strukture

Mutabilne strukture

Sve operacije su mutabilne

Fragmentacija

Optimizacije:

Odloženo ažuriranje brojača

Spajanje uzastopnih promena brojača

Baferovano ažuriranje brojača

69


Mark-and-sweep

Obilazak i obeležavanje grafa objekata

Obilazak svih objekata na hipu i oslobadjanje Onih koji nisu obeleženi

Prednosti:

Radi sa ciklusima

Ne usporava program prilikom kopiranja objekata

Ne usporava program kad objekat postane đubre

70


Mark-and-sweep

Mane:

Zaustavljanje sveta

Lokalnost memorije

Fragmentacija

71


Mark-and-compact

Obilazak i obeležavanje grafa objekata

Sabijanje:

Proizvoljno: nije bitan redosled objekata posle sabijanjaLinearno: srodni objekti susedni (srodnost kroz pokazivače)Klizajuće: održava se prethodni poredak

Memorijska lokalnost?

72


Mark-and-compact: Two finger compaction

Pogodan za objekte iste veličine

Particionisanje skupa sa dva pokazivača

Pripada proizvoljnim algoritmima sabijanja

73


Mark-and-compact

Prednosti:

Mala fragmentacija

Lokalnost

Mane:

Sporo skupljanje otpadaka

74


Mark-and-compact

Kombinacija sa mark-and-sweep -- tek kad fragmentacija postane velika, radise sabijanje.

75


Kopirajući GC

Razdvajanje prostora na fromspace i tospace

Novi objekti se alociraju u tospace delu

Ako nema mesta, živi objekti se pomeraju u fromspace

Stavljaju se prosledjivački pokazivači umesto njih

Uloge fromspace i tospace se obrću

76


Kopirajući GC

Prednosti:

Lokalnost

Jednostavno skupljanje otpadaka

Brza alokacija

Mala fragmentacija

Mane:

Manji prostor za alokacije

Kopiranje podataka

Problem kopiranja velikih besmrtnih objekata

77


GC sa generacijama

Stari objekti se retko uništavaju

Novi objekti su često kratkotrajni

Kratkotrajni objekti su retko kad veliki

78


GC sa generacijama

Razdvajanje hipa na više segmenata

Novi objekti se uvek prave u segmentu za najmladje

Objekti koji prožive nekoliko ciklusa u jednom segmentu se pomeraju usegment za starije

Skupljanje otpadaka se fokusira na segmente za mlade dok je to moguće

79


Linearni tipovi

Nije dozvoljeno kopiranje

Jedna vrednost može da se iskoristi samo jednom

Nema potrebe za brojanjem referenci, ni GC-om

Determinističko uništavanje objekta

80

PARCIJALNA APLIKACIJA I KARIJEVANJE


Parcijalna aplikacija

Od n-arne funkcije f pravimo novu funkciju g tako što funkciji f vežemo nekeod argumenata za konkretne vrednosti.

sum = \ init xs -> foldr (+) init xs

82


Karijevanje

Drugačiji pogled na funkcije -- n-arne funkcije gledamo kao funkcije jednogargumenta:

f x y z = x + y + z

f' = \ x -> \ y -> \ z -> x + y + z

83

ADT


Stanja programa

Zadatak: Napraviti program koji za datu internet adresu vraca koliko reci natoj adresi ima.

85


Stanja programa

struct state_t {

bool started = false;

bool finished = false;

unsigned count = 0;

string url;

socket_t web_page;

};

86


Stanja programa

struct state_t {

bool started = false;

bool finished = true;

unsigned count = 42;

string url = ”http://math.rs”;

socket_t web_page = …;

};

87


Proizvod tipova

Proizvod tipova A i B je tip čija vrednost sadrži tačno jednu vrednost tipa A itačno jednu vrednost tipa B.

88


Primeri

(Int, String)

data Context c = MkContext String c

89


Miš

90


Stanja programa

Stanja:

Inicijalno

Stanje brojanja

Krajnje stanje

91


Stanja programa

enum mode {

initial,

running,

finished

};

92


Suma tipova

Suma tipova A i B je tip čija vrednost sadrži ili jednu vrednost tipa A ili jednuvrednost tipa B.

93


Maybe

data Maybe a = Nothing | Just a

94


Either

data Either a b = Left a | Right b

95


Result

data Result a = Error String | Value a

96


Brojač

data Brojac = Initial { url :: String }

| Counting { count :: Int, reader :: Int }

| Finished { count :: Int }

97

TEORIJA KATEGORIJA


Uvod

Apstraktna teorija funkcija.

99


Osnovni pojmovi

Metagraf se sastoji iz objekata a, b, c, ..., i strelica f, g, h, ..., i dve operacije:

Domen, koja dodeljuje objekat a = dom f svakoj strelici f

Kodomen, koja dodeljuje objekat b = cod f svakoj strelici f

_

Oznaka da su a i b domen, odnosno kodomen strelice f je:

f: a -> b

100


Osnovni pojmovi

Def. Kategorija je metagraf koji ima dve dodatne operacije:

Identitet, koji dodeljuje strelicu id_b = 1_b : b -> b svakom objektub, gde 1_b zadovoljava 1_b . f = f i g . 1_b = g za svako f : a ->

b i g : b -> c.

Kompozicija, koja dodeljuje strelicu g . f svakom paru strelica f i g sadom g = cod f. g . f se naziva kompozicijom strelica g i f sa g . f :

dom f -> cod g. Kompozicija mora biti asocijativna.

101


Primeri kategorija

Skupovi i funkcije

Grupe i homomorfizmi

102


Hask kategorija

Kategorija gde su objekti tipovi u Haskelu,

a strelice funkcije A -> B.

_

Identitet je funkcija id, a kompozicija je .

103


Monoid

Monoid <M, u, n> u kategoriji <C, ., 1> je objekat M uz dve strelice

u : M . M -> M, koji se naziva množenje

n : 1 -> M, koji se naziva jedinica

U Haskelu se u zove mappend, a n se zove mempty

104


Monoid

Pravila:

(<>) = mappend

x <> mempty = x

mempty <> x = x

(x <> y) <> z = x <> (y <> z)

105


Monoid

instance Monoid [a] where

mappend = (++)

mempty = []

106


Monoid

instance Monoid (Maybe a) where

mappend = -- više mogućnosti

mempty = Nothing

107


Funktori

Def. Funktor izmedju kategorija C i D je mapiranje objekata na objekte, istrelica na strelice koje zadovoljava sledeća pravila:

F(f) : F(dom f) -> F(cod f) za svaku strelicu f u kategoriji C

F(g . f) = F(g) . F(f)

F(1_a) = 1_F(a)

108


Kategorija funktora

Kategorija gde su:

Kategorije objekti

Funktori strelice

109


Funktori

Parametrizovan tip

Plus fmap

_

Litfing

110


Endofunktori

Funktori kategorije C na C

111


Primeri

Liste

Maybe

Either Int

Either a

112


Primeri

Funkcije koje slikaju neki tip r na nešto drugo:

`(->) r`

113


Primeri

Krenemo od potpisa za fmap: fmap :: (a -> b) -> f a -> f b

Zamenimo f sa ((->) r): fmap :: (a -> b) -> ((->) r a) ->

((->) r b)

Prezapišemo infiksno: fmap :: (a -> b) -> (r -> a) -> (r ->

b)

114


Primeri

instance Functor ((->) r) where

fmap f g = f . g

115


Monade

Monada M = <M, return, join> nad kategorijom C se sastoji odendofunktora M : C -> C i dve transformacije return : C -> M(C) ijoin: M(M(C)) -> M(C) koje zadovoljavaju sledeće:

levi identitet:

return a >>= f = f a

desni identitet:

m >>= return = m

asocijativnost:

(m >>= f) >>= g = m >>= (\ x -> f x >>= g)

gde je »= kompozicija join i fmap.

116


Monade

levi identitet:

do { x' <- return x do { f x }

; f x

}

desni identitet:

do { x <- m do { m }

; return x

}

117


Monade

asocijativnost:

do { y <- do { x <- m | do { x <- m | do { x <- m

; f x | ; do { y <- f x | ; y <- f x

} | ; g y | ; g y

; g y | } | }

} | } |

118


Klisli operator

Kompozicija funkcija koje vraćaju monadske vrednosti:

f >=> g = \ x -> f x >>= g

119


Klisli operator

Levi i desni identitet:

f >=> return = f = return >=> f

Asocijativnost:

(f >=> g) >=> h = f >=> (g >=> h)

120


Monada parcijalnosti

Maybemonada

121


Monada izuzetaka

Result E (Either E)

122


Par kao monada

Ako je amonoid, onda je (,) amonada:

return b = (mempty, b)

join (a1, (a2, b)) = (mappend a1 a2, b)

123


Funkcije kao monada

Krenemo od return :: a -> f a

Zamenimo f sa (->) r i dobijemo

return :: a -> (r -> a)

_

Dakle: return = const

124


Funkcije kao monada

Krenemo od: join :: Monad m => m (m a) -> m a

Zamenimo m sa (->) r i dobijamo

join :: (((->) e) (((->) e) a))) -> (((->) e) a)

Posle malo sredjivanja, dobijamo

join :: (e -> e -> a) -> e -> a

_

Dakle: join f = \ x -> f x x

125

ZAKLJUČIVANJE TIPOVA -- HASKELL


Tipovi

Obično definišemo tipove kad definišemo promenljive

x :: [Char]

i :: Int

x !! i :: Char;

short i;

std::array<int, 4> a;

a[i] = 6;

127


Parametrizovani tipovi

Umesto da pišemo konkretan tip, imamo tipovske promenljive

f :: a -> Bool

g :: a -> a -> a

template <typename T>

T id(T val, std::vector<T> xs) { ::: }

(genericko programiranje, polimorfizam preko tipova)

128


Implicitni generički tipovi

Ne definišemo tipove -- kompajler treba da zaključi sam.

let f = \ x -> x

let g = f

let h = \ x -> f x

129



let max x y = if x > y then x else y

130



let max cmp x y = if cmp x y then x else y

131



let foo a b c = c (a !! b)

132



let foo a b c = c (a !! b) + a

133


Hindley-Milner provera tipova

Zaključuje tipove koji nisu eksplicitno navedeni

Jezik, konstrukti, …

Unifikacija tipova

134


Konstante

”Hello” :: String

42 :: Int

True, False :: Bool

135


Operacije

<. <=, ==, >=, >, /=

+, -, *, /

!!

136


Funkcije

f a b c ... z

137


Ograničenja

definicija funkcije

if-then-else

138


Unifikacija

počinjemo od korena drveta

kad naletimo na konstrukt sa slobodnim tipovima, napravimo nove tipskeparametre

ako konstrukt ima dodeljena dva tipa T1 i T2, zameniti T1 u celom drvetu

139


Primer

let f a b c = c (a !! b)

let f a b = if a then b

else a + 1

let f a b c = if (a !! b) then c b else a

140

ZAKLJUČIVANJE TIPOVA -- C++


Šabloni, auto, decltype


void f(T value) {}


void f(T& value) {}


void f(const T& value) {}


void f(T* value) {}

142



void f(auto value) {}

void f(auto& value) {}

void f(const auto& value) {}

void f(auto* value) {}

auto value = 42;

const auto& value = f();

auto& ref = value;

auto& ptr = &value;

143




void f(T&& value) {

g(std::forward<T>(value));

}

144



decltype(value) copy = value;

145


Perfect forwarding


decltype(auto) f(T&& value) {

return g(std::forward<T>(value));

}

146


Meta-funkcije


using inner_type_t =

typename T::value_type;

inner_type_t<std::vector<int>>

147


Meta-funkcije


struct inner_type {

using type = typename T::value_type;

};

inner_type<std::vector<int>>::type

148


Meta-funkcije

template <typename T, typename Expected = void>

struct expect_inner {

using type = typename T::value_type;

constexpr bool value =

std::is_same_v<type, Expected>;

};

expect_inner<std::vector<int>>::type

expect_inner<std::vector<int>>::value

149


Meta-funkcije


using expect_inner_t =

typename expect_inner<T, E>::type;


constexpr bool expect_inner_v =

expect_inner<T, E>::value;

150


Meta-funkcije

template <typename C>

??? sum(const C& collection)

{

return …;

}

151


Meta-funkcije

template <typename C,

typename Val = inner_type_t<C>>

Val sum(const C& collection)

{

return …;

}

152


Tipovi


class print_types;

153


Koncepti


concept HasValueType =

requires(C c) { typename C::value_type };


concept HasBeginIterator =

requires(C c) { *std::begin(c); };

154


Koncepti

template <typname T>

requires HasValueType<T>

auto sum(C c) {

}

template <typname T>

requires not HasValueType<T>

and HasBeginIterator<T>

auto sum(C c) {

}

155

Documents

Funkcionalno programiranje - lightgrayÄ udno izdanjepoincare.math.rs/~ivan/files/fp/presentation.pdf · Funkcionalnoprogramiranje Čudnoizdanje January6,2020 drIvanČukić [email protected]