funkcionalno programiranje - lightgrayÄ udno...

Funkcionalno programiranjeČudno izdanje

January 6, 2020

dr Ivan Čukić

ivan@math.rspoincare.math.rs/~ivan

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: ivan@math.rs

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ć

Funkcionalno programiranje

Šta je funkcionalno programiranje?

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.

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 :)

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

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

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

Obaveze tokom godine

Kolokvijum (30%)

Ispit (70%)

Uvod u Haskell

lenjost

karijevanje i parcijalna aplikacija

funkcije višeg reda

map, filter, fold

pattern matching

Razlike izmedju normalnih FP jezika i C++-a

Intervali, transformacije intervala

Monade, optional/maybe, ...

Primena monada u parsiranju, …

Dizajn softvera kroz reaktivne tokove

HASKELL -- OSNOVE, TIPOVI PODATAKA

Implementacije Haskella

Postoje mnoge implementacije jezika Haskell:

GHC -- Glasgow Haskell Compiler

UHC -- Ultrecht Haskell Compiler

LHC -- LLVM Haskell Compiler

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

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

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

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

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

[] -- 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

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

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.

Izrazi i imena

imena počinju malim slovom

cifre, velika i mala slova, _ i '

number = 6

answer = 42

f = sin

f' = cos

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)

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)

Lokalna imena

Listu definicija imena okružujemo vitičastim zagradama

Između definicija, kao ranije ”;”

main = print answer

where answer = 42

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

Osobine imenovanih izraza

Promenljive nisu promenljive

x = 6 -- greška

redosled definicija nije bitan

fakeDiv x y =

let result = div x y

in if y == 0 then 0 else q

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

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)

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

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

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

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 `$`

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

Ciklična lista -- pokušaj 1

Koristimo [Int] da reprezentujemo listu

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

insert value list = (???)

swap :: [Int] -> [Int]

swap = (???)

swap [] = []

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

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

swap xs = xs

swap xs = case xs of

[] -> []

[x] -> [x]

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

Tipovi

Šta su tipovi sledećih vrednosti?

[True, False]

[1, 2, 3]

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.

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

Rotiramo listu

type Ring t = [t]

focusNext :: Ring t -> Ring t

focusNext = (???)

Operacije kontrukcije i konkatenacije

:t (:)

:t (++)

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?

Rotiramo listu na drugu stranu

type Ring t = [t]

focusPrev :: Ring t -> Ring t

focusPrev = (???)

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.

Kompozicija funkcija

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

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

Alternativno, preko lambda funkcije.

Operator aplikacije funkcije

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

f $ x = f x

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.

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)

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'

Primeri

Ekstraktovanje prve reči iz rečenice

Ekstraktovanje prve dve reči iz rečenice

Obrnuta varijanta mapiranja

HASKELL -- OSNOVNE FUNKCIJE, TESTIRANJE

-- 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 ]

zipWith

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

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

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

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)

foldl1

foldr1

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]

Generatori lista (List comprehension)

Lista svih neparnih brojeva od 1 do 42

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

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.

Testiranje fiksnih tačaka

prop_swap s = s == swap (swap s)

import Test.QuickCheck

quickCheck prop_swap

SAKUPLJAČI OTPADAKA

Baratanje memorijom

Nizak nivo

Ručno baratanje memorijom vodi ka greškama

Alokacija memorije na hipu

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)

Brojanje referenci

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

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

Mark-and-sweep

Zaustavljanje sveta

Lokalnost memorije

Fragmentacija

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?

Mark-and-compact: Two finger compaction

Pogodan za objekte iste veličine

Particionisanje skupa sa dva pokazivača

Pripada proizvoljnim algoritmima sabijanja

Mark-and-compact

Prednosti:

Mala fragmentacija

Lokalnost

Sporo skupljanje otpadaka

Mark-and-compact

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

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

Kopirajući GC

Prednosti:

Lokalnost

Jednostavno skupljanje otpadaka

Brza alokacija

Mala fragmentacija

Manji prostor za alokacije

Kopiranje podataka

Problem kopiranja velikih besmrtnih objekata

GC sa generacijama

Stari objekti se retko uništavaju

Novi objekti su često kratkotrajni

Kratkotrajni objekti su retko kad veliki

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

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

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

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

Stanja programa

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

Stanja programa

