currying

Jeffrey Meunier has an implicit Curry macro here , which uses defmacro. I was wondering if someone has ever written this with syntax-rules? There are a number of curry implementations for Scheme -- none can be as elegant as Haskell, since there functions are always unary functions, so everything can be curried. (But this can of course be implemented in a sufficiently powerful Scheme like Racket .) As for the macro that you've dug up -- it's a pretty bad one: not only does it use an unhygienic macro, it's also calling eval explicitly, and relies on an implementation of environments etc. But it

In F#, how do you curry a function that accepts a variable number of parameters? I have code like this...(the log function is just an example, the exact implementation doesn't matter) let log (msg : string) = printfn "%s" msg log "Sample" It gets called throughout the code with sprintf formatted strings, ex. log (sprintf "Test %s took %d seconds" "foo" 2.345) I want to curry the sprintf functionality in the log function so it looks like... logger "Test %s took %d seconds" "foo" 2.345 I've tried something like let logger fmt ([<ParamArray>] args) = log (sprintf fmt args) but I cannot figure out

I don't think I quite understand currying, since I'm unable to see any massive benefit it could provide. Perhaps someone could enlighten me with an example demonstrating why it is so useful. Does it truly have benefits and applications, or is it just an over-appreciated concept? (There is a slight difference between currying and partial application , although they're closely related; since they're often mixed together, I'll deal with both terms.) The place where I realized the benefits first was when I saw sliced operators: incElems = map (+1) --non-curried equivalent: incElems = (\elems ->

I'm trying to understand the point of this language feature of multiple parameter clauses and why you would use it. Eg, what's the difference between these two functions really? class WTF { def TwoParamClauses(x : Int)(y: Int) = x + y def OneParamClause(x: Int, y : Int) = x + y } >> val underTest = new WTF >> underTest.TwoParamClauses(1)(1) // result is '2' >> underTest.OneParamClause(1,1) // result is '2' There's something on this in the Scala specification at point 4.6 . See if that makes any sense to you. NB: the spec calls these 'parameter clauses', but I think some people may also call

I'm just starting up with F# and see how you can use currying to pre-load the 1st parameter to a function. But how would one do it with the 2nd, 3rd, or whatever other parameter? Would named parameters to make this easier? Are there any other functional languages that have named parameters or some other way to make currying indifferent to parameter-order? Typically you just use a lambda: fun x y z -> f x y 42 is a function like 'f' but with the third parameter bound to 42. You can also use combinators (like someone mentioned Haskell's "flip" in a comment), which reorder arguments, but I

Is the following a good example of currying? def sum(a: Int, b: Int) : (Int => Int) = { def go(a: Int) : Int = { a + b; } go } I half understand the below results, but how could I write (or maybe how I should've written) sum() in a curried way? scala> sum(3,4) res0: Int => Int = <function1> scala> sum(3,4).apply(2) res1: Int = 6 scala> sum(3,4).apply(3) res2: Int = 7 4lex1v Currying mechanism was introduced in Scala to support type inference. For example foldLeft function in the standard lib: def foldLeft[B](z: B)(op: (B, A) => B): B Without currying you must provide types explicitly: def