Download as PDF, PPTX
![Java
List <int> fib(int i) {
List <int> seq = new ArrayList(n);
seq[0] = 1;
seq[1] = 1;
for(int i = 2; i < n; i++) {
seq[i] = seq[i-2] + seq[i-1];
}
return seq;
}](https://image.slidesharecdn.com/haskell-120425142132-phpapp02/75/Haskell-Being-lazy-with-class-12-2048.jpg)
![Java VS haskell
fib = 1:1:zipWith (+) fib (tail fib)
List <int> seq = new ArrayList(n);
seq[0] = 1;
seq[1] = 1;
for(int i = 2; i < n; i++) {
seq[i] = seq[i-2] + seq[i-1];
}](https://image.slidesharecdn.com/haskell-120425142132-phpapp02/75/Haskell-Being-lazy-with-class-14-2048.jpg)
![Java VS haskell
fib = 1:1:zipWith (+) fib (tail fib)
List <int> seq = new ArrayList(n);
seq[0] = 1;
seq[1] = 1;
for(int i = 2; i < n; i++) {
seq[i] = seq[i-2] + seq[i-1];
}](https://image.slidesharecdn.com/haskell-120425142132-phpapp02/75/Haskell-Being-lazy-with-class-15-2048.jpg)
![Java VS haskell
fib = 1:1:zipWith (+) fib (tail fib)
List <int> seq = new ArrayList(n);
seq[0] = 1;
seq[1] = 1;
for(int i = 2; i < n; i++) {
seq[i] = seq[i-2] + seq[i-1];
}](https://image.slidesharecdn.com/haskell-120425142132-phpapp02/75/Haskell-Being-lazy-with-class-16-2048.jpg)
![Java VS haskell
fib = 1:1:zipWith (+) fib (tail fib)
List <int> seq = new ArrayList(n);
seq[0] = 1;
seq[1] = 1;
for(int i = 2; i < n; i++) {
seq[i] = seq[i-2] + seq[i-1];
}](https://image.slidesharecdn.com/haskell-120425142132-phpapp02/75/Haskell-Being-lazy-with-class-17-2048.jpg)
![How it works?
fib = 1:1:zipWith (+) fib (tail fib)
take 2 fib -> ? lazy evaluation
fib = 1 : 1 : ..
tail fib = 1 : ..
zipWith (+) fib (tail fib) = ..
take 2 fib -> [1,1]](https://image.slidesharecdn.com/haskell-120425142132-phpapp02/75/Haskell-Being-lazy-with-class-18-2048.jpg)
![How it works?
fib = 1:1:zipWith (+) fib (tail fib)
take 3 fib -> ?
fib = 1 : 1 : 2 : ..
tail fib = 1 : 2 : ..
zipWith (+) fib (tail fib) = 2 : ..
take 3 fib -> [1,1,2]](https://image.slidesharecdn.com/haskell-120425142132-phpapp02/75/Haskell-Being-lazy-with-class-19-2048.jpg)
![How it works?
fib = 1:1:zipWith (+) fib (tail fib)
take 10 fib -> ?
fib = 1 : 1 : 2 : 3 : ..
tail fib = 1 : 2 : 3 : ..
zipWith (+) fib (tail fib) = 2 : 3 : ..
...
fib = 1 : 1 : 2 : 3 : 5 ..
tail fib = 1 : 2 : 3 : 5 : ..
zipWith (+) fib (tail fib) = 2 : 3 : 5 : ..
take 10 fib -> [1,1,2,3,5,8,13,21,34,55]](https://image.slidesharecdn.com/haskell-120425142132-phpapp02/75/Haskell-Being-lazy-with-class-20-2048.jpg)
![Quicksort
[3,2,1,4] -> [1,2,3,4]](https://image.slidesharecdn.com/haskell-120425142132-phpapp02/75/Haskell-Being-lazy-with-class-26-2048.jpg)
![C
// To sort array a[] of size n: qsort(a,0,n-1)
void qsort(int a[], int lo, int hi)
{
int h, l, p, t;
if (lo < hi) {
l = lo;
h = hi;
p = a[hi];
do {
while ((l < h) && (a[l] <= p))
l = l+1;
while ((h > l) && (a[h] >= p))
h = h-1;
if (l < h) {
t = a[l];
a[l] = a[h];
a[h] = t;
}
} while (l < h);
a[hi] = a[l];
a[l] = p;
qsort( a, lo, l-1 );
qsort( a, l+1, hi );
}
}](https://image.slidesharecdn.com/haskell-120425142132-phpapp02/75/Haskell-Being-lazy-with-class-27-2048.jpg)
![Haskell
qsort(p:xs) = (qsort lesser) ++ [p] ++
(qsort greater)
where
lesser = filter (< p) xs
greater = filter (>= p) xs](https://image.slidesharecdn.com/haskell-120425142132-phpapp02/75/Haskell-Being-lazy-with-class-28-2048.jpg)
![Haskell
qsort(p:xs) = qsort [x | x<-xs, x<p]
++ [p]
++ qsort [x | x<-xs, x>=p]](https://image.slidesharecdn.com/haskell-120425142132-phpapp02/75/Haskell-Being-lazy-with-class-29-2048.jpg)
![Haskell
pattern
matching fac 0 = 1
fac n | n > 0 = n * fac (n-1)
fac n = product [1..n]
fac n = foldr1 (*) [1..n]
fac n = if n == 1 then 1 else n * fac (n-1)](https://image.slidesharecdn.com/haskell-120425142132-phpapp02/75/Haskell-Being-lazy-with-class-31-2048.jpg)
![Haskell
fac n = case n of
0 -> 1
n -> n * fac (n-1)
facs = scanl (*) 1 [1..]
fac n = facs !! n](https://image.slidesharecdn.com/haskell-120425142132-phpapp02/75/Haskell-Being-lazy-with-class-32-2048.jpg)
Uploaded byTiago Babo
Haskell - Being lazy with class
Haskell is a pure, lazy, strongly typed functional programming language. It was influenced by languages like Lisp, ML, and Miranda. There are two main implementations, GHC which compiles to native code, and Hugs which is a bytecode interpreter. Haskell avoids bugs through its purity, strong typing, conciseness, and memory management. It is used in industries like aerospace, finance, and web development for tasks like processing internet abuse complaints, programmatically manipulating code, and implementing mathematical models.
More Related Content
Similar to Haskell - Being lazy with class
Haskell - Being lazy with class
- 1. Haskell being lazywith class Tiago Babo PPRO@FEUP 2012
- 2. History Lisp/Scheme ML/OCaml Miranda Haskell 98 1959 1979 1985 2003 functional static lazy language typing evaluation
- 3. History There are twomain Haskell implementations: ▹ GHC. Probably the most popular, compiles to native code on a number of different architectures. ▹ Hugs. It’s a bytecode interpreter and the most portable and lightweight of the Haskell implementations.
- 4. Related languages There aresome languages inspired by Haskell: ▹ Different type system: Epigram, Agda. ▹ JVM-based: Frege, Jaskell. ▹ Other related languages: Curry. ▹ Testbed for many new ideas: Parallel Haskell, Eager Haskell, Generic Haskell, O’Haskell, Hume, Scotch, Disciple...
- 5. haskell Haskell is apure functional language. It means that: ▹ Variables never change after definition. ▹ Functions don’t have side effects. ▹ Functions always return the same output given the same input.
- 6. haskell What haskell offerto the programmer? ▹ Purity. It doesn’t allow any side-effects. ▹ Laziness (non-strict). Nothing is evaluated until it has to be evaluated. ▹ Strong static typing. The compiler automatically infers a precise type for all values and it permits no implicit type conversions. ▹ Elegance. Stuff just work like you’d expect it to.
- 7. haskell and bugs Haskellprograms have fewer bugs because Haskell is: ▹ Pure. There are no side effects. ▹ Strongly typed. There can be no dubious use of types. ▹ Concise. Programs are shorter which make it easier to “take it all” at once.
- 8. haskell and bugs Haskellprograms have fewer bugs because Haskell is: ▹ High Level. Haskell programs most often reads out almost exactly like the algorithm description. ▹ Memory Managed. There’s no worrying about dangling pointers, the Garbage Collector takes care of all that. ▹ Modular. Haskell offers stronger and more “glue” to compose your program from already developed modules.
- 9. haskell cons Haskell hassome disadvantages: ▹ Hard to learn and master. It’s even harder without a proper computer science background. ▹ You can’t write haskell-like code in other programming languages. ▹ Lacks libraries and support from who mantain and improve them.
- 10.
- 11. fibonacci 1 1 23 5 8 13 21 34 ..
- 12. Java List <int> fib(inti) { List <int> seq = new ArrayList(n); seq[0] = 1; seq[1] = 1; for(int i = 2; i < n; i++) { seq[i] = seq[i-2] + seq[i-1]; } return seq; }
- 13. Haskell fib = 1:1:zipWith(+) fib (tail fib)
- 14. Java VS haskell fib= 1:1:zipWith (+) fib (tail fib) List <int> seq = new ArrayList(n); seq[0] = 1; seq[1] = 1; for(int i = 2; i < n; i++) { seq[i] = seq[i-2] + seq[i-1]; }
- 15. Java VS haskell fib= 1:1:zipWith (+) fib (tail fib) List <int> seq = new ArrayList(n); seq[0] = 1; seq[1] = 1; for(int i = 2; i < n; i++) { seq[i] = seq[i-2] + seq[i-1]; }
- 16. Java VS haskell fib= 1:1:zipWith (+) fib (tail fib) List <int> seq = new ArrayList(n); seq[0] = 1; seq[1] = 1; for(int i = 2; i < n; i++) { seq[i] = seq[i-2] + seq[i-1]; }
- 17. Java VS haskell fib= 1:1:zipWith (+) fib (tail fib) List <int> seq = new ArrayList(n); seq[0] = 1; seq[1] = 1; for(int i = 2; i < n; i++) { seq[i] = seq[i-2] + seq[i-1]; }
- 18. How it works? fib= 1:1:zipWith (+) fib (tail fib) take 2 fib -> ? lazy evaluation fib = 1 : 1 : .. tail fib = 1 : .. zipWith (+) fib (tail fib) = .. take 2 fib -> [1,1]
- 19. How it works? fib= 1:1:zipWith (+) fib (tail fib) take 3 fib -> ? fib = 1 : 1 : 2 : .. tail fib = 1 : 2 : .. zipWith (+) fib (tail fib) = 2 : .. take 3 fib -> [1,1,2]
- 20. How it works? fib= 1:1:zipWith (+) fib (tail fib) take 10 fib -> ? fib = 1 : 1 : 2 : 3 : .. tail fib = 1 : 2 : 3 : .. zipWith (+) fib (tail fib) = 2 : 3 : .. ... fib = 1 : 1 : 2 : 3 : 5 .. tail fib = 1 : 2 : 3 : 5 : .. zipWith (+) fib (tail fib) = 2 : 3 : 5 : .. take 10 fib -> [1,1,2,3,5,8,13,21,34,55]
- 21. and how aboutthe types? fib = 1:1:zipWith (+) fib (tail fib)
- 22. and how aboutthe types? int fib = 1:1:zipWith (+) fib (tail fib) int
- 23. and how aboutthe types? List<int> int fib = 1:1:zipWith (+) fib (tail fib) int
- 24. and how aboutthe types? List<int> List<int> int fib = 1:1:zipWith (+) fib (tail fib) int List<int>
- 25. and how aboutthe types? List<int> List<int> List<int> int fib = 1:1:zipWith (+) fib (tail fib) int List<int>
- 26.
- 27. C // To sortarray a[] of size n: qsort(a,0,n-1) void qsort(int a[], int lo, int hi) { int h, l, p, t; if (lo < hi) { l = lo; h = hi; p = a[hi]; do { while ((l < h) && (a[l] <= p)) l = l+1; while ((h > l) && (a[h] >= p)) h = h-1; if (l < h) { t = a[l]; a[l] = a[h]; a[h] = t; } } while (l < h); a[hi] = a[l]; a[l] = p; qsort( a, lo, l-1 ); qsort( a, l+1, hi ); } }
- 28. Haskell qsort(p:xs) = (qsortlesser) ++ [p] ++ (qsort greater) where lesser = filter (< p) xs greater = filter (>= p) xs
- 29. Haskell qsort(p:xs) = qsort[x | x<-xs, x<p] ++ [p] ++ qsort [x | x<-xs, x>=p]
- 30.
- 31. Haskell pattern matching fac 0= 1 fac n | n > 0 = n * fac (n-1) fac n = product [1..n] fac n = foldr1 (*) [1..n] fac n = if n == 1 then 1 else n * fac (n-1)
- 32. Haskell fac n =case n of 0 -> 1 n -> n * fac (n-1) facs = scanl (*) 1 [1..] fac n = facs !! n
- 33. haskell in industry Haskellis used in many areas: ▹ Aerospace, defense, finance, web startups, and hardware design firms.
- 34. haskell in industry automate processing procedural city generation of internet abuse complaints and simulation market programmatically analysis of cryptographic manipulating a PHP code base protocols
- 35. haskell in industry measurethe counterparty risk on implement mathematical portfolios of financial derivates models and other complex job scheduling and brand handwriting recognition matching system
- 36. Haskell being lazy with class Links: http://haskell.org/ - Haskell official homepage http://youtu.be/cXY4fSA7DnM - Stanford Tutorial http://haifux.org/lectures/173/ - An overview of Haskell (Haggai Eran) http://en.wikipedia.org/wiki/Haskell_(programming_language) - Haskell History Tiago Babo PPRO@FEUP 2012