I don't like curry

Question

I don't like curry. Help me reverse the effects of this evil question - Make me some curry - by uncurrying functions.

Task

• Given a blackbox curried function, output its uncurried equivalent.
• The curried function will take a single argument and output either another curried function or a value of another type.
• The uncurried function you create will take the same number of arguments as the curried function, but all at once.

Rules

• In languages without first-class functions, you can use an object with a method in place of a curried function - but please specify this.
• The curried function may also output a function pointer instead.
• If your language does not allow function pointers or makes passing around functions hard to work with, but allows evaluating strings to make functions (e.g. APL), you can use strings to represent both curried functions and your uncurried output function.
• You can also take the number of arguments of the functions as an input to help you determine the depth of currying.
• You may choose to return a function that takes a tuple, list, or other single value containing all the arguments.
• You may constrain the arguments and return type to a data type of your choosing, but that type should have more than 1 possible value.
• If f is the inputted curried function and g is your uncurried function, f(a1)(a2)...(aN) must always equal g(a1, a2, ..., aN).
• The order of arguments in the uncurried function should be the same as in the original curried function.

For example, given the function a -> b -> c -> a + b + c, you can return a function that looks like (a, b, c) -> a + b + c or arr -> arr[0] + arr[1] + arr[2] -> ... but not (c, b, a) -> ... (wrong order). If you also take the number of arguments of the function as input, then (a, b) -> c -> ... would be an acceptable output given the input 2 (2 arguments are curried).

Bounty

Since Rust is the language of the month, I will be offering a 50 rep bounty on Rust answer to this question if you haven't used Rust before.

Answer 1

Haskell, 129 127 bytes, thanks to Wheat Wizard

