Comments on: Function Currying in Scala http://www.codecommit.com/blog/scala/function-currying-in-scala (permanently in beta) Mon, 09 Jan 2012 20:21:24 -0800 http://wordpress.org/?v=2.9.2 hourly 1 By: Ant Kutschera http://www.codecommit.com/blog/scala/function-currying-in-scala/comment-page-1#comment-5497 Ant Kutschera Mon, 09 Jan 2012 20:21:24 +0000 http://www.codecommit.com/blog/scala/function-currying-in-scala#comment-5497 Hi, Nice article. Perhaps a better application of currying is in writing your own control structures, as described in Programming in Scala, 2nd Edition, Chapter 9. Using currying you can write neat things like this, where we no longer have to worry about closing resources, because the control stucture does it for us: val f = new File("c:\\temp\\someFile.txt") //looks a little like a for comprehension. this works, because for functions taking ONE parameter, you can use braces or brackets to call it withPrintWriter(f){ pw => pw.append("now it is " + new Date() + "\r\n") } The function is defined as a curried function: def withPrintWriter(file: File)(op: PrintWriter => Unit) { val writer = new PrintWriter(file) try { op(writer) } finally { writer.close() } } Hi,

Nice article. Perhaps a better application of currying is in writing your own control structures, as described in Programming in Scala, 2nd Edition, Chapter 9. Using currying you can write neat things like this, where we no longer have to worry about closing resources, because the control stucture does it for us:

val f = new File(“c:\\temp\\someFile.txt”)

//looks a little like a for comprehension. this works, because for functions taking ONE parameter, you can use braces or brackets to call it
withPrintWriter(f){
pw => pw.append(“now it is ” + new Date() + “\r\n”)
}

The function is defined as a curried function:

def withPrintWriter(file: File)(op: PrintWriter => Unit) {
val writer = new PrintWriter(file)
try {
op(writer)
} finally {
writer.close()
}
}

]]> By: opensas http://www.codecommit.com/blog/scala/function-currying-in-scala/comment-page-1#comment-5475 opensas Mon, 05 Dec 2011 17:35:33 +0000 http://www.codecommit.com/blog/scala/function-currying-in-scala#comment-5475 Excellent article, I've understood what currying means reading this http://gleichmann.wordpress.com/2011/12/04/functional-scala-curried-functions-and-spicy-methods/ but this helped me understand why it could be useful... Excellent article, I’ve understood what currying means reading this http://gleichmann.wordpress.com/2011/12/04/functional-scala-curried-functions-and-spicy-methods/

but this helped me understand why it could be useful…

]]> By: anon http://www.codecommit.com/blog/scala/function-currying-in-scala/comment-page-1#comment-5441 anon Sat, 20 Aug 2011 11:59:03 +0000 http://www.codecommit.com/blog/scala/function-currying-in-scala#comment-5441 It's correct hat strictly speaking Haskell functions can take only one parameter but I hope you understand that that's more of an implementation detail, i.e. all Haskell functions are inherently curried which has the effect that you can work with function declarations as if they're taking arbitrary amounts of arguments. No need for crappy workarounds like tuples if you want to pass more than one argument. Prelude> let add a b = a + b Prelude> let inc = add 1 Prelude> add 2 3 5 Prelude> inc 3 4 and this works with arbitrary amounts of arguments. and of course this has also has whole-program type inference. Prelude> :t add add :: Num a => a -> a -> a Scala, although quite nice and a great choice among the JVM languages, doesn't even come close to the awesomeness that is Haskell imo. It’s correct hat strictly speaking Haskell functions can take only one parameter but I hope you understand that that’s more of an implementation detail, i.e. all Haskell functions are inherently curried which has the effect that you can work with function declarations as if they’re taking arbitrary amounts of arguments. No need for crappy workarounds like tuples if you want to pass more than one argument.

Prelude> let add a b = a + b
Prelude> let inc = add 1
Prelude> add 2 3
5
Prelude> inc 3
4

and this works with arbitrary amounts of arguments. and of course this has also has whole-program type inference.

Prelude> :t add
add :: Num a => a -> a -> a

