use more method references. make Stream conversions respect laziness. optimize collectors.

jbgi · jbgi · commit 1970c3e04db3 · 2016-10-23T11:34:17.000+02:00
diff --git a/java8/src/main/java/fj/data/Collectors.java b/java8/src/main/java/fj/data/Collectors.java
@@ -21,7 +21,7 @@ public static <A> Collector<A, List.Buffer<A>, Array<A>> toArray() {
         List.Buffer::new,
         List.Buffer::snoc,
         (acc1, acc2) -> acc1.append(acc2.toList()),
-        (buf) -> Array.iterableArray(buf.toList())
+        (buf) -> buf.toList().toArray()
     );
   }
 
@@ -30,7 +30,7 @@ public static <A> Collector<A, List.Buffer<A>, Stream<A>> toStream() {
         List.Buffer::new,
         List.Buffer::snoc,
         (acc1, acc2) -> acc1.append(acc2.toList()),
-        (buf) -> Stream.iterableStream(buf.toList())
+        (buf) -> buf.toList().toStream()
     );
   }
 }
diff --git a/java8/src/main/java/fj/data/Java8.java b/java8/src/main/java/fj/data/Java8.java
@@ -2,6 +2,7 @@
 
 import java.util.Iterator;
 import java.util.Optional;
+import java.util.Spliterators;
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -28,95 +29,95 @@ private Java8() {
     }
 
     public static <A> P1<A> Supplier_P1(final Supplier<A> s) {
-        return Java8.<A>Supplier_P1().f(s);
+        return P.lazy(s::get);
     }
 
     public static <A> F<Supplier<A>, P1<A>> Supplier_P1() {
-        return s -> P.lazy(s::get);
+        return Java8::Supplier_P1;
     }
 
     public static <A> Supplier<A> P1_Supplier(final P1<A> p) {
-        return Java8.<A>P1_Supplier().f(p);
+        return p::_1;
     }
 
     public static <A> F<P1<A>, Supplier<A>> P1_Supplier() {
-        return (p) -> p::_1;
+        return Java8::P1_Supplier;
     }
 
     public static <A, B> F<A, B> Function_F(final Function<A, B> f) {
-        return Java8.<A, B>Function_F().f(f);
+        return f::apply;
     }
 
     public static <A, B> F<Function<A, B>, F<A, B>> Function_F() {
-        return f -> f::apply;
+        return Java8::Function_F;
     }
 
     public static <A, B> Function<A, B> F_Function(final F<A, B> f) {
-        return Java8.<A, B>F_Function().f(f);
+        return f::f;
     }
 
     public static <A, B> F<F<A, B>, Function<A, B>> F_Function() {
-        return f -> f::f;
+        return Java8::F_Function;
     }
 
     public static <A, B, C> F2<A, B, C> BiFunction_F2(final BiFunction<A, B, C> f) {
-        return Java8.<A, B, C>BiFunction_F2().f(f);
+        return f::apply;
     }
 
     public static <A, B, C> F<BiFunction<A, B, C>, F2<A, B, C>> BiFunction_F2() {
-        return f -> f::apply;
+        return Java8::BiFunction_F2;
     }
 
     public static <A, B, C> BiFunction<A, B, C> F2_BiFunction(final F2<A, B, C> f) {
-        return Java8.<A, B, C>F2_BiFunction().f(f);
+        return f::f;
     }
 
     public static <A, B, C> F<F2<A, B, C>, BiFunction<A, B, C>> F2_BiFunction() {
-        return f -> f::f;
+        return Java8::F2_BiFunction;
     }
 
     public static <A, E extends Exception> Supplier<Validation<E, A>> TryCatch0_Supplier(final Try0<A, E> t) {
-        return Java8.<A, E>TryCatch0_Supplier().f(t);
+        return () -> Try.f(t)._1();
     }
 
     public static <A, E extends Exception> F<Try0<A, E>, Supplier<Validation<E, A>>> TryCatch0_Supplier() {
-        return t -> () -> Try.f(t)._1();
+        return Java8::TryCatch0_Supplier;
     }
 
     public static <A, B, E extends Exception> Function<A, Validation<E, B>> TryCatch1_Function(final Try1<A, B, E> t) {
-        return Java8.<A, B, E>TryCatch1_Function().f(t);
+        return a -> Try.f(t).f(a);
     }
 
     public static <A, B, E extends Exception> F<Try1<A, B, E>, Function<A, Validation<E, B>>> TryCatch1_Function() {
-        return t -> a -> Try.f(t).f(a);
+        return Java8::TryCatch1_Function;
     }
 
     public static <A, B, C, E extends Exception> BiFunction<A, B, Validation<E, C>> TryCatch2_BiFunction(final Try2<A, B, C, E> t) {
-        return Java8.<A, B, C, E>TryCatch2_BiFunction().f(t);
+        return (a, b) -> Try.f(t).f(a, b);
     }
 
     public static <A, B, C, E extends Exception> F<Try2<A, B, C, E>, BiFunction<A, B, Validation<E, C>>> TryCatch2_BiFunction() {
-        return t -> (a, b) -> Try.f(t).f(a, b);
+        return Java8::TryCatch2_BiFunction;
     }
 
     public static <A> java.util.stream.Stream<A> List_JavaStream(final List<A> list) {
         return Iterable_JavaStream(list);
     }
 
     public static <A> Option<A> Optional_Option(final Optional<A> o) {
-        return Java8.<A>Optional_Option().f(o);
+        return o.isPresent() ? Option.some(o.get()) : Option.none();
     }
 
     public static <A> F<Optional<A>, Option<A>> Optional_Option() {
-        return o -> o.isPresent() ? Option.some(o.get()) : Option.none();
+        return Java8::Optional_Option;
     }
 
     public static <A> Optional<A> Option_Optional(final Option<A> o) {
-        return Java8.<A>Option_Optional().f(o);
+        return o.option(Optional.empty(), Optional::ofNullable);
     }
 
     public static <A> F<Option<A>, Optional<A>> Option_Optional() {
-        return o -> o.isSome() ? Optional.ofNullable(o.some()) : Optional.empty();
+        return Java8::Option_Optional;
     }
 
     public static <A> F<Consumer<A>, F<A, Unit>> Consumer_F() {
@@ -139,15 +140,15 @@ public static <A> java.util.stream.Stream<A> Iterable_JavaStream(final Iterable<
     }
 
     public static <A> java.util.stream.Stream<A> Iterator_JavaStream(final Iterator<A> it) {
-        return Iterable_JavaStream(() -> it);
+        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(it, 0), false);
     }
 
     public static <A> F<fj.data.Stream<A>, java.util.stream.Stream<A>> Stream_JavaStream() {
         return Java8::Stream_JavaStream;
     }
 
     public static <A> Stream<A> JavaStream_Stream(final java.util.stream.Stream<A> s) {
-        return s.collect(Collectors.toStream());
+        return Stream.iteratorStream(s.iterator());
     }
 
     public static <A> List<A> JavaStream_List(final java.util.stream.Stream<A> s) {

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ public static <A> Collector<A, List.Buffer<A>, Array<A>> toArray() {`
`21`	`21`	`List.Buffer::new,`
`22`	`22`	`List.Buffer::snoc,`
`23`	`23`	`(acc1, acc2) -> acc1.append(acc2.toList()),`
`24`		`- (buf) -> Array.iterableArray(buf.toList())`
	`24`	`+ (buf) -> buf.toList().toArray()`
`25`	`25`	`);`
`26`	`26`	`}`
`27`	`27`
`@@ -30,7 +30,7 @@ public static <A> Collector<A, List.Buffer<A>, Stream<A>> toStream() {`
`30`	`30`	`List.Buffer::new,`
`31`	`31`	`List.Buffer::snoc,`
`32`	`32`	`(acc1, acc2) -> acc1.append(acc2.toList()),`
`33`		`- (buf) -> Stream.iterableStream(buf.toList())`
	`33`	`+ (buf) -> buf.toList().toStream()`
`34`	`34`	`);`
`35`	`35`	`}`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`
`3`	`3`	`import java.util.Iterator;`
`4`	`4`	`import java.util.Optional;`
	`5`	`+import java.util.Spliterators;`
