books pp

pp:2021-demo

2021-06-03T13:05:14+03:00

Examen PP (L/P) Reduceti urmatoarea lambda-expresie folosind strategiile normala si aplicativa. (λx.(x x) (λx.(x y) λy.y)) (L/P) De cate ori se satisface scopul ?- p(X). unde: p(a). q(a). q(b). r(a). r(b). p(X) :- q(X), !, r(X). Justificati.

pp:adt

2017-03-20T12:16:06+03:00

Abstract Datatypes Intro An Abstract Datatype relies on functions to describe the possible values of a type. We start with a simplistic example: data Nat = Zero | Succ Nat * the expression data Nat introduces a new type in the programming language

pp:c06

2017-04-24T12:08:48+03:00

Parameter passing in different programming languages Different programming languages adopt different strategies for passing (and evaluating) parameters during function calls. Such strategies can be split into two categories: * applicative * normal

pp:c07

2017-04-24T12:21:24+03:00

Lazy Evaluation in Haskell Introduction Lazy evaluation means that: * an expression (function application) will be evaluated only when it is needed (precisely as in the Lambda Calculus's normal evaluation) * an expression is evaluated only once

pp:c08

2018-04-09T19:29:43+03:00

Introduction to Prolog The basics Consider the following code: student(gigel). student(ionel). student(john). student(mary). male(gigel). male(ionel). male(john). female(mary). lecture(pp). lecture(aa). studies(gigel,aa). studies(mary,pp). studies(mary,aa). studies(john,pp). $ A_1, \ldots, A_n$$ R\subseteq A_1 \times \ldots \times A_n$$ A_i$$ R\subseteq Prim$$ Prim$$ studies=\{(gigel,aa),(mary,pp),(mary,aa), (john,pp)\}$$ R(t_1,\ldots, t_n)$$ t_i$$ student(M) \wedge male(M) \wedge studie…

pp:c09

2017-05-11T08:14:50+03:00

Formal syntax, Unification, Backtracking, Cut, Negation Prolog syntax The basic programming building block in Prolog is the clause. To define it formally, we first introduce: ::= alphanumeric sequence starting with capital ::= | | | ( ..., ) $ t =_S t'$$ (X,t)$$ X$$ t$$ t/X$$ (X,t)$$ S$$ t_1/X$$ t_2/X$$ t_1 =_S t_2$$ X$$ \displaystyle\frac{}{atom =_S atom}$$ \displaystyle\frac{S \cup \{t/X\} \text{ is consistent }}{X =_S t}$$ X=…

pp:class

2021-04-11T22:15:58+03:00

6. Classes in Haskell Default Classes Today you can use the provided . Last time we've learned how to define our new data types in Haskell. The simpler ones were Ordering (some “constants”), Point Float Float, and Student String String [Float]

pp:exam2022

2022-05-27T13:25:20+03:00

Examen PP 2022 * 12 Exercitii. 8=40 (maxim) 40p - 8p - 12

pp:examen2021

2021-05-20T15:29:28+03:00

Examen PP (sesiunea 2021) Examenul la PP se va desfasura online, si va consta intr-o proba de programare ce va contine: * (L/P) o intrebare legata de Calcul Lambda sau un exercitiu de programare din Prolog * (E1) un exercitiu de programare functionala scurt$ (\lambda x.(x\;x)\;(\lambda y.y\;\lambda z.z))$$ e^x$$ e^x = \displaystyle\sum_{n = 0}^\infty \frac{x^n}{n!}$

pp:examen2022

2022-05-26T13:32:56+03:00

Examen PP 2022 * Examenul la PP va consta in implementarea unor functii, in stil functional, in limbajul Haskell. * Examenul se va desfasura exclusiv fizic. * Folosirea laptopului va fi obligatorie la examen. * Rezolvarea va consta intr-o submisie

pp:functors

2021-04-21T15:51:13+03:00

7. Functors, Foldables Functors are data types over which we can map a function (that is, apply a function on each element while keeping the overall structure). You've already encountered a Functor, namely haskell lists. For historical reasons, map only works on lists (

pp:h01

2018-03-29T13:52:26+03:00

To access the two links you must log in with your LDAP account. Homework Statement Homework Archive

pp:haskell-environment

2019-02-15T18:06:48+03:00

Haskell Environment Setup Primul pas spre a putea învăța Haskell este să avem o modalitate de a rula codul scris. Puteți descărca platforma Haskell de aici (Windows/OS X/Linux) sau puteți căuta pachetul “ghc” în repourile distribuției voastre.

pp:high

2021-03-21T08:14:55+03:00

Higher-order functions In our previous examples, we have seen functions such as (+) or (*) which are passed as parameter to other functions, e.g. foldr. A function which expects another function as parameter is called a higher-order function. One distinctive functional programming trait relies on defining and using higher-order functions. Haskell makes this programming style very natural.

pp:hoogle

2019-04-12T14:49:42+03:00

Hoogle Hoogle este un motor de căutare pentru funcții, tipuri, clase etc. de Haskell. Puterea sa constă în abilitatea de a căuta funcții atât după nume cât și după tip. Căutare după nume Considerați că tocmai ați auzit de funcția Haskell

pp:intro

2019-02-14T18:19:09+03:00

Introduction to Programming Paradigms In how many different ways can we reverse a sequence of integers? We start the lecture by looking at three different Java programs which reverse a sequence of integers. The Cook-book style: public class Rev { public static void main (String[] args) { Integer[] v = new Integer[] {1,2,3,4,5,6,7,8,9}; int i=0; while (i < v.length/2){ int t = v[i]; v[i] = v[v.length-1-i]; v[v.length-1-i] = t; i++; } show(v); } } $ n/2$$ n$

pp:l01

2020-04-07T15:05:26+03:00

1. Introduction to the Haskell language The main (and, as we shall soon see, the only!) programming instrument in Haskell is the function. In mathematics, a function is a relation between specified sets ($ f:A\rightarrow B$ ) that associates to every element of $ A$ , exactly one element of $ B$$ f(x,y) = x$

pp:l02

2021-03-16T19:24:49+03:00

2. Pattern matching and basic types in Haskell 2.1. Pattern matching It is likely that in the above implementations you used head and tail, or branch definitions combined with '_' to solve the exercises. Haskell supports a more elegant means of value introspection

pp:l03

2022-03-20T15:13:24+03:00

3. Higher-order functions Function application and composition as higher-order functions One key idea from functional programming is that functions are first-class (or first-order) values, just like integers, strings, etc. . They can be passed as function $ \{1,2\}$$ \{2^n \mid n\in\mathbb{N}\}$

pp:l04

2023-03-22T18:54:29+03:00

4. Working with matrices and images using higher-order functions 1. Introduction We shall represent matrices as lists of lists, i.e. values of type [ [Integer ] ]. Each element in the outer list represents a line of the matrix. Hence, the matrix $ \displaystyle \left(\begin{array}{ccc} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \\ \end{array}\right)$$ \displaystyle 2 * \left(\begin{array}{ccc} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \\ \end{array}\right) = \left(\begin{array}{ccc} 2 & 4 & 6 \\ 8 & 10…

pp:l04x

2021-04-05T14:51:39+03:00

5. Algebraic Datatypes in Haskell There are multiple ways of defining new data types in Haskell. In this session, we will focus on Algebraic Data Types, which allow us to specify multiply constructors, with any number of arguments. A new ADT can be defined using the keyword $ \forall i, j; i < j, comparator(l_i, l_j) \neq GT$

pp:l04xx

2020-04-07T15:11:17+03:00

6. Programming with ADTs 1. A dictionary is a collection of key-value pairs, which we can represent in Haskell as a list of pairs (String,Integer) where String is the key type and Integer is the value type: type Dict = [(String,Integer)] Implement the function

pp:l05

2020-02-05T15:50:11+03:00

Clase de tipuri (Typeclasses) Scopul laboratorului: * introducerea conceptului de clase de tipuri * introducerea conceptului de constrângeri de tip * clarificarea distincției dintre “polimorfism parametric” și “polimorfism ad hoc”

pp:l05x

2020-04-07T15:11:43+03:00

7. Haskell type-classes 1. Enroll the type Extended shown below, in class Eq: data Extended = Infinity | Value Integer 2. Enroll the type Formula a in class Eq: data Formula a = Atom a | Or (Formula a) (Formula a) | And (Formula a) (Formula a) | Not (Formula a)

pp:l06

2020-02-05T15:50:51+03:00

Evaluare leneșă Moduri de evaluare a unei expresii: * evaluare aplicativă - argumentele funcțiilor sunt evaluate înaintea aplicării funcției asupra lor. * evaluare lenesa - întârzie evaluarea parametrilor până în momentul când aceasta este folosită efectiv.$ e$$ l$$ l_n$$ abs(l_n - l_{n+1}) < e$$ \displaystyle \lim_{n \rightarrow \infty} \frac{F_{n+1}}{F_n} = \varphi$$ F_n$$ \varphi$$ \varphi$$ a_{n+1} = a_n + sin(a_n)$$ a_0$$ a_{n+1} != a_n$$ \displaystyle \lim_{n \rightarrow \infty} a_n…

pp:l07

2019-05-06T11:41:08+03:00

Prolog: Introducere Scopul laboratorului: * Familiarizarea studenților cu limbajul Prolog Despre Prolog Prolog este un limbaj de programare logică, bazat pe un set mic de mecanisme de baza (e.g. pattern-matching, backtracking). Deși setul de mecanisme de baza este limitat, Prolog este un limbaj foarte puternic și flexibil.

pp:l08

2020-04-12T22:34:15+03:00

8. The Lambda Calculus 1. Consider the following datatype which encodes λ-expressions: data LExpr = Var Char | Lambda Char LExpr | App LExpr LExpr Enroll LExpr in class Show. 2. Write a function vars which returns a list of variables used in a λ-expression:

pp:l09

2020-04-25T19:31:48+03:00

Lazy evaluation 1. Consider the following recurrence scheme described informally below. Use it to build the sequence $ 1, 2, \ldots, n!, \ldots$ 4 4*5 4*5*6 ... 3 3 3 3 ---------------------- 3 3*4 3*4*5 3*4*5*6 ... 2. Define the sequence $ 1, \frac{1}{2}, \ldots, \frac{1}{k!}, \ldots $ 3. Write a function which takes a sequence $ (a_n)_{n\geq 0}$$ (s_n)_{n\geq 0}$$ s_k = \sum_{k\geq 0} a_k$$ e$$ d$$ (a_n)_{n\geq 0}$$ a_k$$ \mid a_k - a_{k+1}\mid \leq d$$ f$$ a_0$$…

pp:l10

2021-05-25T15:44:42+03:00

Introduction to Prolog programming 1. Write a query which returns all student names (first and last name), which were born in 1990. (hint: use _ in place of those variables which are not to be shown). 2. Write a query which returns all student names which were born before 1990.

pp:l11

2020-05-19T14:42:51+03:00

Generative predicates 1. Write the predicate sublist/2 which constructs each sublist of a given list. Hint: use append. ?- sublist([7,2,9],R). % R will subsequently be bound to [], [7], [2], [9], [7,2], [2,9], [7,2,9] 2. Rewrite the predicate such that the empty list is reported only once.

pp:l12

2020-05-14T21:56:00+03:00

Lab 12: Programming with cut and not A tic-tac-toe table is encoded as a list [ [X1,Y1,Z1], [X2,Y2,Z2], [X3,Y3,Z3] ] where a variable is bound to atom x or z (zero) if the position has been played or it is uninstantiated otherwise. 1. Write the predicate $ X_1, X_2, \ldots, X_n$$ X_1, X_2, \ldots, X_n$$ D_1, D_2, \ldots, D_n$$ v_1, v_2, \ldots, v_n$$ v_i \in D_i$$ v_1, v_2, \ldots, v_n$

pp:l112021

2021-05-30T12:57:45+03:00

Prolog Programming 1. Lists 1.1. Write a predicate endsWith(X,L), which checks if the list L ends with element X. 1.2. Write a predicate sameFirstLast(L) which checks if the list L begins and ends with the same element. 1.3. Write a predicate inner(L1,L2)$ P$$ x_1, \ldots, x_n$$ \sum_{x_i\in P}x_i = \sum_{x_i \not\in P}x_i$

pp:lab_solutions

2019-03-07T20:10:01+03:00

Rezolvări laboratoare Puteți descărca rezolvările laboratoarelor de la această adresă

pp:lambda

2019-04-08T21:33:37+03:00

The Lambda Calculus A brief history The Lambda Calculus was created in 1928 by Alonzo Church. (To be expanded). Intuition At first glance, the Lambda Calculus formalises the fundamental concept of function application from mathematics. Consider the function $ f(x) = x + 1$$ f(2)$$ f$$ 2$$ 2$$ 2+1$$ x, y, \ldots$$ V$$ e$$ e ::= x \in V \mid \lambda x.e \mid (e_1\;e_2)$$ \lambda$$ x$$ \lambda x.x$$ (\lambda x.\lambda y.x\;z)$$ V$$ \lambda x\lambda y.body$$ \lambda x.x$$ \lambda x.y$$ y$$ \lamb…

pp:lazylab

2021-04-25T17:20:42+03:00

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:$ e$$ l$$ l_n$$ abs(l_n - l_{n+1}) < e$$ \displaystyle \lim_{n \rightarrow \infty} \frac{F_{n+1}}{F_n} = \varphi$$ F_n$$ \varphi$$ \varphi$$ a_{n+1} = a_n + sin(a_n)$$ a_0$$ a_{n+1} != a_n$$ \displaystyle \lim_{n \rightarrow \infty} a_n = \pi$$ \pi$…

pp:lecture01

2022-03-03T12:12:32+03:00

Introduction to Haskell Different ways of defining the sum function in Haskell: sum1 :: [Int] -> Int -> Int -> Int sum1 v crt_sum crt_index = if crt_index == (length v) then crt_sum else sum1 v (crt_sum + (v !! crt_index)) (crt_index + 1) sum2 v crt_sum crt_index | crt_index == (length v) = crt_sum | otherwise = sum2 v (crt_sum + (v !! crt_index)) (crt_index + 1) sum3 v crt_sum | v == [] = crt_sum | otherwise = sum…

pp:lecture03

2022-03-15T18:04:23+03:00

Higher order functions and functional closures Using: higher-order functions, infix/prefix notation, anonymous functions (lambdas) and functional closures to write better code: import Data.Char -- map examples addOne :: [Integer] -> [Integer] addOne = map (+1) remHead = map tail toString = map (:[]) fold op acc [] = acc fold op acc (x:xs) = x 0111p0032(fold op acc xs) sum = foldr (+) 0 -- operatia de adunare, prefixata, este (+) makeLower = foldr ((:).toLower) [] reverse :: [a] …

pp:lecture05

2022-03-17T12:23:04+03:00

Aplicatii (higher-order functions) Separarea unui sir dupa un caracter, folosind foldr: spaceSep :: String -> [String] spaceSep = foldr op [] where op :: Char -> [String] -> [String] op ' ' acc = []:acc op x [] = [[x]] -- atentie! op x (y:ys) = (x:y):ys charSep :: Char -> String -> [String] charSep c = foldr op [] where op x [] | x == c = [] …

pp:lecture07

2022-03-28T10:44:02+03:00

Algebraic datatypes data TList = Void | Cons Integer TList tlength :: TList -> Integer tlength Void = 0 tlength (Cons i l) = 1 + tlength l data PList a = PVoid | PCons a (PList a) plength :: PList a -> Integer plength PVoid = 0 plength (PCons i l) = 1 + plength l toHaskell :: PList a -> [a] toHaskell PVoid = [] toHaskell (PCons i l) = i:(toHaskell l) fromHaskell :: [a] -> PList a fromHaskell [] = PVoid fromHaskell (x:xs) = PCons x (fromHaskell xs) fromm :: [a] -> PList a fromm = foldr…

pp:lecture08

2022-03-29T18:59:03+03:00

L08. Typeclasses {-# LANGUAGE FlexibleInstances, MultiParamTypeClasses #-} {- (A) Ad-hoc polymorphism: "Ad-hoc polymorphism is obtained when a function works, or appears to work, on several different types (which may not exhibit a common structure) and may behave in unrelated ways for each type." – Strachey 1967 (B) Subtype polymorphism: A type S (subtype) is related to another type T (supertype) by some notion of substitutability, meaning that functions written to operate on …

pp:lecture09

2022-03-31T20:12:25+03:00

L09. Type constructors {-# LANGUAGE FlexibleInstances, MultiParamTypeClasses #-} data Tree a = TVoid | Node (Tree a) a (Tree a) data List a = LVoid | Cons a (List a) -- member :: Container of a's -> a -> Bool -- attempt1: class Contains a b where member :: a -> b -> Bool instance Contains Char (List Char) where member _ _ = False -- stub implementation {-This implementation is very particular.-} instance Eq a => Contains a (List a) where member _ LVoid = False member y (Cons x xs) …

pp:lecture12

2022-04-19T12:50:18+03:00

L12. Lazy evaluation {- Lazy evaluation strategy: - evaluate function first (not parameter first) - evaluate each expression AT MOST ONCE! Applications: -} ones = 1:ones -- evaluating ones loops. get 0 (x:xs) = [] get k (x:xs) = x : get (k-1) xs {- get 2 ones get 2 (1:ones) 1:(get 1 ones) 1:(get 1 (1:ones)) 1:(1:(get 0 ones)) 1:(1:[]) [1,1] -} member :: Eq a => a -> [a] -> Bool member x = foldr ((||).(==x)) False or False x = x or True _ = True {- member 1 [2,1,3,4,5,6,7] fol…

pp:lecture13

2022-04-19T12:51:26+03:00

L13. Lazy dynamic programming import Data.Array t0 = [2,3,5,1,4] 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] t2 = [2,3,5,1,4,6,7,1,2,3,5,3,4,7,1,2,3,4,5,6] -- recursive solution: sol0 :: [Integer] -> Integer sol0 prices = max_profit 0 ((length prices) - 1) 1 where max_profit left right year | left > right = 0 | otherwise = maximum [year*(prices !! left) + (max_profit (left+1) right (year+1)), …

pp:lecture15

2022-05-05T18:04:16+03:00

L15. Introduction to Scala /* Sintaxa basic: */ val s = "Hello World" def fibo(n: Int): Int = if (n == 0) 0 else if (n == 1) 1 else fibo(n-1) + fibo(n-2) // varianta tail-recursiva // cum putem defini functii auxiliare (where) def fibo1(n: Int): Int = { def fib_aux(n: Int, last: Int, before_last: Int): Int = if (n == 0) last else fib_aux(n-1,before_last+last,last) fib_aux(n,1,0) } fibo(3) /* Functii de ordin superior */ def sumOf(start: In…

pp:lecture16

2022-05-10T18:05:22+03:00

L16. Case classes /* Clase in Scala */ class Point(a: Int, b: Int) { def getA: Int = a def getB: Int = b def higher(p: Point): Boolean = a >= p.getA //string interpolation override def toString = s"(${a},${b})" } new Point(1,2) new Point(2,1) == new Point(2,1) trait TwoDimensionalObject{ def distanceFromOrigin: Int } trait FTree case class FNode (key: Int, left: FTree, right: FTree) extends FTree // o singura instanta a FEmpty /…

pp:lecture18

2022-05-26T13:37:07+03:00

C18. Scala Hacks // for expressions List(1,2,3).filter(_>2).map(_+1) for (x <- List(1,2,3) if x > 2) yield x + 1 for (x <- List(1,2,3); y <- List(4,5,6)) yield (x,y) // List[List[(Int,Int)]] for (x <- List(1,2,3)) yield for (y <- List(4,5,6)) yield (x,y) // Cateva lucruri despre colectii // Despre Vector val letters = Vector("v", "m", "n", "i", "b", "s") // reprezentati ca arbori, cu branching foarte mare // si adancime foarte mica // // :

pp:lheap

2019-04-18T14:23:48+03:00

Structuri funcționale de date Scopul laboratorului: * recapitularea conceptelor învățate * programarea cu o structură de date funcțională * înțelegerea conceptului de “leftist heap” Priority Queue O coadă de priorități ("priority queue") este o structură de date în care putem stoca elemente și din care îl putem scoate pe cel cu prioritatea cea mai mare. Spre deosebire de o coadă normală, care respectă principiul First In, First Out, elementele unei cozi de priorități sunt scoase în ord…

pp:llambdacalc

2020-02-05T15:50:33+03:00

Evaluare expresii lambda Scopul laboratorului: * obișnuirea studenților cu calculul lambda: * ce e o expresie * ce sunt variabilele libere/legate * cum se evaluează o expresie * implementarea unei aplicații practice de evaluare a expresiilor lambda (în Haskell)$ x$$ x$$\lambda x . E$$ x$$ E$$(E_1\ E_2)$$ E_1$$ E_2$$\lambda x.E$$ x$$ E$$(E_1\ E_2)$$ E_1$$ E_2$$ y$$\lambda x.x$$(\lambda x.x\ y)$$((\lambda x.\lambda y.x\ z)\ \lambda x.x)$$ x$$ E_1$$ E_2$

pp:lplcut

2019-05-06T14:30:49+03:00

Cuts Scopul laboratorului: * aprofundarea mecanismului de căutare din prolog * înțelegerea cut-urilor ca mecanism de control al căutării * distincția între “green cuts” și “red cuts” * metode de colectare a rezultatelor Cut

pp:lplprobs

2020-02-05T15:52:06+03:00

Căutare în spațiul stărilor Scopul laboratorului: * aprofundarea mecanismului de căutare din prolog * metode de colectare a rezultatelor Avantaje prolog Problemele de logică pot fi reprezentate, cât și rezolvate cu mare ușurință în Prolog. Să luăm un exemplu de problemă de logică -

pp:main

2017-02-26T15:16:42+03:00

Programming Paradigms Contents * Introduction * Tail-end Recursion * Team

pp:other-exercises

2021-03-21T08:14:33+03:00

Matrices Haskell implementation of foldl In Haskell, foldl is implemented as follows: foldl op acc [] = acc foldl op acc (h:t) = foldl op (op acc h) t Note the call of the op function. An exercise in modular programming with higher-order functions

pp:plagiarism

2021-03-05T08:55:31+03:00

Reguli de integritate academica Conform regulamentului de desfasurare a studiilor de licenta (articolul 51. punctele d. si i.), studentul are obligatia de a respecta regulile de etica universitara si deontologie academica, specificate in Carta UPB. In cadrul acesteia din urma (articolul 45. punctul 13) a., plagiatul constituie o abatere grava

pp:polymorphism

2018-04-17T16:06:05+03:00

Polymorphism in functional languages Polymorphism in Object-Oriented languages Translated literally, the term polymorphism means multiple shapes. Polymorphism in programming languages is a powerful modularisation tool, which allows programmers to:

pp:project2021

2022-05-11T18:45:21+03:00

Project PP 2022 General info Project team * Mihai-Valentin DUMITRU * Vlad-Andrei BĂDOIU * Teodora-Andreea ION * Mihai UDUBAȘA * Matei POPOVICI * Your Teaching Assistant * You are highly encouraged to talk with your TA about the project and to ask questions during lab. You may also have sessions outside lab hours to check your code with them (either requested by you or by them).$(10+11+12+13+14+15+16+17)/8$$[0-50)$$[50-100)$$[100,500)$

pp:reading

2020-02-05T15:43:29+03:00

Resurse Utile Programare funcțională și Haskell * Why Functional Programming Matters * un articol important despre avantajele programării funcționale * Why Haskell Matters * articol despre avantajele limbajului Haskell, în particular * Haskell in industry * listă de companii care folosesc Haskell intern sau în producție

pp:rec

2019-02-17T23:42:16+03:00

Side-effects Programming with side-effects is one defining feature of imperative programming. A procedure produces a side-effect if its call produces a change in the state of a running program (the memory), apart from the returned value. We (re-)consider the following code discussed in the previous lecture:

pp:rules

2022-02-28T08:32:08+03:00

Regulament Punctajul este organizat astfel: * Parcurs: 7p * Examen: 4p * pentru intrarea în examen sunt necesare: * minim 3p din punctajul de parcurs * minim 2.5p din punctajul pe proiect * pentru promovarea examenului sunt necesare

pp:scala-environment

2026-02-26T10:36:13+03:00

Scala setup Installation Scala can be downloaded and installed on either a Windows or NIX platform (e.g. Linux, OS-X) here. For this lecture you must install Scala 3, and we recommend installing it using Coursier (see the previous link) IDE One of the most widely used IDE (Integrated Development Environment) for Scala is:

pp:scala-project

2022-01-12T11:58:21+03:00

Scala @ PP "Meta ideas" Test-driven development 1. Installation 2. Syntax 2.1. Writing functions 2.2. Function evaluation (order of parameters in function call matters !) * using the => to delay evaluation 2.3. Conditionals * def f(x : Int) = if (x >= 0) x else -x

pp:scalalab1

2022-05-07T17:26:29+03:00

1. Scala syntax, function definition and higher-order functions Objectives: * get yourself familiar with Scala syntax basics * practice writing tail-recursive functions as an alternative to imperative loops * keep your code clean and well-structured.$ n$$ 1 + 2^2 + 3^2 + \ldots + (n-1)^2 + n^2$$ \sqrt{a}$$ x_0 = 1$$ x_{n+1} = \displaystyle\frac{1}{2}(x_n+\frac{a}{x_n})$$ x_n$$ \sqrt{a}$$ x_{n+1}$$ x_0 = 1$$ x_n$$ \sqrt{a}$$ a$$ n$$ (x_n)_n$$ \sqrt{a}$$ \mid x_n^2 - a \mid \leq 0.001$$…

pp:scalalab2

2022-05-19T00:16:45+03:00

L10. List and Datatypes and Functional data representation Objectives: * get familiar with pattern matching lists, as well as common list operations from Scala and how they work * get familiar with common higher-order functions over lists (partition, map, foldRight, foldLeft, filter)

pp:scalalab3

2022-05-25T01:15:54+03:00

Lab 11. Polymorphism and For expressions in Scala I. Polymorphism This lab will start with the implementations discussed during lecture. Please find the polymorphic trait FList[A] below: trait FList[A]{ // list with elements of type A def length: Int def head: A def tail: FList[A] def map[B](f: A => B): FList[B] // a op (b op (c op acc)) def foldRight[B](acc: B)(op: (A,B) => B): B // ((acc op a) op b) op c def foldLeft[B](acc: B)(op: (B,A) => B): B def contains(e: A):Boo…

pp:syntax

2020-03-12T23:18:02+03:00

Crash course into Haskell's syntax Haskell in the Programming Paradigms lecture We use Haskell at PP in order to illustrate some functional programming concepts (or functional programming design patterns) which can be used in any functional or multi-paradigm lecture. These are:

pp:tailend

2016-05-05T18:46:45+03:00

Tail-end Recursion Tail-end Recursion is an efficient way of writing recursive functions so that they use less memory on the stack and sometimes improve the complexity by recurring fewer times. However, in order to use the advantages of tail-end recursion compilers have to be optimized specifically to identify situations where the stack could be used more efficiently. The utility of Tail-end Recursion will be highlighted using a practical example involving a recursive procedure that computes th…

pp:team

2021-03-09T14:21:01+03:00

Paradigme de Programare 2020-2021 Echipa * Matei Popovici * Bogdan-Alexandru ANDREI * Mihai-Valentin DUMITRU * Alexandru POBORANU * Alexandru RAIT * Alexandru GHICULESCU * Andreea DUTULESCU * Calin BUCUR * Roxana STIUCA * Sergiu TOADER Curs Frecvență Zi Interval orar Sală Profesor săptămânal Vineri 12:00-14:00 MS Teams Matei POPOVICI săptămâni impare Marți 16:00-18:00 MS Teams Matei POPOVICI

pp:test1_page

2017-04-04T22:35:26+03:00

Test

pp:test_lab2

2018-03-04T16:02:10+03:00

Exerciții updated 1. Scrieți o funcție ce primește un număr si o listă de numere de forma [a1, a2, ... an] ca parametrii și calculează X - a1 - a2 - ... - an. 2. Inversați o listă folosind foldl. 3. Scrieți o închidere funcțională care elimină caracterul 'a' dintr-un string primit ca parametru. Scrieți o implementare ce utilizează o funcție de tip fold și alta care se folosește funcția filter.

pp:types

2017-03-13T12:04:20+03:00

Types in functional programming Typing in programming languages Strong vs weak typing Consider the following example from Javascript, where the operator + is applied on arguments of different types. The result is given below: [] + [] = "" [] + {} = "[object]" {} + [] = 0 {} + {} = null