struct state_t {

bool started = false;

bool finished = false;

unsigned count = 0;

string url;

socket_t web_page;

Stanja programa

struct state_t {

bool started = false;

bool finished = true;

unsigned count = 42;

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

socket_t web_page = …;

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.

Primeri

(Int, String)

data Context c = MkContext String c

Stanja programa

Stanja:

Inicijalno

Stanje brojanja

Krajnje stanje

Stanja programa

enum mode {

initial,

running,

finished

Suma tipova

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

data Maybe a = Nothing | Just a

Either

data Either a b = Left a | Right b

Result

data Result a = Error String | Value a

Brojač

data Brojac = Initial { url :: String }

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

| Finished { count :: Int }

TEORIJA KATEGORIJA

Apstraktna teorija funkcija.

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

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.

Primeri kategorija

Skupovi i funkcije

Grupe i homomorfizmi

Hask kategorija

Kategorija gde su objekti tipovi u Haskelu,

a strelice funkcije A -> B.

Identitet je funkcija id, a kompozicija je .

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

Monoid

Pravila:

(<>) = mappend

x <> mempty = x

mempty <> x = x

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

Monoid

instance Monoid [a] where

mappend = (++)

mempty = []

Monoid

instance Monoid (Maybe a) where

mappend = -- više mogućnosti

mempty = Nothing

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)

Kategorija funktora

Kategorija gde su:

Kategorije objekti

Funktori strelice

Funktori

Parametrizovan tip

Plus fmap

Litfing

Endofunktori

Funktori kategorije C na C

Primeri

Either Int

Either a

Primeri

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

`(->) r`

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 ->

Primeri

instance Functor ((->) r) where

fmap f g = f . g

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.

Monade

levi identitet:

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

desni identitet:

do { x <- m do { m }

; return x

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 | } | }

} | } |

Klisli operator

Kompozicija funkcija koje vraćaju monadske vrednosti:

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

Klisli operator

Levi i desni identitet:

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

Asocijativnost:

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

Monada parcijalnosti

Maybemonada

Monada izuzetaka

Result E (Either E)

Par kao monada

Ako je amonoid, onda je (,) amonada:

return b = (mempty, b)

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

Funkcije kao monada

Krenemo od return :: a -> f a

Zamenimo f sa (->) r i dobijemo

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

Dakle: return = const

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

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;

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)

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

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

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

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

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

Hindley-Milner provera tipova

Zaključuje tipove koji nisu eksplicitno navedeni

Jezik, konstrukti, …

Unifikacija tipova

Konstante

”Hello” :: String

42 :: Int

True, False :: Bool

Operacije

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

+, -, *, /

Funkcije

f a b c ... z

Ograničenja

definicija funkcije

if-then-else

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

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

ZAKLJUČIVANJE TIPOVA -- C++

Šabloni, auto, decltype

void f(T value) {}

void f(T& value) {}

void f(const T& value) {}

void f(T* value) {}

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;

void f(T&& value) {

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

decltype(value) copy = value;

Perfect forwarding

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

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

Meta-funkcije

using inner_type_t =

typename T::value_type;

inner_type_t<std::vector<int>>

Meta-funkcije

struct inner_type {

using type = typename T::value_type;

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

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

Meta-funkcije

using expect_inner_t =

typename expect_inner<T, E>::type;

constexpr bool expect_inner_v =

expect_inner<T, E>::value;

Meta-funkcije

template <typename C>

??? sum(const C& collection)

return …;

Meta-funkcije

template <typename C,

typename Val = inner_type_t<C>>

Val sum(const C& collection)

return …;

Tipovi

class print_types;

Koncepti

concept HasValueType =

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

concept HasBeginIterator =

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

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) {

funkcionalno programiranje - lightgrayÄ udno...

Documents

ivan nissoli

cum s-a certat ivan ivanovici cu ivan nikiforovici

java konkurentno programiranje - math.rs · pdf fileteme •...

ivan cankar

ivan takaki ajimura ivan@sevenidiomas.com.br diagramando...

plantilla ivan

mỘt ngÀy trong ĐỜi ivan ivan denisovitch

ivan landazabal

ivan minerales

ivan dimitri

Увод у r - math.rs · Табеле...

ivan tscherezov

chorvat ivan

izradili: karlo karlović ivan Živolić ivan rojnić

ivan david

pri»udno »udo i zvieren’je razliko prilog...

ivan tavČar

objektno orijentisano programiranje -...

ivan meštrović

algoritmi na grafovima -...