private Option<Pair<String, Sequence<String>>> parseExpression(Pair<String, Sequence<String>> expression) {
    Option<Class<?>> expressionClass = evaluator.classFrom(expression.first());

    if (!expressionClass.isEmpty()) {
        return some(expression);
    }

    if (expression.first().contains(".")) {
        final String packagePart = expression.first().substring(0, expression.first().lastIndexOf("."));
        final String classPart = expression.first().substring(expression.first().lastIndexOf(".") + 1);

        return parseExpression(pair(packagePart, expression.second().cons(classPart)));
    }

    return Option.none();

}
 

public CompletionResult call(String expression) throws Exception {
    final int lastSeparator = lastIndexOfSeparator(characters(" "), expression) + 1;
    final String packagePart = expression.substring(lastSeparator);

    Option<Pair<Class<?>, String>> completion = completionFor(packagePart);

    if (!completion.isEmpty()) {
        Function1<CompletionCandidate, String> value = CompletionCandidate::value;
        Sequence<CompletionCandidate> candidates = reflectionOf(completion.get().first())
                .declaredMembers()
                .filter(isStatic().and(isPublic()).and(not(isSynthetic())))
                .groupBy(candidateName())
                .map(candidate())
                .filter(where(value, startsWith(completion.get().second())));

        final int beginIndex = packagePart.lastIndexOf('.') + 1;
        return new CompletionResult(expression, lastSeparator + beginIndex, candidates);
    } else {
        return new CompletionResult(expression, 0, Sequences.empty(CompletionCandidate.class));
    }
}
 

@Test
public void canPutAndReturnOldValue() throws Exception {
    PersistentMap <Integer, String> pairs = map(4, "Four", 5, "Five", 3, "Three", 2, "Two", 6, "Six");
    Pair<PersistentMap <Integer, String>, Option<String>> result = PersistentMap.methods.put(pairs, 4, "NewFour");
    assertThat(result.first().lookup(4).get(), is("NewFour"));
    assertThat(result.second().get(), is("Four"));
}
 

private Callable1<? super TestMethod, ? extends Iterable<Pair<String, TestMethod>>> methodTags() {
    return new Callable1<TestMethod, Iterable<Pair<String, TestMethod>>>() {
        @Override
        public Iterable<Pair<String, TestMethod>> call(TestMethod resultFileAndTestMethod) throws Exception {
            return sequence(tagFinder.tags(resultFileAndTestMethod)).zip(repeat(resultFileAndTestMethod));
        }
    };
}
 

@Override
public Result<Pair<A, B>> parse(Segment<Character> characters) {
    Result<? extends A> resultA = parserA.parse(characters);
    if (resultA instanceof Failure) return cast(resultA);

    Result<? extends B> resultB = parserB.parse(resultA.remainder());
    if (resultB instanceof Failure) return cast(resultB);

    return success(Pair.pair(resultA.value(), resultB.value()), resultB.remainder());
}
 

@Override
public ConsoleResult execute(String expression) {
    if (!authenticated) {
        if (expression.startsWith(":login")) {
            Pair<String, Option<String>> command = parseStringCommand(expression);
            if (!command.second().isEmpty()) {
                if (command.second().get().equals(password)) {
                    authenticated = true;
                    return new ConsoleResult(expression, one(success("Logged in")));
                } else {
                    return new ConsoleResult(expression, one(error("Invalid password")));
                }
            } else {
                return new ConsoleResult(expression, one(error("Please specify password")));
            }
        } else {
            return new ConsoleResult(expression, one(error("Please authenticate first.\n    :login <password> to authenticate.\n    :logout at the end of the session to finish.")));
        }
    } else {
        if (expression.startsWith(":logout")) {
            authenticated = false;
            return new ConsoleResult(expression, one(error("Logged out")));
        } else {
            return super.execute(expression);
        }
    }
}
 

@Override
protected Pair<K, V> getNext() throws Exception {
    if(zipper.isEmpty()) return finished();
    Pair<K, V> pair = zipper.get().pair();
    zipper = zipper.get().nextOption();
    return pair;
}
 

private Option<Pair<Class<?>, String>> completionFor(String expression) {
    Option<Pair<String, Sequence<String>>> parsedClass = parseExpression(pair(expression, Sequences.empty(String.class)));

    if (!parsedClass.isEmpty() && !parsedClass.get().second().isEmpty()) {
        return some(Pair.<Class<?>, String>pair(
                evaluator.classFrom(parsedClass.get().first()).get(),
                parsedClass.get().second().toString(".").trim()));
    } else {
        return none();
    }
}
 

