emblem
a reflective signature for a type.
a reflective signature for a type. provides name information, properties, and a tool used to build new instances. the underlying type is treated as immutable, so each property provides a setter that returns a new instance. new instances can be built using a HasEmblemBuilder returned by method builder.
the type that this emblem reflects upon
a TypeKeyMap of HasEmblem to Emblem
an emblem property.
an emblem property. the property belongs to an Emblem, has a name, and a getter and a setter. because the emblem is treated as an immutable object, the setter returns a new instance.
the type that the containing emblem reflects upon
the property value type
a property path that recurses through an emblem tree to a specific leaf
describes an injective relation between two types, Domain and Range.
describes an injective relation between two types, Domain and Range.
every value in the domain maps to a unique value in the range. however, not
all values in the range map back onto the domain. the Range type is
typically a richer type, such as a case class with a single parameter, and
the Domain type is the type wrapped by the case class.
provides functions for mapping between the range and domain types, as well as type keys for the two types. for example:
case class Uri(uri: String) val extractor = Extractor[Uri, String] extractor.domainTypeKey should equal (typeKey[Uri]) extractor.rangeTypeKey should equal (typeKey[String]) extractor.apply(Uri("someUri")) should equal ("someUri") extractor.unapply("someUri") should equal (Some(Uri("someUri")))
the domain type
the range type
an extractor with the domain type unspecified.
an extractor with the domain type unspecified. this type is equivalent to
Extractor[Domain, _], except with a single type parameter Domain. this allows the extractor to be used
as a key or value in a TypeBoundMap or TypeKeyMap
ExtractorPool
A TypeKeyMap of Domain to Extractor
a no-arg function with return type A
a marker trait for a type that we want to reflect upon with an Emblem
a builder of objects that have an emblem.
a builder of objects that have an emblem.
the type of the object to build
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.
the type bound to use for the argument and return value types
the argument type
the return value type
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 ++ or similar 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 TypeBoundMapSpec.scala, up at the top)
the upper bound on the type parameters passed to the Key and Val types
the parameterized type of the keys in the map
the parameterized type of the values in the map
TypeBoundMapSpec.scala and BaseTypeBoundMapSpec.scala for many more examples
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
the upper bound on the type parameters passed into the A and B types of the two elements of this pair
the parameterized type of the first element of this pair
the parameterized type of the second element of this pair
the type param binding both the A and B types of the two elements of this pair
the first element of this type bound pair
the second element of this type bound pair
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 emblem, 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 = emblem.typeKey[List[String]]
or if you already have a TypeTag at hand:
val tag: TypeTag[A] = ??? val key = TypeKey(tag)
the type that we are keying one
the scala-reflect TypeTag for type A
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 ++ or similar methods to add multiple key/value pairs at a time, as
each pair needs to be type-checked separately.
(code presented here is in TypeKeyMapSpec.scala, up at the top)
the upper bound on the type parameters passed to the TypeKey and Val types
the parameterized type of the values in the map
TypeKeyMapSpec.scala and BaseTypeBoundMapSpec.scala for many more examples
ExtractorPool for an example of how to use type key maps when the value type is more sophisticated than just type with a single type parameter.
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.
the type bound to use for the argument type
the type bound to use for the return value type
the argument type
the return value type
TypeBoundFunction
an EmblemPropPath factory
the basic types are the leaf-level types that emblem knows how to process.
the basic types are the leaf-level types that emblem knows how to process. currently, the following basic type are supported:
BooleanCharorg.joda.time.DateTimeDoubleFloatIntLongString
a standard set of imports for emblem.
a standard set of imports for emblem. this will bring in all you need for basic emblem usage, and won't
pollute your namespace the way that import emblem._ will
general purpose functions for working with JSON
generally useful utility functions for working with strings
returns a TypeKey for the specified type A.
returns a TypeKey for the specified type A. this method will only work where a TypeTag is
implicitly available.
an implicit method for producing a TypeKey.
an implicit method for producing a TypeKey. this method allows type keys to be available implicitly
anywhere that the corresponding TypeTag is implicitly available.
a collection of utilities for reflecting on types