Skip to content

Commit a384192

Browse files
mperrymperry
committed
#56: Make P1 an abstract class to maintain consistency. Instantiate using P.lazy
1 parent 985a1cf commit a384192

File tree

38 files changed

+537
-369
lines changed

38 files changed

+537
-369
lines changed

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -188,7 +188,7 @@ public B _1() {
188188
static public <A, B> F<P1<A>, P1<B>> mapP1(final F<A, B> f) {
189189
return new F<P1<A>, P1<B>>() {
190190
public P1<B> f(final P1<A> p) {
191-
return P1Functions.map(p, f);
191+
return p.map(f);
192192
}
193193
};
194194
}

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -282,7 +282,7 @@ public static <A> Hash<Tree<A>> treeHash(final Hash<A> ha) {
282282
* @return A hash instance for a product-1.
283283
*/
284284
public static <A> Hash<P1<A>> p1Hash(final Hash<A> ha) {
285-
return ha.comap(P1Functions.<A>__1());
285+
return ha.comap(P1.<A>__1());
286286
}
287287

288288
/**

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -577,7 +577,7 @@ public Ordering f(final Unit u1, final Unit u2) {
577577
* @return An order instance for a product-1.
578578
*/
579579
public static <A> Ord<P1<A>> p1Ord(final Ord<A> oa) {
580-
return oa.comap(P1Functions.<A>__1());
580+
return oa.comap(P1.<A>__1());
581581
}
582582

583583

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

Lines changed: 188 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,7 @@
11
package fj;
22

3+
import static fj.Unit.unit;
4+
35
/**
46
* Functions across products.
57
*
@@ -672,4 +674,190 @@ public H _8() {
672674
}
673675
};
674676
}
677+
678+
public static <A> P1<A> lazy(F<Unit, A> f) {
679+
return new P1<A>() {
680+
@Override
681+
public A _1() {
682+
return f.f(unit());
683+
}
684+
};
685+
}
686+
687+
public static <A, B> P2<A, B> lazy(F<Unit, A> fa, F<Unit, B> fb) {
688+
return new P2<A, B>() {
689+
@Override
690+
public A _1() {
691+
return fa.f(unit());
692+
}
693+
@Override
694+
public B _2() {
695+
return fb.f(unit());
696+
}
697+
};
698+
}
699+
700+
public static <A, B, C> P3<A, B, C> lazy(F<Unit, A> fa, F<Unit, B> fb, F<Unit, C> fc) {
701+
return new P3<A, B, C>() {
702+
@Override
703+
public A _1() {
704+
return fa.f(unit());
705+
}
706+
@Override
707+
public B _2() {
708+
return fb.f(unit());
709+
}
710+
@Override
711+
public C _3() {
712+
return fc.f(unit());
713+
}
714+
};
715+
}
716+
717+
718+
public static <A, B, C, D> P4<A, B, C, D> lazy(F<Unit, A> fa, F<Unit, B> fb, F<Unit, C> fc, F<Unit, D> fd) {
719+
return new P4<A, B, C, D>() {
720+
@Override
721+
public A _1() {
722+
return fa.f(unit());
723+
}
724+
@Override
725+
public B _2() {
726+
return fb.f(unit());
727+
}
728+
@Override
729+
public C _3() {
730+
return fc.f(unit());
731+
}
732+
@Override
733+
public D _4() {
734+
return fd.f(unit());
735+
}
736+
};
737+
}
738+
739+
public static <A, B, C, D, E> P5<A, B, C, D, E> lazy(F<Unit, A> fa, F<Unit, B> fb, F<Unit, C> fc, F<Unit, D> fd, F<Unit, E> fe) {
740+
return new P5<A, B, C, D, E>() {
741+
@Override
742+
public A _1() {
743+
return fa.f(unit());
744+
}
745+
@Override
746+
public B _2() {
747+
return fb.f(unit());
748+
}
749+
@Override
750+
public C _3() {
751+
return fc.f(unit());
752+
}
753+
@Override
754+
public D _4() {
755+
return fd.f(unit());
756+
}
757+
@Override
758+
public E _5() {
759+
return fe.f(unit());
760+
}
761+
};
762+
}
763+
764+
public static <A, B, C, D, E, F$> P6<A, B, C, D, E, F$> lazy(F<Unit, A> fa, F<Unit, B> fb, F<Unit, C> fc, F<Unit, D> fd, F<Unit, E> fe, F<Unit, F$> ff) {
765+
return new P6<A, B, C, D, E, F$>() {
766+
@Override
767+
public A _1() {
768+
return fa.f(unit());
769+
}
770+
@Override
771+
public B _2() {
772+
return fb.f(unit());
773+
}
774+
@Override
775+
public C _3() {
776+
return fc.f(unit());
777+
}
778+
@Override
779+
public D _4() {
780+
return fd.f(unit());
781+
}
782+
@Override
783+
public E _5() {
784+
return fe.f(unit());
785+
}
786+
@Override
787+
public F$ _6() {
788+
return ff.f(unit());
789+
}
790+
};
791+
}
792+
793+
public static <A, B, C, D, E, F$, G> P7<A, B, C, D, E, F$, G> lazy(F<Unit, A> fa, F<Unit, B> fb, F<Unit, C> fc, F<Unit, D> fd, F<Unit, E> fe, F<Unit, F$> ff, F<Unit, G> fg) {
794+
return new P7<A, B, C, D, E, F$, G>() {
795+
@Override
796+
public A _1() {
797+
return fa.f(unit());
798+
}
799+
@Override
800+
public B _2() {
801+
return fb.f(unit());
802+
}
803+
@Override
804+
public C _3() {
805+
return fc.f(unit());
806+
}
807+
@Override
808+
public D _4() {
809+
return fd.f(unit());
810+
}
811+
@Override
812+
public E _5() {
813+
return fe.f(unit());
814+
}
815+
@Override
816+
public F$ _6() {
817+
return ff.f(unit());
818+
}
819+
@Override
820+
public G _7() {
821+
return fg.f(unit());
822+
}
823+
};
824+
}
825+
826+
public static <A, B, C, D, E, F$, G, H> P8<A, B, C, D, E, F$, G, H> lazy(F<Unit, A> fa, F<Unit, B> fb, F<Unit, C> fc, F<Unit, D> fd, F<Unit, E> fe, F<Unit, F$> ff, F<Unit, G> fg, F<Unit, H> fh) {
827+
return new P8<A, B, C, D, E, F$, G, H>() {
828+
@Override
829+
public A _1() {
830+
return fa.f(unit());
831+
}
832+
@Override
833+
public B _2() {
834+
return fb.f(unit());
835+
}
836+
@Override
837+
public C _3() {
838+
return fc.f(unit());
839+
}
840+
@Override
841+
public D _4() {
842+
return fd.f(unit());
843+
}
844+
@Override
845+
public E _5() {
846+
return fe.f(unit());
847+
}
848+
@Override
849+
public F$ _6() {
850+
return ff.f(unit());
851+
}
852+
@Override
853+
public G _7() {
854+
return fg.f(unit());
855+
}
856+
@Override
857+
public H _8() {
858+
return fh.f(unit());
859+
}
860+
};
861+
}
862+
675863
}

0 commit comments

Comments
 (0)