https://ocw.cs.pub.ro/ppcarte/ 2026-05-20T18:07:42+03:00 https://ocw.cs.pub.ro/ppcarte/ https://ocw.cs.pub.ro/ppcarte/lib/tpl/bootstrap3/images/favicon.ico text/html 2023-04-26T14:25:39+03:00 https://ocw.cs.pub.ro/ppcarte/doku.php?id=pp:2023:haskell:curs09&rev=1682508339&do=diff Curs 09. Introducere in Haskell x = 1 f :: Int -> Int -> Int f x y = x * y g = f 1 f1 :: (Int -> Int) -> Int f1 x = (x 1) + 1 -- signatura unei functii nu e obligatorie h :: a -> a h x = x {- def f[A](x: A): A = x x => x -} {- compunerea de functii -} comp :: (b -> c) -> (a -> b) -> a -> c comp f g x = f (g x) --comp f g = \x -> f (g x) {- \x -> \y -> x + y // functie anonima (lambda) in forma curry \x y -> x + y // forma uncurry (identica cu cea de sus) -} positive :: Int… text/html 2023-04-26T14:26:35+03:00 https://ocw.cs.pub.ro/ppcarte/doku.php?id=pp:2023:haskell:curs10&rev=1682508395&do=diff C10. Evaluare lenesa in Haskell {- In Haskell evaluarea este lazy -} ones :: [Int] ones = 1:ones -- axioma pt take: take n (x:xs) = x:(take (n-1) xs) {- take 2 ones take 2 (1:ones) 1:take 1 ones 1:take 1 (1:ones) 1:1:take 0 ones 1:1:[] -} call = foldr (&&) True [True,False,False,False,True] {- True && (foldr (&&) True [False,False,False,True] ) foldr (&&) True [False,False,False,True] False && (foldr (&&) True [False,False,True]) False foldr op acc x:xs = x
0111p
00… text/html 2023-04-26T14:27:40+03:00 https://ocw.cs.pub.ro/ppcarte/doku.php?id=pp:2023:haskell:curs11&rev=1682508460&do=diff C11. Programare dinamica lenesa import Data.Array t0 :: [Int] t0 = [2,3,5,1,4] t1 :: [Int] t1 = [2,3,5,1,4,6,7,1,2,3,5,3,4,7,1,2,3,4,5,6,7,5,3,4,5,6,7,6,3,2] t3 :: [Int] t3 = [2,3,5,1,4,6,7,1,2,3,5,3,4,7,1,2,3,4,5,6,7,5,3,4,5,6,7,6,3,2,2,3,5,1,4,6,7,1,2,3,5,3,4,7,1,2,3,4,5,6,7,5,3,4,5,6,7,6,3,2,2,3,5,1,4,6,7,1,2,3,5,3,4,7,1,2,3,4,5,6,7,5,3,4,5,6,7,6,3,2,2,3,5,1,4,6,7,1,2,3,5,3,4,7,1,2,3,4,5,6,7,5,3,4,5,6,7,6,3,2] t2 :: [Int] t2 = [2,3,5,1,4,6,7,1,2,3,5,3,4,7,1,2,3,4,5,6] -- the operation (!!… text/html 2023-05-03T14:24:05+03:00 https://ocw.cs.pub.ro/ppcarte/doku.php?id=pp:2023:haskell:curs12&rev=1683113045&do=diff Curs 12. Typeclasses -- import Prelude hiding (show, Show) -- import qualified Prelude as Prelude {- Part 1: Algebraic/Abstract datatypes -} data Nat = Zero | Succ Nat -- deriving Show add :: Nat -> Nat -> Nat add Zero x = x add (Succ y) x = Succ (add y x) toInt :: Nat -> Int toInt Zero = 0 toInt (Succ x) = 1 + toInt x {- 3 + 1 3 + 2 + 1 -} data Expr = Atom Int | Mult Expr Expr | Plus Expr Expr type Age = Int data Student = Student Int (String, String) Int | Absolvent I… text/html 2023-05-23T15:20:34+03:00 https://ocw.cs.pub.ro/ppcarte/doku.php?id=pp:2023:haskell:curs13&rev=1684844434&do=diff Curs 13. Monade data Nat = Zero | Succ Nat deriving Show fromInt :: Int -> Maybe Nat fromInt x | x < 0 = Nothing | otherwise = Just (get x) where get 0 = Zero get x = Succ (get (x-1)) {- minus :: Maybe Nat -> Maybe Nat -> Maybe Nat minus (Just x) (Just y) = case (x,y) of (Zero,Zero) -> Just Zero (Zero,_) -> Nothing (Succ n, Succ m) -> minus (Just n) (Just m) minus _ _ = Nothing -} --increment :: Maybe Nat -> Maybe Nat --larger3 :: Maybe Nat -> Maybe Bool --e0… text/html 2023-05-23T15:21:23+03:00 https://ocw.cs.pub.ro/ppcarte/doku.php?id=pp:2023:haskell:curs14&rev=1684844483&do=diff Curs 14. The Parser Monad import Data.Char import Control.Applicative data Expr = Atom Int | Var String | Plus Expr Expr deriving Show --type Parser a = String -> [(a,String)] -- Parser :: * => * data Parser a = Parser (String -> [(a,String)]) parse :: Parser a -> String -> [(a,String)] parse (Parser p) s = p s --parseAtom :: Parser Expr --parse parseAtom "1 + 2" = [(1, "+ 2")] {- parsere mai generale: -} failParser :: Parser a failParser = Parser $ \s -> [] c… text/html 2024-04-09T18:32:54+03:00 https://ocw.cs.pub.ro/ppcarte/doku.php?id=pp:2023:haskell:l07-extra&rev=1712676774&do=diff Lambda Calculus as a programming language Church Encodings Booleans We can encode boolean values TRUE and FALSE in lambda calculus as functions that take 2 values, x and y, and return the first (for TRUE) or second (for FALSE) value. $ TRUE = \lambda x.\lambda y.y$ $ FALSE = \lambda x.\lambda y.x$ TRUE$ AND = \lambda x.\lambda y.((x \ y) \ x) $$ OR = \lambda x.\lambda y.((x \ x) \ y) $$ NOT = \lambda x.((x \ FALSE) \ TRUE) $$ NOT = \lambda x.\lambda a.\lambda b.((x \ b) \ a) $$ NOT \ T… text/html 2023-04-27T01:17:25+03:00 https://ocw.cs.pub.ro/ppcarte/doku.php?id=pp:2023:haskell:l07&rev=1682547445&do=diff Lab 7. Lambda Calculus. Intro to Haskell 7.1 Lambda Calculus Lambda Calculus represent a axiomatic system that can be used for very basic proofs. Given a set of variables VARS, a expression under lambda calculus can be: variable $ x $ $ x \in VARS $$ \lambda x.e $$ x \in VARS $$ e $$ \lambda $$ (e_1 \ e_2) $$ e_1, e_2 $$ \lambda $$\lambda$$ \lambda x.e $$ \lambda x.body \ param$$ body[x \ / \ param] $$ E_1 = \lambda x.e_1 \ e_2 $$ E_2 = e_1[x \ / \ e_2] $$ \beta $$ E_1 $$ … text/html 2023-04-28T17:43:53+03:00 https://ocw.cs.pub.ro/ppcarte/doku.php?id=pp:2023:haskell:l08&rev=1682693033&do=diff 8. Lazy Evaluation When passing parameters to a function, programming language design offers two options which are not mutually exclusive (both strategies can be implemented in the language): * applicative (also called strict) evaluation strategy:$ 2$$ parent + 1$$ parent * 2$$ \lvert s_n - s_{n+1} \rvert < e$$ \displaystyle \lim_{n \rightarrow \infty} \frac{F_{n+1}}{F_n} = \varphi$$ F_n$$ \varphi$$ a_{n+1} = a_n + sin(a_n)$$ a_0$$ a_{n+1} != a_n$$ \displaystyle \lim_{n \rightarrow \infty} a… text/html 2023-04-27T14:16:02+03:00 https://ocw.cs.pub.ro/ppcarte/doku.php?id=pp:2023:haskell:l08_2&rev=1682594162&do=diff 8. Lazy Evaluation When passing parameters to a function, programming language design offers two options which are not mutually exclusive (both strategies can be implemented in the language): * applicative (also called strict) evaluation strategy:$ 2$$ parent + 1$$ parent * 2$$ \lvert s_n - s_{n+1} \rvert < e$$ \displaystyle \lim_{n \rightarrow \infty} \frac{F_{n+1}}{F_n} = \varphi$$ F_n$$ \varphi$$ a_{n+1} = a_n + sin(a_n)$$ a_0$$ a_{n+1} != a_n$$ \displaystyle \lim_{n \rightarrow \infty} a… text/html 2023-05-02T22:15:56+03:00 https://ocw.cs.pub.ro/ppcarte/doku.php?id=pp:2023:haskell:l09&rev=1683054956&do=diff Lab 9. Algebraic Data Types 9.0. Some theory Types are an essential component in haskell. They start with capital letters, like Int. We have multiple ways of customizing data types. The first one is type aliases, signaled by the keyword type. These allow us to rename complex types to simpler types. They are used for better clarity. text/html 2023-05-15T19:15:12+03:00 https://ocw.cs.pub.ro/ppcarte/doku.php?id=pp:2023:haskell:l10&rev=1684167312&do=diff Lab 10. Monads 10.0. Understanding Monads A monad is an algebraic structure used to describe computations as sequences of steps, and to handle side effects such as state and IO. They also provide a clean way to structure our programs. In Haskell, Monads are defined as follows: