Programare declarativa - Tipuri de date, liste, functii,...

Programare declarativa1

Tipuri de date, liste, funct,ii, recursie

Traian Florin S, erbanut,aIoana Leus, tean

Departamentul de Informatica, FMI, [email protected]

[email protected]

1bazat pe cursul Informatics 1: Functional Programming de la University of EdinburghTraian Florin S, erbanut,a Ioana Leus, tean (UB) PD—Baze 1 / 33

Tipuri de date

Tipuri de date

Traian Florin S, erbanut,a Ioana Leus, tean (UB) PD—Baze 2 / 33

Tipuri de date

Tipuri de date

Integer: 4, 0, -5

Prelude> 4 + 3Prelude> (+ ) 4 3

Prelude> mod 4 3Prelude> 4 ‘mod‘ 3

Float: 3.14

Prelude> truncate 3.14Prelude> sqrt 4

Prelude> l e t x = 4 : : I n tPrelude> sqrt ( fromIntegral x )

Char: ’a’,’A’, ’\n’

Prelude> :m + Data . CharPrelude> chr 65Prelude> ord ’A ’

Prelude> toUpper ’ a ’Prelude> dig i tTo In t ’ 4 ’


Tipuri de date

Tipuri de date

Bool: True, False

data Bool = True | False

Prelude> True && False | | TruePrelude> not True

Prelude> 1 /= 2Prelude> 1 == 2

String: "prog\ndec"

type String = [ Char ] −− sinonim pentru t i p

Prelude> " aa "++" bb "" aabb "Prelude> " aabb " ! ! 2’ b ’

Prelude> l ines " prog \ ndec "[ " prog " , " dec " ]Prelude> words " pr og \ nde c l "[ " pr " , " og " , " de " , " c l " ]


Tipuri de date

Tipuri de date compuse

Tupluri - secvent,e de de tipuri deja existente

Prelude> : t (1 : : Int , ’ a ’ , " ab " )(1 : : Int , ’ a ’ , " ab " ) : : ( Int , Char , [ Char ] )Prelude> f s t ( 1 , ’ a ’ )Prelude> snd ( 1 , ’ a ’ )

Tipul unit

Prelude> : t ( )( ) : : ( )

Liste

Prelude > [1 ,2 ,3 ] == 1 : 2 : 3 : [ ]True


Funct,ii

Funct, ii


Funct,ii

Ce e o funct, ie?

DEX(online): Marime variabila care depinde de una sau de mai multemarimi variabile independenteO ret,eta pentru a obt,ine ies, iri din intrari: „Ridica un numar la patrat”O relat,ie între intrari s, i ies, iri {(1, 1), (2, 4), (3, 9), (4, 16), . . .}O ecuat,ie algebrica f(x) = x2

Un grafic reprezentând ies, irile pentru intrarile posibile

−5 0 50

10

20

x

f(x)

=x2


Funct,ii

Tipuri de datepentru intrari/ies, iri ale funct,iilor

Integer: 4, 0, -5

Float: 3.14

Char: ’a’

Bool: True, False

String: "abc"

Tuplu: (1,2)

Lista: [1..100], [1..]

Picture: ,


Funct,ii

Tipuri de funct, ii s, i aplicarea lor

i n v e r t : : P i c tu re −> P ic tu re

kn igh t : : P i c tu re

i n v e r t kn igh t

invert


Funct,ii

Compunerea funct, iilor

beside : : P i c tu re −> P ic tu re −> P ic tu ref l i p V : : P i c tu re −> P ic tu rei n v e r t : : P i c tu re −> P ic tu re

kn igh t : : P i c tu re

beside ( f l i p V kn igh t ) ( i n v e r t kn igh t )

invert

flipV

beside


Funct,ii

Definirea unei funct, ii noi

double : : P i c tu re −> P ic tu redouble p = beside ( f l i p V p ) ( i n v e r t p )

double kn igh t

flipV

invert

beside

double


Funct,ii

Definirea unei funct, ii noi

double : : P i c tu re −> P ic tu redouble p = beside ( f l i p V p ) ( i n v e r t p )

double kn igh t

double


Funct,ii

Terminologie

Prototipul funct,iei double :: Picture -> Picture

Numele funct,iei

Signatura funct,iei

Definit,ia funct,iei double p = beside (flipV p) (invert p)

numele funct,iei

parametrul formal

corpul funct,iei

Aplicarea funct,iei double knight

numele funct,iei

