CODEWITHSUNDEEP
scalacurrying
learningJava2020
learningJava2020

Reputation: 117

Scala Curry-Uncurry A Function

I am trying to create a function that receives a basic curried adder function with 2 parameters and returns uncurried adder function, and vice versa for the currying function(receives uncurried-returns curried) in scala. I am having a hard time figuring the return types of curried functions , can anyone help out?

def adderCurried(a: Int)(b: Int): Int = a + b

//define a function that returns uncurried version of this function:

val adderUncurried = toAdderUncurried(adderCurried)

adderUncurried(5,6) // returns 11

def adder(a: Int, b: Int): Int = a + b

//define a function that returns curried version of this function:

val adderCurried = toAdderCurried(adder)

adderCurried(5,6) // returns 11

Upvotes: 1

Views: 778

Answers (3)

John Joker
John Joker

Reputation: 82

The toAdderUncurried function will be like this.

def toAdderUncurried(f: Int => Int => Int): (Int, Int) => Int = (x, y) => f(x)(y)

You can call it like this.

toAdderUncurried(adderCurried)(x, y)

And the curry function will be like this.

def curry(f: (Int, Int) => Int): Int => Int => Int = x => y => f(x, y)

you can call it like this

curry(toAdderUncurried(adderCurried))(x)(y)

Upvotes: 1

Boris Azanov
Boris Azanov

Reputation: 4491

Let me add Tim answer. Right here you have 2 options of your adder function:

  • curried type Curried = (Int => Int => Int)
  • and uncurried type Uncurried = (Int, Int) => Int

and your signatures of converting functions should looks like:

def toAdderUncurried(adderCurried: Curried): Uncurried = ???
def toAdderCurried(adderUncurried: Uncurried): Curried = ???

Upvotes: 0

Tim
Tim

Reputation: 27356

Part of the problem is that you are not calling the curried function correctly:

adderCurried(5,6) // too many arguments (found 2, expected 1)

It should be called in a way that matches the declaration:

def adderCurried(a: Int)(b: Int)

adderCurried(5)(6)

This gives the clue that there are actually two function invocations here. The first invocation (5) returns a function that when called with (6) gives the answer. That second function must take an Int and return an Int so it is Int => Int, and this must be what is returned by adderCurried(5).

So adderCurried takes an Int and returns Int => Int so the type is

Int => (Int => Int)

or just

Int => Int => Int

You can check this as follows:

val check: Int => Int => Int = adderCurried // OK

You should be able to create the signatures for toAdderCurried and toAdderUncurried based on these types.

Upvotes: 2

Related Questions