SuperRecord.Variant

Documentation

data Variant (opts :: [*])

A variant is used to express that a values type is of any of the types tracked in the type level list.

Instances

(Eq t, Eq (Variant ts)) => Eq (Variant ((:) * t ts))

Methods

(==) :: Variant ((* ': t) ts) -> Variant ((* ': t) ts) -> Bool

(/=) :: Variant ((* ': t) ts) -> Variant ((* ': t) ts) -> Bool

Eq (Variant ([] *))

Methods

(==) :: Variant [*] -> Variant [*] -> Bool

(/=) :: Variant [*] -> Variant [*] -> Bool

(Ord t, Ord (Variant ts)) => Ord (Variant ((:) * t ts))

Methods

compare :: Variant ((* ': t) ts) -> Variant ((* ': t) ts) -> Ordering

(<) :: Variant ((* ': t) ts) -> Variant ((* ': t) ts) -> Bool

(<=) :: Variant ((* ': t) ts) -> Variant ((* ': t) ts) -> Bool

(>) :: Variant ((* ': t) ts) -> Variant ((* ': t) ts) -> Bool

(>=) :: Variant ((* ': t) ts) -> Variant ((* ': t) ts) -> Bool

max :: Variant ((* ': t) ts) -> Variant ((* ': t) ts) -> Variant ((* ': t) ts)

min :: Variant ((* ': t) ts) -> Variant ((* ': t) ts) -> Variant ((* ': t) ts)

Ord (Variant ([] *))

Methods

compare :: Variant [*] -> Variant [*] -> Ordering

(<) :: Variant [*] -> Variant [*] -> Bool

(<=) :: Variant [*] -> Variant [*] -> Bool

(>) :: Variant [*] -> Variant [*] -> Bool

(>=) :: Variant [*] -> Variant [*] -> Bool

max :: Variant [*] -> Variant [*] -> Variant [*]

min :: Variant [*] -> Variant [*] -> Variant [*]

(Show t, Show (Variant ts)) => Show (Variant ((:) * t ts))

Methods

showsPrec :: Int -> Variant ((* ': t) ts) -> ShowS

show :: Variant ((* ': t) ts) -> String

showList :: [Variant ((* ': t) ts)] -> ShowS

Show (Variant ([] *))

Methods

showsPrec :: Int -> Variant [*] -> ShowS

show :: Variant [*] -> String

showList :: [Variant [*]] -> ShowS

(ToJSON t, ToJSON (Variant ts)) => ToJSON (Variant ((:) * t ts))

Methods

toJSON :: Variant ((* ': t) ts) -> Value

toEncoding :: Variant ((* ': t) ts) -> Encoding

toJSONList :: [Variant ((* ': t) ts)] -> Value

toEncodingList :: [Variant ((* ': t) ts)] -> Encoding

ToJSON (Variant ([] *))

Methods

toJSON :: Variant [*] -> Value

toEncoding :: Variant [*] -> Encoding

toJSONList :: [Variant [*]] -> Value

toEncodingList :: [Variant [*]] -> Encoding

(FromJSON t, FromJSON (Variant ts)) => FromJSON (Variant ((:) * t ts))

Methods

parseJSON :: Value -> Parser (Variant ((* ': t) ts))

parseJSONList :: Value -> Parser [Variant ((* ': t) ts)]

FromJSON (Variant ([] *))

Methods

parseJSON :: Value -> Parser (Variant [*])

parseJSONList :: Value -> Parser [Variant [*]]

(NFData t, NFData (Variant ts)) => NFData (Variant ((:) * t ts))

Methods

rnf :: Variant ((* ': t) ts) -> ()

NFData (Variant ([] *))

Methods

rnf :: Variant [*] -> ()

type family VariantMember a opts where ...

Equations

VariantMember x (x ': xs) = True ~ True

VariantMember x (y ': ys) = VariantMember x ys

type VariantPos a opts = VariantPosHelper 1 a opts

emptyVariant :: Variant '[]

An empty Variant, equivalent to `()`

toVariant :: forall opts a pos. (KnownNat pos, VariantPos a opts ~ pos, VariantMember a opts) => a -> Variant opts

Convert a usual Haskell type into a Variant. It's very useful to provide type signatures for the Variants.

fromVariant :: forall opts a pos. (KnownNat pos, VariantPos a opts ~ pos, VariantMember a opts) => Variant opts -> Maybe a

Convert a Variant back to a usual Haskell type, returning Nothing if the variant is not of the desired type.

data VariantMatch r ts where

Constructors

VariantCase :: (t -> r) -> VariantMatch r ts -> VariantMatch r (t ': ts)

VariantEnd :: VariantMatch r '[]

VariantWildCard :: r -> VariantMatch r ts

class VariantMatcher r opts where

Pattern matching helper with totality check. Note that the performance of this pattern match is roughly like a normal pattern match. (See benchmarks)

Minimal complete definition

variantMatch

Methods

variantMatch :: Variant opts -> VariantMatch r opts -> r

Instances

VariantMatcher r ([] *)

Methods

variantMatch :: Variant [*] -> VariantMatch r [*] -> r

VariantMatcher r ts => VariantMatcher r ((:) * t ts)

Methods

variantMatch :: Variant ((* ': t) ts) -> VariantMatch r ((* ': t) ts) -> r

shrinkVariant :: Variant (t ': ts) -> Variant ts

Remove an option from a Variant

extendVariant :: Variant ts -> Variant (t ': ts)

Add an option to a Variant