cats and function compositions

Question

I have data types:

import cats.Monoid
import cats.implicits._

object Domain {
  case class Money(amount: Double) extends AnyVal {}

  implicit val moneyMonoid = new Monoid[Money] {
    override def combine(a: Money, b: Money): Money = Money(a.amount + b.amount)
    override def empty: Money                       = Money(0)
  }

  case class Operation(account: Account, amount: Money) extends AnyRef
  type Operations = List[Operation]
}

I want to implement totalAmountCalculation like function composition

val calcTotalAmount = map(x => x.amount) >>> combineAll

For this I wrote some code:

def map[A, B](F: A => B): List[A] => List[B] = (m: List[A]) => m.map(F) 
val combineAll      = moneyMonoid.combineAll _

val calcTotalAmount = map[Operation, Money](x => x.amount) >>> combineAll

What cats features I can use for avoid write Monad wrapper for use it in functions composition ?

I want to see my code like:

map(x => x + 1) >>>
filter(x < 100) >>> 
fold(1)((a,b) => a+b))

*I can use for avoid write Monad wrapper* - Did you mean `Monoid`? — Yuval Itzchakov, Aug 21 '19 at 08:01
I mean: For `Monoid` I have some methods like `combine combineAll`, for Monad I have `flatMap, map`, for Foldable 'foldLeft foldRight`. How can I easy curry for use it in composition? — nonlux, Aug 21 '19 at 08:25
It's easy to use something `val filterOdd= filter(x => x %2); val sumOdd = filterOdd >> combineAll` — nonlux, Aug 21 '19 at 08:36
Maybe something like `Iso` or `Invariant` to translate from monoid on `Double` to monoid on `Money` and `Order.by` to create `Order[Money]` from `Order[Double]`? — Mateusz Kubuszok, Aug 21 '19 at 10:28

Yuval Itzchakov · Accepted Answer · 2020-06-23T03:27:15.940

If I understood your question correctly, you want to avoid using the wrapper Amount and having to use x => x.amount everywhere in your function definitions.

There are a couple of ways to solve that problem. The first would be to use a type alias, as you did for operations. This will naturally give you the default Monoid[Int] which has 0 for zero and addition for combine:

allMoney
 .map(_ + 1.0)
 .filter(_ > 3.0)
 .foldLeft(1.0)(_ + _)

// 13.0

allMoney.combineAll

// 12.0

Another option would be to use the newtype library which gives a similar effect using case classes:

@newsubtype case class Money(amount: Double)

allMoney
  .map(_ + 1.0)
  .filter(_ > 3.0)
  .foldLeft(1.0)(_ + _)

// 13.0

cats and function compositions

1 Answers1