import fj.data.Stream; //导入依赖的package包/类
private static Parser<Stream<Character>, Double, String> doubleParser() {
	final F<Character, F<Stream<Character>, Stream<Character>>> cons = Streams.cons();
	final F<Stream<Character>, F<Stream<Character>, Stream<Character>>> append = Streams.append();
	final F<Stream<Character>, F<Character, Stream<Character>>> snoc = flip(Streams.<Character>snoc());
	
	final Parser<Stream<Character>, Stream<Character>, String> sign = 
		charParser('-').optional().map(Options.<Character>optionToStream());
	final Parser<Stream<Character>, Stream<Character>, String> digits = 
		digitParser().map(Digit.toChar).repeat1();
	final Parser<Stream<Character>, Stream<Character>, String> dotDigits =
		charParser('.').bind(digits, cons);
	final Parser<Stream<Character>, Stream<Character>, String> digitsDotDigits =
		digits.bind(charParser('.'), snoc).bind(digits, append);
	final Parser<Stream<Character>, Stream<Character>, String> scientific =
		charParser('E').or(charParser('e')).bind(sign.bind(digits, append), cons).optional().map(
			new F<Option<Stream<Character>>, Stream<Character>>() {
				@Override
				public Stream<Character> f(final Option<Stream<Character>> option) {
					return option.orSome(Stream.<Character>nil());
				}
			});
	return sign.bind(dotDigits.or(digitsDotDigits).or(digits), append).bind(scientific, append)
		.map(charStreamToString).map(Doubles.parseDouble).map(Option.<Double>fromSome());
}
 

import fj.data.Stream; //导入依赖的package包/类
public static Show<RouteNodeDocumentation> loggerShow(int indent) {
    return Show.show(rnd -> {
        Stream<Character> s = toIndent(indent).append(lparen).append(space).append(Stream.fromString(rnd.label)).append(space).append(rparen).append(nl);
        Stream<Character> withNext =
          rnd.next.isEmpty() ?
          s :
          s.append(mkString(RouteNodeDocumentation.loggerShow(indent + 1), "\n").show(rnd.next));
        return withNext;
    });
}
 

import fj.data.Stream; //导入依赖的package包/类
public static <T> Show<List<T>>  mkString(Show<T> s,String separator){
    return Show.show(ts->{
        if(ts.isEmpty())
            return Stream.nil();

        T head = ts.head();
        List<T> tail = ts.tail();

        if(tail.isEmpty())
            return s.show(head);

        else
            return s.show(head).append(Stream.fromString(separator)).append(mkString(s,separator).show(tail));
    });
}
 

import fj.data.Stream; //导入依赖的package包/类
private static final <A> Parser<Stream<Character>, Stream<A>, String> csvParser(final Parser<Stream<Character>, A, String> pa) {
	return pa.bind(new F<A, Parser<Stream<Character>, Stream<A>, String>>() {
		@Override
		public Parser<Stream<Character>, Stream<A>, String> f(A a) {
			return charParser(',').sequence(csvParser(pa).map(Stream.<A>cons_().f(a)));
		}
	}).or(Read.<Stream<Character>, A, String>nilStreamParser());
}
 

import fj.data.Stream; //导入依赖的package包/类
private static <I, A, E> Parser<I, Stream<A>, E> nilStreamParser() {
	return Parser.parser(new F<I, Validation<E, Result<I, Stream<A>>>>() {
		@Override
		public Validation<E, Result<I, Stream<A>>> f(final I input) {
			return success(result(input, Stream.<A>nil()));
		}
	});
}
 

import fj.data.Stream; //导入依赖的package包/类
private static Parser<Stream<Character>, Digit, String> digitParser() {
	return CharsParser.digit("Expected an digit", new F<Character, String>() {
		@Override
		public String f(final Character c) {
			return "Expected a digit but found '" + c + "'";
		}
	});
}
 

import fj.data.Stream; //导入依赖的package包/类
public static <A> F<Stream<A>, List<A>> toList() {
	return new F<Stream<A>, List<A>>() {
		@Override
		public List<A> f(final Stream<A> stream	) {
			return stream.toList();
		}
	};
}
 

import fj.data.Stream; //导入依赖的package包/类
public static final <A> Stream<A> fromIterator(final Iterator<A> iterator) {
	if (!iterator.hasNext())
		return nil();
	return Stream.cons(iterator.next(), new P1<Stream<A>>() {
		@Override
		public Stream<A> _1() {
			return fromIterator(iterator);
		}
	});
}
 

import fj.data.Stream; //导入依赖的package包/类
/**
 * First-class version of {@link Stream#unzip(Stream)}
 */
public static final <A, B> F<Stream<P2<A, B>>, P2<Stream<A>, Stream<B>>> unzip() {
	return new F<Stream<P2<A, B>>, P2<Stream<A>, Stream<B>>>() {
		@Override
		public P2<Stream<A>, Stream<B>> f(final Stream<P2<A, B>> as) {
			return Stream.unzip(as);
		}
	};
}
 

import fj.data.Stream; //导入依赖的package包/类
public static final <A> F<A, F<Stream<A>, Stream<A>>> snoc() {
	return curry(new F2<A, Stream<A>, Stream<A>>() {
		@Override
		public Stream<A> f(final A a, final Stream<A> as) {
			return as.snoc(a);
		}
	});
}
 

import fj.data.Stream; //导入依赖的package包/类
/**
 * Returns a function that transforms a vector-4 to a stream of its elements.
 *
 * @return a function that transforms a vector-4 to a stream of its elements.
 */
public static <A> F<V4<A>, Stream<A>> toStream_() {
  return new F<V4<A>, Stream<A>>() {
    public Stream<A> f(final V4<A> v) {
      return v.toStream();
    }
  };
}
 

