Data.Microgroove

Immutable Heterogeneous Records

newtype Rec (f :: u -> *) (us :: [u])

A heterogeneous record represented by an untyped vector

Constructors

Rec# (Vector Any)

Bundled Patterns

pattern RNil :: us ~ '[] => Rec f us

Construct or pattern match an empty record, refining its type

pattern (:&) :: us' ~ (u ': us) => f u -> Rec f us -> Rec f us' infixr 5

Construct or pattern match a nonempty record, refining its type. Matching is O(1), prepending is O(n)

Instances

KnownNat (Length u ((:) u x xs)) => IsList (Rec u f ((:) u x xs))

Associated Types

type Item (Rec u f ((u ': x) xs)) :: *

Methods

fromList :: [Item (Rec u f ((u ': x) xs))] -> Rec u f ((u ': x) xs)

fromListN :: Int -> [Item (Rec u f ((u ': x) xs))] -> Rec u f ((u ': x) xs)

toList :: Rec u f ((u ': x) xs) -> [Item (Rec u f ((u ': x) xs))]

IsList (Rec u f ([] u))

Associated Types

type Item (Rec u f [u]) :: *

Methods

fromList :: [Item (Rec u f [u])] -> Rec u f [u]

fromListN :: Int -> [Item (Rec u f [u])] -> Rec u f [u]

toList :: Rec u f [u] -> [Item (Rec u f [u])]

Eq (Rec u f ([] u))

Methods

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

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

(KnownNat (Length k ((:) k x xs)), Fractional (Rec k f ((:) k x xs)), AllF k Floating f ((:) k x xs)) => Floating (Rec k f ((:) k x xs))

Methods

pi :: Rec k f ((k ': x) xs)

exp :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

log :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

sqrt :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

(**) :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

logBase :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

sin :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

cos :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

tan :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

asin :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

acos :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

atan :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

sinh :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

cosh :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

tanh :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

asinh :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

acosh :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

atanh :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

log1p :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

expm1 :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

log1pexp :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

log1mexp :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

Floating (Rec u f ([] u))

Methods

pi :: Rec u f [u]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(KnownNat (Length k ((:) k x xs)), AllF k Num f ((:) k x xs), AllF k Fractional f ((:) k x xs)) => Fractional (Rec k f ((:) k x xs))

Methods

(/) :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

recip :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

fromRational :: Rational -> Rec k f ((k ': x) xs)

Fractional (Rec u f ([] u))

Methods

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

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

fromRational :: Rational -> Rec u f [u]

(KnownNat (Length k ((:) k x xs)), AllF k Num f ((:) k x xs)) => Num (Rec k f ((:) k x xs))

Methods

(+) :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

(-) :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

(*) :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

negate :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

abs :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

signum :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

fromInteger :: Integer -> Rec k f ((k ': x) xs)

Num (Rec u f ([] u))

Methods

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

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

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

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

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

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

fromInteger :: Integer -> Rec u f [u]

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]

(Show (f x), Show (Rec a f xs)) => Show (Rec a f ((:) a x xs))

Methods

showsPrec :: Int -> Rec a f ((a ': x) xs) -> ShowS

show :: Rec a f ((a ': x) xs) -> String

showList :: [Rec a f ((a ': x) xs)] -> ShowS

Show (Rec u f ([] u))

Methods

showsPrec :: Int -> Rec u f [u] -> ShowS

show :: Rec u f [u] -> String

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

(KnownNat (Length k ((:) k x xs)), AllF k Monoid f ((:) k x xs)) => Monoid (Rec k f ((:) k x xs))

mappend fields pairwise

Methods

mempty :: Rec k f ((k ': x) xs)

mappend :: Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs) -> Rec k f ((k ': x) xs)

mconcat :: [Rec k f ((k ': x) xs)] -> Rec k f ((k ': x) xs)

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]

type Item (Rec u f ((:) u x xs))

type Item (Rec u f ((:) u x xs)) = Any *

type Item (Rec u f ([] u))

type Item (Rec u f ([] u)) = Any *

Mutable / Immutable Conversions

thaw :: PrimMonad m => Rec f us -> m (MRec (PrimState m) f us)

Copy a record into a fresh mutable record. O(n)

thaw# :: PrimMonad m => Rec f us -> m (MRec (PrimState m) f us)

unsafely thaw a record. The original record should no longer be used, but this is not checked. O(1)

freeze :: PrimMonad m => MRec (PrimState m) f us -> m (Rec f us)

Copy a mutable record into a fresh record. O(n)

freeze# :: PrimMonad m => MRec (PrimState m) f us -> m (Rec f us)

Unsafely freeze a mutable record. The original record should no longer be modified, but this is not checked. O(1)

Constructing Records

new :: forall (c :: * -> Constraint) (xs :: [*]) f. (AllF c f xs, KnownNat (Length xs)) => (forall x. c (f x) => f x) -> Rec f xs

construct a record with values given by the constrained expression. Ex:

new @Num @'[Int,Double,Word] @Sum (3 * 2) = Sum (6::Int) :& Sum (6.0::Double) :& Sum (6::Word) :& RNil

O(n)

new' :: forall (c :: * -> Constraint) (xs :: [k]) f. (AllF c f xs, KnownNat (Length xs)) => (forall x. c (f x) => f x) -> Rec f xs

Create a recoord with values given by the constrained expression. Like new but polykinded. O(n)

fromVectorN :: forall n f x. KnownNat n => Vector (f x) -> Maybe (Rec f (Replicate n x))

Convert a vector into a homogeneous record of statically known size. O(1)

fromVector :: forall f (x :: u). Vector (f x) -> Some (Rec f)

Convert a vector into a homogeneous record with dynamically known size. O(n)

replicate :: forall n f x. KnownNat n => f x -> Rec f (Replicate n x)

Create a record of statically known size by replicating a single element. O(n)

Modifying Records

modify :: forall n f xs y. KnownNat n => (f (xs !! n) -> f y) -> Rec f xs -> Rec f (SetAt n xs y)

Transform a record by appling an endofunctor at the index. O(n)

rmap :: (forall x. f x -> g x) -> Rec f xs -> Rec g xs

Transform a record by mapping a natural tranformation over each element. O(n)

rmapM :: forall m f g xs. PrimMonad m => (forall x. f x -> m (g x)) -> Rec f xs -> m (Rec g xs)

Traverse a record by mapping an effectful natural tranformation over each element. O(n)

Modification With Constraint

crmap :: forall c g f xs. AllF c f xs => (forall x. c (f x) => f x -> g x) -> Rec f xs -> Rec g xs

Transform a record by mapping a natural tranformation that can make use of the provided constraint. Ex:

crmap @Show (K . show) :: (Rec f xs) -> (MRec (K String) xs)

O(n)

crmapM :: forall c m g f xs. (PrimMonad m, AllF c f xs) => (forall x. c (f x) => f x -> m (g x)) -> Rec f xs -> m (Rec g xs)

Traverse a record by mapping an effectful constrained tranformation. O(n)

Combining Records

rappend :: Rec f as -> Rec f bs -> Rec f (as ++ bs)

Append two records. O(n+m)

rzip :: forall h (f :: k -> *) g (xs :: [k]). (forall x. f x -> g x -> h x) -> Rec f xs -> Rec g xs -> Rec h xs

Zip two records together with a natural combiner. O(n)

Combining with Constraint

crzip :: forall (c :: * -> Constraint) h f g (xs :: [Type]). (AllF c f xs, AllF c g xs) => (forall x. (c (f x), c (g x)) => f x -> g x -> h x) -> Rec f xs -> Rec g xs -> Rec h xs

Deconstructing Records

splitCons :: Rec f (x ': xs) -> (f x, Rec f xs)

Split a record into a head element, and the remaining record must be statically known to be nonempty. O(1)

foldMapF :: forall r f xs. Monoid r => (forall x. f x -> r) -> Rec f xs -> r

Convert a record to a vector by mapping to a homogeneous type. O(n)

Fold over a record by naturally mapping to a Monoid accumulator

toVector :: (forall x. f x -> r) -> Rec f xs -> Vector r

Convert a record to a vector by mapping to a homogeneous type. O(n)

Deconstructing with Constraint

cfoldMapF :: forall (c :: * -> Constraint) r f xs. (AllF c f xs, Monoid r) => (forall x. c (f x) => f x -> r) -> Rec f xs -> r

Fold over a record by mapping to a Monoid accumulator

ctoVector :: forall c r f xs. AllF c f xs => (forall x. c (f x) => f x -> r) -> Rec f xs -> Vector r

Convert a record to a vector by mapping to a homogeneous type, making use of provided constraint. O(n)

Filtering Records

subRecord# :: forall ns f xs. (KnownNat (Length ns), KnownNats ns) => Rec f xs -> Rec f (SubList# ns xs)

Choose a satically known ordered subset of the fields in a record. Ex:

subRecord @'[0,2] ([1] :& "a" :& ["wow","what"] :& [[1,2,3], [4,5]] :& RNil)
= [1] :& ["wow","what"] :& RNil

ns must be in ascending order, but this is not checked. O(m)

Prepared Indicies into a Record

newtype Index (xs :: [u]) (x :: u)

A prepared index into a record, allowing fast access

Constructors

Index# Int

Bundled Patterns

pattern RZ :: Index (x ': xs) (x :: u)

Construct or pattern match the zero index, refining its type

pattern RS :: Index (xs :: [u]) (x :: u) -> Index (y ': xs) x

Construct or pattern match a successor index, refining its type

Instances

Show (Index u xs x)

Methods

showsPrec :: Int -> Index u xs x -> ShowS

show :: Index u xs x -> String

showList :: [Index u xs x] -> ShowS

Constructing Indicies

mkIndex :: forall n xs. (KnownNat n, n <= (Length xs - 1)) => Index xs (xs !! n)

Construct a statically known index into a record. O(1)

checkIndex :: forall (xs :: [*]). KnownNat (Length xs) => Int -> MaybeSome (Index xs)

Prepare a dynamically known index into a statically known record. O(n) and better constants than checkIndex'

checkDynIndex :: forall (xs :: [u]) f. Rec f xs -> Int -> MaybeSome (Index xs)

Prepare a dynamically known index. O(n)

Indexing

index :: forall n f xs. KnownNat n => Rec f xs -> f (xs !! n)

Index into a statically known element of a record. O(1)

(!) :: Rec f us -> Index us u -> f u

Index into a record with a prepared index. O(1)