`5`	`6`	`import java.util.function.BiFunction;`
`6`	`7`	`import java.util.function.Consumer;`
`7`	`8`	`import java.util.function.Function;`
`@@ -28,95 +29,95 @@ private Java8() {`
`28`	`29`	`}`
`29`	`30`
`30`	`31`	`public static <A> P1<A> Supplier_P1(final Supplier<A> s) {`
`31`		`- return Java8.<A>Supplier_P1().f(s);`
	`32`	`+ return P.lazy(s::get);`
`32`	`33`	`}`
`33`	`34`
`34`	`35`	`public static <A> F<Supplier<A>, P1<A>> Supplier_P1() {`
`35`		`- return s -> P.lazy(s::get);`
	`36`	`+ return Java8::Supplier_P1;`
`36`	`37`	`}`
`37`	`38`
`38`	`39`	`public static <A> Supplier<A> P1_Supplier(final P1<A> p) {`
`39`		`- return Java8.<A>P1_Supplier().f(p);`
	`40`	`+ return p::_1;`
`40`	`41`	`}`
`41`	`42`
`42`	`43`	`public static <A> F<P1<A>, Supplier<A>> P1_Supplier() {`
`43`		`- return (p) -> p::_1;`
	`44`	`+ return Java8::P1_Supplier;`
