* is obsolete. Да здравствует новый король.
Четыре года тому назад я писал вот прямо в этот ЖЖ, что наконец понял, как должна быть правильно устроена система типов и перегрузка операторов, зачем как именно оно должно быть отдельено от ООП и как должно выглядеть последнее. Показал с примерами кода. (Был, кстати, отчасти заклёван firtree) Начиная с того, что

a + b + c — это вовсе не a.add(b).add(c)
a + b + c = (AdditiveSemigroup.[+] a, b, c)
А вот функция AdditiveSemigroup.[+] должна извлекать наиближайшего общего предка a, b и c, являющгося имплементирующим интерфейс AdditiveSemigroup, в котором должна иметься статическая функция add(a, b), выполняющая аксиомы полугруппы. И вот этот AdditiveSemigroup.[+] должен вызывать эту функцию для сложения. Причём, оптимизируя вызовы для параллелизации, т.е. превращая список в бинарное дерева и редуцируя его. Не (((a + b) + c) + d), а ((a + b) + (c + d)).
А ежели аддитивная семигруппа ещё явлется и моноидом, то AdditiveSemigroup.[+]() должна выплёвывать .unit.

Потом я писал всякое про миксины.. Так вот. Сегодня sorhed наконец заставил меня прочитать про Скалу. И я понял, что в мире наконец-то появился язык программирования, на котором мне не пративно писать. Это язык программирования, авторы которого врубаются и в то, как надо делать систему типов, и в то, как делать императивное программирование (в первую очередь, мутабельные переменные), не выходя за рамки абсолютно чистой лямбда-семантики. Да, авторы старательно прячут эти вещи от программиста, справедливо считая его идиотом слабо знакомым с ФП, но внутри у них всё на месте.

Цитирую пример со Scala.org:

    abstract class SemiGroup[A] {
      def add(x: A, y: A): A
    }
    abstract class Monoid[A] extends SemiGroup[A] {
      def unit: A
    }
    object ImplicitTest extends Application {
      implicit object StringMonoid extends Monoid[String] {
        def add(x: String, y: String): String = x concat y
        def unit: String = ""
      }
      implicit object IntMonoid extends Monoid[int] {
        def add(x: Int, y: Int): Int = x + y
        def unit: Int = 0
      }
      def sum[A](xs: List[A])(implicit m: Monoid[A]): A =
        if (xs.isEmpty) m.unit
        else m.add(xs.head, sum(xs.tail))

      println(sum(List(1, 2, 3)))
      println(sum(List("a", "b", "c")))
    }

@ http://www.scala-lang.org/intro/implicit.html

В скале вообще есть всё, для того, чтобы можно было начинать работать. Кое-какой template matching (не Хаскелл, конечно, но очень хорошо), Erlang-style messaging system, базовая функциональщина и прекрасный интерфейс ко всему богатству существующих библиотек для говноджавы. Есть даже case classes (известные также как «конструкторы» в среде функциональщиков и «енумы с параметрами» в среде императивщиков), те самые, позволяющие писать эффективные стейт-машины и темплейты-генераторы, а так же выпендриваться знанием слова катаморфизм.

Вы всё ещё кипятите? Тогда мы идём к вам!