Names

Atomic names. AName is just an existential wrapper around things which are Typeable, Ord and Show.

Prism onto AName.

A (qualified) name is a (possibly empty) sequence of atomic names.

Class for those types which can be used as names. They must support Typeable (to facilitate extracting them from existential wrappers), Ord (for comparison and efficient storage) and Show.

To make an instance of IsName, you need not define any methods, just declare it.

WARNING: it is not recommended to use GeneralizedNewtypeDeriving in conjunction with IsName, since in that case the underlying type and the newtype will be considered equivalent when comparing names. For example:

    newtype WordN = WordN Int deriving (Show, Ord, Eq, Typeable, IsName)
  

is unlikely to work as intended, since (1 :: Int) and (WordN 1) will be considered equal as names. Instead, use

    newtype WordN = WordN Int deriving (Show, Ord, Eq, Typeable, IsName)
    instance IsName WordN
  

Convenient operator for writing qualified names with atomic components of different types. Instead of writing toName a1 <> toName a2 <> toName a3 you can just write a1 .> a2 .> a3.

Traversal over each name in a Name that matches the target type.

>>> toListOf eachName (a .> False .> b) :: String
"ab"
>>> a .> True .> b & eachName %~ not
a .> False .> b

Note that the type of the name is very important.

>>> sumOf eachName ((1::Int) .> (2 :: Integer) .> (3 :: Int)) :: Int
4
>>> sumOf eachName ((1::Int) .> (2 :: Integer) .> (3 :: Int)) :: Integer
2

Instances of Qualifiable are things which can be qualified by prefixing them with a name.