Rename Finction1 with Function in examples.

javadev · javadev · commit f1df42c06a90 · 2018-03-09T08:29:46.000+02:00
diff --git a/examples/src/main/java/com/github/underscore/examples/Chaining.java b/examples/src/main/java/com/github/underscore/examples/Chaining.java
@@ -1,7 +1,7 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright 2015 Valentyn Kolesnikov
+ * Copyright 2015-2018 Valentyn Kolesnikov
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -35,7 +35,7 @@ public static <E> E first(final Iterable<E> iterable) {
         return iterable.iterator().next();
     }
 
-    public static <T, E> List<T> map(final List<E> list, final Function1<? super E, T> func) {
+    public static <T, E> List<T> map(final List<E> list, final Function<? super E, T> func) {
         final List<T> transformed = new ArrayList<T>(list.size());
         for (E element : list) {
             transformed.add(func.apply(element));
@@ -44,7 +44,7 @@ public static <T, E> List<T> map(final List<E> list, final Function1<? super E,
     }
 
     public static <E, T extends Comparable<? super T>> List<E> sortBy(final List<E> iterable,
-        final Function1<E, T> func) {
+        final Function<E, T> func) {
         final List<E> sortedList = new ArrayList<E>(iterable);
         Collections.sort(sortedList, new Comparator<E>() {
             @Override
@@ -85,11 +85,11 @@ public Chain<T> first() {
             return new Chain<T>(Chaining.first(list));
         }
 
-        public <F> Chain<F> map(final Function1<? super T, F> func) {
+        public <F> Chain<F> map(final Function<? super T, F> func) {
             return new Chain<F>(Chaining.map(list, func));
         }
 
-        public <F extends Comparable<? super F>> Chain<T> sortBy(final Function1<T, F> func) {
+        public <F extends Comparable<? super F>> Chain<T> sortBy(final Function<T, F> func) {
             return new Chain<T>(Chaining.sortBy(list, func));
         }
 
diff --git a/examples/src/main/java/com/github/underscore/examples/Function.java b/examples/src/main/java/com/github/underscore/examples/Function.java
@@ -1,6 +1,6 @@
 package com.github.underscore.examples;
 
-public interface Function1<F, T> {
+public interface Function<F, T> {
     T apply(F arg);
 
     @Override
diff --git a/examples/src/main/java/com/github/underscore/examples/Intersection.java b/examples/src/main/java/com/github/underscore/examples/Intersection.java
@@ -33,7 +33,7 @@
 public class Intersection {
     public static <E> Optional<E> find(final Iterable<E> iterable, final Predicate<E> pred) {
         for (E element : iterable) {
-            if (pred.apply(element)) {
+            if (pred.test(element)) {
                 return Optional.of(element);
             }
         }
@@ -47,7 +47,7 @@ public static <E> boolean some(final Iterable<E> iterable, final Predicate<E> pr
     public static <E> boolean contains(final Iterable<E> iterable, final E elem) {
         return some(iterable, new Predicate<E>() {
             @Override
-            public Boolean apply(E e) {
+            public boolean test(E e) {
                 return elem == null ? e == null : elem.equals(e);
             }
         });
@@ -56,7 +56,7 @@ public Boolean apply(E e) {
     public static <E> List<E> filter(final List<E> list, final Predicate<E> pred) {
         final List<E> filtered = new ArrayList<E>();
         for (E element : list) {
-            if (pred.apply(element)) {
+            if (pred.test(element)) {
                 filtered.add(element);
             }
         }
@@ -66,7 +66,7 @@ public static <E> List<E> filter(final List<E> list, final Predicate<E> pred) {
     public static <E> List<E> intersection(final List<E> list1, final List<E> list2) {
         return filter(list1, new Predicate<E>() {
             @Override
-            public Boolean apply(E elem) {
+            public boolean test(E elem) {
                 return contains(list2, elem);
             }
         });
diff --git a/examples/src/main/java/com/github/underscore/examples/Predicate.java b/examples/src/main/java/com/github/underscore/examples/Predicate.java
@@ -1,4 +1,8 @@
 package com.github.underscore.examples;
 
-public interface Predicate<T> extends Function1<T, Boolean> {
+public interface Predicate<T> {
+    boolean test(T arg);
+
+    @Override
+    boolean equals(Object object);
 }
diff --git a/examples/src/main/java/com/github/underscore/examples/SnakeCase.java b/examples/src/main/java/com/github/underscore/examples/SnakeCase.java
@@ -88,9 +88,9 @@ public static List<String> words(final String string) {
         return result;
     }
 
-    private static Function1<String, String> createCompounder(
+    private static Function<String, String> createCompounder(
         final Function3<String, String, Integer, String> callback) {
-        return new Function1<String, String>() {
+        return new Function<String, String>() {
             public String apply(final String string) {
                 int index = -1;
                 List<String> array = words(deburr(string));
diff --git a/examples/src/main/java/com/github/underscore/examples/Xor.java b/examples/src/main/java/com/github/underscore/examples/Xor.java
@@ -37,7 +37,7 @@ public static <E> List<E> uniq(final List<E> list) {
 
     public static <E> Optional<E> find(final Iterable<E> iterable, final Predicate<E> pred) {
         for (E element : iterable) {
-            if (pred.apply(element)) {
+            if (pred.test(element)) {
                 return Optional.of(element);
             }
         }
@@ -51,7 +51,7 @@ public static <E> boolean some(final Iterable<E> iterable, final Predicate<E> pr
     public static <E> boolean contains(final Iterable<E> iterable, final E elem) {
         return some(iterable, new Predicate<E>() {
             @Override
-            public Boolean apply(E e) {
+            public boolean test(E e) {
                 return elem == null ? e == null : elem.equals(e);
             }
         });
@@ -60,7 +60,7 @@ public Boolean apply(E e) {
     public static <E> List<E> filter(final List<E> list, final Predicate<E> pred) {
         final List<E> filtered = new ArrayList<E>();
         for (E element : list) {
-            if (pred.apply(element)) {
+            if (pred.test(element)) {
                 filtered.add(element);
             }
         }
@@ -70,7 +70,7 @@ public static <E> List<E> filter(final List<E> list, final Predicate<E> pred) {
     public static <E> List<E> difference(final List<E> list1, final List<E> list2) {
         return filter(list1, new Predicate<E>() {
             @Override
-            public Boolean apply(E elem) {
+            public boolean test(E elem) {
                 return !contains(list2, elem);
             }
         });
diff --git a/examples/src/test/java/com/github/underscore/examples/ChainingTest.java b/examples/src/test/java/com/github/underscore/examples/ChainingTest.java
@@ -58,13 +58,13 @@ public void chain() {
         } };
         final String youngest = Chaining.chain(stooges)
             .sortBy(
-                new Function1<Map<String, Object>, Integer>() {
+                new Function<Map<String, Object>, Integer>() {
                 public Integer apply(Map<String, Object> item) {
                     return (Integer) item.get("age");
                 }
             })
             .map(
-                new Function1<Map<String, Object>, String>() {
+                new Function<Map<String, Object>, String>() {
                 public String apply(Map<String, Object> item) {
                     return item.get("name") + " is " + item.get("age");
                 }

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`/*`
`2`	`2`	`* The MIT License (MIT)`
`3`	`3`	`*`
`4`		`- * Copyright 2015 Valentyn Kolesnikov`
	`4`	`+ * Copyright 2015-2018 Valentyn Kolesnikov`
`5`	`5`	`*`
`6`	`6`	`* Permission is hereby granted, free of charge, to any person obtaining a copy`
`7`	`7`	`* of this software and associated documentation files (the "Software"), to deal`
`@@ -35,7 +35,7 @@ public static <E> E first(final Iterable<E> iterable) {`
`35`	`35`	`return iterable.iterator().next();`
`36`	`36`	`}`
`37`	`37`
`38`		`- public static <T, E> List<T> map(final List<E> list, final Function1<? super E, T> func) {`
	`38`	`+ public static <T, E> List<T> map(final List<E> list, final Function<? super E, T> func) {`
`39`	`39`	`final List<T> transformed = new ArrayList<T>(list.size());`
`40`	`40`	`for (E element : list) {`
`41`	`41`	`transformed.add(func.apply(element));`
`@@ -44,7 +44,7 @@ public static <T, E> List<T> map(final List<E> list, final Function1<? super E,`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`public static <E, T extends Comparable<? super T>> List<E> sortBy(final List<E> iterable,`
`47`		`- final Function1<E, T> func) {`
	`47`	`+ final Function<E, T> func) {`
`48`	`48`	`final List<E> sortedList = new ArrayList<E>(iterable);`
`49`	`49`	`Collections.sort(sortedList, new Comparator<E>() {`
`50`	`50`	`@Override`
`@@ -85,11 +85,11 @@ public Chain<T> first() {`
`85`	`85`	`return new Chain<T>(Chaining.first(list));`
`86`	`86`	`}`
`87`	`87`
`88`		`- public <F> Chain<F> map(final Function1<? super T, F> func) {`
	`88`	`+ public <F> Chain<F> map(final Function<? super T, F> func) {`
`89`	`89`	`return new Chain<F>(Chaining.map(list, func));`
`90`	`90`	`}`
`91`	`91`
`92`		`- public <F extends Comparable<? super F>> Chain<T> sortBy(final Function1<T, F> func) {`
	`92`	`+ public <F extends Comparable<? super F>> Chain<T> sortBy(final Function<T, F> func) {`
`93`	`93`	`return new Chain<T>(Chaining.sortBy(list, func));`
`94`	`94`	`}`
`95`	`95`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@`
`33`	`33`	`public class Intersection {`
`34`	`34`	`public static <E> Optional<E> find(final Iterable<E> iterable, final Predicate<E> pred) {`
`35`	`35`	`for (E element : iterable) {`
`36`		`- if (pred.apply(element)) {`
	`36`	`+ if (pred.test(element)) {`
`37`	`37`	`return Optional.of(element);`
`38`	`38`	`}`
`39`	`39`	`}`
`@@ -47,7 +47,7 @@ public static <E> boolean some(final Iterable<E> iterable, final Predicate<E> pr`
`47`	`47`	`public static <E> boolean contains(final Iterable<E> iterable, final E elem) {`
`48`	`48`	`return some(iterable, new Predicate<E>() {`
`49`	`49`	`@Override`
`50`		`- public Boolean apply(E e) {`
	`50`	`+ public boolean test(E e) {`
`51`	`51`	`return elem == null ? e == null : elem.equals(e);`
`52`	`52`	`}`
`53`	`53`	`});`
`@@ -56,7 +56,7 @@ public Boolean apply(E e) {`
`56`	`56`	`public static <E> List<E> filter(final List<E> list, final Predicate<E> pred) {`
`57`	`57`	`final List<E> filtered = new ArrayList<E>();`
`58`	`58`	`for (E element : list) {`
`59`		`- if (pred.apply(element)) {`
	`59`	`+ if (pred.test(element)) {`
`60`	`60`	`filtered.add(element);`
`61`	`61`	`}`
`62`	`62`	`}`
`@@ -66,7 +66,7 @@ public static <E> List<E> filter(final List<E> list, final Predicate<E> pred) {`
`66`	`66`	`public static <E> List<E> intersection(final List<E> list1, final List<E> list2) {`
`67`	`67`	`return filter(list1, new Predicate<E>() {`
`68`	`68`	`@Override`
`69`		`- public Boolean apply(E elem) {`
	`69`	`+ public boolean test(E elem) {`
`70`	`70`	`return contains(list2, elem);`
`71`	`71`	`}`
`72`	`72`	`});`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,8 @@`
`1`	`1`	`package com.github.underscore.examples;`
`2`	`2`
`3`		`-public interface Predicate<T> extends Function1<T, Boolean> {`
	`3`	`+public interface Predicate<T> {`
	`4`	`+ boolean test(T arg);`
	`5`	`+`
	`6`	`+ @Override`
	`7`	`+ boolean equals(Object object);`
`4`	`8`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ public static <E> List<E> uniq(final List<E> list) {`
`37`	`37`
`38`	`38`	`public static <E> Optional<E> find(final Iterable<E> iterable, final Predicate<E> pred) {`
`39`	`39`	`for (E element : iterable) {`
`40`		`- if (pred.apply(element)) {`
	`40`	`+ if (pred.test(element)) {`
`41`	`41`	`return Optional.of(element);`
`42`	`42`	`}`
`43`	`43`	`}`
`@@ -51,7 +51,7 @@ public static <E> boolean some(final Iterable<E> iterable, final Predicate<E> pr`
`51`	`51`	`public static <E> boolean contains(final Iterable<E> iterable, final E elem) {`
`52`	`52`	`return some(iterable, new Predicate<E>() {`
`53`	`53`	`@Override`
`54`		`- public Boolean apply(E e) {`
	`54`	`+ public boolean test(E e) {`
`55`	`55`	`return elem == null ? e == null : elem.equals(e);`
`56`	`56`	`}`
`57`	`57`	`});`
`@@ -60,7 +60,7 @@ public Boolean apply(E e) {`
`60`	`60`	`public static <E> List<E> filter(final List<E> list, final Predicate<E> pred) {`
`61`	`61`	`final List<E> filtered = new ArrayList<E>();`
`62`	`62`	`for (E element : list) {`
`63`		`- if (pred.apply(element)) {`
	`63`	`+ if (pred.test(element)) {`
`64`	`64`	`filtered.add(element);`
`65`	`65`	`}`
`66`	`66`	`}`
`@@ -70,7 +70,7 @@ public static <E> List<E> filter(final List<E> list, final Predicate<E> pred) {`
`70`	`70`	`public static <E> List<E> difference(final List<E> list1, final List<E> list2) {`
`71`	`71`	`return filter(list1, new Predicate<E>() {`
`72`	`72`	`@Override`
`73`		`- public Boolean apply(E elem) {`
	`73`	`+ public boolean test(E elem) {`
`74`	`74`	`return !contains(list2, elem);`
`75`	`75`	`}`
`76`	`76`	`});`