parametrul actual (argumentul)


Liste

Liste


Liste

Operatorii : s, i ++Mod de folosire

Prelude> : t ( : )( : ) : : a −> [ a ] −> [ a ]

Prelude> 1 : [ 2 , 3 ][ 1 , 2 , 3 ]

Prelude> : t " bcd "" bc " : : [ Char ]Prelude> ’ a ’ : " bcd "" abcd "

Prelude> : t (++)(++) : : [ a ] −> [ a ] −> [ a ]

Prelude> [ 1 ] ++ [ 2 , 3 ][ 1 , 2 , 3 ]Prelude> [ 1 , 2 ] ++ [ 3 ][ 1 , 2 , 3 ]Prelude> " a " ++ " bcd "" abcd "Prelude> " ab " ++ " cd "" abcd "

: (cons) Construies, te o lista noua având primul argument ca primelement s, i continuând cu al doilea argument ca restul listei.

++ (append) Construies, te o lista noua obt,inuta prin alipirea celor doualiste argument

[Char] S, irurile de caractere (String) sunt liste de caractere (Char)Traian Florin S, erbanut,a Ioana Leus, tean (UB) PD—Baze 14 / 33

Liste

Operatorii : s, i ++Erori de începator

Prelude> : t ( : )( : ) : : a −> [ a ] −> [ a ]

Prelude> : t (++)(++) : : [ a ] −> [ a ] −> [ a ]

Prelude> [ 1 , 2 ] : 3−− eroare de t i p u r i

Prelude> 1 ++ [ 2 , 3 ]−− eroare de t i p u r i

Prelude> [ 1 ] : [ 2 , 3 ]−− eroare de t i p u r i

Prelude> " ab " : ’ c ’−− eroare de t i p u r i

Prelude> ’ a ’ ++ " bc "−− eroare de t i p u r i

Prelude> " a " : " bc "−− eroare de t i p u r i


Liste

ListeDefinit,ie

Observat,ie

Orice lista poate fi scrisa folosind doar constructorul (:) s, i lista vida []

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

"abcd" == [’a’,’b’,’c’,’d’] == ’a’ : (’b’ : (’c’ : (’d’ : []))) == ’a’ : ’b’ : ’c’ : ’d’ : []

Definit,ie recursiva

O lista este

vida, notata []; sau

compusa, notata x:xs, dintr-un un element x numit capul listei (head) s, io lista xs numita coada listei (tail).


Liste

Definit, ii de liste

Intervale s, i progresii

i n t e r v a l = [ ’ c ’ . . ’ e ’ ] −− [ ’ c ’ , ’ d ’ , ’ e ’ ]progres ie = [ 2 0 , 1 7 . . 1 ] −− [20 ,17 ,14 ,11 ,8 ,5 ,2 ]progres ie ’ = [ 2 . 0 , 2 . 5 . . 4 . 0 ] −− [ 2 . 0 , 2 . 5 , 3 . 0 , 3 . 5 , 4 . 0 ]

Definit,ii prin select,ie (comprehensiune)[E(x)| x <- [x1,. . . ,xn], P(x)]

Prelude> l e t xs = [ 0 . . 1 0 ]Prelude> [ x | x<−xs , even x ][0 ,2 ,4 ,6 ,8 ,10 ]

Prelude> l e t xs = [ 0 . . 6 ]Prelude> [ ( x , y ) | x<−xs , y<−xs , x+y == 10][ ( 4 , 6 ) , ( 5 , 5 ) , ( 6 , 4 ) ]

Prelude> [ ( i , j ) | i < − [ 1 . . 3 ] , l e t k= i * i , j < − [1 . . k ] ]

Observat,i folosirea lui let pentru declarat,ii locale!


Liste

Procesarea listelor

Prelude> head [ 1 , 2 , 3 ]1Prelude> t a i l [ 1 , 2 , 3 ][ 2 , 3 ]

Prelude> nul l [ 1 , 2 , 3 ]FalsePrelude> nul l [ ]True

Evaluare lenes, a

Argumentele sunt evaluate doar cand e necesar si doar cat e necesar

Prelude> head [ ]

* * * Except ion : Prelude . head : empty l i s tPrelude> l e t x = head [ ]Prelude> l e t f a = 5Prelude> f x5Prelude> head [ 1 , head [ ] , 3 ]1Prelude> head [ head [ ] , 3 ]

