Hacker Read

karmakaze · 2022-01-29 10:39:02

I would go for a split of the currying and proposed solutions. Logically

  y = x |> f2(a, _)
  y = x |> f2(_, b)

are currying, but the implementation doesn't need to create functions any more than if the _ was %. And

  fb = f2(a, _)
  fa = f2(_, b)

are explicit currying which would be nice to have at times, but would mostly use in piped context at first, perhaps to give it a more meaningful or narrowed-scope name.

ackfoobar | karma 407 | avg karma 1.61 · | 2023-04-25 17:40:17

Scala does that, with `_` being a "hole in the expression". I wouldn't call it currying though.

  func(param1, _)

Every once in a while you have to make some change to that expression.

  // you may want to write
  func(param1, func2(_))
  // but you need to write the full lambda
  param2 => func(param1, func2(param2))

josephcsible | karma 22500 | avg karma 3.06 · | 2021-09-19 11:24:25

You can curry the second parameter without it being too ugly like this:

  half = (`div` 2)

Also, I think the idea with curried languages is that you're supposed to write your functions with the parameter that people are most likely to want to curry first.

bpicolo | karma 6988 | avg karma 2.56 · | 2015-07-20 17:05:04+00:00

Ahh, I see what you meant. That should work with a correct currying implementation for sure

ebingdom | karma 577 | avg karma 4.62 · | 2022-06-19 06:31:43

That's an interesting idea, but how does it work for functions of multiple arguments?

If functions are curried, then I suppose the syntax for `f x y` would be `y.(x.f)`, which maybe you could write as `y.x.f` if the associativity worked as such. But that means you have to provide your arguments in reverse order?

If functions are not curried, do you write `(x, y).f`?

reply

tel | karma 10892 | avg karma 2.75 · | 2014-06-20 16:53:46

Firstly, this is definitely partial application not currying (see my other post on this thread for great expansion on this point).

Secondly, this is merely a syntactic item you're looking for. It's trivial to achieve this end in any language with first class anonymous functions. I'm not claiming that syntax isn't important, but instead just pointing out that it really is a trivial transformation to include if it were valuable enough.

reply

elros | karma 503 | avg karma 2.52 · | 2016-06-23 13:29:53+00:00

I don't know much about F#, but in a language with currying, such distinction does not exist, given f(x, y) == f(x)(y)

masklinn | karma 65147 | avg karma 3.36 · | 2010-06-19 11:46:11

> It strikes me as being very useful in combination with the 'apply' functions.

It's very useful with higher-order functions in general. Even more so because most of the languages with operators simply being (binary) infix function calls also default to curried functions[1], which you can easily partially apply.

Haskell also has the reverse operation (MLs probably have it as well) of being able to use a binary function as an operator: "a `foo` b" is equivalent to "foo a b", but sometimes reads much better.

[1] http://en.wikipedia.org/wiki/Currying

reply

hood_syntax | karma 788 | avg karma 2.52 · | 2017-11-07 14:59:08+00:00

Let's say you have a validation function that matches a string with a given regex, and you need to use that same logic in several places, using a different regex. Currying allows you to write something like this:

validate :: Regex -> String -> T

validate r s = ...

validateIpAddr :: String -> T

validateIpAddr = validate ipRegex

validateZipCode :: String -> T

validateZipCode = validate zipCodeRegex

And so on and so forth. It can reduce boilerplate, and lets you do stuff like map partially applied functions to functors.

reply

T-R | karma 1337 | avg karma 3.34 · | 2011-02-14 03:19:39+00:00

I was just thinking about that. You have to do it by hacking the infix syntactic sugar.

    x |> f = f x

gives you lambda calculus, but it gets ugly, since you need to specify order of operations with parentheses.

    (4 |> (5 |> (+))) |> (3 |> (*))

You can take it a step further with tuples, but you still need to be explicit about the number of arguments:

    (x,y) |> f = f x y
    ((4,5) |> (+), 3) |> (*)

Maybe you could go almost all the way by telling it to create a List when passed two values, and telling it apply to the (nested) List when called with a List and an operator, but off hand, I can't think of a way to get it to type check, particularly not without killing currying.