`44`	`45`	`}`
`45`	`46`
`46`	`47`	`public static <A, B> F<A, B> Function_F(final Function<A, B> f) {`
`47`		`- return Java8.<A, B>Function_F().f(f);`
	`48`	`+ return f::apply;`
`48`	`49`	`}`
`49`	`50`
`50`	`51`	`public static <A, B> F<Function<A, B>, F<A, B>> Function_F() {`
`51`		`- return f -> f::apply;`
	`52`	`+ return Java8::Function_F;`
`52`	`53`	`}`
`53`	`54`
`54`	`55`	`public static <A, B> Function<A, B> F_Function(final F<A, B> f) {`
`55`		`- return Java8.<A, B>F_Function().f(f);`
	`56`	`+ return f::f;`
`56`	`57`	`}`
`57`	`58`
`58`	`59`	`public static <A, B> F<F<A, B>, Function<A, B>> F_Function() {`
`59`		`- return f -> f::f;`
	`60`	`+ return Java8::F_Function;`
`60`	`61`	`}`
`61`	`62`
`62`	`63`	`public static <A, B, C> F2<A, B, C> BiFunction_F2(final BiFunction<A, B, C> f) {`
`63`		`- return Java8.<A, B, C>BiFunction_F2().f(f);`
	`64`	`+ return f::apply;`
`64`	`65`	`}`
`65`	`66`
`66`	`67`	`public static <A, B, C> F<BiFunction<A, B, C>, F2<A, B, C>> BiFunction_F2() {`
`67`		`- return f -> f::apply;`
	`68`	`+ return Java8::BiFunction_F2;`
`68`	`69`	`}`
`69`	`70`
`70`	`71`	`public static <A, B, C> BiFunction<A, B, C> F2_BiFunction(final F2<A, B, C> f) {`
`71`		`- return Java8.<A, B, C>F2_BiFunction().f(f);`
	`72`	`+ return f::f;`
`72`	`73`	`}`
`73`	`74`
`74`	`75`	`public static <A, B, C> F<F2<A, B, C>, BiFunction<A, B, C>> F2_BiFunction() {`
`75`		`- return f -> f::f;`
	`76`	`+ return Java8::F2_BiFunction;`
`76`	`77`	`}`
`77`	`78`
`78`	`79`	`public static <A, E extends Exception> Supplier<Validation<E, A>> TryCatch0_Supplier(final Try0<A, E> t) {`
`79`		`- return Java8.<A, E>TryCatch0_Supplier().f(t);`
	`80`	`+ return () -> Try.f(t)._1();`
`80`	`81`	`}`
`81`	`82`
`82`	`83`	`public static <A, E extends Exception> F<Try0<A, E>, Supplier<Validation<E, A>>> TryCatch0_Supplier() {`
`83`		`- return t -> () -> Try.f(t)._1();`
	`84`	`+ return Java8::TryCatch0_Supplier;`
