凄いバカなプログラムを作ろう

前回に引き続き挑戦
http://d.hatena.ne.jp/nowokay/20070324#1174695655

DSL(なのかな？)を作ってしまうことを目指して実装。
してたけど、場当たり的に作っていたらぐだぐだに
とりあえず動くところまで持っていった版
へっぽこ具合もバカということで

package print;

import static print.SortPrinter.Ex.IF;
import static print.SortPrinter.Ex.IS_EMPTY;
import static print.SortPrinter.Ex.IS_NULL;
import static print.SortPrinter.Ex.SORT;
import static print.SortPrinter.Ex.STRING;

public class SortPrinter {
    public static void main(String[] args) {
        print(new int[] { 14, 13, 71, 2, 24, 19 });
        print(new int[] { 3, 2 });
        print(new int[] { 5 });
        print(new int[] {});
        print(null);
    }

    public static void print(int[] array) {
        System.out.println(
            IF(IS_NULL(array),
                STRING("nullです"),
                IF(IS_EMPTY(array),
                    STRING("空です"),
                    STRING(SORT(array))
                )
            ).eval()
        );
    }

    static abstract class Ex<V> {
        public abstract V eval();

        public static <V> Ex<V> IF(final Ex<Boolean> boolEx, final Ex<V> trueEx, final Ex<V> falseEx) {
            return new Ex<V>() {
                @SuppressWarnings("unchecked")
                public V eval() {
                    Ex<V>[] ops = new Ex[] { trueEx, falseEx };
                    return ops[boolEx.eval().toString().length() - 4].eval();
                }
            };
        }

        public static <V> Ex<V> IF(final boolean bool, Ex<V> trueEx, Ex<V> falseEx) {
            return IF(new Ex<Boolean>() {
                public Boolean eval() {
                    return bool;
                }
            }, trueEx, falseEx);
        }

        public static Ex<Boolean> IS_NULL(final Object object) {
            return new Ex<Boolean>() {
                public Boolean eval() {
                    return object == null;
                }
            };
        }

        public static Ex<Boolean> IS_EMPTY(final int[] ints) {
            return new Ex<Boolean>() {
                public Boolean eval() {
                    return ints.length == 0;
                }
            };
        }

        public static Ex<String> STRING(final String string) {
            return new Ex<String>() {
                public String eval() {
                    return string;
                }
            };
        }

        public static Ex<String> STRING(final Ex<int[]> ex) {
            return new Ex<String>() {
                public String eval() {
                    return appendAll("", ex.eval(), 0);
                }

                private String appendAll(final String str, final int[] ints, final int index) {
                    return IF(index < ints.length, new Ex<String>() {
                        public String eval() {
                            String sep = IF(index == 0, STRING(""), STRING(" ")).eval();
                            return appendAll(str + sep + ints[index], ints, index + 1);
                        }
                    }, STRING(str)).eval();
                }
            };
        }

        public static Ex<int[]> SORT(final int[] ints) {
            return new Ex<int[]>() {
                public int[] eval() {
                    return sort(ints, 0, 1);
                }

                private int[] sort(final int[] ints, final int i, final int j) {
                    return
                        IF(i < ints.length,
                            IF(j < ints.length,
                                IF(new Ex<Boolean>() {
                                    public Boolean eval() {
                                        return ints[i] > ints[j];
                                    }},
                                    new Ex<int[]>() {
                                        public int[] eval() {
                                            swap(ints, i, j);
                                            return sort(ints, i, j + 1);
                                        }},
                                    new Ex<int[]>() {
                                        public int[] eval() {
                                            return sort(ints, i, j + 1);
                                        }
                                    }
                                ),
                                new Ex<int[]>() {
                                    public int[] eval() {
                                        return sort(ints, i + 1, i + 2);
                                    }
                                }
                            ),new Ex<int[]>() {
                                public int[] eval() {
                                    return ints;
                                }
                            }
                        ).eval();
                }

                private void swap(int[] ints, int i, int j) {
                    int tmp = ints[i];
                    ints[i] = ints[j];
                    ints[j] = tmp;
                }
            };
        }
    }
}