private static <T> Sequence<Sequence<T>> cartesianProductPower(Sequence<T> items, int times) {
    if (times == 0)
        return items.cartesianProduct().map(Pair.functions.values()).unsafeCast();

    return cartesianProductPower(items, times - 1)
            .cartesianProduct(items)
            .map(pair -> pair.first().append(pair.second()).unique())
            .unique();
}
 

@Override
public int indexOf(Object pair) {
    int difference = difference(Unchecked.<Pair<K,V>>cast(pair).first());
    if (difference == 0) return left.size();
    if (difference < 0) return left.indexOf(pair);
    return 1 + left.size() + right.indexOf(pair);
}
 

private <T> WikiResultRenderer withCustomRenderer(Predicate<T> predicate, Renderer<T> renderer) {
    customRenderers.add(Pair.<Predicate, Renderer>pair(predicate, renderer));
    return this;
}
 

@SafeVarargs
public static Transformer transformer(Pair<String, Object>... attributes) throws TransformerConfigurationException {
    return internalTransformer(attributes);
}
 

@Override
Pair<AVLTree<K, V>, Pair<K, V>> removeLast();
 

@Test
public void canRemoveFirst() throws Exception {
    final Pair<? extends PersistentSortedMap<Integer, String>, Pair<Integer, String>> result = sortedMap(4, "Alex", 1, "Dan", 3, "Stu", 2, "Ray").removeFirst();
    assertThat(result.first(), hasExactly(pair(2, "Ray"), pair(3, "Stu"), pair(4, "Alex")));
    assertThat(result.second(), is(pair(1, "Dan")));
}
 

default <B> Parser<Pair<A, B>> then(Parser<? extends B> parser) {
    return PairParser.pair(this, parser);
}
 

static <A, B> Parser<Pair<A, B>> pair(final Parser<? extends A> parserA, final Parser<? extends B> parserB) {
    return PairParser.pair(parserA, parserB);
}
 

@Override
public Option<V> lookup(K key) {
    return list.toSequence().find(key(key)).map(Pair::getValue);
}
 

public static Predicate<? super Pair<Type, Type>> equalTo() {
    return pair -> equalTo(pair.first(), pair.second());
}
 

@Test
public void doesBlowUpWhenLessCharacters() throws Exception {
    Result<Pair<Character, Character>> result = PairParser.pair(character('A'), character('B')).parse("A");
    assertThat(result, instanceOf(Failure.class));
}
 

@Test
public void canCombineTwoParsers() throws Exception {
    Result<Pair<Character, Character>> result = PairParser.pair(character('A'), character('B')).parse("ABC");
    assertThat(result.value(), is(pair('A', 'B')));
    assertThat(result.remainder(), is(characters("C")));
}
 

private static <T> Unary<Pair<String, Sequence<String>>> overrideMessages(final T instance, final Function1<T, String> messageBuilder) {
    return keyAndMessages -> {
        String message1 = Callers.call(messageBuilder, instance);
        return pair(keyAndMessages.first(), keyAndMessages.second().map(returns1(message1)));
    };
}
 

public Sequence<Pair<String, Sequence<String>>> messages() {
    return sequence(messages);
}
 

@Override
public Pair<K, V> value() {
    return focus.head();
}
 

@Test
@SuppressWarnings("unchecked")
public void supportsFold() throws Exception {
    assertThat(map(1, "2").fold(Lists.list(pair(0, "1")), Lists.functions.<Pair<Integer, String>>add()), is(Lists.list(pair(0, "1"), pair(1, "2"))));
}
 

@Override
public <S> S fold(S seed, Function2<? super S, ? super Pair<K, V>, ? extends S> callable) {
    return toSequence().fold(seed, callable);
}
 

public static Curried2<ValidationResult, Pair<String, ? extends Iterable<String>>, ValidationResult> add() {
    return (validationResult, keyAndMessages) -> validationResult.add(keyAndMessages.first(), keyAndMessages.second());
}
 

@Override
Pair<AVLTree<K, V>, Pair<K, V>> removeFirst();
 

public static <V> Result<Sequence<Pair<String, V>>> parsePairs(Reader json) {
    return cast(Grammar.PAIRS.parse(json));
}
 

@Override
public PersistentList<Pair<K, V>> toPersistentList() {
    return PersistentList.constructors.empty();
}
 

@Override
public Pair<K, V> head() throws NoSuchElementException {
    return iterator().next();
}