Data.Variant.Internal

newtype VariantRep a

Constructors

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

data VariantCase :: Type

data VariantFCase :: Type -> Type

class VariantTags rl  where

Members

• variantTags :: forall proxy. proxy rl -> List String

Instances

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

class Contractable gt lt  where

Members

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

Instances

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

class VariantMatchCases rl vo b | rl -> vo b

Instances

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

class VariantFMatchCases rl vo a b | rl -> vo a b

Instances

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

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

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

lookupLast :: forall a b. String -> (a -> b) -> List String -> List a -> { type :: String, value :: b }

lookupFirst :: forall a b. String -> (a -> b) -> List String -> List a -> { type :: String, value :: b }

lookupPred :: forall a. VariantRep a -> List String -> List (BoundedDict a) -> List (BoundedEnumDict a) -> Maybe (VariantRep a)

lookupSucc :: forall a. VariantRep a -> List String -> List (BoundedDict a) -> List (BoundedEnumDict a) -> Maybe (VariantRep a)

lookupCardinality :: forall a. List (BoundedEnumDict a) -> Int

lookupFromEnum :: forall a. VariantRep a -> List String -> List (BoundedEnumDict a) -> Int

lookupToEnum :: forall a. Int -> List String -> List (BoundedEnumDict a) -> Maybe (VariantRep a)

type BoundedDict a = { bottom :: a, top :: a }

type BoundedEnumDict a = { cardinality :: Int, fromEnum :: a -> Int, pred :: a -> Maybe a, succ :: a -> Maybe a, toEnum :: Int -> Maybe a }

impossible :: forall a. String -> a

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

Checks if a record has a key, using a string for the key.

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

Unsafely gets a value from a record, using a string for the key.

If the key does not exist this will cause a runtime error elsewhere.