Composite.Record

Documentation

data Rec u a b :: forall u. (u -> *) -> [u] -> * where

A record is parameterized by a universe u, an interpretation f and a list of rows rs. The labels or indices of the record are given by inhabitants of the kind u; the type of values at any label r :: u is given by its interpretation f r :: *.

Constructors

RNil :: Rec u a ([] u)

(:&) :: Rec u a ((:) u r rs) infixr 7

Instances

MonadContext c ((->) (Record c))

Methods

askContext :: Record c -> Record c

localContext :: (Record c -> Record c) -> (Record c -> a) -> Record c -> a

TestCoercion u f => TestCoercion [u] (Rec u f)

Methods

testCoercion :: f a -> f b -> Maybe (Coercion (Rec u f) a b)

TestEquality u f => TestEquality [u] (Rec u f)

Methods

testEquality :: f a -> f b -> Maybe ((Rec u f :~: a) b)

Eq (Rec u f ([] u))

Methods

(==) :: Rec u f [u] -> Rec u f [u] -> Bool

(/=) :: Rec u f [u] -> Rec u f [u] -> Bool

(Eq (f r), Eq (Rec a f rs)) => Eq (Rec a f ((:) a r rs))

Methods

(==) :: Rec a f ((a ': r) rs) -> Rec a f ((a ': r) rs) -> Bool

(/=) :: Rec a f ((a ': r) rs) -> Rec a f ((a ': r) rs) -> Bool

Ord (Rec u f ([] u))

Methods

compare :: Rec u f [u] -> Rec u f [u] -> Ordering

(<) :: Rec u f [u] -> Rec u f [u] -> Bool

(<=) :: Rec u f [u] -> Rec u f [u] -> Bool

(>) :: Rec u f [u] -> Rec u f [u] -> Bool

(>=) :: Rec u f [u] -> Rec u f [u] -> Bool

max :: Rec u f [u] -> Rec u f [u] -> Rec u f [u]

min :: Rec u f [u] -> Rec u f [u] -> Rec u f [u]

(Ord (f r), Ord (Rec a f rs)) => Ord (Rec a f ((:) a r rs))

Methods

compare :: Rec a f ((a ': r) rs) -> Rec a f ((a ': r) rs) -> Ordering

(<) :: Rec a f ((a ': r) rs) -> Rec a f ((a ': r) rs) -> Bool

(<=) :: Rec a f ((a ': r) rs) -> Rec a f ((a ': r) rs) -> Bool

(>) :: Rec a f ((a ': r) rs) -> Rec a f ((a ': r) rs) -> Bool

(>=) :: Rec a f ((a ': r) rs) -> Rec a f ((a ': r) rs) -> Bool

