Java02. ДЗ 03, Shevchenko Ilya

.gitignore

@@ -0,0 +1,3 @@
+.idea
+.gradle
+build/

FunctionalJava/build.gradle

@@ -0,0 +1,14 @@
+group 'ru.spbau.shevchenko'
+version '1.0-SNAPSHOT'
+
+apply plugin: 'java'
+
+sourceCompatibility = 1.8
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testCompile group: 'junit', name: 'junit', version: '4.11'
+}

FunctionalJava/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Mon Oct 24 23:58:01 MSK 2016
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.13-bin.zip

FunctionalJava/settings.gradle

@@ -0,0 +1,2 @@
+rootProject.name = 'FunctionalJava'
+

FunctionalJava/src/main/java/Collections.java

@@ -0,0 +1,55 @@
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Created by ilya on 10/25/16.
+ */
+public class Collections {
+    public static <Return, Param> List<Return> map(Function1<? super Param, ? extends Return> f, Iterable<Param> iterable){
+        List<Return> result = new ArrayList<>();
+        iterable.forEach(param -> result.add(f.apply(param)));
+        return result;
+    }
+    public static <Param> List<Param> filter(Predicate<? super Param> f, Iterable<Param> iterable){
+        List<Param> result = new ArrayList<>();
+        for(Param param : iterable){
+            if (f.apply(param)){
+                result.add(param);
+            }
+        }
+        return result;
+    }
+    public static <Param> List<Param> takeWhile(Predicate<? super Param> f, Iterable<Param> iterable){
+        List<Param> result = new ArrayList<>();
+        for(Param param : iterable){
+            if (f.apply(param)){
+                result.add(param);
+            }
+            else{
+                break;
+            }
+        }
+        return result;
+    }
+    public static <Param> List<Param> takeUnless(Predicate<? super Param> f, Iterable<Param> iterable){
+        return takeWhile(f.not(), iterable);
+    }
+    public static <Return> Return foldl(Function2<? super Return, ? super Return, ? extends Return> f, Return ini, Iterable<Return> iterable){
+        Return result = ini;
+        for(Return a : iterable){
+            result = f.apply(result, a);
+        }
+        return result;
+    }
+    public static <Return> Return foldr(Function2<? super Return, ? super Return, ? extends Return> f, Return ini, Iterable<Return> iterable){
+        return foldr(f, ini, iterable.iterator());
+    }
+    private static <Return> Return foldr(Function2<? super Return, ? super Return, ? extends Return> f, Return ini, Iterator<Return> iterator) {
+        if(!iterator.hasNext()){
+            return ini;
+        }
+        Return first = iterator.next();
+        return f.apply(first, foldr(f, ini, iterator));
+    }
+}

FunctionalJava/src/main/java/Function1.java

@@ -0,0 +1,10 @@
+/**
+ * Created by ilya on 10/24/16.
+ */
+public interface Function1<Param, Return> {
+    Return apply(Param xw);
+
+    default <R> Function1<Param, R> compose(Function1<? super Return, ? extends R> g) {
+        return param -> g.apply(apply(param));
+    }
+}

FunctionalJava/src/main/java/Function2.java

@@ -0,0 +1,20 @@
+/**
+ * Created by ilya on 10/25/16.
+ */
+public interface Function2<Param1, Param2, Return> {
+    Return apply(Param1 x, Param2 y);
+
+    default <R> Function2<Param1, Param2, R> compose(Function1<? super Return, ? extends R> g){
+        return (param1, param2) -> g.apply(apply(param1, param2));
+    }
+    default Function1<Param2, Return> bind1(Param1 param1){
+        return param2 -> apply(param1, param2);
+    }
+    default Function1<Param1, Return> bind2(Param2 param2){
+        return param1 -> apply(param1, param2);
+    }
+    default Function1<Param1, Function1<Param2, Return>> curry(){
+        return this::bind1;
+    }
+}
+

FunctionalJava/src/main/java/Predicate.java

@@ -0,0 +1,17 @@
+/**
+ * Created by ilya on 10/25/16.
+ */
+public interface Predicate<Param> extends Function1<Param, Boolean>{
+    Predicate<Object> ALWAYS_TRUE = x -> true;
+    Predicate<Object> ALWAYS_FALSE = x -> false;
+
+    default Predicate<Param> not(){
+        return param -> !apply(param);
+    }
+    default Predicate<Param> or(Predicate<? super Param> g){
+        return param -> apply(param) || g.apply(param);
+    }
+    default Predicate<Param> and(Predicate<? super Param> g){
+        return param -> apply(param) && g.apply(param);
+    }
+}