1. Условная компиляция. В Java все проверки внутренней корректности, осуществляемые утверждениями (зарезервированным словом assert):

   assert obj != null: "Ошибка!";

   , являющимися аналогом .NET-класса System.Diagnostic.Debug, всегда включаются в байт-код, но при запуске виртуальной машины могут быть разрешены (ключом -ea/-enableassertion) или запрещены (по умолчанию так и есть, все утверждения просто игнорируются при исполнении). Можно ли считать это наличием условной компиляции?
   
2. Локальные функции. Некоторый суррогат в Java есть — анонимные классы:

   obj.someMethod(new ISomeInterface() {
       public void someImplementedMethod() {
           ...
       }
   });

   Канает?
   
3. Поддержка Unicode в идентификаторах. Есть.

class Functor f where
    fmap :: (a -> b) -> f a -> f b

-- | Type functions which converts universal ST/IO types to IO-specific ones
type IOSpecific  (a :: * -> *)           = a RealWorld
type IOSpecific2 (a :: * -> * -> *)      = a RealWorld
type IOSpecific3 (a :: * -> * -> * -> *) = a RealWorld

data WithEncoding m h = WithEncoding h !(Encoding m)    -- Encoding
                                       !(Char -> m ())  -- putChar inlined
                                       !(m Char)        -- getChar inlined

N>>Заодно будет возможность еще раз доказать, что ВАШ язык — самый лучший.

func([List]) ->
    ok.

func(atom, atom2) ->
    ok.

func({tuple, t}, {tuple, t2}, [L]) ->
    ok.

Overload (programming)

To overload a method in programming is to have two or more methods with the same name, but are distinguished by the number and/or type of variables they require.

Возможность компиляции/Erlang. HiPE — High Performance Erlang. Доступен только для *nix-систем

M>func([List]) ->
M>    ok.

M>func(atom, atom2) ->
M>    ok.

M>func({tuple, t}, {tuple, t2}, [L]) ->
M>    ok.
M>

M>Получили func/1, func/2, func/3. Правда, возможно я ошибаюсь, и это не overloading.

VD>Если серьезно, то там многие вещи вообще вообще для Хаскеля смысла не имеют, но фанатизм столь велик, что ты даже их приписал бедному Хаскелю. Как map может быть forech-ем? forech не функция, а опертор вроде for-а, т.е. в доску императивный. Какой к черту break в "чистом ФЯ"? Акстись!

int n;//аккумулятор

foreach (int x in arr)
   n+=x;

//это синтакс. сахар для (например вариант для Net 1.0)
IEnumerator en=arr.GetEnumerator();
while (en.MoveNext)
{
    n+=(int)en.Current;
}

//Вводим функцию, для краткости вместо замыкания - возвращаем результат.
int MySum(int n, int x){return x+n;};
IEnumerator en=arr.GetEnumerator();
while (en.MoveNext)
{
    n=MySum(n, en.Current);
}


//концевую рекурсию наоборот
def a=MyForeach(arr.GetEnumerator(), n, MySum);
MyForeach(en:IEnumerator, n:int, f):int
{
   match (en.MoveNext){
      | false => n;
      | true => MyForeach(en, f(n, x), f);
   }
}
//заменяем IEnumerator на list
def a=MyForeach([1,2,3,4,5], n, MySum);
MyForeach(l:list, n:int, f):int
{
    match (l)
    | [] => n;
    | (x:xs) => MyForeach(xs, f(n, x), f);

}
//чем не map?

Type classes provide a uniform solution to overloading,
including providing operations for equality, arithmetic,
and string conversion

Haskell: the world's finest imperative programming language
(C) Simon Peyton Jones

Мне кажется, интереснее было бы сравнивать не конкретные решения сами по себе, а то, как проблемы решаются на том или ином языке, В С++ это шаблоны, в Хаскеле для этого просто не надо уточнять тип функции Ну и дальше всё в том же духе, как то мне это представляется может быть и интересным, но не сильно полезным, ну разве что для расширения кругозора — теперь буду тыкать тебя в то, что Немерле отстой, потому что у него нет параметрического полиморфизма высших порядков

(map (lambda (x) (x + 5)) lyst)

lyst.Map(x => x + 5)

map (+5) lyst

lyst.Map(_ + 5)

var res = from x in Arg select x.Foo;

var res = Arg.Select(x => x.Foo);

var res =
    from x in Arg
    where x.Foo > 5
    select x.Foo;

var res = Arg.Where(x => x.Foo > 5).Select(x => x.Foo);

class C
{
    public C<T> Cast<T>();
}

class C<T>
{
    public C<T> Where(Func<T,bool> predicate);
    public C<U> Select<U>(Func<T,U> selector);
    public C<U> SelectMany<U>(Func<T,C<U>> selector);
    public C<V> Join<U,K,V>(C<U> inner, Func<T,K> outerKeySelector,
        Func<U,K> innerKeySelector, Func<T,U,V> resultSelector);
    public C<V> GroupJoin<U,K,V>(C<U> inner, Func<T,K> outerKeySelector,
        Func<U,K> innerKeySelector, Func<T,C<U>,V> resultSelector);
    public O<T> OrderBy<K>(Func<T,K> keySelector);
    public O<T> OrderByDescending<K>(Func<T,K> keySelector);
    public C<G<K,T>> GroupBy<K>(Func<T,K> keySelector);
    public C<G<K,E>> GroupBy<K,E>(Func<T,K> keySelector,
        Func<T,E> elementSelector);
}

class O<T> : C<T>
{
    public O<T> ThenBy<K>(Func<T,K> keySelector);
    public O<T> ThenByDescending<K>(Func<T,K> keySelector);
}

class G<K,T> : C<T>
{
    public K Key { get; }
}

delegate R Func<T1,R>(T1 arg1);
delegate R Func<T1,T2,R>(T1 arg1, T2 arg2);

class C
{
    public C<T> Cast<T>();
}

class C<T> : C
{
    public C<T> Where(Func<T,bool> predicate);
    public C<U> Select<U>(Func<T,U> selector);
    public C<V> SelectMany<U,V>(Func<T,C<U>> selector,
        Func<T,U,V> resultSelector);
    public C<V> Join<U,K,V>(C<U> inner, Func<T,K> outerKeySelector,
        Func<U,K> innerKeySelector, Func<T,U,V> resultSelector);
    public C<V> GroupJoin<U,K,V>(C<U> inner, Func<T,K> outerKeySelector,
        Func<U,K> innerKeySelector, Func<T,C<U>,V> resultSelector);
    public O<T> OrderBy<K>(Func<T,K> keySelector);
    public O<T> OrderByDescending<K>(Func<T,K> keySelector);
    public C<G<K,T>> GroupBy<K>(Func<T,K> keySelector);
    public C<G<K,E>> GroupBy<K,E>(Func<T,K> keySelector,
        Func<T,E> elementSelector);
}

class O<T> : C<T>
{
    public O<T> ThenBy<K>(Func<T,K> keySelector);
    public O<T> ThenByDescending<K>(Func<T,K> keySelector);
}

class G<K,T> : C<T>
{
    public K Key { get; }
}