{-#Language GADTs#-}
data N c u o where Z::N o()o;S::N c u o->N(i->c)(i,u)o
(!)::N c u o->c->u->o
(Z!o)_=o
(S n!g)(i,u)=n!g i$u

Try it online! An unobfuscated version looks like this:

{-# Language GADTs #-}

data Natural curried uncurriedArguments output where
    Zero :: Natural output () output
    Successor ::
        Natural curried uncurriedArguments output ->
        Natural (input -> curried) (input, uncurriedArguments) output

deepUncurry ::
    Natural curried uncurriedArguments output ->
    curried ->
    uncurriedArguments -> output
deepUncurry Zero output () = output
deepUncurry (Successor n) g (input, uncurriedArguments)
    = deepUncurry n (g input) uncurriedArguments

The caller must specify the number of arguments they want uncurried as a natural number, where Z represents 0 and S adds one to a number. For example, to uncurry two arguments, you would use S (S Z):

> :t S (S Z) ! (+)
S (S Z) ! (+) :: Num o => (o, (o, ())) -> o

Answer 2

Python 3, 46 bytes

lambda g,i:lambda*l,g=g:eval(f'g{"(%a)"*i%l}')

Try it online!

Python 3, 48 bytes

f=lambda g:lambda x,*a:f(g(x))(*a)if a else g(x)

Try it online!

Answer 3

JavaScript (Node.js), 34 bytes

g=>(...a)=>a.reduce((h,x)=>h(x),g)

Try it online!

-1 byte, thanks to ASCII-only.

---

JavaScript (Node.js), 31 bytes

g=>(...a)=>(a.map(x=>g=g(x)),g)

Try it online!

This 31 byte version, the returned function is not reusable. I'm not sure if this is allowed in this question...

Answer 4

Wolfram Language (Mathematica), 19 bytes

Fold[#@#2&]~Curry~2

Try it online!

Returns a function of a list of arguments, i.e. u[f][{a,b,...}]=f[a][b]....

Ironically, a short uncurrying involves Curry. Then again, functions curried with Mathematica's Curry built-in can accept arguments in uncurried form - per the docs, "the structure of brackets is not relevant, only the number of arguments."

---

To accept a sequence of arguments, i.e. u[f][a,b,...]=f[a][b]..., 20 bytes:

f#@#2&~Fold~f?##&

Try it online!

Answer 5

Underload, 11 bytes

((^)~^~a~*)

Try it online!

Function submission (because Underload full programs can't take input).

The TIO link shows a curried function a(*a(*)*)* that concatenates its three arguments in reverse order (calling it three times by using the (argument)~^ function call syntax that calls a function with one literal argument). Then it uses the program above, calling it with arguments 3 ((::**)) and the same curried function, producing the output (a(*a(*)*)*)^^^. The final line runs this input on the same three literal arguments ((arg3)~(arg2)~(arg1)~^), demonstrating that it produces the same result.

Explanation

((^)~^~a~*)
(         )   define function literal:
    ~^          call {argument 1} with argument
 (^)              lambda f, x: f(x)
                {replacing argument 1 with the return value}
      ~ ~       replace argument 2 with
       a          uneval(argument 2)
         *      compose argument 1 and argument 2
                  {and return the function newly created}

The basic idea here is to exploit the fact that Underload is generally very polymorphic with respect to how many arguments a function takes. In particular, we can take a function which takes two arguments and produces one return value, and call it in a loop in order to create a function that takes more than two arguments; each iteration will steal an additional argument from the argument stack.

Numbers in Underload are basically curried loops with a specific number of iterations; you can think of the number 3 as having an effect similar to lambda f: lambda x: f(f(f(x))) (except with the number of arguments being more flexible than this). So by executing the first argument on lambda f, x: f(x), we effectively end up creating a loop that uncurries a function via simply just calling it repeatedly, consuming an extra argument each time.

This could have been just 8 bytes if not for an off-by-one error: if a function takes 1 argument, it's the same curried and uncurried; if it takes 2 arguments, we have to call it one more time; if it takes 3 arguments, we have to call it twice more, etc.. Arithmetic (other than multiplication and exponentiation) is very verbose in Underload, so instead of fixing the off-by-one error with subtraction, we uneval the function we're uncurrying. The uneval'ed function will consume no arguments and output the original function, so this neatly cancels out one level of uncurrying and thus fixes the off-by-one error.

Answer 6

R, 68 67 71 bytes

Edit: -1 byte thanks to Giuseppe, but then +4 bytes to fix a bug spotted by ASCII-only

function(f)function(...,g=f)el(rev(sapply(c(...),function(a)g<<-g(a))))

Try it online!

This is a horrible bit of R code, but my attempts using for or while have so far failed.

Creates a function that uses sapply to loop over all its arguments, updating the passed function f in each iteration using the <<- assignment operator to assign in the 'parent' scope. This generates a list of all the intermediate values (all except the last one are partially-uncurried versions of f), so we reverse it and return the new first element (so, effectively the last element), which is the result of the fully uncurried function call.

uncurry=                        # define 'uncurry' as
function(f)                     # a function taking argument f, a curried function,
    function(...){              # that returns an anonymous function  
                                # with an undefined number of arguments, denoted as '...'.
        x=                      # define x as 
            sapply(             # the results of applying a function (see below) to each element of
                c(...),         # the concatenation of all the elements of '...' (so: the arguments)
                function(a)     # this is the function to apply, taking argument 'a' as each element:
                    f<<-f(a))   # the value of f(a)
                                # while updating 'f' to this value, in the parent scope
                                # (so the next iteration will use this new version of 'f')
        rev(x)[[1]]             # now, output the last element of x
                                # (which is the value final, uncurried output;
                                # the earlier elements of x are all the partially-uncurried 
                                # versions of f)
    }

Note that since we use c() to concatenate the argument list ... into a vector (rather than into a list), the arguments are constrained to be all of the same type (as allowed by the challenge rules). For a more-general version that can accept argments of different types, exchange c for list (at the cost of an extra 3 bytes).

---

R, 65 61 bytes

Edit: -5 bytes thanks to Giuseppe

g=function(f)function(a,...)`if`(nargs()>1,g(f(a))(...),f(a))

Try it online!

Alternative recursive version: shorter, easier to understand, and without horrible scoping hacks. Heavily based on comment by ASCII-only, and made nicer (as well as even shorter) by Giuseppe.

Answer 7

JavaScript (Node.js), 42 bytes

f=g=>(x,...a)=>a.length?f(g(x))(...a):g(x)

Try it online! Resulting function assumes that you give it the correct number of arguments.

Answer 8

Ruby, 27 25 24 bytes

-3 bytes thanks to vrintle

->f{->a{a.inject f,:[]}}

Try it online!

Answer 9

R, 60 58 51 bytes

-2 bytes thanks to Dominic van Essen. Nicer form thanks to Giuseppe

function(f)function(a)Reduce(function(f,a)f(a),a,f)

Try it online!

Answer 10

Common Lisp, 54 48 bytes

(lambda(f)(lambda(a)(reduce'funcall(cons f a))))

Try it online!

Answer 11

APL (Dyalog Unicode), 14 bytes (SBCS)

Anonymous tacit prefix function taking the name of a Curried function as right argument, and returning the source of the un-Curried function.

⎕NR⊃⍨4-2⍳⍨183⌶

Try it online!

For example, with the function f ← (~,∩)∘' ', which consists of the function ~,∩ with a space character as curried right-argument, passing the name "f" gives:

183⌶ explain representation; a structure identical to the structure of the target function, but with integers indicating the name class of the components
 [[3,3,3],4,2] (3 is function, 4 is higher-order function, 2 is array)

2⍳⍨ index of 2
 3

4- subtract that from 4
 1

…⊃⍨ use that index to pick from:

 ⎕NR the Nested Representation, ["~,∩","∘"," "]

This picks out our result, "~,∩".

Answer 12

Attache, 11 bytes

Fold&:`!##V

Try it online!

Anonymous function that takes input like f[curried, a1, a2, ..., aN].

Explanation

With some more whitespace:

(Fold&:`!) ## V

V is a function that converts its arguments into a list. V[1, 2, 3] yields [1, 2, 3]. Fold is given the execute operation ! as a function (`!) for its first argument, via f&:n. ## composes these two functions.

Answer 13

Java (JDK), 81 bytes

(-9 bytes thanks to user. -2 bytes after removing curly braces from for loop.)

f->a->{var g=f;for(int i:a)g=((java.util.function.Function)g).apply(i);return g;}

Try it online!

Accepts an arbitrary depth Function<Integer, ?> where ? is either Integer or Function<Integer, ?>, and returns a Function<int[], Object>.

I can't really find rules on Java submissions. I tried to mostly follow the format for what counts as the header and what the code body has to look like from an answer on the inspiration for this question. Let me know if I got anything wrong

Answer 14

R, 56 bytes

g=function(f)function(a,...)`if`(nargs(),g(f(a))(...),f)

Try it online!

Credit to Dominic van Essen and ASCII-only for a decent part of this, so please upvote their submissions as well.

The ... aka dots is a special R construct for functions with arbitrary number of inputs.

Answer 15

Julia, 22 bytes

!f=x->foldl(map,[f;x])

g = !f will expect an array

Try it online!

Answer 16

PHP, 84 bytes

function u($f){return function($a,...$b)use($f){return$b?u($f($a))(...$b):$f($a);};}

Try it online!

Answer 17

Perl 5, 54 bytes

sub f($n,$g){--$n?sub($p,@p){&{f($n,&$g($p))}(@p)}:$g}

Try it online!

Parameter $n is the number of arguments to uncurry, $g is the input function which has to be uncurried.

Answer 18

C++ (gcc), 189 bytes

#define T template
T<class F>struct U{F f;auto operator()(){return f;}T<class A,class...B>auto operator()(A a,B...b){return U<decltype(f(a))>{f(a)}(b...);}};T<class F>U<F>u(F f){return{f};}

Try it online!

Function u takes in a curried callable object, and returns another callable object which is uncurried.

(I don't see any allowance for a restriction on the return type of the curried function, just on the argument types. If it were allowed, we could save two bytes by replacing both instances of auto with int.)