salimmadjd | karma 7007 | avg karma 7.88 · | 2015-05-31 15:06:23

Is there a typo on the Currying example?

let addToFiveAndThree = addFive(3);

Should be:

let addToFiveAndThree = addToFive(3);

I belive.

reply

dagheti | karma 151 | avg karma 3.97 · | 2010-05-24 04:08:16+00:00

The pipe operator in F# |> is used in this way. When combined with currying it is especially effective:

  let double_then_sum a_list =
      a_list
      |> List.map  ((*) 2)
      |> List.fold (+) 0

JoshTriplett | karma 44606 | avg karma 4.76 · | 2017-04-12 20:21:46+00:00

I think in that case, for clarity, I'd rather write:

    f (Just (i, cs)) = Just (i, map toUpper cs)
    f x = x

Especially because I find the instances that apply fmap to the second item of a two-item tuple confusing.

But in general I don't mind that kind of use of '.'; I was talking more about any expression like "g . (f .)" or similarly inscrutable curries.

reply

sinhpham | karma 64 | avg karma 2.29 · | 2015-11-18 05:32:24+00:00

Is the currying example even currying? It looks like it's just a function returning a function to me. I thought currying it's some thing like func contains(subString: String, string: String) -> Bool, and calling contains("a") would automatically return a func(x: String) -> Bool.

d0m | karma 3151 | avg karma 2.19 · | 2010-04-23 18:25:00+00:00

It would be nice if [] would act as a currying function if _ isn't present.

For instance:

(map [+ 10 _] '(1 2 3))

could be rewritten as:

(map [+ 10] '(1 2 3))

Or, taken directly from the tutorial:

arc> (trues [if (odd _) (+ _ 10)] '(1 2 3 4 5))

could be rewritten as:

(trues [if [odd] [+ 10]] '(1 2 3 4 5))

which is arguably simpler and clearer.

And by the way, _ could also be usable as before such as:

(filter [> _ 10] (range 1 100)).

reply

nh23423fefe | karma 850 | avg karma 1.04 · | 2023-07-06 11:50:24

consider currying, exploit symmetry, or exhaust cases

mg | karma 6096 | avg karma 7.29 · | 2023-01-20 13:06:01

I wonder if "%" placeholder is the right approach. It makes the code longer in most cases.

Without pipes:

    a = d(c(b))

With pipes in the proposed form:

    a = b|>c(%)|>d(%)

My first approach to design it would be:

    a = b~>c~>d

So the rule is that on the right side of the pipe operator (~>) there is always a function. We don't need parenthesis to indicate that.

If the function takes more than one argument, it can be defined by another value on the left of it.

Without pipes:

    a = d(c(b,7))

With pipes in the proposed form:

    a = b|>c(%,7)|>d(%)

With the ~> approach:

    a = b,7~>c~>d

samatman | karma 17828 | avg karma 2.76 · | 2022-10-02 06:22:43

Yes, and this sort of application (pun intended) is what the one-liner library is for.

If you have a function isEqualTo(a, b), you can curry(isEqualTo, 5) and filter with it.

`assign` could be used in the same way for assigning/overwriting the same field in an array of Objects, and so on.

reply

smsm42 | karma 17167 | avg karma 2.28 · | 2015-09-26 08:49:02

Very nice trick, while using of foo|(bar) is very simple, somehow I don't see such approach being used very often, and it looks like it could simplify a number of things.

fweimer | karma 860 | avg karma 2.28 · | 2024-06-12 19:38:54

Try this:

    let f0  = fun x -> (x, x) in
        let f1  = fun y -> f0(f0 y) in
        let f2  = fun y -> f1(f1 y) in
        let f3  = fun y -> f2(f2 y) in
        let f4  = fun y -> f3(f3 y) in
        let f5  = fun y -> f4(f4 y) in
        f5 (fun z -> z)

Lifted from https://dl.acm.org/doi/pdf/10.1145/96709.96748 via Pierce, Types And Programming Languages.