Data.Variant.Internal

data FProxy (a :: Type -> Type)

Proxy for a Functor.

Constructors

• FProxy

newtype VariantRep a

Constructors

• VariantRep { type :: String, value :: a }

class VariantMatchCases (rl :: RowList) (vo :: Row Type) b | rl -> vo b

Instances

• (VariantMatchCases rl vo' b, RowCons sym a vo' vo, TypeEquals k (a -> b)) => VariantMatchCases (Cons sym k rl) vo b
• VariantMatchCases Nil () b

class VariantFMatchCases (rl :: RowList) (vo :: Row Type) a b | rl -> vo a b

Instances

• (VariantFMatchCases rl vo' a b, RowCons sym (FProxy f) vo' vo, TypeEquals k (f a -> b)) => VariantFMatchCases (Cons sym k rl) vo a b
• VariantFMatchCases Nil () a b

data VariantCase :: Type

data VariantFCase :: Type -> Type

class VariantTags (rl :: RowList)  where

Members

• variantTags :: RLProxy rl -> List String

Instances

• VariantTags Nil
• (VariantTags rs, IsSymbol sym) => VariantTags (Cons sym a rs)

lookupTag :: String -> List String -> Boolean

A specialized lookup function which bails early. Foldable's elem is always worst-case.

lookupEq :: List String -> List (VariantCase -> VariantCase -> Boolean) -> VariantRep VariantCase -> VariantRep VariantCase -> Boolean

lookupOrd :: List String -> List (VariantCase -> VariantCase -> Ordering) -> VariantRep VariantCase -> VariantRep VariantCase -> Ordering

lookup :: forall a. String -> String -> List String -> List a -> a

class Contractable gt lt  where

Members

• contractWith :: forall a f. Alternative f => RProxy gt -> RProxy lt -> String -> a -> f a

Instances

• (RowToList lt ltl, Union lt a gt, VariantTags ltl) => Contractable gt lt

unsafeHas :: forall r1. String -> Record r1 -> Boolean

unsafeGet :: forall a r. String -> Record r -> a

data RProxy (row :: Row Type)

Constructors

• RProxy

data RLProxy (rowList :: RowList)

Constructors

• RLProxy