Geek asks and answers

Limit class with implicit evidence

Let's say I have this:

  trait Animal {
    type Species
  }

I can write quite easily a function that accepts only two animals of the same species

def breed(a: Animal, b: Animal)(implicit evidence: a.Species =:= b.Species) = ???

but I want to create a class with the same restriction:

class Bed(a: Animal, b: Animal)(implicit evidence: a.Species =:= b.Species)

but it will not compile. I tried several combinations of trying to use traits with stable identifiers and restrictions and what not, but no matter what I do, I seem to always get problems

  trait Bed {
    type T
    def a: Animal { type Species = T }
    def b: Animal { type Species = T }
  }

  object Bed {

    def apply(a1: Animal, b1: Animal)(implicit ev: a1.Species =:= b1.Species) = new Bed {
      type T = b1.Species
      def a = a1  // this line won't compile,  as the compiler can't see the two species are equal ?
      def b = b1 
    }

  }

Thank.

+5
source share
1 answer

You can express the constraint using the type argument in Bed.apply, and not through the type equality constraint,

object Bed {
  def apply[T1](
    a1: Animal { type Species = T1 },
    b1: Animal { type Species = T1 }) = new Bed {
    type T = T1
    def a = a1
    def b = b1
  }
}

This can be done a bit with an alias of type

type AnimalAux[S] = Animal { type Species = S }

object Bed {
  def apply[T1](a1: AnimalAux[T1], b1: AnimalAux[T1]) =
    new Bed {
      type T = T1
      def a = a1
      def b = b1
    }
}

Sample REPL Session,

scala> trait Dog
defined trait Dog

scala> val tigger = new Animal { type Species = Dog }
tigger: Animal{type Species = Dog} = $anon$1@64bd8f9c

scala> val zebedee = new Animal { type Species = Dog }
zebedee: Animal{type Species = Dog} = $anon$1@61f2bf35

scala> Bed(tigger, zebedee)
res0: Bed{type T = Dog} = Bed$$anon$1@2b0ce330

scala> val b = Bed(tigger, zebedee)
b: Bed{type T = Dog} = Bed$$anon$1@681c81de
+4
source

More articles:


All Articles