lol java

Config.java

interface MaybeVisitor<A, R> {
    public R just(A v);
    public R nothing();
}

interface Maybe<A> {
    public <R> R fold(MaybeVisitor<A, R> visitor);
}

interface PairVisitor<A, B, R> {
    public R visit(A fst, B snd);
}

interface Pair<A, B> {
    public <R> R fold(PairVisitor<A, B, R> visitor);
}

interface ListVisitor<A, R> {
    public R cons(A head, R tail);
    public R nil();
}

interface List<A> {
    public <R> R fold(ListVisitor<A, R> visitor);
}

public abstract class Config implements List<Pair<String, String>> {
    private Config() {
    }

    private static Config empty = null;

    public static Config getEmpty() {
        if(empty == null)
            empty = new Config() {
                public <R> R fold(ListVisitor<Pair<String, String>, R> visitor) {
                    return visitor.nil();
                }
            };

        return empty;
    }

    public Config set(final String key, final String val) {
        final Config old = this;

        return new Config() {
            public <R> R fold(ListVisitor<Pair<String, String>, R> visitor) {
                return visitor.cons(
                    new Pair<String, String>() {
                        public <R> R fold(PairVisitor<String, String, R> visitor) {
                            return visitor.visit(key, val);
                        }
                    },
                    old.fold(visitor));
            }
        };
    }

    public Maybe<String> lookup(final String key) {
        return fold(new ListVisitor<Pair<String, String>, Maybe<String>>() {
            public Maybe<String> cons(final Pair<String, String> head, final Maybe<String> tail) {
                return head.fold(new PairVisitor<String, String, Maybe<String>>() {
                    public Maybe<String> visit(final String fst, final String snd) {
                        if(fst.equals(key))
                            return new Maybe<String>() {
                                public <R> R fold(final MaybeVisitor<String, R> visitor) {
                                    return visitor.just(snd);
                                }
                            };
                        else
                            return new Maybe<String>() {
                                public <R> R fold(final MaybeVisitor<String, R> visitor) {
                                    return visitor.nothing();
                                }
                            };
                    }
                }).fold(new MaybeVisitor<String, Maybe<String>>() {
                    // We found the key in the head of the list.
                    public Maybe<String> just(final String s) {
                        return new Maybe<String>() {
                            public <R> R fold(MaybeVisitor<String, R> visitor) {
                                return visitor.just(s);
                            }
                        };
                    }

                    public Maybe<String> nothing() {
                        return tail;
                    }
                });
            }

            public Maybe<String> nil() {
                return new Maybe<String>() {
                    public <R> R fold(MaybeVisitor<String, R> visitor) {
                        return visitor.nothing();
                    }
                };
            }
        });
    }

    public static void main(String[] args) {
        Config cfg = Config.getEmpty().set("hello", "world").set("hello", "nick");
        Maybe<String> result = cfg.lookup("hello");

        result.fold(new MaybeVisitor<String, Void>() {
                public Void just(String a) {
                    System.out.println(a);
                    return null;
                }

                public Void nothing() {
                    System.out.println("Didn't find anything!");
                    return null;
                }
            });
    }
}

LOL is right