Functional reposiotory - build get() based on find()/create() methods - scala

Question

I have algebra like this
object Algebra {
case class Product(id: String, description: String)
case class ShoppingCart(id: String, products: List[Product])
trait ShoppingCarts[F[_]] {
def create(id: String): F[Unit]
def get(id: String): F[ShoppingCart]
def find(id: String): F[Option[ShoppingCart]]
}
}
I came up with following implementation. But I wonder if it would be possible to implement it as generic method within the trait itself. I have tried to bound context to functor to gain access to map but this is not valid construct.
override def get(id: String): ScRepoState[ShoppingCart] =
find(id).flatMap {
case Some(sc) => sc.pure[ScRepoState]
case None => create(id) *> get(id)
}
Another problem is to implement addMany() metdhod. I got something like this
def addMany[F[_] : Monad](cartId: String, products: List[Product])(implicit shoppingCarts: ShoppingCarts[F]): F[ShoppingCart] = {
for {
cart <- shoppingCarts.get(cartId)
product <- products.pure[F]
newCart <- product.traverse(product => shoppingCarts.add(cart, product))
} yield newCart
}
I struggle how to mix differetnt wrappers within single for comprehension block

Answer 1

But I wonder if it would be possible to implement it as generic method within the trait itself.
Not quite. Scala 2 doesn't allow traits to have parameters, but you can use an abstract class instead. You can either not use trait entirely, or have a default class with all derivable implementations, e.g.:
abstract class DefaultShoppingCarts[F[_]: Monad] extends ShoppingCarts[F] {
override def get(id: String): F[ShoppingCart] =
find(id).flatMap {
case Some(sc) => sc.pure[F]
case None => create(id) >> get(id)
}
}
This is my preferred method, but there are other options for changing traits directly.
You can add a Monad parameter to a method:
trait ShoppingCarts[F[_]] {
def create(id: String): F[Unit]
def find(id: String): F[Option[ShoppingCart]]
def get(id: String)(implicit F: Monad[F]): F[ShoppingCart] =
find(id).flatMap {
case Some(sc) => sc.pure[F]
case None => create(id) >> get(id)
}
}
This is quite different from what we did in abstract class example, b/c the use site of ShoppingCarts will be forced to have a monad available instead of construction site, and the implementor, if they want to override the method, would have to replicate the signature exactly even if that Monad[F] is not used.
You can also emulate what trait parameters would do with abstract implicit defs:
trait ShoppingCarts[F[_]] {
implicit protected def F: Monad[F]
def create(id: String): F[Unit]
def get(id: String): F[ShoppingCart] =
find(id).flatMap {
case Some(sc) => sc.pure[F]
case None => create(id) >> get(id)
}
def find(id: String): F[Option[ShoppingCart]]
}
This works but you are more likely to run into technical issues with implicit scope when implementing the F member.
I struggle how to mix different wrappers within single for comprehension block
You don't. No mixing is allowed. Don't use for-comprehension for list, only use it for F. In some more complex cases you might want to nest for comprehensions, or use a monad transformer, but here you only need to work in F. I'm also not sure what's the return type of add, but assuming it's F[ShoppingCart]:
def addMany[F[_] : Monad](cartId: String, products: List[Product])(implicit shoppingCarts: ShoppingCarts[F]): F[ShoppingCart] = {
for {
cart <- shoppingCarts.get(cartId)
results <- products.traverse(product => shoppingCarts.add(cart, product))
// results is a list of intermediate carts, get the last one; fallback if list was empty
} yield results.lastOption.getOrElse(cart)
}
Also please ask second question separately next time.