Use functional combinators on Scala Tuples?

Question

'map' preserves the number of elements, so using it on a Tuple seems sensible.

My attempts so far:

scala> (3,4).map(_*2)    
error: value map is not a member of (Int, Int)
       (3,4).map(_*2)
             ^
scala> (3,4).productIterator.map(_*2)
error: value * is not a member of Any
       (3,4).productIterator.map(_*2)
                                  ^
scala> (3,4).productIterator.map(_.asInstanceOf[Int]*2)
res4: Iterator[Int] = non-empty iterator

scala> (3,4).productIterator.map(_.asInstanceOf[Int]*2).toList
res5: List[Int] = List(6, 8)

It looks quite painful... And I haven't even begun to try to convert it back to a tuple.
Am I doing it wrong? Could the library be improved?

It looks like you're using a tuple where you really ought to be using a collection. Consider using a real collection class instead - tuples should not be used as a kind of collections. — Jesper
– Jesper, Commented Apr 30, 2010 at 18:47
@Jesper: I disagree: I might simply want to apply the same operation DRY'ly and consicely on a collection of item whose size is statically known. — Erik Kaplun
– Erik Kaplun, Commented Mar 8, 2014 at 5:16

retronym · Accepted Answer · 2010-06-27 18:48:49Z

36

In general, the element types of a tuple aren't the same, so map doesn't make sense. You can define a function to handle the special case, though:

scala> def map[A, B](as: (A, A))(f: A => B) = 
     as match { case (a1, a2) => (f(a1), f(a2)) } 
map: [A,B](as: (A, A))(f: (A) => B)(B, B)

scala> val p = (1, 2)    
p: (Int, Int) = (1,2)

scala> map(p){ _ * 2 }
res1: (Int, Int) = (2,4)

You could use the Pimp My Library pattern to call this as p.map(_ * 2).

UPDATE

Even when the types of the elements are not the same, Tuple2[A, B] is a Bifunctor, which can be mapped with the bimap operation.

scala> import scalaz._
import scalaz._

scala> import Scalaz._
import Scalaz._

scala> val f = (_: Int) * 2
f: (Int) => Int = <function1>

scala> val g = (_: String) * 2
g: (String) => String = <function1>

scala> f <-: (1, "1") :-> g
res12: (Int, String) = (2,11)

UPDATE 2

http://gist.github.com/454818

edited Jun 27, 2010 at 18:48

answered Feb 26, 2010 at 7:11

retronym

55.1k12 gold badges158 silver badges168 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Eldritch Conundrum Over a year ago

For the record, I'm changing the accepted answer from this to the more recent answer about the Shapeless library, which wasn't available back in 2010.

Miles Sabin · Accepted Answer · 2013-10-22 09:35:49Z

30

shapeless Supports mapping and folding over tuples via an intermediary HList representation,

Sample REPL session,

scala> import shapeless._ ; import Tuples._
import shapeless._
import Tuples._

scala> object double extends (Int -> Int) (_*2)
defined module double

scala> (3, 4).hlisted.map(double).tupled
res0: (Int, Int) = (6,8)

Where the elements of the tuple are of different types you can map with a polymorphic function with type-specific cases,

scala> object frob extends Poly1 {
     |   implicit def caseInt     = at[Int](_*2)
     |   implicit def caseString  = at[String]("!"+_+"!")
     |   implicit def caseBoolean = at[Boolean](!_)
     | }
defined module frob

scala> (23, "foo", false, "bar", 13).hlisted.map(frob).tupled
res1: (Int, String, Boolean, String, Int) = (46,!foo!,true,!bar!,26)

Update

As of shapeless 2.0.0-M1 mapping over tuples is supported directly. The above examples now look like this,

scala> import shapeless._, poly._, syntax.std.tuple._
import shapeless._
import poly._
import syntax.std.tuple._

scala> object double extends (Int -> Int) (_*2)
defined module double

scala> (3, 4) map double
res0: (Int, Int) = (6,8)

scala> object frob extends Poly1 {
     |   implicit def caseInt     = at[Int](_*2)
     |   implicit def caseString  = at[String]("!"+_+"!")
     |   implicit def caseBoolean = at[Boolean](!_)
     | }
defined module frob

scala> (23, "foo", false, "bar", 13) map frob
res1: (Int, String, Boolean, String, Int) = (46,!foo!,true,!bar!,26)

edited Oct 22, 2013 at 9:35

answered May 7, 2012 at 18:56

Miles Sabin

23k6 gold badges63 silver badges95 bronze badges

4 Comments

Eldritch Conundrum Over a year ago

This is great! I would mark your answer as accepted, but I don't know if it's ok to change the accepted answer after several years.

Miles Sabin Over a year ago

You should accept whichever answer you think is best. If the circumstances or your opinion changes over time, then I think it's reasonable to update your acceptance accordingly.

Juh_ Over a year ago

IMHO, this stuff is way too abstract. I mean, it needs to import 3 whole namespaces (import xxxxx._) and for the full generic case, it needs as many additional implicits as item type in the tuples. It certainly depends on use cases, but most probably that a simple, explicit code would be more readable without loss of efficiency.

Michael Lafayette Over a year ago

object double extends (Int -> Int) (_*2) causes my IDE to freak out. WTF is this line doing?

Sagi · Accepted Answer · 2019-09-03 17:01:15Z

1

map function gets an A => B and returns F[B].

def map[A, B](f: A => B) : F[B]

As retronym wrote Tuple2[A, B] is a Bifunctor, so you can look for the bimap function in scalaz or cats.
bimap is a function that maps both sides of the tuple:

def bimap[A, B, C, D](fa: A => C, fb: B => D): Tuple2[C, D]

Because Tuple[A, B] holds 2 values and only one value can be mapped (by convention the right value), you can just return the same value for the left side and use the right function to map over the right value of the tuple.

(3, 4).bimap(identity, _ * 2)

edited Sep 3, 2019 at 17:01

answered Dec 14, 2018 at 19:23

Sagi

9,3643 gold badges38 silver badges43 bronze badges

Collectives™ on Stack Overflow

Use functional combinators on Scala Tuples?

3 Answers 3

1 Comment

4 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

1 Comment

4 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related