Kleisli vs Methods vs Functions

Kleisli.scala

/**
  * Methods vs Functions vs Kleisli  
  */
trait TradingMethods[Account, Market, Order, ClientOrder, Execution, Trade] {
  def clientOrders(order: ClientOrder): List[Order]
  def execute(order: Order, m: Market, a: Account): List[Execution]
  def allocate(execution: Execution, as: List[Account]): List[Trade]

  def tradeGeneration(clientOrder: ClientOrder,
                      market: Market,
                      broker: Account,
                      clientAccounts: List[Account]): List[Trade] =
    for {
      orders     <- clientOrders(clientOrder)
      executions <- execute(orders, market, broker)
      trades     <- allocate(executions, clientAccounts)
    } yield trades
}

trait TradingFunctions[Account, Market, Order, ClientOrder, Execution, Trade] {
  def clientOrders: ClientOrder => List[Order]
  def execute(m: Market, a: Account): Order => List[Execution]
  def allocate(as: List[Account]): Execution => List[Trade]

  def tradeGeneration(market: Market,
                      broker: Account,
                      clientAccounts: List[Account]): (ClientOrder) => List[Trade] =
    clientOrders.andThen(
      _.flatMap(execute(market, broker).andThen(_.flatMap(allocate(clientAccounts)))))
}

trait TradingKleisli[Account, Market, Order, ClientOrder, Execution, Trade] {
  def clientOrders: Kleisli[List, ClientOrder, Order]
  def execute(m: Market, a: Account): Kleisli[List, Order, Execution]
  def allocate(as: List[Account]): Kleisli[List, Execution, Trade]

  def tradeGeneration(market: Market,
                      broker: Account,
                      clientAccounts: List[Account]): Kleisli[List, ClientOrder, Trade] =
    clientOrders andThen execute(market, broker) andThen allocate(clientAccounts)
}