* * * Except ion : Prelude . head : empty l i s tTraian Florin S, erbanut,a Ioana Leus, tean (UB) PD—Baze 18 / 33

Liste

Procesarea listelor

Evaluare lenes, a

Se pot defini liste infinite (fluxuri de date)

Prelude> l e t n a t u r a l = [ 0 , . . ]Prelude> take 5 n a t u r a l[ 0 ,1 ,2 ,3 ,4 ]

Prelude> l e t evenNat = [ 0 , 2 . . ] −− progres ie i n f i n i t \ u aPrelude> take 7 evenNat[0 ,2 ,4 ,6 ,8 ,10 ,12 ]

Prelude> l e t ones = [ 1 , 1 . . ]Prelude> l e t zeros = [ 0 , 0 . . ]Prelude> l e t both = zip ones zerosPrelude> take 5 both[ ( 1 , 0 ) , ( 1 , 0 ) , ( 1 , 0 ) , ( 1 , 0 ) , ( 1 , 0 ) ]


Funct,ii s, i recursie

Funct, ii s, i recursie


Funct,ii s, i recursie

Funct, ii s, i recursie - Probleme

Transformarea fiecarui element dintr-o lista

Selectarea elementelor dintr-o lista

Agregarea elementelor dintr-o lista

Mapare, filtrare s, i agregare deodata


Funct,ii s, i recursie Transformarea fiecarui element dintr-o lista

Transformarea fiecarui element dintr-o listaProblema s, i abordare

Definit,i o funct,ie care pentru o lista de numere întregi data ridica la patratfiecare element din lista.

Solut,ie descriptiva

squares : : [ I n t ] −> [ I n t ]squares xs = [ x * x | x <− xs ]

Solut,ie recursiva

squaresRec : : [ I n t ] −> [ I n t ]squaresRec [ ] = [ ]squaresRec ( x : xs ) = x * x : squaresRec xs



Variante recursive

Ecuat,ional (pattern matching)squaresRec : : [ I n t ] −> [ I n t ]squaresRec [ ] = [ ]squaresRec ( x : xs ) = x * x : squaresRec xs

Condit,ional (cu operatori de legare)squaresCond : : [ I n t ] −> [ I n t ]squaresCond ys =

i f nu l l ys then [ ]else l e t

x = head ysxs = t a i l ys

inx * x : squaresCond xs



Recursia în act, iune

squaresRec :: [Int] -> [Int]squaresRec [] = []squaresRec (x:xs) = x*x : squaresRec xs

squaresRec [1,2,3]

=squaresRec (1 : (2 : (3 : [])))=1 * 1 : squaresRec (2 : (3 : []))=1 * 1 : (2 * 2 : squaresRec (3 : []))=1 * 1 : (2 * 2 : ( 3 * 3 : squaresRec []))=1 * 1 : (2 * 2 : ( 3 * 3 : []))=1 : (4 : (9 : [])) = [1,4,9]





squaresRec [1,2,3]=squaresRec (1 : (2 : (3 : [])))

=1 * 1 : squaresRec (2 : (3 : []))=1 * 1 : (2 * 2 : squaresRec (3 : []))=1 * 1 : (2 * 2 : ( 3 * 3 : squaresRec []))=1 * 1 : (2 * 2 : ( 3 * 3 : []))=1 : (4 : (9 : [])) = [1,4,9]





squaresRec [1,2,3]=squaresRec (1 : (2 : (3 : [])))= {x 7→ 1, xs 7→ 2 : (3 : [])}1 * 1 : squaresRec (2 : (3 : []))

=1 * 1 : (2 * 2 : squaresRec (3 : []))=1 * 1 : (2 * 2 : ( 3 * 3 : squaresRec []))=1 * 1 : (2 * 2 : ( 3 * 3 : []))=1 : (4 : (9 : [])) = [1,4,9]





squaresRec [1,2,3]=squaresRec (1 : (2 : (3 : [])))=1 * 1 : squaresRec (2 : (3 : []))= {x 7→ 2, xs 7→ 3 : []}1 * 1 : (2 * 2 : squaresRec (3 : []))

=1 * 1 : (2 * 2 : ( 3 * 3 : squaresRec []))=1 * 1 : (2 * 2 : ( 3 * 3 : []))=1 : (4 : (9 : [])) = [1,4,9]





squaresRec [1,2,3]=squaresRec (1 : (2 : (3 : [])))=1 * 1 : squaresRec (2 : (3 : []))=1 * 1 : (2 * 2 : squaresRec (3 : []))= {x 7→ 3, xs 7→ []}1 * 1 : (2 * 2 : ( 3 * 3 : squaresRec []))