import fj.data.Stream; //导入依赖的package包/类
/**
 * Returns a stream of the elements of this vector.
 *
 * @return a stream of the elements of this vector.
 */
public Stream<A> toStream() {
  return Stream.cons(head._1(), new P1<Stream<A>>() {
    public Stream<A> _1() {
      return tail.toStream();
    }
  });
}
 

import fj.data.Stream; //导入依赖的package包/类
/**
   * Returns a parser that produces an element from the stream if it is available and fails otherwise.
   *
   * @param e The error to fail with if no element is available.
   * @return A parser that produces an element from the stream if it is available and fails otherwise.
   */
  public static <I, E> Parser<Stream<I>, I, E> element(final P1<E> e) {
    return parser(new F<Stream<I>, Validation<E, Result<Stream<I>, I>>>() {
      @Override
public Validation<E, Result<Stream<I>, I>> f(final Stream<I> is) {
        return is.isEmpty() ?
            Validation.<E, Result<Stream<I>, I>>fail(e._1()) :
            Validation.<E, Result<Stream<I>, I>>success(result(is.tail()._1(), is.head()));
      }
    });
  }
 

import fj.data.Stream; //导入依赖的package包/类
/**
   * Returns a parser that produces the given character or fails otherwise.
   *
   * @param missing The error if no character is available.
   * @param sat     The error if the produced character is not the one given.
   * @param c       The character to produce in the parser.
   * @return A parser that produces the given character or fails otherwise.
   */
  public static <E> Parser<Stream<Character>, Character, E> character(final P1<E> missing, final F<Character, E> sat,
                                                                      final char c) {
    return StreamParser.satisfy(missing, sat, new F<Character, Boolean>() {
      @Override
public Boolean f(final Character x) {
        return x == c;
      }
    });
  }
 

import fj.data.Stream; //导入依赖的package包/类
/**
 * An order instance for the {@link Stream} type.
 *
 * @param oa Order across the elements of the stream.
 * @return An order instance for the {@link Stream} type.
 */
public static <A> Ord<Stream<A>> streamOrd(final Ord<A> oa) {
  return ord(s1 -> s2 -> {
      if (s1.isEmpty())
          return s2.isEmpty() ? Ordering.EQ : Ordering.LT;
      else if (s2.isEmpty())
          return s1.isEmpty() ? Ordering.EQ : Ordering.GT;
      else {
          final Ordering c = oa.compare(s1.head(), s2.head());
          return c == Ordering.EQ ? streamOrd(oa).f.f(s1.tail()._1()).f(s2.tail()._1()) : c;
      }
  });
}
 

import fj.data.Stream; //导入依赖的package包/类
/**
   * Returns a parser that produces a upper-case character.
   *
   * @param missing The error if there is no character on the stream to produce a upper-case character with.
   * @param sat     The error if the produced character is not a upper-case character.
   * @return A parser that produces a upper-case character.
   * @see Character#isUpperCase(char)
   */
  public static <E> Parser<Stream<Character>, Character, E> upper(final P1<E> missing, final F<Character, E> sat) {
    return StreamParser.satisfy(missing, sat, new F<Character, Boolean>() {
      @Override
public Boolean f(final Character c) {
        return Character.isUpperCase(c);
      }
    });
  }
 

import fj.data.Stream; //导入依赖的package包/类
/**
   * Returns a parser that produces a defined character.
   *
   * @param missing The error if there is no character on the stream to produce a defined character with.
   * @param sat     The error if the produced character is not a defined character.
   * @return A parser that produces a defined character.
   * @see Character#isDefined(char)
   */
  public static <E> Parser<Stream<Character>, Character, E> defined(final P1<E> missing, final F<Character, E> sat) {
    return StreamParser.satisfy(missing, sat, new F<Character, Boolean>() {
      @Override
public Boolean f(final Character c) {
        return Character.isDefined(c);
      }
    });
  }
 

import fj.data.Stream; //导入依赖的package包/类
/**
   * Returns a parser that produces an identifier-ignorable character.
   *
   * @param missing The error if there is no character on the stream to produce an identifier-ignorable character with.
   * @param sat     The error if the produced character is not an identifier-ignorable character.
   * @return A parser that produces an identifier-ignorable character.
   * @see Character#isIdentifierIgnorable(char)
   */
  public static <E> Parser<Stream<Character>, Character, E> identifierIgnorable(final P1<E> missing,
                                                                                final F<Character, E> sat) {
    return StreamParser.satisfy(missing, sat, new F<Character, Boolean>() {
      @Override
public Boolean f(final Character c) {
        return Character.isIdentifierIgnorable(c);
      }
    });
  }
 

import fj.data.Stream; //导入依赖的package包/类
/**
 * Returns a function that transforms a vector-8 to a stream of its elements.
 *
 * @return a function that transforms a vector-8 to a stream of its elements.
 */
public static <A> F<V8<A>, Stream<A>> toStream_() {
  return new F<V8<A>, Stream<A>>() {
    public Stream<A> f(final V8<A> v) {
      return v.toStream();
    }
  };
}
 

import fj.data.Stream; //导入依赖的package包/类
/**
   * Returns a parser that produces an ISO control character.
   *
   * @param missing The error if there is no character on the stream to produce an ISO control character with.
   * @param sat     The error if the produced character is not an ISO control character.
   * @return A parser that produces an ISO control character.
   * @see Character#isISOControl(char)
   */
  public static <E> Parser<Stream<Character>, Character, E> isoControl(final P1<E> missing,
                                                                       final F<Character, E> sat) {
    return StreamParser.satisfy(missing, sat, new F<Character, Boolean>() {
      @Override
public Boolean f(final Character c) {
        return Character.isISOControl(c);
      }
    });
  }