Variant vs has an implementation similar to Dynamic, except the contained value is one of the elements of the vs list, rather than being one particular instance of Typeable.

>>> v .!. _right
Nothing

>>> v .!. _left
Just 'x'

In some cases the pun quasiquote works with variants,

>>> let f [pun| left right |] = (left,right)
>>> f v
(Just 'x',Nothing)

>>> f w
(Nothing,Just 5)

>>> let add1 v = hMapV (Fun succ :: Fun '[Enum] '()) v

>>> f (add1 v)
(Just 'y',Nothing)

>>> f (add1 w)
(Nothing,Just 6)

This is only safe if the n'th element of vs has type Tagged t v

Safe when (e ~ e') given that

Tagged t e ~ HLookupByHNatR n v
Tagged t' e' ~ HLookupByHNatR n v'

hUpdateAtLabel is the safe version

in ghc>=7.8, coerce is probably a better choice

private destructor. This is safe only if the value contained actually has type e

This function is unsafe because it can lead to a runtime error when used together with the HExtend instance (.*.)

>>> print $ (Label :: Label "x") .=. (Nothing :: Maybe ()) .*. unsafeEmptyVariant
V{*** Exception: invalid variant

use mkVariant1 instead

x ~ Tagged s t

Make a Prism (Variant s) (Variant t) a b out of a Label.

See Data.HList.Labelable.hLens' is a more overloaded version.

Few type annotations are necessary because of the restriction that s and t have the same labels in the same order, and to get "t" the "a" in "s" is replaced with "b".

helper class for defining the Show instance

implementation of gunfold for Variant

In ghci

:set -ddump-deriv -XDeriveDataTypeable
data X a b c = A a | B b | C c deriving (Data,Typeable)

shows that gunfold is defined something like

gunfold k z c = case constrIndex c of
      1 -> k (z Ghci1.A)
      2 -> k (z Ghci1.B)
      _ -> k (z Ghci1.C)

If we instead had

type X a b c = Variant [Tagged "A" a, Tagged "B" b, Tagged "C" c]

Then we could write:

gunfold1 :: (forall b r. Data b => (b -> r) -> c r)
         -> Variant [Tagged "A" a, Tagged "B" b, Tagged "C" c]
gunfold1 f c = case constrIndex c of
      1 -> f mkA
      2 -> f mkB
      _ -> f mkC
  where mkA a = mkVariant (Label :: Label "A") (a :: a) v
        mkB b = mkVariant (Label :: Label "B") (b :: b) v
        mkC c = mkVariant (Label :: Label "C") (c :: c) v
        v = Proxy :: Proxy [Tagged "A" a, Tagged "B" b, Tagged "C" c]

where f = k.z

Apply a function to all possible elements of the variant

shortcut for applyAB . HMapV. hMap is more general

hMapOutV f = unvariant . hMapV f, except an ambiguous type variable is resolved by HMapOutV_gety

resolves an ambiguous type in hMapOutV

Similar to unvariant, except type variables in v will be made equal to e if possible. That allows the type of Nothing to be inferred as Maybe Char.

>>> unvariant' $ x .=. Nothing .*. mkVariant1 y 'y'
'y'

However, this difference leads to more local error messages (Couldn't match type ‘()’ with ‘Char’), rather than the following with unvariant:

Fail
   '("Variant",
     '[Tagged "left" Char, Tagged "right" ()],
     "must have all values equal to ",
     e))

Convert a Variant which has all possibilities having the same type into a value of that type. Analogous to either id id.

See also unvariant'

Lens (Variant s) (Variant t) a b

Analogue of Control.Lens.chosen :: Lens (Either a a) (Either b b) a b

Lens' (Variant s) a

where we might have s ~ '[Tagged t1 a, Tagged t2 a]

Applies to variants that have the same labels in the same order. A generalization of

zipEither :: Either a b -> Either a b -> Maybe (Either (a,a) (b,b))
zipEither (Left a) (Left a') = Just (Left (a,a'))
zipEither (Right a) (Right a') = Just (Right (a,a'))
zipEither _ _ = Nothing

see HZip for zipping other collections

Apply a record of functions to a variant of values. The functions are selected based on those having the same label as the value.

>>> let xy = x .*. y .*. emptyProxy
>>> let p = Proxy `asLabelsOf` xy
>>> let vs = [ mkVariant x 1.0 p, mkVariant y () p ]

>>> zipVR (hBuild (+1) id) `map` vs
[V{x=2.0},V{y=()}]

Lets zipVR act as if ZipVR fs v v' had an FD v v' -> fs

ZipVRCxt [Tagged s f,  Tagged t g]
         [Tagged s fx, Tagged t gx]
         [Tagged s fy, Tagged t gy]
  = (f ~ (fx -> fy), g ~ (gx -> gy))

implemented like and (zipWith (==) xs ys). Behaves the same as the Eq instances for Variant

convert a variant with more fields into one with fewer (or the same) fields.

>>> let ty = Proxy :: Proxy [Tagged "left" Int, Tagged "right" Int]
>>> let l = mkVariant _left 1 ty
>>> let r = mkVariant _right 2 ty

>>> map projectVariant [l, r] :: [Maybe (Variant '[Tagged "left" Int])]
[Just V{left=1},Nothing]

rearrangeVariant = fromJust . projectVariant is one implementation of rearrangeVariant, since the result can have the same fields with a different order:

>>> let yt = Proxy :: Proxy [Tagged "right" Int, Tagged "left" Int]

>>> map projectVariant [l, r] `asTypeOf` [Just (mkVariant _left 0 yt)]
[Just V{left=1},Just V{right=2}]

projectExtendVariant = fmap extendVariant . projectVariant

where intermediate variant is as large as possible. Used to implement Data.HList.Labelable.projected

Note that:

>>> let r = projectExtendVariant (mkVariant1 Label 1 :: Variant '[Tagged "x" Int])
>>> r :: Maybe (Variant '[Tagged "x" Integer])
Nothing

projectVariant . extendsVariant = Just (when the types match up)

extendVariant is a special case

rearrangeVariant is a specialization of extendsVariant whose result is always . see also rearranged

Prism (Record tma) (Record tmb) (Variant ta) (Variant tb)

see hMaybied'

Prism' (Record tma) (Variant ta)

where tma and tmb are lists like

tma ~ '[Tagged x (Maybe a), Tagged y (Maybe b)]
ta  ~ '[Tagged x        a , Tagged y        b ]

If one element of the record is Just, the Variant will contain that element. Otherwise, the prism fails.

Note

The types work out to define a prism:

l = prism' variantToHMaybied (listToMaybe . hMaybiedToVariants)

but the law: s^?l ≡ Just a ==> l # a ≡ s is not followed, because we could have:

  s, s2 :: Record '[Tagged "x" (Maybe Int), Tagged "y" (Maybe Char)]
  s = hBuild (Just 1) (Just '2')
  s2 = hBuild (Just 1) Nothing

  v :: Variant '[Tagged "x" Int, Tagged "y" Char]
  v = mkVariant (Label :: Label "x") 1 Proxy

So that s^?l == Just v. But l#v == s2 /= s, while the law requires l#v == s. hMaybied avoids this problem by only producing a value when there is only one present.

Every element of the record that is Just becomes one element in the resulting list. See hMaybied' example types that r and v can take.