=1 * 1 : (2 * 2 : ( 3 * 3 : []))=1 : (4 : (9 : [])) = [1,4,9]





squaresRec [1,2,3]=squaresRec (1 : (2 : (3 : [])))=1 * 1 : squaresRec (2 : (3 : []))=1 * 1 : (2 * 2 : squaresRec (3 : []))=1 * 1 : (2 * 2 : ( 3 * 3 : squaresRec []))=1 * 1 : (2 * 2 : ( 3 * 3 : []))

=1 : (4 : (9 : [])) = [1,4,9]





squaresRec [1,2,3]=squaresRec (1 : (2 : (3 : [])))=1 * 1 : squaresRec (2 : (3 : []))=1 * 1 : (2 * 2 : squaresRec (3 : []))=1 * 1 : (2 * 2 : ( 3 * 3 : squaresRec []))=1 * 1 : (2 * 2 : ( 3 * 3 : []))=1 : (4 : (9 : []))

= [1,4,9]





squaresRec [1,2,3]=squaresRec (1 : (2 : (3 : [])))=1 * 1 : squaresRec (2 : (3 : []))=1 * 1 : (2 * 2 : squaresRec (3 : []))=1 * 1 : (2 * 2 : ( 3 * 3 : squaresRec []))=1 * 1 : (2 * 2 : ( 3 * 3 : []))=1 : (4 : (9 : [])) = [1,4,9]


Funct,ii s, i recursie Selectarea elementelor dintr-o lista

Selectarea elementelor dintr-o listaProblema s, i abordare

Definit,i o funct,ie care data fiind o lista de numere întregi selecteaza doarelementele impare din lista.


odds : : [ I n t ] −> [ I n t ]odds xs = [ x | x <− xs , odd x ]

Solut,ie recursiva

oddsRec : : [ I n t ] −> [ I n t ]oddsRec [ ] = [ ]oddsRec ( x : xs ) | odd x = x : oddsRec xs

| otherwise = oddsRec xs



Variante recursive

Ecuat,ional (pattern matching)oddsRec : : [ I n t ] −> [ I n t ]oddsRec [ ] = [ ]oddsRec ( x : xs ) | odd x = x : oddsRec xs


Condit,ional (cu operatori de legare)oddsCond : : [ I n t ] −> [ I n t ]oddsCond ys =

i f nu l l ys then [ ]else l e t

x = head ysxs = t a i l ys

ini f odd x then x : oddsCond xselse oddsCond xs




oddsRec :: [Int] -> [Int] oddsRec [] = []oddsRec (x:xs) | odd x = x : oddsRec xs


oddsRec [1,2,3]

=oddsRec (1 : (2 : (3 : [])))=1 : oddsRec (2 : (3 : []))=1 : oddsRec (3 : [])=1 : ( 3 : oddsRec [])=1 : ( 3 : []) = [1,3]






oddsRec [1,2,3]=oddsRec (1 : (2 : (3 : [])))

=1 : oddsRec (2 : (3 : []))=1 : oddsRec (3 : [])=1 : ( 3 : oddsRec [])=1 : ( 3 : []) = [1,3]






oddsRec [1,2,3]=oddsRec (1 : (2 : (3 : [])))= {x 7→ 1, xs 7→ 2 : (3 : [])}; odd 1 = True1 : oddsRec (2 : (3 : []))

=1 : oddsRec (3 : [])=1 : ( 3 : oddsRec [])=1 : ( 3 : []) = [1,3]






oddsRec [1,2,3]=oddsRec (1 : (2 : (3 : [])))=1 : oddsRec (2 : (3 : []))= {x 7→ 2, xs 7→ 3 : []}; odd 2 = False1 : oddsRec (3 : [])

=1 : ( 3 : oddsRec [])=1 : ( 3 : []) = [1,3]






oddsRec [1,2,3]=oddsRec (1 : (2 : (3 : [])))=1 : oddsRec (2 : (3 : []))=1 : oddsRec (3 : [])= {x 7→ 3, xs 7→ []}; odd 3 = True1 : ( 3 : oddsRec [])

=1 : ( 3 : []) = [1,3]






oddsRec [1,2,3]=oddsRec (1 : (2 : (3 : [])))=1 : oddsRec (2 : (3 : []))=1 : oddsRec (3 : [])=1 : ( 3 : oddsRec [])=1 : ( 3 : [])

