1. Learning FP
Lev Walkin
@levwalkin

2. Myself
Founder, Chief Editor of a peer-reviewed
«Practice of Functional Programming»
journal http://fprog.ru/
CTO Echo, a venture backed company
http://aboutecho.com/
Proficient in N languages, M of them FP

3. Echo
50,000+ HTTP requests per second
500,000+ simultaneous users on site
1,527,721,774 search queries last month
JavaScript, Clojure, Haskell, C, LAMP, RoR,
OCaml, Python, Perl, Visual Basic, C++

4. What’s your reason
to learn FP?
1. You already suspect that FP approach
works best for your domain
2. You want to learn FP to expand your tool
set

5. Mature options
Haskell (OCaml, F#)
Scala
Clojure (CL, Scheme)
Erlang

6. Statically typed
Haskell, OCaml, F# — part of ML family
Utilize Hindley—Milner type inference
You might not even SEE any types
Types provide useful documentation

7. Statically typed
Scala
Very sophisticated type system
Type inference fails often (you have to
annotate with types)
Lots of syntax sugar, lots of ways to do
things

8. Type inference
-- Haskell program
main = print “Hello, world!”
(* OCaml program *)
let main = print_string “Hello, world!”

9. Explicit types
-- Haskell program
main :: IO ()
main = print “Hello, world!”
(* OCaml program *)
val main : unit
let main = print_string “Hello, world!”

10. Dynamically typed
LISP (type annotations are NOT static
types)
Erlang (Dialyzer helps a bit)

11. Pure FP training
...requires pure language.
Haskell is the only viable option.

12. Purity in Haskell
Function have no side effects
All state changes are only through
specially constructed monads (IO, ST)
Static types force isolation
Lazyness thrown in for a deeper fun

13. Haskell
Medium-size syntax, relatively easy to
learn, but...
Simple & interesting things are EASY
Yet, there are LOTS of abstractions and
approaches to learn: Type classes,
Monads, Arrows, parsing, pretty-printing.
This is why we chose Haskell, right?

14. “One”
“silly” “example.”

15. Haskell, OCaml, F#
data Tree a =
! Leaf a
! | Node (Tree a) (Tree a)
type ‘a tree =
! | Leaf of ‘a
! | Node of ‘a tree * ‘a tree
type Tree<'a> =
| Leaf of ‘a
| Branch of ‘a Tree * ‘a Tree
http://fprog.ru/2009/issue2/roman-dushkin-algebraic-data-types/

16. “One”
3
“silly” “example.”
5 8

17. Haskell
data Tree String =
! Leaf String
! | Node (Tree String) (Tree String)
strToLenTree :: Tree String ! Tree Int
strToLenTree (Leaf s) = Leaf (length s)
strToLenTree (Node left right) =
! ! ! Node (strToLenTree left)
! ! ! ! ! (strToLenTree right)

18. Haskell
data Tree a =
! Leaf a
! | Node (Tree a) (Tree a)
mapTree :: (a ! b) ! Tree a ! Tree b
mapTree f (Leaf x) = Leaf (f x)
mapTree f (Node left right) =
! ! ! ! Node (mapTree f left)
! ! ! ! ! ! (mapTree f right)
strToLenTree :: Tree String ! Tree Int
strToLenTree = mapTree length

19. Prototyping
[~]> ghci tree.hs
GHCi, version 7.0.4 :? for help
[1 of 1] Compiling Main ( tree.hs, interpreted )
Ok, modules loaded: Main.
*Main> let tree = Node (Leaf "An") (Leaf "example")
*Main> mapTree (s -> length s) tree
Node (Leaf 2) (Leaf 7)
*Main> mapTree (s -> filter Data.Char.isUpper s) tree
Node (Leaf "A") (Leaf "")
*Main> mapTree (filter Data.Char.isLower) tree
Node (Leaf "n") (Leaf "example")
*Main> :t mapTree
mapTree :: (a -> b) -> Tree a -> Tree b
*Main> :t mapTree length
mapTree length :: Tree [a] -> Tree Int

20. LISP
Clojure: immutability, persistent data
structures, JVM
Scheme: very small language, suitable for
teaching/learning
Common Lisp: it is a fat multiparadigm
language and has everything (though
parts may be rotten a bit)

21. Erlang
Simple language
Telecom systems, 24/7, системы
массового обслуживания (web?)
Hot code reload, deep introspection,
embedded facilities for easier clustering

22. Erlang
% Reverse a string
reverse(String) -> reverse2(String, []).
% Reverse with an accumulator
reverse2([ ], Acc) -> Acc;
reverse2([Head | Tail], Acc) ->
! reverse2(Tail, [Head | Acc]).

23. Erlang
% Sends request to the [remote] system
% and waits for the response back
send_and_wait(Pid, Message, Timeout) ->
! Pid ! Message,
! receive
! ! Response -> {ok, Response}
! after
! ! Timeout -> {error, timeout}
! end.

24. Clojure vs LISP*
NEW language, with sound idioms
Immutable data structures are idiomatic
Fast pace of development
JVM may be a big bon for some
Learn it if you want sound, practical
language
http://tonsky.livejournal.com/tag/clojure

25. Scheme vs LISP*
Small, simple language (R5RS)
A basis for SICP — Structure and
Interpretation of Computer Programs
Learn SICP if you want to study
Programming

26. CL vs LISP*
Many complex ideas mixed in
No enforcement of a good style — you
have to do it on your own
Learn it if you want unrestricted power

27. Haskell vs ML*
More sound type system
LOTS of language research happen on
Haskell
Learn it if you want to learn FP
Learn it if it fits your domain well
http://www.ozon.ru/context/detail/id/8696277/

28. OCaml
Several mostly compatible syntaxes
You can always create a mutable variable
or class field, though not idiomatic
Clearer semantics and computation
model (straightforward translation to
assembly)
http://mirror.ocamlcore.org/ocaml-tutorial.org/the_basics.html

29. OCaml vs ML*
OCaml is to Haskell as C is to C++
Poor library support
FAST (on 1-core systems)
Learn it if you want a practical tool and
not satisfied with Haskell or F#
http://www.slideshare.net/michielovereem/beyond-functional-
programming-in-haskell-an-introduction-to-ocaml

30. F# vs ML*
Works under Microsoft .Net
F# on Mono is somewhat usable
Learn it if you want to tinker with FP on
MS platform
http://www.ozon.ru/context/detail/id/6151130/

31. Erlang vs *
SMALL language, somewhat bigger OTP
Great support for concurrency (Actors),
and parallelism
Hot code reload & run time introspection
OOP on the outside; FP on the inside
Learn it if you build 24/7 production
system

32. Scala vs *
Big language, a functional C++ of sorts
JVM
Learn it if you want a great tool, not
satisfied with Java, yet have no
appreciation for true elegance (Clojure)

33. Learning FP
Haskell provides models and abstractions
(read papers) — pure FP
Scheme teaches you Programming (read
SICP)
Everything else is too practical

34. Practicing FP
.Net → F#
JVM → Clojure (elegance and simplicity),
Scala (less restrictions)
!{.Net|JVM} → OCaml (if you do not need
libraries), Clojure, Haskell (if you have
balls)
24/7 → Erlang

35. For individuals
You want flexible system which allows
you to cut corners
Common Lisp
Scala
F#

36. For teams
You want to think about lifecycle,
support, maintenance, group dynamics
OCaml (static typing provides some
guarantees)
Erlang (simple and straightforward,
designed to withstand errors, good for
novices)

37. For teams
Scala gets increasingly popular because
people do not appreciate elegance and
sound restrictions
People will throw up in a few years
working with accumulated Scala code
...like C++
http://ru.xored.com/2012/12/02/scala/

38. Haskell resources
Мягкое введение в Haskell
Изучай Haskell во имя добра!
http://www.rsdn.ru/article/haskell/haskell_part1.xml

39. Clojure resources
1. Learn spoken English
2. Журнал Никиты Прокопова (tonsky@LJ)
содержит ссылки и рекомендации
http://tonsky.livejournal.com/tag/clojure

40. Erlang resources
1. Programming Erlang: Software for a
Concurrent World
2. http://learnyousomeerlang.com
http://www.ozon.ru/context/detail/id/3645143/

41. Shameless plug
Журнал «Практика
функционального
программирования»
fprog.ru
@fprogru

42. Thank you!
Questions?
@levwalkin