Skip to content

Commit 94a79d0

Browse files
mperrymperry
committed
Reviewed creating instances from iterable, iterator and varargs array for classes in core
1 parent 292ac83 commit 94a79d0

26 files changed

Lines changed: 328 additions & 183 deletions

File tree

‎core/src/main/java/fj/F1Functions.java‎

Lines changed: 11 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,6 @@
1212
import java.util.concurrent.*;
1313

1414
import static fj.data.Option.some;
15-
import static fj.data.Stream.fromIterable;
1615
import static fj.data.Stream.iterableStream;
1716
import static fj.data.Zipper.fromStream;
1817

@@ -559,7 +558,7 @@ static public <A, B> F<P2<A, A>, P2<B, B>> mapBoth(final F<A, B> f) {
559558
*/
560559
static public <A, B> SynchronousQueue<B> mapJ(final F<A, B> f, final SynchronousQueue<A> as) {
561560
final SynchronousQueue<B> bs = new SynchronousQueue<B>();
562-
bs.addAll(fromIterable(as).map(f).toCollection());
561+
bs.addAll(iterableStream(as).map(f).toCollection());
563562
return bs;
564563
}
565564

@@ -571,7 +570,7 @@ static public <A, B> SynchronousQueue<B> mapJ(final F<A, B> f, final Synchronous
571570
* @return A new PriorityBlockingQueue with this function applied to each element.
572571
*/
573572
static public <A, B> PriorityBlockingQueue<B> mapJ(final F<A, B> f, final PriorityBlockingQueue<A> as) {
574-
return new PriorityBlockingQueue<B>(fromIterable(as).map(f).toCollection());
573+
return new PriorityBlockingQueue<B>(iterableStream(as).map(f).toCollection());
575574
}
576575

577576
/**
@@ -581,7 +580,7 @@ static public <A, B> PriorityBlockingQueue<B> mapJ(final F<A, B> f, final Priori
581580
* @return A new LinkedBlockingQueue with this function applied to each element.
582581
*/
583582
static public <A, B> LinkedBlockingQueue<B> mapJ(final F<A, B> f, final LinkedBlockingQueue<A> as) {
584-
return new LinkedBlockingQueue<B>(fromIterable(as).map(f).toCollection());
583+
return new LinkedBlockingQueue<B>(iterableStream(as).map(f).toCollection());
585584
}
586585

587586
/**
@@ -591,7 +590,7 @@ static public <A, B> LinkedBlockingQueue<B> mapJ(final F<A, B> f, final LinkedBl
591590
* @return A new CopyOnWriteArraySet with this function applied to each element.
592591
*/
593592
static public <A, B> CopyOnWriteArraySet<B> mapJ(final F<A, B> f, final CopyOnWriteArraySet<A> as) {
594-
return new CopyOnWriteArraySet<B>(fromIterable(as).map(f).toCollection());
593+
return new CopyOnWriteArraySet<B>(iterableStream(as).map(f).toCollection());
595594
}
596595

597596
/**
@@ -601,7 +600,7 @@ static public <A, B> CopyOnWriteArraySet<B> mapJ(final F<A, B> f, final CopyOnWr
601600
* @return A new CopyOnWriteArrayList with this function applied to each element.
602601
*/
603602
static public <A, B> CopyOnWriteArrayList<B> mapJ(final F<A, B> f, final CopyOnWriteArrayList<A> as) {
604-
return new CopyOnWriteArrayList<B>(fromIterable(as).map(f).toCollection());
603+
return new CopyOnWriteArrayList<B>(iterableStream(as).map(f).toCollection());
605604
}
606605

607606
/**
@@ -611,7 +610,7 @@ static public <A, B> CopyOnWriteArrayList<B> mapJ(final F<A, B> f, final CopyOnW
611610
* @return A new ConcurrentLinkedQueue with this function applied to each element.
612611
*/
613612
static public <A, B> ConcurrentLinkedQueue<B> mapJ(final F<A, B> f, final ConcurrentLinkedQueue<A> as) {
614-
return new ConcurrentLinkedQueue<B>(fromIterable(as).map(f).toCollection());
613+
return new ConcurrentLinkedQueue<B>(iterableStream(as).map(f).toCollection());
615614
}
616615

617616
/**
@@ -622,7 +621,7 @@ static public <A, B> ConcurrentLinkedQueue<B> mapJ(final F<A, B> f, final Concur
622621
*/
623622
static public <A, B> ArrayBlockingQueue<B> mapJ(final F<A, B> f, final ArrayBlockingQueue<A> as) {
624623
final ArrayBlockingQueue<B> bs = new ArrayBlockingQueue<B>(as.size());
625-
bs.addAll(fromIterable(as).map(f).toCollection());
624+
bs.addAll(iterableStream(as).map(f).toCollection());
626625
return bs;
627626
}
628627

@@ -634,7 +633,7 @@ static public <A, B> ArrayBlockingQueue<B> mapJ(final F<A, B> f, final ArrayBloc
634633
* @return A new TreeSet with this function applied to each element.
635634
*/
636635
static public <A, B> TreeSet<B> mapJ(final F<A, B> f, final TreeSet<A> as) {
637-
return new TreeSet<B>(fromIterable(as).map(f).toCollection());
636+
return new TreeSet<B>(iterableStream(as).map(f).toCollection());
638637
}
639638

640639
/**
@@ -644,7 +643,7 @@ static public <A, B> TreeSet<B> mapJ(final F<A, B> f, final TreeSet<A> as) {
644643
* @return A new PriorityQueue with this function applied to each element.
645644
*/
646645
static public <A, B> PriorityQueue<B> mapJ(final F<A, B> f, final PriorityQueue<A> as) {
647-
return new PriorityQueue<B>(fromIterable(as).map(f).toCollection());
646+
return new PriorityQueue<B>(iterableStream(as).map(f).toCollection());
648647
}
649648

650649
/**
@@ -654,7 +653,7 @@ static public <A, B> PriorityQueue<B> mapJ(final F<A, B> f, final PriorityQueue<
654653
* @return A new LinkedList with this function applied to each element.
655654
*/
656655
static public <A, B> LinkedList<B> mapJ(final F<A, B> f, final LinkedList<A> as) {
657-
return new LinkedList<B>(fromIterable(as).map(f).toCollection());
656+
return new LinkedList<B>(iterableStream(as).map(f).toCollection());
658657
}
659658

660659
/**
@@ -664,7 +663,7 @@ static public <A, B> LinkedList<B> mapJ(final F<A, B> f, final LinkedList<A> as)
664663
* @return A new ArrayList with this function applied to each element.
665664
*/
666665
static public <A, B> ArrayList<B> mapJ(final F<A, B> f, final ArrayList<A> as) {
667-
return new ArrayList<B>(fromIterable(as).map(f).toCollection());
666+
return new ArrayList<B>(iterableStream(as).map(f).toCollection());
668667
}
669668

670669
static public <A, B, C> F<A, C> map(F<A, B> target, F<B, C> f) {

‎core/src/main/java/fj/F2Functions.java‎

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -2,11 +2,9 @@
22

33
import fj.control.parallel.Promise;
44
import fj.data.*;
5-
import fj.function.Try2;
65

76
import static fj.P.p;
87
import static fj.data.IterableW.wrap;
9-
import static fj.data.Set.fromIterable;
108
import static fj.data.Set.iterableSet;
119
import static fj.data.Tree.node;
1210
import static fj.data.TreeZipper.treeZipper;
@@ -201,7 +199,7 @@ static public <A, B, C> F2<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> zi
201199
* @return A function that zips two sets with this function.
202200
*/
203201
static public <A, B, C> F2<Set<A>, Set<B>, Set<C>> zipSetM(final F2<A, B, C> f, final Ord<C> o) {
204-
return (as, bs) -> fromIterable(o, as.toStream().zipWith(bs.toStream(), f));
202+
return (as, bs) -> iterableSet(o, as.toStream().zipWith(bs.toStream(), f));
205203
}
206204

207205
/**

‎core/src/main/java/fj/Monoid.java‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,6 @@
1010
import fj.data.Stream;
1111

1212
import static fj.Semigroup.multiply1p;
13-
import static fj.data.Stream.fromIterable;
1413
import static fj.data.Stream.iterableStream;
1514

1615
import java.math.BigInteger;
@@ -184,7 +183,7 @@ public F<Stream<A>, A> sumLeftS() {
184183
* @return The sum of the given values and the interspersed value.
185184
*/
186185
public A join(final Iterable<A> as, final A a) {
187-
final Stream<A> s = fromIterable(as);
186+
final Stream<A> s = iterableStream(as);
188187
return s.isEmpty() ?
189188
zero :
190189
s.foldLeft1(Function.compose(sum, flip(sum).f(a)));

‎core/src/main/java/fj/Show.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -324,7 +324,7 @@ public static <A> Show<Set<A>> setShow(final Show<A> sa) {
324324
*/
325325
public static <K, V> Show<TreeMap<K, V>> treeMapShow(final Show<K> sk, final Show<V> sv) {
326326
return show(tm -> {
327-
Stream<P2<K, V>> stream = Stream.fromIterator(tm.iterator());
327+
Stream<P2<K, V>> stream = Stream.iteratorStream(tm.iterator());
328328
return streamShow(Show.p2MapShow(sk, sv), "TreeMap(", ",", ")").show(stream);
329329
});
330330
}

‎core/src/main/java/fj/control/parallel/ParModule.java‎

Lines changed: 5 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,6 @@
1818
import fj.function.Effect1;
1919

2020
import static fj.data.Option.some;
21-
import static fj.data.Stream.fromIterable;
2221
import static fj.data.Stream.iterableStream;
2322

2423
/**
@@ -293,7 +292,7 @@ public <A, B> F<F<A, B>, F<Stream<A>, Promise<Stream<B>>>> parMapStream() {
293292
* @return A Promise of a new Iterable with the given function applied to each element.
294293
*/
295294
public <A, B> Promise<Iterable<B>> parMap(final Iterable<A> as, final F<A, B> f) {
296-
return parMap(fromIterable(as), f)
295+
return parMap(iterableStream(as), f)
297296
.fmap(Function.<Stream<B>, Iterable<B>>vary(Function.<Stream<B>>identity()));
298297
}
299298

@@ -465,7 +464,7 @@ public <A, B, C> Promise<Array<C>> parZipWith(final Array<A> as, final Array<B>
465464
* @return A Promise of a new iterable with the results of applying the given function across the two iterables, stepwise.
466465
*/
467466
public <A, B, C> Promise<Iterable<C>> parZipWith(final Iterable<A> as, final Iterable<B> bs, final F<A, F<B, C>> f) {
468-
return parZipWith(fromIterable(as), fromIterable(bs), f).fmap(
467+
return parZipWith(iterableStream(as), iterableStream(bs), f).fmap(
469468
Function.<Stream<C>, Iterable<C>>vary(Function.<Iterable<C>>identity()));
470469
}
471470

@@ -515,8 +514,8 @@ public <A, B> Promise<B> parFoldMap(final Stream<A> as, final F<A, B> map, final
515514
*/
516515
public <A, B> Promise<B> parFoldMap(final Iterable<A> as, final F<A, B> map, final Monoid<B> reduce,
517516
final F<Iterable<A>, P2<Iterable<A>, Iterable<A>>> chunking) {
518-
return parFoldMap(fromIterable(as), map, reduce, (Stream<A> stream) -> {
519-
final F<Iterable<A>, Stream<A>> is = iterable -> fromIterable(iterable);
517+
return parFoldMap(iterableStream(as), map, reduce, (Stream<A> stream) -> {
518+
final F<Iterable<A>, Stream<A>> is = iterable -> iterableStream(iterable);
520519
return chunking.f(stream).map1(is).map2(is);
521520
});
522521
}
@@ -531,7 +530,7 @@ public <A, B> Promise<B> parFoldMap(final Iterable<A> as, final F<A, B> map, fin
531530
* @return A promise of a result of mapping and folding in parallel.
532531
*/
533532
public <A, B> Promise<B> parFoldMap(final Iterable<A> as, final F<A, B> map, final Monoid<B> reduce) {
534-
return parFoldMap(fromIterable(as), map, reduce);
533+
return parFoldMap(iterableStream(as), map, reduce);
535534
}
536535

537536

‎core/src/main/java/fj/data/Array.java‎

Lines changed: 20 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@
2222
import static fj.P.p;
2323
import static fj.P.p2;
2424
import static fj.Unit.unit;
25-
import static fj.data.List.fromIterable;
25+
import static fj.data.List.iterableList;
2626
import static fj.data.Option.none;
2727
import static fj.data.Option.some;
2828
import static java.lang.Math.min;
@@ -559,12 +559,12 @@ public static <A> Array<A> empty() {
559559
/**
560560
* Constructs an array from the given elements.
561561
*
562-
* @param a The elements to construct the array with.
562+
* @param as The elements to construct the array with.
563563
* @return A new array of the given elements.
564564
*/
565565
@SafeVarargs
566-
public static <A> Array<A> array(final A... a) {
567-
return new Array<A>(a);
566+
public static <A> Array<A> array(final A...as) {
567+
return arrayArray(as);
568568
}
569569

570570
/**
@@ -802,7 +802,22 @@ public int size() {
802802
* @return An array from the given iterable.
803803
*/
804804
public static <A> Array<A> iterableArray(final Iterable<A> i) {
805-
return fromIterable(i).toArray();
805+
return iterableList(i).toArray();
806+
}
807+
808+
public static <A> Array<A> iteratorArray(final Iterator<A> i) {
809+
return iterableArray(() -> i);
810+
}
811+
812+
/**
813+
* Returns a copy of the underlying primitive array.
814+
* Equivalent to array(A...)
815+
*
816+
* @return A copy of the underlying primitive array.
817+
*/
818+
@SafeVarargs
819+
public static <A> Array<A> arrayArray(final A...as) {
820+
return new Array<A>(as);
806821
}
807822

808823
/**

‎core/src/main/java/fj/data/DList.java‎

Lines changed: 44 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,10 @@
44
import fj.P;
55
import fj.control.Trampoline;
66

7+
import java.util.Iterator;
8+
9+
import static fj.data.List.iterableList;
10+
711
/**
812
* Difference List. It converts left associative appends into right associative ones to improve performance.
913
*
@@ -12,20 +16,51 @@
1216
public class DList<A> {
1317
private final F<List<A>,Trampoline<List<A>>> appendFn;
1418

15-
private DList(F<List<A>,Trampoline<List<A>>> appendFn) {
19+
private DList(final F<List<A>,Trampoline<List<A>>> appendFn) {
1620
this.appendFn = appendFn;
1721
}
18-
22+
1923
/**
20-
* Wraps a list with a DList.
21-
* @param <A>
22-
* @param a the regular List
23-
* @return the DList
24+
* Creates a DList from the function
25+
*
26+
* For alternatives functions to create a DList see:
27+
* @see #iterableDList
28+
* @see #iteratorDList
29+
* @see #arrayDList
2430
*/
25-
public static <A> DList<A> fromList(List<A> a) {
26-
return new DList<>((List<A> tail) -> Trampoline.pure(a.append(tail)));
31+
public static <A> DList<A> dlist(final F<List<A>,Trampoline<List<A>>> f) {
32+
return new DList<>(f);
2733
}
28-
34+
35+
/**
36+
* Creates a DList from a List
37+
*/
38+
public static <A> DList<A> listDList(final List<A> a) {
39+
return dlist((List<A> tail) -> Trampoline.pure(a.append(tail)));
40+
}
41+
42+
/**
43+
* Creates a DList from an Iterable
44+
*/
45+
public static <A> DList<A> iterableDList(final Iterable<A> it) {
46+
return listDList(iterableList(it));
47+
}
48+
49+
/**
50+
* Creates a DList from an Iterator
51+
*/
52+
public static <A> DList<A> iteratorDList(final Iterator<A> it) {
53+
return iterableDList(() -> it);
54+
}
55+
56+
/**
57+
* Creates a DList from an array
58+
*/
59+
@SafeVarargs
60+
public static <A> DList<A> arrayDList(final A...as) {
61+
return listDList(List.list(as));
62+
}
63+
2964
/**
3065
* Concatenates all the internal Lists together that are held in
3166
* the DList's lambda's state to produce a List.

0 commit comments

Comments
 (0)