Ruby ou Python ?

[srm]

C'est intéressant comme article, du moins surtout les commentaires
Je vais mettre ici le plus intéressant (car l'auteur de l'article ne connait pas assez bien le Scala)

Things aren't quite as verbose as you make them. I'll paste in some Scala interpretter sessions. OCaml's:

let f x = x + 1;;

looks like this in Scala:

def f(x: Int) = x + 1

For example:

scala> def f(x: Int) = x + 1
f: (Int)Int

scala> f(2)
res0: Int = 3

You can do currying in a few ways in Scala. For OCaml's:

let x a b = a + b;;
let y = x 1;;
y 2;; (* 3 *)

You can either define a function with two parameter lists:

scala> def x(a: Int)(b: Int) = a + b
x: (Int)(Int)Int

scala> x(1)(2)
res1: Int = 3

To leave out a parameter in Scala, you need to put an underscore to signal your intent to actually leave one out. This is because Scala to have good cross compatibility with Java libraries needed to kind of adopt the overloading rules. So you could have an x method with one parameter and an x with two. So it doesn't work to just do what they do in languages where currying is the default. So it looks like this:

scala> val y = x(1) _
y: (Int) => Int =

That underscore tells the compiler I did indeed mean to leave off the 2nd param, so I get currying:

scala> y(2)
res2: Int = 3

Another way to do currying is to just put both parameters in one parameter list, like this:

scala> def x(a: Int, b: Int) = a + b
x: (Int,Int)Int

Then put an underscore just for that parameter that you want to leave out. You also have to specify the type in that case too, again, because of overloading (the overloading was a compromise to be compatible):

scala> val y = x(1, _: Int)
y: (Int) => Int =

scala> y(2)
res3: Int = 3

The set of case classes you showed is correct, except you don't need to seal the subtypes. (And you don't need those semicolons either!) It could just be:

sealed abstract class Robert
case class Foo(value:Int) extends Robert
case class Bar(value:String) extends Robert
case class Baz extends Robert

That is more verbose than OCaml's:

type robert = Foo of int | Bar of string | Baz;;

But although I don't know OCaml, I suspect there's more you can do with case classes. You can put behavior in them. You can subclass them too. What they were talking about removing was letting you subclass a case class with *another case class*, but you'd still be able to subclass them. So you get the pattern matching plus all the OO stuff.

En effet le fonctionnel de Scala est plus verbeux, mais ne semble pas en tout cas particulièrement moins puissant, c'était sans doute abusé de dire "le meilleur du fonctionnel", mais en tout cas pas loin.
Un autre commentaire que j'ai bien aimé :

Scala was built to scale up, not scale down.

Car en effet Scala est conçu comme un micro kernel de règles et tout le reste est fait en librairie, n'importe qui, même toi peut facilement étendre Scala pour lui ajouter un truc qui te manque, une syntaxe qui te manque, ou presque ce que tu veux.