Transcript
FP, simplified for java programmers
Naveen Muguda
Programming Paradigms
• Wikipedia lists about 30+ paradigms
Programming Paradigms(..continued)
• Two paradigms are largely prevalent • Procedural (vast majority)
• Object Oriented (occasional)
• Functional (old kid making a come back)
Procedural
OO
Functional
Structures
procedures
functions
types
objects
Paradigm:Data
Shared/Hidden Mutable/Immutable
Procedural Shared Mutable
Object Oriented Hidden Mutable
Functional Shared Immutable
Paradigm: snippets
• Find elements of a list
Procedural find(list)
Object Oriented list.find(y)
Functional list.filter(x -> (x == y));
Snippets(..continued)
even list.filter(x -> (x % 2) == 0)
odd list.filter(x -> (x % 2) != 0)
prime list.filter(Primes::isPrime)
Multiple of list.filter(x -> isMultiple(x, 4))
Building block: Function
• Functions return value vs stack.push()
• Functions are methods which have no side effects vs list.add()
• Functions always return the same value for the same input vs stack.pop()
• Functions don’t access data in other contexts* vs list.size()
Side effects
• Have to be managed
• push():pop()
• lock():unlock()
• allocate():free()
Control abstractions
Have side effects Don’t have side effects
statement Expression
procedure function
Higher order functions
• x, f, f(x)
• filter(Predicate predicate)• …
• if(predicate.test(x) == true)• result.add(x)
Granularity
• filter(Predicate<X> predicate)
• map(Function<X, Y> mapper)
• fold(T zero, Bifunction<T, T>combiner)
parameterization
• fold(1, (x, y) -> (x * y))
• fold(0, (x, y) -> (x + y))
• fold(Integer.Minimum, (x, y)-> max(x, y))
composability
• f(g(h(x)))
• map(h).map(g).map(f)
• filter(m).find(f).map(g).orElse(y)
..benefits
• Functions are easier to reason
• Functions are modular
• Functions are safer
Monad
• wrap data
• accept a chain of functions
• create a chain of monads
• Provide utility around wrapped data
Monad(..continued)
• wrap
• map
• flatMap
Monads
Monad Value
Identity storage
Stream parallelising pipeline
Promise deferring pipeline execution
Optional creates non-null and null pipelines,provides null safety
Either creates two pipelines, usually happy path and other path, encapsulates concerns
Try Creates two pipelines, happy path and exception path, encapsulates concerns
Modularization in non-FP worldModularization in FP world
Where is FP being used?
• map/reduce
• Java Streams
• Reactive
• Spark
• Kafka
recommendations
• statements -> expressions
• procedures-> functions
• null check -> Optional
• if-else-> Either
• if-else-> ternary
• for-> stream
• try-catch-> Try
catch
• Sorting, inserting are all painful
• great for queries, figuring out for mutations
top related