I'm trying to convert an Haskell Semigroup
to Scala. The Haskell code works fine but I can't write it in Scala
Haskell:
import Data.Semigroup
newtype Combine a b = Combine { unCombine :: (a -> b) }
instance Semigroup b => Semigroup (Combine a b) where
Combine f <> Combine g = Combine (f <> g)
f = Combine $ \n -> Sum (n + 1)
g = Combine $ \n -> Sum (n - 1)
print (unCombine (f <> g) $ 0) -- Sum 0
print (unCombine (f <> g) $ 10) -- Sum 20
Scala code
import cats.Semigroup
import cats.instances.all._
trait Combine[A, B] {
def unCombine(a: A): B
}
val f = new Combine[Int, Int] {
override def unCombine(n: Int): Int = n + 1
}
val g = new Combine[Int, Int] {
override def unCombine(n: Int): Int = n - 1
}
implicit val mySemigroup: Semigroup[Combine[Int, Int]] = new Semigroup[Combine[Int, Int]] {
def combine(x: Combine[Int, Int], y: Combine[Int, Int]): Combine[Int, Int] = (x,y) match {
// ???
}
}
In addition to the answer by @KartikSabharwal, because both Semigroup
and Combine
are functional interfaces, since Scala 2.12 you can define the specific case like this:
implicit val mySemigroup: Semigroup[Combine[Int, Int]] =
(x, y) => a => x.unCombine(a) + y.unCombine(a)
And the generic case, which @KartikSabharwal has mentioned would look like this in Scala 2.12:
// Don't forget to NOT import `cats.instances.all._` together with this import
import cats.implicits._
implicit def combineSemigroup[A, B](
implicit ev: Semigroup[B]
): Semigroup[Combine[A, B]] =
(x, y) => a => x.unCombine(a) combine y.unCombine(a)
And like this in Scala 2.11:
import cats.implicits._
implicit def combineSemigroup[A, B](
implicit ev: Semigroup[B]
): Semigroup[Combine[A, B]] =
new Semigroup[Combine[A, B]] {
override def combine(x: Combine[A, B], y: Combine[A, B]): Combine[A, B] =
new Combine[A, B] {
override def unCombine(a: A): B = x.unCombine(a) combine y.unCombine(a)
}
}
Here's code that answers your specific question.
import cats.Semigroup
import cats.instances.all._
object Main extends App {
trait Combine[A, B] {
def unCombine(a: A): B
}
override def main(args: Array[String]): Unit = {
implicit val mySemigroup: Semigroup[Combine[Int, Int]] =
new Semigroup[Combine[Int, Int]] {
def combine(x: Combine[Int, Int], y: Combine[Int, Int]): Combine[Int, Int] =
new Combine[Int, Int] {
override def unCombine(n: Int): Int =
Semigroup[Int].combine(x.unCombine(n), y.unCombine(n))
}
}
val f = new Combine[Int, Int] {
override def unCombine(n: Int): Int = n + 1
}
val g = new Combine[Int, Int] {
override def unCombine(n: Int): Int = n - 1
}
val example = Semigroup[Combine[Int, Int]].combine(f, g).unCombine(10)
printf("%d\n", example)
}
}
Ideally I'd like to duplicate the Haskell code in spirit and implement something of the form
// 'a' can be any type
// Semigroup[b] must exist
implicit val mySemigroup: Semigroup[Combine[a, b]] =
def combine(x: Combine[a, b], y: Combine[a, b]): Combine[a, b] =
new Combine[a, b] {
override def unCombine(n: a): b =
Semigroup[b].combine(x.unCombine(n), y.unCombine(n))
}
But I don't know enough Scala to accomplish it. I'll update the answer when I figure it out or someone else can come along and edit this answer/post a better one.
The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.