`84`	`85`	`}`
`85`	`86`
`86`	`87`	`public static <A, B, E extends Exception> Function<A, Validation<E, B>> TryCatch1_Function(final Try1<A, B, E> t) {`
`87`		`- return Java8.<A, B, E>TryCatch1_Function().f(t);`
	`88`	`+ return a -> Try.f(t).f(a);`
`88`	`89`	`}`
`89`	`90`
`90`	`91`	`public static <A, B, E extends Exception> F<Try1<A, B, E>, Function<A, Validation<E, B>>> TryCatch1_Function() {`
`91`		`- return t -> a -> Try.f(t).f(a);`
	`92`	`+ return Java8::TryCatch1_Function;`
`92`	`93`	`}`
`93`	`94`
`94`	`95`	`public static <A, B, C, E extends Exception> BiFunction<A, B, Validation<E, C>> TryCatch2_BiFunction(final Try2<A, B, C, E> t) {`
`95`		`- return Java8.<A, B, C, E>TryCatch2_BiFunction().f(t);`
	`96`	`+ return (a, b) -> Try.f(t).f(a, b);`
`96`	`97`	`}`
`97`	`98`
`98`	`99`	`public static <A, B, C, E extends Exception> F<Try2<A, B, C, E>, BiFunction<A, B, Validation<E, C>>> TryCatch2_BiFunction() {`
`99`		`- return t -> (a, b) -> Try.f(t).f(a, b);`
	`100`	`+ return Java8::TryCatch2_BiFunction;`
`100`	`101`	`}`
`101`	`102`
`102`	`103`	`public static <A> java.util.stream.Stream<A> List_JavaStream(final List<A> list) {`
`103`	`104`	`return Iterable_JavaStream(list);`
`104`	`105`	`}`
`105`	`106`
`106`	`107`	`public static <A> Option<A> Optional_Option(final Optional<A> o) {`
`107`		`- return Java8.<A>Optional_Option().f(o);`
	`108`	`+ return o.isPresent() ? Option.some(o.get()) : Option.none();`
`108`	`109`	`}`
`109`	`110`
`110`	`111`	`public static <A> F<Optional<A>, Option<A>> Optional_Option() {`
`111`		`- return o -> o.isPresent() ? Option.some(o.get()) : Option.none();`
	`112`	`+ return Java8::Optional_Option;`
`112`	`113`	`}`
`113`	`114`
`114`	`115`	`public static <A> Optional<A> Option_Optional(final Option<A> o) {`
`115`		`- return Java8.<A>Option_Optional().f(o);`
	`116`	`+ return o.option(Optional.empty(), Optional::ofNullable);`
`116`	`117`	`}`
`117`	`118`
`118`	`119`	`public static <A> F<Option<A>, Optional<A>> Option_Optional() {`
`119`		`- return o -> o.isSome() ? Optional.ofNullable(o.some()) : Optional.empty();`
	`120`	`+ return Java8::Option_Optional;`
`120`	`121`	`}`
`121`	`122`
`122`	`123`	`public static <A> F<Consumer<A>, F<A, Unit>> Consumer_F() {`
`@@ -139,15 +140,15 @@ public static <A> java.util.stream.Stream<A> Iterable_JavaStream(final Iterable<`
`139`	`140`	`}`
`140`	`141`
`141`	`142`	`public static <A> java.util.stream.Stream<A> Iterator_JavaStream(final Iterator<A> it) {`
`142`		`- return Iterable_JavaStream(() -> it);`
	`143`	`+ return StreamSupport.stream(Spliterators.spliteratorUnknownSize(it, 0), false);`
`143`	`144`	`}`
`144`	`145`
`145`	`146`	`public static <A> F<fj.data.Stream<A>, java.util.stream.Stream<A>> Stream_JavaStream() {`
`146`	`147`	`return Java8::Stream_JavaStream;`
`147`	`148`	`}`
`148`	`149`
`149`	`150`	`public static <A> Stream<A> JavaStream_Stream(final java.util.stream.Stream<A> s) {`
`150`		`- return s.collect(Collectors.toStream());`
	`151`	`+ return Stream.iteratorStream(s.iterator());`
`151`	`152`	`}`
`152`	`153`
`153`	`154`	`public static <A> List<A> JavaStream_List(final java.util.stream.Stream<A> s) {`