for-comprehensions: map() and flatMap() with additional parameters

[Martin Senne]

Hi ML, hi *,

assuming

trait FunTrait+T] {

  def map[S]( f: T => S )(p: Int) : FunTrait[S]

  def flatMap[S](f: T => FunTrait[S])(q: Int)): FunTrait[S]

}

How do I translate the expression for s1

val t1: FunTrait[Int] = ...
val t2: FunTrait[Int] = ...

val s1 : FunTrait[Int] = t1.flatMap(v1 => t2.map( v2 => v1*v2 )(3))(5)

(which is absolutely valid)

into the appropriate for-comprehension syntax??? Either I'm really blind today or I am totally missing some detail ......

for {
  v1 <- t1
  v2 <- t2
} yield v1*v2

... but where to place to additional params???


Cheers, Martin

[Marius Danciu]

Well you can have:

trait FunTrait+T] {

  def map[S](p: Int)( f: T => S ) : FunTrait[S]

  def flatMap[S](q: Int)(f: T => FunTrait[S]): FunTrait[S]

}

and then

for {
  v1 <- t1(3)
  v2 <- t2(5)
} yield v1*v2

--
You received this message because you are subscribed to the Google Groups "scala-user" group.
To unsubscribe from this group and stop receiving emails from it, send an email to scala-user+...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[Marius Danciu]

Ignore this ... but you should be able to use implicits for p and q params.

[Martin Senne]

Hi Marius, hi all,

ya, implicits work, but are not what I really want.

Isn't there a way to solve it without implicits???

Cheers, Martin

[Jed Wesley-Smith]

solve what? what you are doing doesn't really make any sense, and you haven't provided any information as to why you want to do that.

Functor and Monad (essentially `map` and `flatMap`) have laws that your proposed implementation will almost certainly break, specifically composition. If you want to "change the shape" of the container/effect, you need to do so within the body of the function passed to flatMap.

cheers,

jed 

[Arya Irani]

Your

trait FunTrait[+T] {
  def map[S](f: T => S)(p: Int) : FunTrait[S]

  def flatMap[S](f: T => FunTrait[S])(q: Int)): FunTrait[S]
}

is also roughly equivalent to

trait FunTrait[+T] {
  def map[S](f: T => S): Int => FunTrait[S]
  def flatMap[S](f: T => FunTrait[S]): Int => FunTrait[S]
}

which may make it clearer why it doesn't fit into the for-comprehension.