CODEWITHSUNDEEP
scalatypesfunctional-programmingtypeclass
Rabzu
Rabzu

Reputation: 100

How to extract types from a tuple that implements a typeclass

Function a can receive single argument or a tuple, these arguments need to be members of typeclass StringIdentifiable

How to extract and decompose tuple type into types that also have instances of the typeclass

@typeclass trait StringIdentifiable[M] {
  def identify(id: M): String
}

def a[K: StringIdentifiable] (k:K){
 k match{
case (k1) => 
 implicitly[StringIdentifiable[K]].identify(k1)
case (k1,k2) =>
 implicitly[StringIdentifiable[k1.type]].identify(k1) 
 implicitly[StringIdentifiable[k2.type]].identify(k2)
}

I get error in the second match:

Could not find an instance of StringIdentifiable for k1.type

Upvotes: 0

Views: 200

Answers (2)

Jasper-M
Jasper-M

Reputation: 15086

You can do this with shapeless. For instance:

import shapeless._, ops.hlist._

object MyPoly extends Poly2 { 
  implicit def foo[A] = at[A, StringIdentifiable[A]]( (a, f) => f.identify(a) ) 
}

def a[K: StringIdentifiable, L <: HList, O <: HList](k: K)(
  implicit 
  gen: Generic.Aux[K, L], // decompose K into HList L
  lift: LiftAll.Aux[StringIdentifiable, L, O], // find an instance of StringIdentifiable for every element of L
  zip: ZipWith[L, O, MyPoly.type] // zip L with its typeclass instances and map the results with the polymorphic function MyPoly
): String :: zip.Out = { 
  val l = gen.to(k)
  val o = lift.instances
  implicitly[StringIdentifiable[K]].identify(k) :: zip(l, o) 
}

implicit def id1[A,B]: StringIdentifiable[(A, B)] = _ => "1"
implicit val id2: StringIdentifiable[String] = _ => "2"
implicit val id3: StringIdentifiable[Int] = _ => "3"

a(("foo", 42)) // 1 :: 2 :: 3 :: HNil

A full solution to your problem (IIUC) probably consists of using shapeless to automatically generate StringIdentifiable instances for all tuples.

trait StringIdentifiable[M] {
  def identify(id: M): String
}
object StringIdentifiable {
  object MyPoly extends Poly2 { 
     implicit def foo[A] = at[A, StringIdentifiable[A]]( (a, f) => f.identify(a) ) 
  }

  implicit def mkSI[K, L <: HList, O <: HList](
    implicit
    tup: IsTuple[K],
    gen: Generic.Aux[K, L],
    lift: LiftAll.Aux[StringIdentifiable, L, O],
    zip: ZipWith[L, O, MyPoly.type]
  ): StringIdentifiable[K] = { 
    val o = lift.instances
    k => {
      val l = gen.to(k)
      zip(l, o).mkString("(", ", ", ")")
    }
  }
}

Upvotes: 1

Dmytro Mitin
Dmytro Mitin

Reputation: 51648

k1.type, k2.type are singleton types. Try

@typeclass trait StringIdentifiable[M] {
  def identify(id: M): String
}

object StringIdentifiable {
  implicit def one[K]: StringIdentifiable[K] = ???

  implicit def two[K1: StringIdentifiable, K2: StringIdentifiable]: StringIdentifiable[(K1, K2)] = {
    new StringIdentifiable[(K1, K2)] {
      override def identify(id: (K1, K2)): String = id match {
        case (k1,k2) =>
          implicitly[StringIdentifiable[K1]].identify(k1)
          implicitly[StringIdentifiable[K2]].identify(k2)
          ???
      }
    }
  }
}

def a[K: StringIdentifiable](k:K): String = implicitly[StringIdentifiable[K]].identify(k)

Upvotes: 2

Related Questions