Type Members

1.  trait TypeBoundFunction [TypeBound, Arg[_ <: TypeBound], ReturnVal[_ <: TypeBound]] extends WideningTypeBoundFunction[TypeBound, TypeBound, Arg, ReturnVal]

   a function with one type parameter, where both the argument and the return value are types with a single type parameter, bound to the type parameter of the function.

   a function with one type parameter, where both the argument and the return value are types with a single type parameter, bound to the type parameter of the function.

   TypeBound

   the type bound to use for the argument and return value types

   Arg

   the argument type

   ReturnVal

   the return value type

2.  class TypeBoundMap [TypeBound, Key[_ <: TypeBound], Val[_ <: TypeBound]] extends BaseTypeBoundMap[TypeBound, Key, Val]

   a map where the types for keys and values share a type parameter with the same bounds.

   a map where the types for keys and values share a type parameter with the same bounds. the key and value of each key/value pair are constrained to match on that type parameter. for example, we might have some pet stores that only cater to a single kind of pet:

   trait Pet
   case class Cat(name: String) extends Pet
   case class Dog(name: String) extends Pet
   class PetStore[P <: Pet]
   
   val catStore1 = new PetStore[Cat]
   val catStore2 = new PetStore[Cat]
   val dogStore1 = new PetStore[Dog]

   we can use a TypeBoundMap to store a list of pets of the appropriate type for every pet store:

   var inventories = TypeBoundMap[Pet, PetStore, List]
   inventories += (catStore1 -> List(Cat("cat11"), Cat("cat12"), Cat("cat13")))
   inventories += (catStore2 -> List(Cat("cat21")))
   inventories += (dogStore1 -> List(Dog("dog11"), Dog("dog12")))

   now we can look up pet lists by pet store, with everything coming back as the expected type:

   val cats1: List[Cat] = inventories(catStore1)
   cats1.size should be (3)
   val cats2: List[Cat] = inventories(catStore2)
   cats2.size should be (1)
   val dogs1: List[Dog] = inventories(dogStore1)
   dogs1.size should be (2)
   
   val cat: Cat = inventories(catStore1).head
   cat should equal (Cat("cat11"))
   val dog: Dog = inventories(dogStore1).head
   dog should equal (Dog("dog11"))

   note that the API does not provide methods to add multiple key/value pairs at a time, as each pair needs to be type-checked separately.

   (the code presented here is in test class typekey.typeBoundMap.ScaladocSpec.)

   TypeBound

   the upper bound on the type parameters passed to the Key and Val types

   Key

   the parameterized type of the keys in the map

   Val

   the parameterized type of the values in the map

   See also

   src/test/scala/typekey/typeBoundMap/ for many more examples

3.  case class TypeBoundPair [TypeBound, A[_ <: TypeBound], B[_ <: TypeBound], TypeParam <: TypeBound](_1: A[TypeParam], _2: B[TypeParam]) extends Product with Serializable

   mimics a pair found in an ordinary map, but preserves the type parameter equality in the two elements of the pair

   mimics a pair found in an ordinary map, but preserves the type parameter equality in the two elements of the pair

   TypeBound

   the upper bound on the type parameters passed into the A and B types of the two elements of this pair

   A

   the parameterized type of the first element of this pair

   B

   the parameterized type of the second element of this pair

   TypeParam

   the type param binding both the A and B types of the two elements of this pair

   _1

   the first element of this type bound pair

   _2

   the second element of this type bound pair

4.  case class TypeKey [A](tag: scala.reflect.api.JavaUniverse.TypeTag[A]) extends Product with Serializable

   behaves much like a scala.reflect.runtime.universe.TypeTag, except that it can also be safely used as a key in a hash or a set.

   behaves much like a scala.reflect.runtime.universe.TypeTag, except that it can also be safely used as a key in a hash or a set. Two type keys will be equal if and only if their underlying types are equivalent according to method =:= in scala.reflect.api.Types.Type. The hashCode method does its best to produce unique hash values, and always produces values compatible with equals.

   type keys are provided by an implicit method in package typekey, so you can get one implicitly like so:

   def foo[A : TypeKey]() = {
     val key = implicitly[TypeKey[A]]
   }

   or you can get one explicitly like so:

   val key = typekey.typeKey[List[String]]

   or if you already have a TypeTag at hand:

   val tag: TypeTag[A] = ???
   val key = TypeKey(tag)

   A

   the type that we are keying one

   tag

   the scala-reflect TypeTag for type A

5.  class TypeKeyMap [TypeBound, Val[_ <: TypeBound]] extends BaseTypeBoundMap[TypeBound, TypeKey, Val]

   a map where the keys are type keys with an upper bound, and the values have a type parameter with the same bound.

   a map where the keys are type keys with an upper bound, and the values have a type parameter with the same bound. The key and value of each key/value pair are constrained to match on that type parameter. For example, suppose we are maintaining an inventory of computer parts:

   sealed trait ComputerPart
   case class Memory(gb: Int) extends ComputerPart
   case class CPU(mhz: Double) extends ComputerPart
   case class Display(resolution: Int) extends ComputerPart

   we can use a TypeKeyMap to store a list of parts for each kind of part:

   var partLists = TypeKeyMap[ComputerPart, List]()
   partLists += Memory(2) :: Memory(4) :: Memory(8) :: Nil
   partLists += CPU(2.2) :: CPU(2.4) :: CPU(2.6) :: Nil
   partLists += Display(720) :: Display(1080) :: Nil

   now we can look up part lists by part type, with everything coming back as the expected type:

   val memories: List[Memory] = partLists[Memory]
   memories.size should be (3)
   val cpus: List[CPU] = partLists[CPU]
   cpus.size should be (3)
   val displays: List[Display] = partLists[Display]
   displays.size should be (2)
   
   val cpu: CPU = partLists[CPU].head
   cpu should equal (CPU(2.2))
   val display: Display = partLists[Display].tail.head
   display should equal (Display(1080))

   note that the API does not provide methods to add multiple key/value pairs at a time, as each pair needs to be type-checked separately.

   (code presented here is in typekey.typeKeyMap.ScaladocSpec.)

   TypeBound

   the upper bound on the type parameters passed to the TypeKey and Val types

   Val

   the parameterized type of the values in the map

   See also

   src/test/scala/typekey/typeKeyMap/ for many more examples

6.  trait WideningTypeBoundFunction [TypeBound, WiderTypeBound >: TypeBound, Arg[_ <: TypeBound], ReturnVal[_ <: WiderTypeBound]] extends AnyRef

   like a TypeBoundFunction, except that the type bound for the return value is wider than the type bound for the argument.

   like a TypeBoundFunction, except that the type bound for the return value is wider than the type bound for the argument. This is useful for mapWiden and mapValuesWiden methods in TypeKeyMap and TypeBoundMap that return a map with a wider type bound than the original.

   TypeBound

   the type bound to use for the argument type

   WiderTypeBound

   the type bound to use for the return value type

   Arg

   the argument type

   ReturnVal

   the return value type

   See also

   TypeBoundFunction