max :: Rec a f ((a ': r) rs) -> Rec a f ((a ': r) rs) -> Rec a f ((a ': r) rs)

min :: Rec a f ((a ': r) rs) -> Rec a f ((a ': r) rs) -> Rec a f ((a ': r) rs)

RecAll u f rs Show => Show (Rec u f rs)

Records may be shown insofar as their points may be shown. reifyConstraint is used to great effect here.

Methods

showsPrec :: Int -> Rec u f rs -> ShowS

show :: Rec u f rs -> String

showList :: [Rec u f rs] -> ShowS

Monoid (Rec u f ([] u))

Methods

mempty :: Rec u f [u]

mappend :: Rec u f [u] -> Rec u f [u] -> Rec u f [u]

mconcat :: [Rec u f [u]] -> Rec u f [u]

(Monoid (f r), Monoid (Rec a f rs)) => Monoid (Rec a f ((:) a r rs))

Methods

mempty :: Rec a f ((a ': r) rs)

mappend :: Rec a f ((a ': r) rs) -> Rec a f ((a ': r) rs) -> Rec a f ((a ': r) rs)

mconcat :: [Rec a f ((a ': r) rs)] -> Rec a f ((a ': r) rs)

Storable (Rec u f ([] u))

Methods

sizeOf :: Rec u f [u] -> Int

alignment :: Rec u f [u] -> Int

peekElemOff :: Ptr (Rec u f [u]) -> Int -> IO (Rec u f [u])

pokeElemOff :: Ptr (Rec u f [u]) -> Int -> Rec u f [u] -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Rec u f [u])

pokeByteOff :: Ptr b -> Int -> Rec u f [u] -> IO ()

peek :: Ptr (Rec u f [u]) -> IO (Rec u f [u])

poke :: Ptr (Rec u f [u]) -> Rec u f [u] -> IO ()

(Storable (f r), Storable (Rec a f rs)) => Storable (Rec a f ((:) a r rs))

Methods

sizeOf :: Rec a f ((a ': r) rs) -> Int

alignment :: Rec a f ((a ': r) rs) -> Int

peekElemOff :: Ptr (Rec a f ((a ': r) rs)) -> Int -> IO (Rec a f ((a ': r) rs))

pokeElemOff :: Ptr (Rec a f ((a ': r) rs)) -> Int -> Rec a f ((a ': r) rs) -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Rec a f ((a ': r) rs))

pokeByteOff :: Ptr b -> Int -> Rec a f ((a ': r) rs) -> IO ()

peek :: Ptr (Rec a f ((a ': r) rs)) -> IO (Rec a f ((a ': r) rs))

poke :: Ptr (Rec a f ((a ': r) rs)) -> Rec a f ((a ': r) rs) -> IO ()

type Record = Rec Identity

The type of regular plain records where each field has a value, equal to Rec Identity.

pattern (:*:) :: forall a rs s. a -> Rec * Identity rs -> Rec * Identity ((:) * ((:->) s a) rs) infixr 5

Bidirectional pattern matching the first field of a record using :-> values and the Identity functor.

This pattern is bidirectional meaning you can use it either as a pattern or a constructor, e.g.

  let rec = 123 :*: Just "foo" :*: RNil
      foo :*: bar :*: RNil = rec

Mnemonic: * for products.

pattern (:^:) :: forall f a rs s. Functor f => f a -> Rec * f rs -> Rec * f ((:) * ((:->) s a) rs) infixr 5

Bidirectional pattern matching the first field of a record using :-> values and any functor.

This pattern is bidirectional meaning you can use it either as a pattern or a constructor, e.g.

  let rec = Just 123 :^: Just "foo" :^: RNil
      Just foo :^: Just bar :^: RNil = rec

Mnemonic: ^ for products (record) of products (functor).

newtype s :-> a

Some value of type a tagged with a symbol indicating its field name or label. Used as the usual type of elements in a Rec or Record.

Recommended pronunciation: record val.

Constructors

Val

Fields

• getVal :: a

Instances

Monad ((:->) s)

Methods

(>>=) :: (s :-> a) -> (a -> s :-> b) -> s :-> b

(>>) :: (s :-> a) -> (s :-> b) -> s :-> b

return :: a -> s :-> a

fail :: String -> s :-> a

Functor ((:->) s)

Methods

fmap :: (a -> b) -> (s :-> a) -> s :-> b

(<$) :: a -> (s :-> b) -> s :-> a

Applicative ((:->) s)

Methods

pure :: a -> s :-> a

(<*>) :: (s :-> (a -> b)) -> (s :-> a) -> s :-> b

(*>) :: (s :-> a) -> (s :-> b) -> s :-> b

(<*) :: (s :-> a) -> (s :-> b) -> s :-> a

Foldable ((:->) s)

Methods

fold :: Monoid m => (s :-> m) -> m

foldMap :: Monoid m => (a -> m) -> (s :-> a) -> m

foldr :: (a -> b -> b) -> b -> (s :-> a) -> b

foldr' :: (a -> b -> b) -> b -> (s :-> a) -> b

foldl :: (b -> a -> b) -> b -> (s :-> a) -> b

foldl' :: (b -> a -> b) -> b -> (s :-> a) -> b

foldr1 :: (a -> a -> a) -> (s :-> a) -> a

foldl1 :: (a -> a -> a) -> (s :-> a) -> a

toList :: (s :-> a) -> [a]

null :: (s :-> a) -> Bool

length :: (s :-> a) -> Int

elem :: Eq a => a -> (s :-> a) -> Bool

maximum :: Ord a => (s :-> a) -> a

minimum :: Ord a => (s :-> a) -> a

sum :: Num a => (s :-> a) -> a

product :: Num a => (s :-> a) -> a

Traversable ((:->) s)

Methods

traverse :: Applicative f => (a -> f b) -> (s :-> a) -> f (s :-> b)

sequenceA :: Applicative f => (s :-> f a) -> f (s :-> a)

mapM :: Monad m => (a -> m b) -> (s :-> a) -> m (s :-> b)

sequence :: Monad m => (s :-> m a) -> m (s :-> a)

Bounded a => Bounded ((:->) s a)

Methods

minBound :: s :-> a

maxBound :: s :-> a

Enum a => Enum ((:->) s a)

Methods

succ :: (s :-> a) -> s :-> a

pred :: (s :-> a) -> s :-> a

toEnum :: Int -> s :-> a

fromEnum :: (s :-> a) -> Int

enumFrom :: (s :-> a) -> [s :-> a]

enumFromThen :: (s :-> a) -> (s :-> a) -> [s :-> a]

enumFromTo :: (s :-> a) -> (s :-> a) -> [s :-> a]

enumFromThenTo :: (s :-> a) -> (s :-> a) -> (s :-> a) -> [s :-> a]

Eq a => Eq ((:->) s a)

Methods

(==) :: (s :-> a) -> (s :-> a) -> Bool

(/=) :: (s :-> a) -> (s :-> a) -> Bool

Floating a => Floating ((:->) s a)

Methods

pi :: s :-> a

exp :: (s :-> a) -> s :-> a

log :: (s :-> a) -> s :-> a

sqrt :: (s :-> a) -> s :-> a

(**) :: (s :-> a) -> (s :-> a) -> s :-> a

logBase :: (s :-> a) -> (s :-> a) -> s :-> a

sin :: (s :-> a) -> s :-> a

cos :: (s :-> a) -> s :-> a

tan :: (s :-> a) -> s :-> a

asin :: (s :-> a) -> s :-> a

acos :: (s :-> a) -> s :-> a

atan :: (s :-> a) -> s :-> a

sinh :: (s :-> a) -> s :-> a

cosh :: (s :-> a) -> s :-> a

tanh :: (s :-> a) -> s :-> a

asinh :: (s :-> a) -> s :-> a

acosh :: (s :-> a) -> s :-> a

atanh :: (s :-> a) -> s :-> a

log1p :: (s :-> a) -> s :-> a

expm1 :: (s :-> a) -> s :-> a

log1pexp :: (s :-> a) -> s :-> a

log1mexp :: (s :-> a) -> s :-> a

Fractional a => Fractional ((:->) s a)

Methods

(/) :: (s :-> a) -> (s :-> a) -> s :-> a

recip :: (s :-> a) -> s :-> a

fromRational :: Rational -> s :-> a

Integral a => Integral ((:->) s a)

Methods

quot :: (s :-> a) -> (s :-> a) -> s :-> a

rem :: (s :-> a) -> (s :-> a) -> s :-> a

div :: (s :-> a) -> (s :-> a) -> s :-> a

mod :: (s :-> a) -> (s :-> a) -> s :-> a

quotRem :: (s :-> a) -> (s :-> a) -> (s :-> a, s :-> a)

divMod :: (s :-> a) -> (s :-> a) -> (s :-> a, s :-> a)

toInteger :: (s :-> a) -> Integer

Num a => Num ((:->) s a)

Methods

(+) :: (s :-> a) -> (s :-> a) -> s :-> a

(-) :: (s :-> a) -> (s :-> a) -> s :-> a

(*) :: (s :-> a) -> (s :-> a) -> s :-> a

negate :: (s :-> a) -> s :-> a

abs :: (s :-> a) -> s :-> a

signum :: (s :-> a) -> s :-> a

fromInteger :: Integer -> s :-> a

Ord a => Ord ((:->) s a)

Methods

compare :: (s :-> a) -> (s :-> a) -> Ordering

(<) :: (s :-> a) -> (s :-> a) -> Bool

(<=) :: (s :-> a) -> (s :-> a) -> Bool

(>) :: (s :-> a) -> (s :-> a) -> Bool

(>=) :: (s :-> a) -> (s :-> a) -> Bool

max :: (s :-> a) -> (s :-> a) -> s :-> a

min :: (s :-> a) -> (s :-> a) -> s :-> a

Real a => Real ((:->) s a)

Methods

toRational :: (s :-> a) -> Rational

RealFloat a => RealFloat ((:->) s a)

Methods

floatRadix :: (s :-> a) -> Integer

floatDigits :: (s :-> a) -> Int

floatRange :: (s :-> a) -> (Int, Int)

decodeFloat :: (s :-> a) -> (Integer, Int)

encodeFloat :: Integer -> Int -> s :-> a

exponent :: (s :-> a) -> Int

significand :: (s :-> a) -> s :-> a

scaleFloat :: Int -> (s :-> a) -> s :-> a

isNaN :: (s :-> a) -> Bool

isInfinite :: (s :-> a) -> Bool

isDenormalized :: (s :-> a) -> Bool

isNegativeZero :: (s :-> a) -> Bool

isIEEE :: (s :-> a) -> Bool

atan2 :: (s :-> a) -> (s :-> a) -> s :-> a

RealFrac a => RealFrac ((:->) s a)

Methods

properFraction :: Integral b => (s :-> a) -> (b, s :-> a)

truncate :: Integral b => (s :-> a) -> b

round :: Integral b => (s :-> a) -> b

ceiling :: Integral b => (s :-> a) -> b

floor :: Integral b => (s :-> a) -> b

(KnownSymbol s, Show a) => Show ((:->) s a)

Methods

showsPrec :: Int -> (s :-> a) -> ShowS

show :: (s :-> a) -> String

showList :: [s :-> a] -> ShowS

IsString a => IsString ((:->) s a)

Methods

fromString :: String -> s :-> a

Semigroup a => Semigroup ((:->) s a)

Methods

(<>) :: (s :-> a) -> (s :-> a) -> s :-> a

sconcat :: NonEmpty (s :-> a) -> s :-> a

stimes :: Integral b => b -> (s :-> a) -> s :-> a

Monoid a => Monoid ((:->) s a)

Methods

mempty :: s :-> a

mappend :: (s :-> a) -> (s :-> a) -> s :-> a

mconcat :: [s :-> a] -> s :-> a

Storable a => Storable ((:->) s a)

Methods

sizeOf :: (s :-> a) -> Int

alignment :: (s :-> a) -> Int

peekElemOff :: Ptr (s :-> a) -> Int -> IO (s :-> a)

pokeElemOff :: Ptr (s :-> a) -> Int -> (s :-> a) -> IO ()

peekByteOff :: Ptr b -> Int -> IO (s :-> a)

pokeByteOff :: Ptr b -> Int -> (s :-> a) -> IO ()

peek :: Ptr (s :-> a) -> IO (s :-> a)

poke :: Ptr (s :-> a) -> (s :-> a) -> IO ()

Wrapped ((:->) s0 a0)

Associated Types

type Unwrapped ((:->) s0 a0) :: *

Methods

_Wrapped' :: Iso' (s0 :-> a0) (Unwrapped (s0 :-> a0))

(~) * ((:->) s0 a0) t0 => Rewrapped ((:->) s1 a1) t0

(KnownSymbol s, ReifyNames rs) => ReifyNames ((:) * ((:->) s a) rs)

Methods

reifyNames :: Rec * f ((* ': (s :-> a)) rs) -> Rec * ((* :. *) ((,) Text) f) ((* ': (s :-> a)) rs)

type Unwrapped ((:->) s0 a0)

type Unwrapped ((:->) s0 a0) = a0

val :: forall s a. a -> Identity (s :-> a)

Convenience function to make an Identity (s :-> a) with a particular symbol, used for named field construction.

For example:

  type FFoo = "foo" :-> Int
  type FBar = "bar" :-> String
  type FBaz = "baz" :-> Double
  type MyRecord = [FFoo, FBar, FBaz]

  myRecord1 :: Record MyRecord
  myRecord1
    =  val "foo" 123
    :& val "bar" "foobar"
    :& val "baz" 3.21
    :& RNil

  myRecord2 :: Record MyRecord
  myRecord2 = rcast
    $  val "baz" 3.21
    :& val "foo" 123
    :& val "bar" "foobar"
    :& RNil

In this example, both myRecord1 and myRecord2 have the same value, since rcast can reorder records.

valName :: forall s a. KnownSymbol s => (s :-> a) -> Text

Reflect the type level name of a named value s :-> a to a Text. For example, given "foo" :-> Int, yields "foo" :: Text

valWithName :: forall s a. KnownSymbol s => (s :-> a) -> (Text, a)

Extract the value and reflect the name of a named value.

type RElem r rs = RElem r rs (RIndex r rs)

Constraint expressing that r is in rs and providing the index of r in rs. Equal to RElem rs (RIndex r rs).

rlens :: (Functor g, RElem (s :-> a) rs, Functor g) => proxy (s :-> a) -> (a -> g a) -> Rec Identity rs -> g (Rec Identity rs)

Lens to a particular field of a record using the Identity functor.

For example, given:

  type FFoo = "foo" :-> Int
  type FBar = "bar" :-> String
  fBar_ :: Proxy FBar
  fBar_ = Proxy

  rec :: Rec Identity '[FFoo, FBar]
  rec = 123 :*: "hello!" :*: Nil

Then:

  view (rlens fBar_)               rec == "hello!"
  set  (rlens fBar_) "goodbye!"    rec == 123 :*: "goodbye!" :*: Nil
  over (rlens fBar_) (map toUpper) rec == 123 :*: "HELLO!"   :*: Nil

rlens' :: (Functor f, Functor g, RElem (s :-> a) rs, Functor g) => proxy (s :-> a) -> (f a -> g (f a)) -> Rec f rs -> g (Rec f rs)

Lens to a particular field of a record using any functor.

For example, given:

  type FFoo = "foo" :-> Int
  type FBar = "bar" :-> String
  fBar_ :: Proxy FBar
  fBar_ = Proxy

  rec :: Rec Maybe '[FFoo, FBar]
  rec = Just 123 :^: Just "hello!" :^: Nil

Then:

  view (rlens' fBar_)                      rec == Just "hello!"
  set  (rlens' fBar_) Nothing              rec == Just 123 :^: Nothing       :^: Nil
  over (rlens' fBar_) (fmap (map toUpper)) rec == Just 123 :^: Just "HELLO!" :^: Nil

type family AllHave (cs :: [u -> Constraint]) (as :: [u]) :: Constraint where ...

Type function which produces the cross product of constraints cs and types as.

For example, AllHave '[Eq, Ord] '[Int, Text] is equivalent to (Eq Int, Ord Int, Eq Text, Ord Text)

Equations

AllHave cs '[] = ()

AllHave cs (a ': as) = (HasInstances a cs, AllHave cs as)

type family HasInstances (a :: u) (cs :: [u -> Constraint]) :: Constraint where ...

Type function which produces a constraint on a for each constraint in cs.

For example, HasInstances Int '[Eq, Ord] is equivalent to (Eq Int, Ord Int).

Equations

HasInstances a '[] = ()

HasInstances a (c ': cs) = (c a, HasInstances a cs)

type family ValuesAllHave (cs :: [u -> Constraint]) (as :: [u]) :: Constraint where ...

Type function which produces the cross product of constraints cs and the values carried in a record rs.

For example, ValuesAllHave '[Eq, Ord] '["foo" :-> Int, "bar" :-> Text] is equivalent to (Eq Int, Ord Int, Eq Text, Ord Text)

Equations

ValuesAllHave cs '[] = ()

ValuesAllHave cs ((s :-> a) ': as) = (HasInstances a cs, ValuesAllHave cs as)

zipRecsWith :: (forall a. f a -> g a -> h a) -> Rec f as -> Rec g as -> Rec h as

zipWith for Rec's.

reifyDicts :: forall cs f rs proxy. (AllHave cs rs, RecApplicative rs) => proxy cs -> (forall proxy' a. HasInstances a cs => proxy' a -> f a) -> Rec f rs

Given a list of constraints cs, apply some function for each r in the target record type rs with proof that those constraints hold for r, generating a record with the result of each application.

recordToNonEmpty :: Rec (Const a) (r ': rs) -> NonEmpty a

Convert a provably nonempty Rec (Const a) rs to a NonEmpty a.

class ReifyNames rs where

Class which reifies the symbols of a record composed of :-> fields as Text.

Minimal complete definition

reifyNames

Methods

reifyNames :: Rec f rs -> Rec ((,) Text :. f) rs

Given a Rec f rs where each r in rs is of the form s :-> a, make a record which adds the Text for each s.

Instances

ReifyNames ([] *)

Methods

reifyNames :: Rec * f [*] -> Rec * ((* :. *) ((,) Text) f) [*]

(KnownSymbol s, ReifyNames rs) => ReifyNames ((:) * ((:->) s a) rs)

Methods

reifyNames :: Rec * f ((* ': (s :-> a)) rs) -> Rec * ((* :. *) ((,) Text) f) ((* ': (s :-> a)) rs)

class RecWithContext ss ts where

Class with rmap but which gives the natural transformation evidence that the value its working over is contained within the overall record ss.

Minimal complete definition

rmapWithContext

Methods

rmapWithContext :: proxy ss -> (forall r. r ∈ ss => f r -> g r) -> Rec f ts -> Rec g ts

Apply a natural transformation from f to g to each field of the given record, except that the natural transformation can be mildly unnatural by having evidence that r is in ss.

Instances

RecWithContext ss ([] *)

Methods

rmapWithContext :: proxy ss -> (forall r. (* ∈ r) ss => f r -> g r) -> Rec * f [*] -> Rec * g [*]

((∈) * r ss, RecWithContext ss ts) => RecWithContext ss ((:) * r ts)

Methods

rmapWithContext :: proxy ss -> (forall a. (* ∈ a) ss => f a -> g a) -> Rec * f ((* ': r) ts) -> Rec * g ((* ': r) ts)

type family RDelete (r :: u) (rs :: [u]) where ...

Type function which removes the first element r from a list rs, and doesn't expand if r is not present in rs.

Equations

RDelete r (r ': rs) = rs

RDelete r (s ': rs) = s ': RDelete r rs

type RDeletable r rs = (r ∈ rs, RDelete r rs ⊆ rs)

Constraint which reflects that an element r can be removed from rs using rdelete.

rdelete :: RDeletable r rs => proxy r -> Rec f rs -> Rec f (RDelete r rs)

Remove an element r from a Rec f rs. Note this is just a type constrained rcast.