Want more features on Pastebin? Sign Up, it's FREE!
Guest

FM.java

By: PthariensFlame on Feb 4th, 2012  |  syntax: Java  |  size: 6.26 KB  |  views: 72  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. package fmlist;
  2.  
  3. import fj.F;
  4. import fj.F2;
  5. import fj.F3;
  6. import fj.Function;
  7. import fj.Monoid;
  8. import fj.data.Either;
  9.  
  10. abstract class FM<E> {
  11.  
  12.     abstract boolean couldBeFinite();
  13.  
  14.     abstract <X> X fm(Monoid<X> monoid, F<E, X> mapFunc);
  15.  
  16.     <X> F2<Monoid<X>, F<E, X>, X> fm() {
  17.         final FM<E> self = this;
  18.         return new F2<Monoid<X>, F<E, X>, X>() {
  19.  
  20.             @Override
  21.             public X f(Monoid<X> a, F<E, X> b) {
  22.                 return self.fm(a, b);
  23.             }
  24.         };
  25.     }
  26.  
  27.     <X> F<F<E, X>, X> fm(Monoid<X> monoid) {
  28.         final Monoid<X> qm = monoid;
  29.         final FM<E> self = this;
  30.         return new F<F<E, X>, X>() {
  31.  
  32.             @Override
  33.             public X f(F<E, X> a) {
  34.                 return self.fm(qm, a);
  35.             }
  36.         };
  37.     }
  38.  
  39.     static <X, E> F3<Monoid<X>, F<E, X>, FM<E>, X> fm_() {
  40.         return new F3<Monoid<X>, F<E, X>, FM<E>, X>() {
  41.  
  42.             @Override
  43.             public X f(Monoid<X> a, F<E, X> b, FM<E> c) {
  44.                 return c.fm(a, b);
  45.             }
  46.         };
  47.     }
  48.  
  49.     static <E> FM<E> newFM() {
  50.         return new FM<E>() {
  51.  
  52.             @Override
  53.             <X> X fm(Monoid<X> monoid, F<E, X> mapFunc) {
  54.                 return monoid.zero();
  55.             }
  56.  
  57.             @Override
  58.             boolean couldBeFinite() {
  59.                 return true;
  60.             }
  61.         };
  62.     }
  63.  
  64.     static <E> FM<E> newFM(E e) {
  65.         final E k = e;
  66.         return new FM<E>() {
  67.  
  68.             @Override
  69.             <X> X fm(Monoid<X> monoid, F<E, X> mapFunc) {
  70.                 return mapFunc.f(k);
  71.             }
  72.  
  73.             @Override
  74.             boolean couldBeFinite() {
  75.                 return true;
  76.             }
  77.         };
  78.     }
  79.  
  80.     static <E> FM<E> newFM(Iterable<? extends E> c) {
  81.         final Iterable<? extends E> i = c;
  82.         return new FM<E>() {
  83.  
  84.             @Override
  85.             <X> X fm(Monoid<X> monoid, F<E, X> mapFunc) {
  86.                 X z = monoid.zero();
  87.                 for (E x : i) {
  88.                     X q = mapFunc.f(x);
  89.                     z = monoid.sum(q, z);
  90.                 }
  91.                 return z;
  92.             }
  93.  
  94.             @Override
  95.             boolean couldBeFinite() {
  96.                 return true;
  97.             }
  98.         };
  99.  
  100.     }
  101.  
  102.     FM<E> appendFM(FM<E> other) {
  103.         return FM.appendFM(this, other);
  104.     }
  105.  
  106.     static <E> FM<E> appendFM(FM<E> fm1, FM<E> fm2) {
  107.         final FM<E> fmA = fm1;
  108.         final FM<E> fmB = fm2;
  109.         return new FM<E>() {
  110.  
  111.             @Override
  112.             <X> X fm(Monoid<X> monoid, F<E, X> mapFunc) {
  113.                 return monoid.sum(fmA.fm(monoid, mapFunc), fmB.fm(monoid, mapFunc));
  114.             }
  115.  
  116.             @Override
  117.             boolean couldBeFinite() {
  118.                 return fmA.couldBeFinite() && fmB.couldBeFinite();
  119.             }
  120.         };
  121.     }
  122.  
  123.     static <E> F2<FM<E>, FM<E>, FM<E>> appendFM() {
  124.         return new F2<FM<E>, FM<E>, FM<E>>() {
  125.  
  126.             @Override
  127.             public FM<E> f(FM<E> a, FM<E> b) {
  128.                 return FM.appendFM(a, b);
  129.             }
  130.         };
  131.     }
  132.  
  133.     <N> FM<N> transform(TransformFunc<N, E> tf) {
  134.         final FM<E> self = this;
  135.         final TransformFunc<N, E> func = tf;
  136.         return new FM<N>() {
  137.  
  138.             @Override
  139.             <X> X fm(Monoid<X> monoid, F<N, X> mapFunc) {
  140.                 return self.fm(monoid, func.f(monoid, mapFunc));
  141.             }
  142.  
  143.             @Override
  144.             boolean couldBeFinite() {
  145.                 return true;
  146.             }
  147.         };
  148.     }
  149.  
  150.     <N, S> FM<N> transformCS(TransformCSFunc<E, N, S> tcf, S s) {
  151.         final FMList<E> l = new FMList<E>(this);
  152.         final TransformCSFunc<E, N, S> t = tcf;
  153.         final S s0 = s;
  154.         return new FM<N>() {
  155.  
  156.             @Override
  157.             <X> X fm(Monoid<X> monoid, F<N, X> mapFunc) {
  158.                 final Monoid<X> m1 = monoid;
  159.                 final Monoid<F<S, X>> m2 = Monoid.functionMonoid(monoid);
  160.                 final F<N, X> mf = mapFunc;
  161.                 final F3<F<S, X>, X, S, X> a3 = new F3<F<S, X>, X, S, X>() {
  162.  
  163.                     @Override
  164.                     public X f(F<S, X> a, X b, S c) {
  165.                         return m1.sum(b, a.f(c));
  166.                     }
  167.                 };
  168.                 final F2<E, F<S, X>, F<S, X>> a2 = new F2<E, F<S, X>, F<S, X>>() {
  169.  
  170.                     @Override
  171.                     public F<S, X> f(E a, F<S, X> b) {
  172.                         return t.f(m1, mf, a, Function.uncurryF2(Function.curry(a3).f(b)));
  173.                     }
  174.                 };
  175.                 return l.foldr(a2, m2.zero()).f(s0);
  176.             }
  177.  
  178.             @Override
  179.             boolean couldBeFinite() {
  180.                 return true;
  181.             }
  182.         };
  183.     }
  184.  
  185.     static <E, N> FM<E> unfold(F<N, FM<Either<N, E>>> unfoldFunc, N seedValue) {
  186.         final F<N, FM<Either<N, E>>> g = unfoldFunc;
  187.         return g.andThen(new F<FM<Either<N, E>>, FM<E>>() {
  188.  
  189.             @Override
  190.             public FM<E> f(FM<Either<N, E>> a) {
  191.                 final FM<Either<N, E>> z = a;
  192.                 return z.transform(new TransformFunc<E, Either<N, E>>() {
  193.  
  194.                     @Override
  195.                     <M> M f(Monoid<M> monoid, F<E, M> func, Either<N, E> val) {
  196.                         final F3<Monoid<M>, F<E, M>, FM<E>, M> fmi = fm_();
  197.                         if (val.isLeft()) {
  198.                             return fmi.f(monoid, func, unfold(g, val.left().value()));
  199.                         } else {
  200.                             return func.f(val.right().value());
  201.                         }
  202.                     }
  203.                 });
  204.             }
  205.         }).f(seedValue);
  206.     }
  207.  
  208.     static <E, N> F<N, FM<E>> unfold(F<N, FM<Either<N, E>>> unfoldFunc) {
  209.         final F<N, FM<Either<N, E>>> g = unfoldFunc;
  210.         return new F<N, FM<E>>() {
  211.  
  212.             @Override
  213.             public FM<E> f(N a) {
  214.                 return unfold(g, a);
  215.             }
  216.         };
  217.     }
  218.  
  219.     static <E, N> F2<F<N, FM<Either<N, E>>>, N, FM<E>> unfold() {
  220.         return new F2<F<N, FM<Either<N, E>>>, N, FM<E>>() {
  221.  
  222.             @Override
  223.             public FM<E> f(F<N, FM<Either<N, E>>> a, N b) {
  224.                 return unfold(a, b);
  225.             }
  226.         };
  227.     }
  228. }
clone this paste RAW Paste Data