private List() {

}

/**

public final Iterator<A> iterator() {

return toCollection().iterator();

}

/**

public abstract A head();

/**

public abstract List<A> tail();

/**

public final int length() {

// WARNING: In JDK 8, update 25 (current version) the following code triggers an internal JDK compiler error, likely due to https://bugs.openjdk.java.net/browse/JDK-8062253. The code below is a workaround for this compiler bug.

// return foldLeft(i -> a -> i + 1, 0);

F2<Integer, A, Integer> f = (i, a) -> i + 1;

return foldLeft(f, 0);

}

/**

public final boolean isEmpty() {

return this instanceof Nil;

}

/**

public final boolean isNotEmpty() {

return this instanceof Cons;

}

/**

public final <B> B list(final B nil, final F<A, F<List<A>, B>> cons) {

return isEmpty() ? nil : cons.f(head()).f(tail());

}

/**

public final A orHead(final P1<A> a) {

return isEmpty() ? a._1() : head();

}

/**

public final List<A> orTail(final P1<List<A>> as) {

return isEmpty() ? as._1() : tail();

}

/**

public final Option<A> toOption() {

return isEmpty() ? Option.<A>none() : some(head());

}

/**

public final <X> Either<X, A> toEither(final P1<X> x) {

return isEmpty() ? Either.<X, A>left(x._1()) : Either.<X, A>right(head());

}

/**

public final Stream<A> toStream() {

final Stream<A> nil = Stream.nil();

return foldRight(a -> as -> as.cons(a), nil);

}

/**

@SuppressWarnings({"unchecked"})

public final Array<A> toArray() {

final Object[] a = new Object[length()];

List<A> x = this;

for (int i = 0; i < length(); i++) {

a[i] = x.head();

x = x.tail();

}

return mkArray(a);

}

/**

@SuppressWarnings({"unchecked", "UnnecessaryFullyQualifiedName"})

public final Array<A> toArray(final Class<A[]> c) {

final A[] a = (A[]) java.lang.reflect.Array.newInstance(c.getComponentType(), length());

List<A> x = this;

for (int i = 0; i < length(); i++) {

a[i] = x.head();

x = x.tail();

}

return Array.array(a);

}

/**

public final A[] array(final Class<A[]> c) {

return toArray(c).array(c);

}

/**

public final List<A> cons(final A a) {

return new Cons<A>(a, this);

}

/**

public final List<A> conss(final A a) {

return new Cons<A>(a, this);

}

/**

public final <B> List<B> map(final F<A, B> f) {

final Buffer<B> bs = empty();

for (List<A> xs = this; xs.isNotEmpty(); xs = xs.tail()) {

bs.snoc(f.f(xs.head()));

}

return bs.toList();

}

/**

public final Unit foreach(final F<A, Unit> f) {

for (List<A> xs = this; xs.isNotEmpty(); xs = xs.tail()) {

f.f(xs.head());

}

return unit();

}

/**

public final void foreachDoEffect(final Effect1<A> f) {

for (List<A> xs = this; xs.isNotEmpty(); xs = xs.tail()) {

f.f(xs.head());

}

}

/**

public final List<A> filter(final F<A, Boolean> f) {

final Buffer<A> b = empty();

for (List<A> xs = this; xs.isNotEmpty(); xs = xs.tail()) {

final A h = xs.head();

if (f.f(h)) {

b.snoc(h);

}

}

return b.toList();

}

/**

public final List<A> removeAll(final F<A, Boolean> f) {

return filter(compose(not, f));

}

/**

public final List<A> delete(final A a, final Equal<A> e) {

final P2<List<A>, List<A>> p = span(compose(not, e.eq(a)));

return p._2().isEmpty() ? p._1() : p._1().append(p._2().tail());

}

/**

public final List<A> takeWhile(final F<A, Boolean> f) {

final Buffer<A> b = empty();

boolean taking = true;

for (List<A> xs = this; xs.isNotEmpty() && taking; xs = xs.tail()) {

final A h = xs.head();

if (f.f(h)) {

b.snoc(h);

} else {

taking = false;

}

}

return b.toList();

}

/**

public final List<A> dropWhile(final F<A, Boolean> f) {

List<A> xs;

//noinspection StatementWithEmptyBody

for (xs = this; xs.isNotEmpty() && f.f(xs.head()); xs = xs.tail()) ;

return xs;

}

/**

public final P2<List<A>, List<A>> span(final F<A, Boolean> p) {

final Buffer<A> b = empty();

for (List<A> xs = this; xs.isNotEmpty(); xs = xs.tail()) {

if (p.f(xs.head()))

b.snoc(xs.head());

else

return P.p(b.toList(), xs);

}

return P.p(b.toList(), List.<A>nil());

}

/**

public final P2<List<A>, List<A>> breakk(final F<A, Boolean> p) {

return span(a -> !p.f(a));

}

/**

public final List<List<A>> group(final Equal<A> e) {

if (isEmpty())

return nil();

else {

final P2<List<A>, List<A>> z = tail().span(e.eq(head()));

return cons(z._1().cons(head()), z._2().group(e));

}

}

/**

public final <B> List<B> bind(final F<A, List<B>> f) {

final Buffer<B> b = empty();

for (List<A> xs = this; xs.isNotEmpty(); xs = xs.tail()) {

b.append(f.f(xs.head()));

}

return b.toList();

}

/**

public final <B, C> List<C> bind(final List<B> lb, final F<A, F<B, C>> f) {

return lb.apply(map(f));

}

/**

public final <B, C> List<C> bind(final List<B> lb, final F2<A, B, C> f) {

return bind(lb, curry(f));

}

/**

public static <A, B, C> F<List<A>, F<List<B>, List<C>>> liftM2(final F<A, F<B, C>> f) {

return curry((as, bs) -> as.bind(bs, f));

}

/**

public final <B, C, D> List<D> bind(final List<B> lb, final List<C> lc, final F<A, F<B, F<C, D>>> f) {

return lc.apply(bind(lb, f));

}

/**

public final <B, C, D, E> List<E> bind(final List<B> lb, final List<C> lc, final List<D> ld,

final F<A, F<B, F<C, F<D, E>>>> f) {

return ld.apply(bind(lb, lc, f));

}

/**

public final <B, C, D, E, F$> List<F$> bind(final List<B> lb, final List<C> lc, final List<D> ld, final List<E> le,

final F<A, F<B, F<C, F<D, F<E, F$>>>>> f) {

return le.apply(bind(lb, lc, ld, f));

}

/**

public final <B, C, D, E, F$, G> List<G> bind(final List<B> lb, final List<C> lc, final List<D> ld, final List<E> le,

final List<F$> lf, final F<A, F<B, F<C, F<D, F<E, F<F$, G>>>>>> f) {

return lf.apply(bind(lb, lc, ld, le, f));

}

/**

public final <B, C, D, E, F$, G, H> List<H> bind(final List<B> lb, final List<C> lc, final List<D> ld, final List<E> le,

final List<F$> lf, final List<G> lg,

final F<A, F<B, F<C, F<D, F<E, F<F$, F<G, H>>>>>>> f) {

return lg.apply(bind(lb, lc, ld, le, lf, f));

}

/**

public final <B, C, D, E, F$, G, H, I> List<I> bind(final List<B> lb, final List<C> lc, final List<D> ld, final List<E> le,

final List<F$> lf, final List<G> lg, final List<H> lh,

final F<A, F<B, F<C, F<D, F<E, F<F$, F<G, F<H, I>>>>>>>> f) {

return lh.apply(bind(lb, lc, ld, le, lf, lg, f));

}

/**

public final <B> List<B> sequence(final List<B> bs) {

final F<A, List<B>> c = constant(bs);

return bind(c);

}

/**

public <B> Option<List<B>> traverseOption(final F<A, Option<B>> f) {

return foldRight(

(a, obs) -> f.f(a).bind(o -> obs.map(os -> os.cons(o))),

Option.some(List.<B>nil())

);

}

/**

public <B, E> Either<E, List<B>> traverseEither(final F<A, Either<E, B>> f) {

return foldRight(

(a, acc) -> f.f(a).right().bind(e -> acc.right().map(es -> es.cons(e))),

Either.<E, List<B>>right(List.<B>nil())

);

}

public <B> Stream<List<B>> traverseStream(final F<A, Stream<B>> f) {

return foldRight(

(a, acc) -> f.f(a).bind(s -> acc.map(ss -> ss.cons(s))),

Stream.<List<B>>nil()

);

}

public <B> P1<List<B>> traverseP1(final F<A, P1<B>> f){

return foldRight(

(a, acc) -> f.f(a).bind(b -> acc.map(bs -> bs.cons(b))),

P.p(List.<B>nil())

);

}

public <B> IO<List<B>> traverseIO(F<A, IO<B>> f) {

return this.foldRight(

(a, acc) -> IOFunctions.bind(acc, (bs) -> IOFunctions.map(f.f(a), b -> bs.cons(b))),

IOFunctions.unit(List.<B>nil())

);

}

/**

public final <B> List<B> apply(final List<F<A, B>> lf) {

return lf.bind(f -> map(f));

}

/**

public final List<A> append(final List<A> as) {

return fromList(this).append(as).toList();

}

/**

public final <B> B foldRight(final F<A, F<B, B>> f, final B b) {

return isEmpty() ? b : f.f(head()).f(tail().foldRight(f, b));

}

/**

public final <B> B foldRight(final F2<A, B, B> f, final B b) {

return foldRight(curry(f), b);

}

/**

public final <B> Trampoline<B> foldRightC(final F2<A, B, B> f, final B b) {

return Trampoline.suspend(new P1<Trampoline<B>>() {

public Trampoline<B> _1() {

return isEmpty() ? Trampoline.pure(b) : tail().foldRightC(f, b).map(F2Functions.f(f, head()));

}

});

}

/**

public final <B> B foldLeft(final F<B, F<A, B>> f, final B b) {

B x = b;

for (List<A> xs = this; !xs.isEmpty(); xs = xs.tail()) {

x = f.f(x).f(xs.head());

}

return x;

}

/**

public final <B> B foldLeft(final F2<B, A, B> f, final B b) {

return foldLeft(curry(f), b);

}

/**

public final A foldLeft1(final F2<A, A, A> f) {

return foldLeft1(curry(f));

}

/**

public final A foldLeft1(final F<A, F<A, A>> f) {

if (isEmpty())

throw error("Undefined: foldLeft1 on empty list");

return tail().foldLeft(f, head());

}

/**

public final List<A> reverse() {

return foldLeft(as -> a -> cons(a, as), List.<A>nil());

}

/**

public final A index(final int i) {

if (i < 0 || i > length() - 1)

throw error("index " + i + " out of range on list with length " + length());

else {

List<A> xs = this;

for (int c = 0; c < i; c++) {

xs = xs.tail();

}

return xs.head();

}

}

/**

public final List<A> take(final int i) {

return i <= 0 || isEmpty() ? List.<A>nil() : cons(head(), tail().take(i - 1));

}

/**

public final List<A> drop(final int i) {

int c = 0;

List<A> xs = this;

for (; xs.isNotEmpty() && c < i; xs = xs.tail())

c++;

return xs;

}

/**

public final P2<List<A>, List<A>> splitAt(final int i) {

P2<List<A>, List<A>> s = p(List.<A>nil(), List.<A>nil());

int c = 0;

for (List<A> xs = this; xs.isNotEmpty(); xs = xs.tail()) {

final A h = xs.head();

s = c < i ? s.map1(as -> as.snoc(h)) : s.map2(as1 -> as1.snoc(h));

c++;

}

return s;

}

/**

public final List<List<A>> partition(final int n) {

if (n < 1)

throw error("Can't create list partitions shorter than 1 element long.");

if (isEmpty())

throw error("Partition on empty list.");

return unfold(as -> as.isEmpty() ? Option.<P2<List<A>, List<A>>>none() : some(as.splitAt(n)), this);

}

/**

public final List<List<A>> inits() {

List<List<A>> s = single(List.<A>nil());

if (isNotEmpty())

s = s.append(tail().inits().map(List.<A>cons().f(head())));

return s;

}

/**

public final List<List<A>> tails() {

return isEmpty() ? single(List.<A>nil()) : cons(this, tail().tails());

}

/**

public final List<A> sort(final Ord<A> o) {

if (isEmpty())

return nil();

else if (tail().isEmpty())

return this;

else {

final class Merge<A> {

List<A> merge(List<A> xs, List<A> ys, final Ord<A> o) {

final Buffer<A> buf = empty();

while (true) {

if (xs.isEmpty()) {

buf.append(ys);

break;

}

if (ys.isEmpty()) {

buf.append(xs);

break;

}

final A x = xs.head();

final A y = ys.head();

if (o.isLessThan(x, y)) {

buf.snoc(x);

xs = xs.tail();

} else {

buf.snoc(y);

ys = ys.tail();

}

}

return buf.toList();

}

}

final P2<List<A>, List<A>> s = splitAt(length() / 2);

return new Merge<A>().merge(s._1().sort(o), s._2().sort(o), o);

}

}

/**

public final <B, C> List<C> zipWith(List<B> bs, final F<A, F<B, C>> f) {

final Buffer<C> buf = empty();

List<A> as = this;

while (as.isNotEmpty() && bs.isNotEmpty()) {

buf.snoc(f.f(as.head()).f(bs.head()));

as = as.tail();

bs = bs.tail();

}

return buf.toList();

}

/**

public final <B, C> List<C> zipWith(final List<B> bs, final F2<A, B, C> f) {

return zipWith(bs, curry(f));

}

/**

public static <A, B, C> F<List<A>, F<List<B>, F<F<A, F<B, C>>, List<C>>>> zipWith() {

return curry((as, bs, f) -> as.zipWith(bs, f));

}

/**

public final <B> List<P2<A, B>> zip(final List<B> bs) {

final F<A, F<B, P2<A, B>>> __2 = p2();

return zipWith(bs, __2);

}

/**

public static <A, B> F<List<A>, F<List<B>, List<P2<A, B>>>> zip() {

return curry((as, bs) -> as.zip(bs));

}

/**

public final List<P2<A, Integer>> zipIndex() {

return zipWith(range(0, length()), a -> i -> p(a, i));

}

/**

public final List<A> snoc(final A a) {

return fromList(this).snoc(a).toList();

}

/**

public final boolean forall(final F<A, Boolean> f) {

return isEmpty() || f.f(head()) && tail().forall(f);

}

/**

public final boolean exists(final F<A, Boolean> f) {

return find(f).isSome();

}

/**

public final Option<A> find(final F<A, Boolean> f) {

for (List<A> as = this; as.isNotEmpty(); as = as.tail()) {

if (f.f(as.head()))

return some(as.head());

}