Interpreters for the Free Monad - scala

Question

I've been doing an exercise to try to implement a basic Calculator with Free Monad.
As I understand the intention of the Free Monad and what I wanted to achieve is:
write my program (math expression) once run it with different interpreters.
Now i am not sure that I did the 100% idiomatic implementation at least because:
My program kinda needs to be parametrized on the generic type A which should match the interpreter context.
def program[A] = for {
two <- lit[A](2)
four <- lit[A](4)
sum <- add(two, four)
} yield sum
program[Int].foldMap(eval) shouldBe 6
program[String].foldMap(print) shouldBe "(2 + 4)"
import cats.instances.option._
program[Option[Int]].foldMap(evalOpt) shouldBe Option(6)
The ADT/algebra and 'smart constructors'
trait Expression2[A] extends Product with Serializable
case class Lit[A](a: Int) extends Expression2[A]
case class Add[A](a: A, b: A) extends Expression2[A]
case class Mult[A](a: A, b: A) extends Expression2[A]
type ExprAlg[B] = Free[Expression2, B]
def lit[A](a: Int): ExprAlg[A] = Free.liftF(Lit(a))
def add[A](a: A, b: A): ExprAlg[A] = Free.liftF(Add(a, b))
def mult[A](a: A, b: A): ExprAlg[A] = Free.liftF(Mult(a, b))
The math interpreter:
def eval: Expression2 ~> Id = new (Expression2 ~> Id) {
override def apply[A](fa: Expression2[A]): Id[A] = eval(fa).asInstanceOf[A]
def eval[A](expression2: Expression2[A]): Int = expression2 match {
case Lit(n) => n
case Add(a, b) => a.asInstanceOf[Int] + b.asInstanceOf[Int]
case Mult(a, b) => a.asInstanceOf[Int] * b.asInstanceOf[Int]
}
}
The print interpreter:
def print: Expression2 ~> Id = new (Expression2 ~> Id) {
override def apply[A](fa: Expression2[A]): Id[A] = eval(fa).asInstanceOf[A]
def eval[A](expression2: Expression2[A]): String = expression2 match {
case Lit(n) => n.toString
case Add(a, b) => "(" + a.toString + " + " + b.toString + ")"
case Mult(a, b) => "(" + a.toString + " * " + b.toString + ")"
}
}
The math in Option interpreter:
def evalOpt: Expression2 ~> Option = new (Expression2 ~> Option) {
override def apply[A](fa: Expression2[A]): Option[A] = eval(fa).map{_.asInstanceOf[A]}
def eval[A](expression2: Expression2[A]): Option[Int] = expression2 match {
case Lit(n) => Option(n)
case Add(a, b) => Option(a.asInstanceOf[Int] + b.asInstanceOf[Int])
case Mult(a, b) => Option(a.asInstanceOf[Int] * b.asInstanceOf[Int])
}
}
Related to the Option interpreter, I would have expected that the a and b vars to be option, and in the string interpreter a and b to be strings because of my the ADT result type is A: Expression2[A].
I also tried instead of Lit[A](a: Int), to have Lit[A](a: A) but then it breaks down: i cannot pass different interpreters for the same expression when A is fixed to an Int in my program and I expect not to have to rewrite my program for different interpreters.

Answer 1

So a couple things. Generally you reaaaally want to avoid asInstanceOf because right now you can construct an Expression2 with any type and then it'd just crash on evaluating because it's not actually an Int. There's a couple ways to mitigate this. You can either just fix the type of the contained numeric type in your Expression2
import scalaz._
import Scalaz._
trait Expression2[A] extends Product with Serializable
case class Lit[A](a: Int) extends Expression2[Int]
case class Add[A](a: Int, b: Int) extends Expression2[Int]
case class Mult[A](a: Int, b: Int) extends Expression2[Int]
type ExprAlg[A] = Free[Expression2, A]
def lit(a: Int): ExprAlg[Int] = Free.liftF(Lit(a))
def add(a: Int, b: Int): ExprAlg[Int] = Free.liftF(Add(a, b))
def mult(a: Int, b: Int): ExprAlg[Int] = Free.liftF(Mult(a, b))
val eval: Expression2 ~> Id = new (Expression2 ~> Id) {
override def apply[A](fa: Expression2[A]): Id[A] = eval(fa)
def eval[A](expression2: Expression2[A]): A = expression2 match {
case Lit(n) => n
case Add(a, b) => a+b
case Mult(a, b) => a*b
}
}
Or you can associate the capability with the operations like this. basically you can think of the cases in your ADT like Add like this: The parameters of the case class are like function parameters and the type you put into the Extends is the result type.
import scalaz._
import Scalaz._
import spire.algebra._
import spire.implicits._
trait Expression2[A] extends Product with Serializable
case class Lit[A](a: A) extends Expression2[A]
case class Add[A](a: A, b: A)(implicit val ev:Semiring[A]) extends Expression2[A]
case class Mult[A](a: A, b: A)(implicit val ev:Semiring[A]) extends Expression2[A]
type ExprAlg[A] = Free[Expression2, A]
def lit[A](a: A): ExprAlg[A] = Free.liftF(Lit(a))
def add[A](a: A, b: A)(implicit ev:Semiring[A]): ExprAlg[A] = Free.liftF(Add(a, b))
def mult[A](a: A, b: A)(implicit ev:Semiring[A]): ExprAlg[A] = Free.liftF(Mult(a, b))
val eval: Expression2 ~> Id = new (Expression2 ~> Id) {
override def apply[A](fa: Expression2[A]): Id[A] = eval(fa)
def eval[A](expression2: Expression2[A]): Id[A] = expression2 match {
case Lit(n) => n
case x:Add[A] => x.ev.plus(x.a,x.b)
case x:Mult[A] => x.ev.times(x.a,x.b)
}
}
def program[A: Semiring](a:A,b:A) = for {
two <- lit(a)
four <- lit(b)
sum <- add(two, four)
} yield sum
println(program[Int](2,4).foldMap(eval) )
Now as for your Option case I am not quite sure why you want to interpret into an Option here. if you can do F ~> Id for some F, F ~> Option really is just Some applied to the first natural transformation.