Scala, although quite nice and a great choice among the JVM languages, doesn’t even come close to the awesomeness that is Haskell imo.

]]> By: Andreas S. http://www.codecommit.com/blog/scala/function-currying-in-scala/comment-page-1#comment-5428 Andreas S. Sat, 09 Jul 2011 21:31:53 +0000 http://www.codecommit.com/blog/scala/function-currying-in-scala#comment-5428 Hi Horst! Yes both process methods have the same signatures. But the interesting bit is the processEvens function value where he combines a function (add) with the process method so that a new function value. And this only takes one parameter, you create a function with certain "default" behaviour. I think that's it. Hi Horst!
Yes both process methods have the same signatures. But the interesting bit is the processEvens function value where he combines a function (add) with the process method so that a new function value. And this only takes one parameter, you create a function with certain “default” behaviour. I think that’s it.

]]> By: Horst Makitta http://www.codecommit.com/blog/scala/function-currying-in-scala/comment-page-1#comment-4957 Horst Makitta Thu, 01 Apr 2010 21:29:03 +0000 http://www.codecommit.com/blog/scala/function-currying-in-scala#comment-4957 Well a bit late to the game, but maybe i get an answer? As a Java-Programmer i am interested in Scala 'cause it presents all those functional advanced concepts in a very readable manner (unlike Lisp). Or let's say in a form that's much easier to grasp when used to Java. However i still fail to see what the difference in currying and using partially applied functions is (besides having to specify the types of the underscores): Both appear to return the exact same function signatures. You example with process, using partially applied functions: def process[A](filter:A=>Boolean,list:List[A]):List[A] = { lazy val recurse = process(filter, _:List[A]) ... Everything else remains the same and it works as expected: scala> process(even,numbersAsc) res11: List[Int] = List(2, 4) scala> process(even,numbersDesc) res12: List[Int] = List(4, 2) So what is the reason for the special curryable form? Well a bit late to the game, but maybe i get an answer?

As a Java-Programmer i am interested in Scala ’cause it presents all those functional advanced concepts in a very readable manner (unlike Lisp). Or let’s say in a form that’s much easier to grasp when used to Java.

However i still fail to see what the difference in currying and using partially applied functions is (besides having to specify the types of the underscores): Both appear to return the exact same function signatures.

You example with process, using partially applied functions:
def process[A](filter:A=>Boolean,list:List[A]):List[A] = {
lazy val recurse = process(filter, _:List[A])
…

Everything else remains the same and it works as expected:
scala> process(even,numbersAsc)
res11: List[Int] = List(2, 4)

scala> process(even,numbersDesc)
res12: List[Int] = List(4, 2)

So what is the reason for the special curryable form?

]]> By: Landei http://www.codecommit.com/blog/scala/function-currying-in-scala/comment-page-1#comment-3314 Landei Thu, 20 Mar 2008 09:27:45 +0000 http://www.codecommit.com/blog/scala/function-currying-in-scala#comment-3314 Very cool post, you have a new reader :-) Very cool post, you have a new reader :-)

]]> By: Daniel Spiewak http://www.codecommit.com/blog/scala/function-currying-in-scala/comment-page-1#comment-3313 Daniel Spiewak Thu, 20 Mar 2008 08:29:02 +0000 http://www.codecommit.com/blog/scala/function-currying-in-scala#comment-3313 Very true, but it would still be nice to get the inference whenever possible. Very true, but it would still be nice to get the inference whenever possible.

]]> By: Florian Hars http://www.codecommit.com/blog/scala/function-currying-in-scala/comment-page-1#comment-3312 Florian Hars Thu, 20 Mar 2008 07:33:34 +0000 http://www.codecommit.com/blog/scala/function-currying-in-scala#comment-3312 The type of the arguments of add5 can't be inferred in general, because there might be overloaded add methods in scope with argument types (Int, Float, Float) and (Int, Boolean, String). Which one should add(5,_,_) resolve to? The type of the arguments of add5 can’t be inferred in general, because there might be overloaded add methods in scope with argument types (Int, Float, Float) and (Int, Boolean, String). Which one should add(5,_,_) resolve to?

]]> By: Daniel Spiewak http://www.codecommit.com/blog/scala/function-currying-in-scala/comment-page-1#comment-3308 Daniel Spiewak Wed, 19 Mar 2008 01:51:16 +0000 http://www.codecommit.com/blog/scala/function-currying-in-scala#comment-3308 Yes, I am misusing the term "dynamic programming". The problem is that there doesn't seem to be a very good term to describe that particular concept. Dynamic typing is close, but insufficient. Meta-programming perhaps, but meta-programming is possible with entirely static constructs. We really need a new term which encompasses all of the modern techniques which go along with languages like Ruby and Groovy. Yes, I am misusing the term “dynamic programming”. The problem is that there doesn’t seem to be a very good term to describe that particular concept. Dynamic typing is close, but insufficient. Meta-programming perhaps, but meta-programming is possible with entirely static constructs. We really need a new term which encompasses all of the modern techniques which go along with languages like Ruby and Groovy.

]]> By: abulafia http://www.codecommit.com/blog/scala/function-currying-in-scala/comment-page-1#comment-3307 abulafia Wed, 19 Mar 2008 00:19:18 +0000 http://www.codecommit.com/blog/scala/function-currying-in-scala#comment-3307 Hi, i think the term "dynamic programming" is misused in this article. You probably mean something like dynamic typing but not http://en.wikipedia.org/wiki/Dynamic_programming. abu Hi,

i think the term “dynamic programming” is misused in this article. You probably mean something like dynamic typing but not http://en.wikipedia.org/wiki/Dynamic_programming.

abu

]]>