Poor Man's Functional Programming
Upcoming SlideShare
Loading in...5
×
 

Poor Man's Functional Programming

on

  • 2,874 views

 

Statistics

Views

Total Views
2,874
Slideshare-icon Views on SlideShare
539
Embed Views
2,335

Actions

Likes
2
Downloads
1
Comments
0

7 Embeds 2,335

http://jug.lv 2327
http://translate.googleusercontent.com 2
http://assets.txmblr.com 2
http://www.bing.com 1
http://webcache.googleusercontent.com 1
https://www.google.lv 1
https://www.google.com 1
More...

Accessibility

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment
  • Functions are higher-order when they can take other functions as arguments, and return them as results.
  • Pure functions support the mathematical definition of a function:y = f(x)Which means:1- A function should return the same exact value given the same exact input.2- A function does one thing exactly(has one clear mission), it has no side effects like changing some other value or write to stream or any other mission rather than its assigned one.In fact Ruby doesn’t force you to write pure functions, but certainly it helps you to do so. Actually exercising yourself to write in pure functional style when possible helps you really in many ways:1- It makes your code clean, readable and self-documenting.2- It makes your code more “thread safe”3- It helps you more when it comes to TDD.
  • Iteration (looping) in functional languages is usually accomplished via recursion.
  • Higher-order functions enable Currying, which the ability to take a function that accepts n parameters and turns it into a composition of n functions each of them take 1 parameter. A direct use of currying is the Partial Functions where if you have a function that accepts n parameters then you can generate from it one of more functions with some parameter values already filled in.

Poor Man's Functional Programming Poor Man's Functional Programming Presentation Transcript

  • Poor man’s FPHow to change your javacode in a way you neverthought about
  • Dmitry Lebedev• WILDCARD conf• AIESEC/Lotus conf
  • Functional Programming• Higher order functions• Pure functions• Recursion• Non-strict evaluation• Currying
  • Higher order functionsfoo = Proc.new { |prompt| prompt.echo = false }new_pass = ask("Enter your new password: ", &foo)
  • Pure Functionsfoo = Proc.new { |x| x*x+(x+20) }
  • Recursiondef fib(n)return n if (0..1).include? nfib(n-1) + fib(n-2) if n > 1end
  • Non-strict evaluationprint length([2+1, 3*2, 1/0, 5-4])
  • Curryingplus = lambda {|a,b| a + b}plus.(3,5) #=> 8plus_one = plus.curry.(1)plus_one.(5) #=> 6plus_one.(11) #=> 12
  • Java 8?import java.awt.Button;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;public class Java8 {public static void main(String[] args) {Button myButton = new Button();myButton.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent ae) {System.out.println(ae.getSource());}});}}
  • Java 8?import java.awt.Button;import java.awt.event.ActionEvent;public class Java8 {public static void main(String[] args) {Button myButton = new Button();myButton.addActionListener((ActionEvent ae) -> {System.out.println(ae.getSource());});}}
  • Java 8?import java.awt.Button;public class Java8 {public static void main(String[] args) {Button myButton = new Button();myButton.addActionListener(ae ->{System.out.println(ae.getSource());});}}
  • Still living under Java 6?Languages• Scala• ClojureLibraries• Guava• LambdaJ• Functional Java
  • Guava• Function<A, B>, which has the single method Bapply(A input). Instances of Function aregenerally expected to be referentially transparent -- noside effects -- and to be consistent with equals, thatis, a.equals(b) implies thatfunction.apply(a).equals(function.apply(b)).• Predicate<T>, which has the single methodboolean apply(T input). Instances ofPredicate are generally expected to be side-effect-freeand consistent with equals.
  • GuavaList converted = ImmutableList.copyOf(Iterables.transform( userDTOs, new Function(){public User apply( UserDTO input ){return new User( input.name, input.id );}}));
  • LambdaJPerson me = new Person("Mario", "Fusco", 35);Person luca = new Person("Luca", "Marrocco", 29);Person biagio = new Person("Biagio", "Beatrice", 39);Person celestino = new Person("Celestino", "Bellone", 29);List<Person> meAndMyFriends =asList(me, luca, biagio, celestino);List<Person> oldFriends =filter(having(on(Person.class).getAge(), greaterThan(30)),meAndMyFriends);
  • FunctionalJavaimport fj.data.Array;import static fj.data.Array.array;import static fj.Show.arrayShow;import static fj.Show.intShow;import static fj.function.Integers.even;public final class Array_filter {public static void main(final String[] args) {final Array<Integer> a = array(97, 44, 67, 3, 22, 90,1, 77, 98, 1078, 6, 64, 6, 79, 42);final Array<Integer> b = a.filter(even);arrayShow(intShow).println(b);// {44,22,90,98,1078,6,64,6,42}}}
  • Invention of Own Bicycle
  • First Attemptpublic static <T> void forEach(Collection<T> list,Procedure<T> proc) {for (T object : list) {proc.invoke(object);}}
  • Another trypublic static <T, E> Collection<E> each(Collection<T>list, Function<T, E> function) {ArrayList<E> result = new ArrayList<E>();for (T object : list) {result.add(function.apply(object));}return result;}
  • Use Caseresult.addAll(each(imageList,new Function<S3ObjectSummary, String>({@Overridepublic String apply(@NullableS3ObjectSummary input) {return siteURL + input.getKey();}}));
  • Let’s complicate!public interface MapFunction<T, K, V> {Pair<K,V> proceed(T key);}
  • Let’s complicate!public static <T, K, V> Map<K, V>map(Collection<T> list,MapFunction<T, K, V> function) {Map<K, V> result = new HashMap<K, V>();for (T object : list) {Pair<K, V> pair =function.proceed(object);result.put(pair.getKey(),pair.getValue());}return result;}
  • Let’s complicate!...List<Future> fs = newArrayList<Future>(list.size());for (final T object : list) {fs.add(exec.submit(new Callable() {@Overridepublic Object call() throws Exception {return function.proceed(object);}}));}...
  • Let’s complicate!...for (Future ft : fs) {Pair<K, V> pair = (Pair<K, V>) ft.get();result.put(pair.getKey(), pair.getValue());}...
  • Question?
  • The End