(03-05-2012, 03:21 PM)oxman a écrit : Moi depuis que je connais Scala qui allie en gros le meilleur du fonctionnel et de l'objet, je ne peux pas me résoudre à me suffire d'un langage uniquement fonctionnel.

Citation :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.

Citation :Scala was built to scale up, not scale down.