= [1,3]






oddsRec [1,2,3]=oddsRec (1 : (2 : (3 : [])))=1 : oddsRec (2 : (3 : []))=1 : oddsRec (3 : [])=1 : ( 3 : oddsRec [])=1 : ( 3 : []) = [1,3]


Funct,ii s, i recursie Agregarea elementelor dintr-o lista

Agregarea elementelor dintr-o listaProblema s, i abordare

Definit,i o funct,ie care data fiind o lista de numere întregi calculeaza sumaelementelor din lista.

Solut,ie recursiva

suma : : [ I n t ] −> I n tsuma [ ] = 0suma ( x : xs ) = x + suma xs




suma :: [Int] -> Int suma [] = 0suma (x:xs) = x + suma xs

suma [1,2,3]

=suma (1 : (2 : (3 : [])))=1 + suma (2 : (3 : []))=1 + (2 + suma (3 : []))=1 + (2 + ( 3 + suma []))=1 + (2 + ( 3 + 0)) = 6





suma [1,2,3]=suma (1 : (2 : (3 : [])))

=1 + suma (2 : (3 : []))=1 + (2 + suma (3 : []))=1 + (2 + ( 3 + suma []))=1 + (2 + ( 3 + 0)) = 6





suma [1,2,3]=suma (1 : (2 : (3 : [])))= {x 7→ 1, xs 7→ 2 : (3 : [])}1 + suma (2 : (3 : []))

=1 + (2 + suma (3 : []))=1 + (2 + ( 3 + suma []))=1 + (2 + ( 3 + 0)) = 6





suma [1,2,3]=suma (1 : (2 : (3 : [])))=1 + suma (2 : (3 : []))= {x 7→ 2, xs 7→ 3 : []}1 + (2 + suma (3 : []))

=1 + (2 + ( 3 + suma []))=1 + (2 + ( 3 + 0)) = 6





suma [1,2,3]=suma (1 : (2 : (3 : [])))=1 + suma (2 : (3 : []))=1 + (2 + suma (3 : []))= {x 7→ 3, xs 7→ []}1 + (2 + ( 3 + suma []))

=1 + (2 + ( 3 + 0)) = 6





suma [1,2,3]=suma (1 : (2 : (3 : [])))=1 + suma (2 : (3 : []))=1 + (2 + suma (3 : []))=1 + (2 + ( 3 + suma []))=1 + (2 + ( 3 + 0))

= 6





suma [1,2,3]=suma (1 : (2 : (3 : [])))=1 + suma (2 : (3 : []))=1 + (2 + suma (3 : []))=1 + (2 + ( 3 + suma []))=1 + (2 + ( 3 + 0)) = 6



Problema s, i abordare

Definit,i o funct,ie care data fiind o lista de numere întregi calculeazaprodusul elementelor din lista.

Solut,ie recursiva

produs : : [ I n t ] −> I n tprodus [ ] = 1produs ( x : xs ) = x * produs xs




produs :: [Int] -> Int produs [] = 1produs (x:xs) = x * produs xs

produs [1,2,3]

=produs (1 : (2 : (3 : [])))=1 * produs (2 : (3 : []))=1 * (2 * produs (3 : []))=1 * (2 * ( 3 * produs []))=1 * (2 * ( 3 * 1)) = 6





produs [1,2,3]=produs (1 : (2 : (3 : [])))

=1 * produs (2 : (3 : []))=1 * (2 * produs (3 : []))=1 * (2 * ( 3 * produs []))=1 * (2 * ( 3 * 1)) = 6





produs [1,2,3]=produs (1 : (2 : (3 : [])))= {x 7→ 1, xs 7→ 2 : (3 : [])}1 * produs (2 : (3 : []))

=1 * (2 * produs (3 : []))=1 * (2 * ( 3 * produs []))=1 * (2 * ( 3 * 1)) = 6





produs [1,2,3]=produs (1 : (2 : (3 : [])))=1 * produs (2 : (3 : []))= {x 7→ 2, xs 7→ 3 : []}1 * (2 * produs (3 : []))

=1 * (2 * ( 3 * produs []))=1 * (2 * ( 3 * 1)) = 6





produs [1,2,3]=produs (1 : (2 : (3 : [])))=1 * produs (2 : (3 : []))=1 * (2 * produs (3 : []))= {x 7→ 3, xs 7→ []}1 * (2 * ( 3 * produs []))

