Safe Haskell | None |
---|---|
Language | Haskell2010 |
- newtype Rec (f :: u -> *) (us :: [u]) where
- thaw :: PrimMonad m => Rec f us -> m (MRec (PrimState m) f us)
- thaw# :: PrimMonad m => Rec f us -> m (MRec (PrimState m) f us)
- freeze :: PrimMonad m => MRec (PrimState m) f us -> m (Rec f us)
- freeze# :: PrimMonad m => MRec (PrimState m) f us -> m (Rec f us)
- new :: forall (c :: * -> Constraint) (xs :: [*]) f. (AllF c f xs, KnownNat (Length xs)) => (forall x. c (f x) => f x) -> Rec f xs
- new' :: forall (c :: * -> Constraint) (xs :: [k]) f. (AllF c f xs, KnownNat (Length xs)) => (forall x. c (f x) => f x) -> Rec f xs
- fromVectorN :: forall n f x. KnownNat n => Vector (f x) -> Maybe (Rec f (Replicate n x))
- fromVector :: forall f (x :: u). Vector (f x) -> Some (Rec f)
- replicate :: forall n f x. KnownNat n => f x -> Rec f (Replicate n x)
- modify :: forall n f xs y. KnownNat n => (f (xs !! n) -> f y) -> Rec f xs -> Rec f (SetAt n xs y)
- rmap :: (forall x. f x -> g x) -> Rec f xs -> Rec g xs
- rmapM :: forall m f g xs. PrimMonad m => (forall x. f x -> m (g x)) -> Rec f xs -> m (Rec g xs)
- 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
- 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)
- rappend :: Rec f as -> Rec f bs -> Rec f (as ++ bs)
- 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
- 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
- splitCons :: Rec f (x ': xs) -> (f x, Rec f xs)
- foldMapF :: forall r f xs. Monoid r => (forall x. f x -> r) -> Rec f xs -> r
- toVector :: (forall x. f x -> r) -> Rec f xs -> Vector r
- 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
- ctoVector :: forall c r f xs. AllF c f xs => (forall x. c (f x) => f x -> r) -> Rec f xs -> Vector r
- subRecord# :: forall ns f xs. (KnownNat (Length ns), KnownNats ns) => Rec f xs -> Rec f (SubList# ns xs)
- newtype Index (xs :: [u]) (x :: u) where
- mkIndex :: forall n xs. (KnownNat n, n <= (Length xs - 1)) => Index xs (xs !! n)
- checkIndex :: forall (xs :: [*]). KnownNat (Length xs) => Int -> MaybeSome (Index xs)
- checkDynIndex :: forall (xs :: [u]) f. Rec f xs -> Int -> MaybeSome (Index xs)
- index :: forall n f xs. KnownNat n => Rec f xs -> f (xs !! n)
- (!) :: Rec f us -> Index us u -> f u
Immutable Heterogeneous Records
newtype Rec (f :: u -> *) (us :: [u]) Source #
A heterogeneous record represented by an untyped vector
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) |
KnownNat (Length u ((:) u x xs)) => IsList (Rec u f ((:) u x xs)) Source # | |
IsList (Rec u f ([] u)) Source # | |
Eq (Rec u f ([] u)) Source # | |
(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)) Source # | |
Floating (Rec u f ([] u)) Source # | |
(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)) Source # | |
Fractional (Rec u f ([] u)) Source # | |
(KnownNat (Length k ((:) k x xs)), AllF k Num f ((:) k x xs)) => Num (Rec k f ((:) k x xs)) Source # | |
Num (Rec u f ([] u)) Source # | |
Ord (Rec u f ([] u)) Source # | |
(Show (f x), Show (Rec a f xs)) => Show (Rec a f ((:) a x xs)) Source # | |
Show (Rec u f ([] u)) Source # | |
(KnownNat (Length k ((:) k x xs)), AllF k Monoid f ((:) k x xs)) => Monoid (Rec k f ((:) k x xs)) Source # |
|
Monoid (Rec u f ([] u)) Source # | |
type Item (Rec u f ((:) u x xs)) Source # | |
type Item (Rec u f ([] u)) Source # | |
Mutable / Immutable Conversions
thaw :: PrimMonad m => Rec f us -> m (MRec (PrimState m) f us) Source #
Copy a record into a fresh mutable record. O(n)
thaw# :: PrimMonad m => Rec f us -> m (MRec (PrimState m) f us) Source #
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) Source #
Copy a mutable record into a fresh record. O(n)
freeze# :: PrimMonad m => MRec (PrimState m) f us -> m (Rec f us) Source #
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 Source #
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 Source #
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)) Source #
Convert a vector into a homogeneous record of statically known size. O(1)
fromVector :: forall f (x :: u). Vector (f x) -> Some (Rec f) Source #
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) Source #
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) Source #
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 Source #
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) Source #
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 Source #
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) Source #
Traverse a record by mapping an effectful constrained tranformation. O(n)
Combining Records
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 Source #
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 Source #
Deconstructing Records
splitCons :: Rec f (x ': xs) -> (f x, Rec f xs) Source #
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 Source #
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 Source #
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 Source #
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 Source #
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) Source #
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) Source #
A prepared index into a record, allowing fast access
Constructing Indicies
mkIndex :: forall n xs. (KnownNat n, n <= (Length xs - 1)) => Index xs (xs !! n) Source #
Construct a statically known index into a record. O(1)
checkIndex :: forall (xs :: [*]). KnownNat (Length xs) => Int -> MaybeSome (Index xs) Source #
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) Source #
Prepare a dynamically known index. O(n)