=1 * (2 * ( 3 * 1)) = 6





produs [1,2,3]=produs (1 : (2 : (3 : [])))=1 * produs (2 : (3 : []))=1 * (2 * produs (3 : []))=1 * (2 * ( 3 * produs []))=1 * (2 * ( 3 * 1))

= 6





produs [1,2,3]=produs (1 : (2 : (3 : [])))=1 * produs (2 : (3 : []))=1 * (2 * produs (3 : []))=1 * (2 * ( 3 * produs []))=1 * (2 * ( 3 * 1)) = 6


Funct,ii s, i recursie Mapare, filtrare s, i agregare deodata

Mapare, filtrare s, i agregare deodataProblema s, i abordare

Definit,i o funct,ie care data fiind o lista de numere întregi calculeaza sumapatratelor elementelor impare din lista.


sumSqOdd : : [ I n t ] −> I n tsumSqOdd xs = sum [ x * x | x <− xs , odd x ]

Solut,ie recursiva

sumSqOddRec : : [ I n t ] −> I n tsumSqOddRec [ ] = 0sumSqOddRec ( x : xs ) | odd x = x * x + sumSqOddRec xs

| otherwise = sumSqOddRec xs

Solut,ie combinatoriala sumSqOdd = sum . squares . oddsTraian Florin S, erbanut,a Ioana Leus, tean (UB) PD—Baze 32 / 33



oddsRec :: [Int] -> [Int]sumSqOddRec [] = 0sumSqOddRec (x:xs) | odd x = x*x + sumSqOddRec xs


sumSqOddRec [1,2,3]

=sumSqOddRec (1 : (2 : (3 : [])))=1 * 1 + sumSqOddRec (2 : (3 : []))=1 * 1 + sumSqOddRec (3 : [])=1 * 1 + ( 3 * 3 + sumSqOddRec [])=1 * 1 + ( 3 * 3 + 0) = 10






sumSqOddRec [1,2,3] =sumSqOddRec (1 : (2 : (3 : [])))

=1 * 1 + sumSqOddRec (2 : (3 : []))=1 * 1 + sumSqOddRec (3 : [])=1 * 1 + ( 3 * 3 + sumSqOddRec [])=1 * 1 + ( 3 * 3 + 0) = 10






sumSqOddRec [1,2,3] =sumSqOddRec (1 : (2 : (3 : [])))= {x 7→ 1, xs 7→ 2 : (3 : [])}; odd 1 = True1 * 1 + sumSqOddRec (2 : (3 : []))

=1 * 1 + sumSqOddRec (3 : [])=1 * 1 + ( 3 * 3 + sumSqOddRec [])=1 * 1 + ( 3 * 3 + 0) = 10






sumSqOddRec [1,2,3] =sumSqOddRec (1 : (2 : (3 : [])))=1 * 1 + sumSqOddRec (2 : (3 : []))= {x 7→ 2, xs 7→ 3 : []}; odd 2 = False1 * 1 + sumSqOddRec (3 : [])

=1 * 1 + ( 3 * 3 + sumSqOddRec [])=1 * 1 + ( 3 * 3 + 0) = 10






sumSqOddRec [1,2,3] =sumSqOddRec (1 : (2 : (3 : [])))=1 * 1 + sumSqOddRec (2 : (3 : []))=1 * 1 + sumSqOddRec (3 : [])= {x 7→ 3, xs 7→ []}; odd 3 = True1 * 1 + ( 3 * 3 + sumSqOddRec [])

=1 * 1 + ( 3 * 3 + 0) = 10






sumSqOddRec [1,2,3] =sumSqOddRec (1 : (2 : (3 : [])))=1 * 1 + sumSqOddRec (2 : (3 : []))=1 * 1 + sumSqOddRec (3 : [])=1 * 1 + ( 3 * 3 + sumSqOddRec [])=1 * 1 + ( 3 * 3 + 0)

= 10






sumSqOddRec [1,2,3] =sumSqOddRec (1 : (2 : (3 : [])))=1 * 1 + sumSqOddRec (2 : (3 : []))=1 * 1 + sumSqOddRec (3 : [])=1 * 1 + ( 3 * 3 + sumSqOddRec [])=1 * 1 + ( 3 * 3 + 0) = 10


Programare declarativa - Tipuri de date, liste, functii,...

Documents

Transcript of Programare declarativa - Tipuri de date, liste, functii,...