Safe Haskell | None |
---|---|
Language | Haskell2010 |
- newtype Many xs = Many (Seq Any)
- class IsMany t xs a where
- fromMany' :: IsMany Tagged xs a => Many xs -> a
- toMany' :: IsMany Tagged xs a => a -> Many xs
- nil :: Many '[]
- single :: x -> Many '[x]
- prefix :: x -> Many xs -> Many (x ': xs)
- (./) :: x -> Many xs -> Many (x ': xs)
- postfix :: Many xs -> y -> Many (Append xs '[y])
- postfix' :: forall y xs. MaybeUniqueMember y xs => Many xs -> y -> Many (SnocUnique xs y)
- (\.) :: Many xs -> y -> Many (Append xs '[y])
- append :: Many xs -> Many ys -> Many (Append xs ys)
- class CanAppendUnique xs ys where
- (/./) :: Many xs -> Many ys -> Many (Append xs ys)
- viewf :: Many (x ': xs) -> (x, Many xs)
- viewb :: Many (x ': xs) -> (Many (Init (x ': xs)), Last (x ': xs))
- front :: Many (x ': xs) -> x
- back :: Many (x ': xs) -> Last (x ': xs)
- aft :: Many (x ': xs) -> Many xs
- fore :: Many (x ': xs) -> Many (Init (x ': xs))
- fetch :: forall x xs. UniqueMember x xs => Many xs -> x
- fetchL :: forall l xs proxy x. (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => proxy l -> Many xs -> x
- fetchN :: forall n xs proxy x. MemberAt n x xs => proxy n -> Many xs -> x
- replace :: forall x xs. UniqueMember x xs => Many xs -> x -> Many xs
- replace' :: forall x y xs proxy. UniqueMember x xs => proxy x -> Many xs -> y -> Many (Replace x y xs)
- replaceL :: forall l xs proxy x. (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => proxy l -> Many xs -> x -> Many xs
- replaceL' :: forall l y xs proxy x. (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => proxy l -> Many xs -> y -> Many (Replace x y xs)
- replaceN :: forall n xs proxy x. MemberAt n x xs => proxy n -> Many xs -> x -> Many xs
- replaceN' :: forall n y xs proxy x. MemberAt n x xs => proxy n -> Many xs -> y -> Many (ReplaceIndex n y xs)
- type Select smaller larger = AFoldable (CollectorAny (CaseSelect smaller larger) larger) (Maybe (Int, WrappedAny))
- select :: forall smaller larger. Select smaller larger => Many larger -> Many smaller
- selectL :: forall ls smaller larger proxy. (Select smaller larger, smaller ~ KindsAtLabels ls larger, IsDistinct ls, UniqueLabels ls larger) => proxy ls -> Many larger -> Many smaller
- type SelectN ns smaller larger = (AFoldable (CollectorAnyN (CaseSelectN ns smaller) 0 larger) (Maybe (Int, WrappedAny)), smaller ~ KindsAtIndices ns larger, IsDistinct ns)
- selectN :: forall ns smaller larger proxy. SelectN ns smaller larger => proxy ns -> Many larger -> Many smaller
- type Amend smaller larger = (AFoldable (CollectorAny (CaseAmend larger) smaller) (Int, WrappedAny), IsDistinct smaller)
- amend :: forall smaller larger. Amend smaller larger => Many larger -> Many smaller -> Many larger
- type Amend' smaller smaller' larger = (AFoldable (CollectorAny (CaseAmend' larger) (Zip smaller smaller')) (Int, WrappedAny), IsDistinct smaller)
- amend' :: forall smaller smaller' larger proxy. Amend' smaller smaller' larger => proxy smaller -> Many larger -> Many smaller' -> Many (Replaces smaller smaller' larger)
- amendL :: forall ls smaller larger proxy. (Amend smaller larger, smaller ~ KindsAtLabels ls larger, IsDistinct ls, UniqueLabels ls larger) => proxy ls -> Many larger -> Many smaller -> Many larger
- amendL' :: forall ls smaller smaller' larger proxy. (Amend' smaller smaller' larger, smaller ~ KindsAtLabels ls larger, IsDistinct ls, UniqueLabels ls larger) => proxy ls -> Many larger -> Many smaller' -> Many (Replaces smaller smaller' larger)
- type AmendN ns smaller larger = (AFoldable (CollectorAnyN (CaseAmendN ns larger) 0 smaller) (Int, WrappedAny), smaller ~ KindsAtIndices ns larger, IsDistinct ns)
- amendN :: forall ns smaller larger proxy. AmendN ns smaller larger => proxy ns -> Many larger -> Many smaller -> Many larger
- type AmendN' ns smaller smaller' larger = (AFoldable (CollectorAnyN (CaseAmendN' ns larger) 0 (Zip smaller smaller')) (Int, WrappedAny), smaller ~ KindsAtIndices ns larger, IsDistinct ns)
- amendN' :: forall ns smaller smaller' larger proxy. AmendN' ns smaller smaller' larger => proxy ns -> Many larger -> Many smaller' -> Many (ReplacesIndex ns smaller' larger)
- type Collect c r xs = (AFoldable (Collector c xs) r, Case (c r) xs)
- data Collector c xs r
- forMany :: Collect c r xs => c r xs -> Many xs -> Collector c xs r
- collect :: Collect c r xs => Many xs -> c r xs -> Collector c xs r
- type CollectN c r n xs = (AFoldable (CollectorN c n xs) r, Case (c r n) xs)
- data CollectorN c n xs r
- forManyN :: CollectN c r n xs => c r n xs -> Many xs -> CollectorN c n xs r
- collectN :: CollectN c r n xs => Many xs -> c r n xs -> CollectorN c n xs r
- splitBefore :: forall x xs proxy. UniqueMember x xs => proxy x -> Many xs -> (Many (Before x xs), Many (From x xs))
- splitBeforeL :: forall l xs proxy x. (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => proxy l -> Many xs -> (Many (Before x xs), Many (From x xs))
- splitBeforeN :: forall n xs proxy. (KnownNat n, (n + 1) <= Length xs) => proxy n -> Many xs -> (Many (BeforeIndex n xs), Many (FromIndex n xs))
- splitAfter :: forall x xs proxy. UniqueMember x xs => proxy x -> Many xs -> (Many (To x xs), Many (After x xs))
- splitAfterL :: forall l xs proxy x. (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => proxy l -> Many xs -> (Many (To x xs), Many (After x xs))
- splitAfterN :: forall n xs proxy. (KnownNat n, (n + 1) <= Length xs) => proxy n -> Many xs -> (Many (ToIndex n xs), Many (AfterIndex n xs))
- insetBefore :: forall x ys xs proxy. UniqueMember x xs => proxy x -> Many ys -> Many xs -> Many (Append (Before x xs) (Append ys (From x xs)))
- insetBeforeL :: forall l ys xs proxy x. (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => proxy l -> Many ys -> Many xs -> Many (Append (Before x xs) (Append ys (From x xs)))
- insetBeforeN :: forall n ys xs proxy. (KnownNat n, (n + 1) <= Length xs) => proxy n -> Many ys -> Many xs -> Many (Append (BeforeIndex n xs) (Append ys (FromIndex n xs)))
- insetAfter :: forall x ys xs proxy. UniqueMember x xs => proxy x -> Many ys -> Many xs -> Many (Append (To x xs) (Append ys (After x xs)))
- insetAfterL :: forall l ys xs proxy x. (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => proxy l -> Many ys -> Many xs -> Many (Append (To x xs) (Append ys (After x xs)))
- insetAfterN :: forall n ys xs proxy. (KnownNat n, (n + 1) <= Length xs) => proxy n -> Many ys -> Many xs -> Many (Append (ToIndex n xs) (Append ys (AfterIndex n xs)))
- insertBefore :: forall x y xs proxy. UniqueMember x xs => proxy x -> y -> Many xs -> Many (Append (Before x xs) (y ': From x xs))
- insertBeforeL :: forall l y xs proxy x. (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => proxy l -> y -> Many xs -> Many (Append (Before x xs) (y ': From x xs))
- insertBeforeN :: forall n y xs proxy. (KnownNat n, (n + 1) <= Length xs) => proxy n -> y -> Many xs -> Many (Append (BeforeIndex n xs) (y ': FromIndex n xs))
- insertAfter :: forall x y xs proxy. UniqueMember x xs => proxy x -> y -> Many xs -> Many (Append (To x xs) (y ': After x xs))
- insertAfterL :: forall l y xs proxy x. (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => proxy l -> y -> Many xs -> Many (Append (To x xs) (y ': After x xs))
- insertAfterN :: forall n y xs proxy. (KnownNat n, (n + 1) <= Length xs) => proxy n -> y -> Many xs -> Many (Append (ToIndex n xs) (y ': AfterIndex n xs))
- remove :: forall x xs proxy. UniqueMember x xs => proxy x -> Many xs -> Many (Remove x xs)
- removeL :: forall l xs proxy x. (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => proxy l -> Many xs -> Many (Remove x xs)
- removeN :: forall n xs proxy. (KnownNat n, (n + 1) <= Length xs) => proxy n -> Many xs -> Many (RemoveIndex n xs)
Many
type
A Many is an anonymous product type (also know as polymorphic record), with no limit on the number of fields.
The following functions are available can be used to manipulate unique fields
- getter/setter for single field:
fetch
andreplace
- getter/setter for multiple fields:
select
andamend
- folds:
forMany
orcollect
These functions are type specified. This means labels are not required because the types themselves can be used to access the 'Many. It is a compile error to use those functions for duplicate fields.
For duplicate fields, Nat-indexed versions of the functions are available:
- getter/setter for single field:
fetchN
andreplaceN
- getter/setter for multiple fields:
selectN
andamendN
- folds:
forManyN
orcollectN
Encoding: The record is encoded as (S.Seq Any). This encoding should reasonabily efficient for any number of fields.
The map Key is index + offset of the type in the typelist.
The Offset is used to allow efficient cons prefix
.
Key = Index of type in typelist + Offset
The constructor will guarantee the correct number and types of the elements. The constructor is only exported in the Data.Diverse.Many.Internal module
AFunctor Many_ c as => AFunctor Many c as Source # | Given a |
Eq (Many_ xs) => Eq (Many xs) Source # | Two |
Ord (Many_ xs) => Ord (Many xs) Source # | Two |
Read (Many_ xs) => Read (Many xs) Source # | read "5 . False . |
Show (Many_ xs) => Show (Many xs) Source # | show (5 :: Int) |
Generic (Many ((:) Type x xs)) Source # | A |
Generic (Many ([] Type)) Source # | |
Semigroup (Many_ xs) => Semigroup (Many xs) Source # | |
Monoid (Many_ xs) => Monoid (Many xs) Source # | |
(NFData x, NFData (Many xs)) => NFData (Many ((:) * x xs)) Source # | |
NFData (Many ([] Type)) Source # | |
type Rep (Many ((:) Type x xs)) Source # | |
type Rep (Many ([] Type)) Source # | |
Isomorphism
class IsMany t xs a where Source #
This instance allows converting to and from Many There are instances for converting tuples of up to size 15.
IsMany * (Tagged [Type]) ([] Type) () Source # | These instances add about 7 seconds to the compile time! |
IsMany * (Tagged [Type]) ((:) Type a ([] Type)) a Source # | This single field instance is the reason for |
IsMany * (Tagged [Type]) ((:) Type a ((:) Type b ([] Type))) (a, b) Source # | |
IsMany * (Tagged [Type]) ((:) Type a ((:) Type b ((:) Type c ([] Type)))) (a, b, c) Source # | |
IsMany * (Tagged [Type]) ((:) Type a ((:) Type b ((:) Type c ((:) Type d ([] Type))))) (a, b, c, d) Source # | |
IsMany * (Tagged [Type]) ((:) Type a ((:) Type b ((:) Type c ((:) Type d ((:) Type e ([] Type)))))) (a, b, c, d, e) Source # | |
IsMany * (Tagged [Type]) ((:) Type a ((:) Type b ((:) Type c ((:) Type d ((:) Type e ((:) Type f ([] Type))))))) (a, b, c, d, e, f) Source # | |
IsMany * (Tagged [Type]) ((:) Type a ((:) Type b ((:) Type c ((:) Type d ((:) Type e ((:) Type f ((:) Type g ([] Type)))))))) (a, b, c, d, e, f, g) Source # | |
IsMany * (Tagged [Type]) ((:) Type a ((:) Type b ((:) Type c ((:) Type d ((:) Type e ((:) Type f ((:) Type g ((:) Type h ([] Type))))))))) (a, b, c, d, e, f, g, h) Source # | |
IsMany * (Tagged [Type]) ((:) Type a ((:) Type b ((:) Type c ((:) Type d ((:) Type e ((:) Type f ((:) Type g ((:) Type h ((:) Type i ([] Type)))))))))) (a, b, c, d, e, f, g, h, i) Source # | |
IsMany * (Tagged [Type]) ((:) Type a ((:) Type b ((:) Type c ((:) Type d ((:) Type e ((:) Type f ((:) Type g ((:) Type h ((:) Type i ((:) Type j ([] Type))))))))))) (a, b, c, d, e, f, g, h, i, j) Source # | |
IsMany * (Tagged [Type]) ((:) Type a ((:) Type b ((:) Type c ((:) Type d ((:) Type e ((:) Type f ((:) Type g ((:) Type h ((:) Type i ((:) Type j ((:) Type k ([] Type)))))))))))) (a, b, c, d, e, f, g, h, i, j, k) Source # | |
IsMany * (Tagged [Type]) ((:) Type a ((:) Type b ((:) Type c ((:) Type d ((:) Type e ((:) Type f ((:) Type g ((:) Type h ((:) Type i ((:) Type j ((:) Type k ((:) Type l ([] Type))))))))))))) (a, b, c, d, e, f, g, h, i, j, k, l) Source # | |
IsMany * (Tagged [Type]) ((:) Type a ((:) Type b ((:) Type c ((:) Type d ((:) Type e ((:) Type f ((:) Type g ((:) Type h ((:) Type i ((:) Type j ((:) Type k ((:) Type l ((:) Type m ([] Type)))))))))))))) (a, b, c, d, e, f, g, h, i, j, k, l, m) Source # | |
IsMany * (Tagged [Type]) ((:) Type a ((:) Type b ((:) Type c ((:) Type d ((:) Type e ((:) Type f ((:) Type g ((:) Type h ((:) Type i ((:) Type j ((:) Type k ((:) Type l ((:) Type m ((:) Type n ([] Type))))))))))))))) (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source # | |
IsMany * (Tagged [Type]) ((:) Type a ((:) Type b ((:) Type c ((:) Type d ((:) Type e ((:) Type f ((:) Type g ((:) Type h ((:) Type i ((:) Type j ((:) Type k ((:) Type l ((:) Type m ((:) Type n ((:) Type o ([] Type)))))))))))))))) (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source # | |
fromMany' :: IsMany Tagged xs a => Many xs -> a Source #
Converts from a Many to a value (eg a tuple), via a Tagged wrapper
Construction
prefix :: x -> Many xs -> Many (x ': xs) infixr 5 Source #
Add an element to the left of a Many.
Not named cons
to avoid conflict with cons
postfix :: Many xs -> y -> Many (Append xs '[y]) infixl 5 Source #
Add an element to the right of a Many
Not named snoc
to avoid conflict with snoc
postfix' :: forall y xs. MaybeUniqueMember y xs => Many xs -> y -> Many (SnocUnique xs y) infixl 5 Source #
Add an element to the right of a Many iff the field doesn't already exist.
class CanAppendUnique xs ys where Source #
append' :: Many xs -> Many ys -> Many (AppendUnique xs ys) infixr 5 Source #
Appends the unique fields fields from the right Many using postfix'
CanAppendUnique xs ([] Type) Source # | |
(MaybeUniqueMember Type y xs, CanAppendUnique (SnocUnique Type xs y) ys, (~) [Type] (AppendUnique Type (SnocUnique Type xs y) ys) (AppendUnique Type xs ((:) Type y ys))) => CanAppendUnique xs ((:) Type y ys) Source # | |
Simple queries
viewf :: Many (x ': xs) -> (x, Many xs) Source #
Split a non-empty Many into the first element, then the rest of the Many.
Analogous to viewl
viewb :: Many (x ': xs) -> (Many (Init (x ': xs)), Last (x ': xs)) Source #
Split a non-empty Many into initial part of Many, and the last element.
Analogous to viewr
front :: Many (x ': xs) -> x Source #
Extract the first element of a Many, which guaranteed to be non-empty.
Analogous to head
aft :: Many (x ': xs) -> Many xs Source #
Extract the elements after the front of a Many, which guaranteed to be non-empty.
Analogous to tail
Single field
Getter for single field
fetch :: forall x xs. UniqueMember x xs => Many xs -> x Source #
fetchL :: forall l xs proxy x. (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => proxy l -> Many xs -> x Source #
Setter for single field
replace' :: forall x y xs proxy. UniqueMember x xs => proxy x -> Many xs -> y -> Many (Replace x y xs) Source #
replaceL :: forall l xs proxy x. (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => proxy l -> Many xs -> x -> Many xs Source #
Setter by unique label. Set the field with label l
.
let y = (5 :: Int)./
False./
Tagged @Foo 'X'./
Tagged @"Hello" (6 :: Int)./
nil
replaceL
@Foo Proxy y (Tagged @Foo 'Y') `shouldBe` (5 :: Int)./
False./
Tagged @Foo 'Y'./
Tagged @"Hello" (6 :: Int)./
nil
replaceL
@"Hello" Proxy y (Tagged @"Hello" 7) `shouldBe` (5 :: Int)./
False./
Tagged @Foo 'X'./
Tagged @"Hello" (7 :: Int)./
nil
replaceL' :: forall l y xs proxy x. (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => proxy l -> Many xs -> y -> Many (Replace x y xs) Source #
Polymorphic setter by unique type. Set the field with type x
, and replace with type y
let y = (5 :: Int)./
False./
Tagged @Foo 'X'./
Tagged @"Hello" (6 :: Int)./
nil
replaceL' @Foo Proxy y (Tagged @Bar 'Y')shouldBe
(5 :: Int)./
False./
TaggedBar
Hello (6 :: Int)Y
./
Tagged./
nil
replaceL' @"Hello" Proxy y (Tagged @"Hello" False) `shouldBe` (5 :: Int)./
False./
Tagged @Foo 'X'./
Tagged @"Hello" False./
nil
replaceN' :: forall n y xs proxy x. MemberAt n x xs => proxy n -> Many xs -> y -> Many (ReplaceIndex n y xs) Source #
Polymorphic version of replaceN
Multiple fields
Getter for multiple fields
type Select smaller larger = AFoldable (CollectorAny (CaseSelect smaller larger) larger) (Maybe (Int, WrappedAny)) Source #
A friendlier type constraint synomyn for select
select :: forall smaller larger. Select smaller larger => Many larger -> Many smaller Source #
Construct a Many
with a smaller number of fields than the original.
Analogous to fetch
getter but for multiple fields.
This can also be used to reorder fields in the original Many
.
let x = (5 :: Int)./
False./
'X'./
Just 'O'./
(6 :: Int)./
Just 'A'./
nil
select
@'[Bool, Char] x `shouldBe` False./
'X'./
nil
selectL :: forall ls smaller larger proxy. (Select smaller larger, smaller ~ KindsAtLabels ls larger, IsDistinct ls, UniqueLabels ls larger) => proxy ls -> Many larger -> Many smaller Source #
A variation of select
which selects by labels
let x = False./
Tagged @"Hi" (5 :: Int)./
Tagged @Foo False./
Tagged @Bar 'X'./
Tagged @"Bye"O
./
nil
selectL
@'[Foo, Bar] Proxy x `shouldBe` Tagged @Foo False./
Tagged @Bar 'X'./
nil
selectL
@'["Hi", "Bye"] Proxy x `shouldBe` Tagged @"Hi" (5 :: Int)./
Tagged @"Bye" 'O'./
nil
type SelectN ns smaller larger = (AFoldable (CollectorAnyN (CaseSelectN ns smaller) 0 larger) (Maybe (Int, WrappedAny)), smaller ~ KindsAtIndices ns larger, IsDistinct ns) Source #
A friendlier type constraint synomyn for selectN
selectN :: forall ns smaller larger proxy. SelectN ns smaller larger => proxy ns -> Many larger -> Many smaller Source #
A variation of select
which uses a Nat list n
to specify how to reorder the fields, where
indices[branch_idx] = tree_idx@
This variation allows smaller
or larger
to contain indistinct since
the mapping is specified by indicies
.
let x = (5 :: Int)./
False./
'X'./
Just 'O'./
(6 :: Int)./
Just 'A'./
nil
selectN
(Proxy @'[5, 4, 0]) x `shouldBe` Just 'A'./
(6 :: Int)./
(5 ::Int)./
nil
Setter for multiple fields
type Amend smaller larger = (AFoldable (CollectorAny (CaseAmend larger) smaller) (Int, WrappedAny), IsDistinct smaller) Source #
A friendlier type constraint synomyn for amend
amend :: forall smaller larger. Amend smaller larger => Many larger -> Many smaller -> Many larger Source #
type Amend' smaller smaller' larger = (AFoldable (CollectorAny (CaseAmend' larger) (Zip smaller smaller')) (Int, WrappedAny), IsDistinct smaller) Source #
A friendlier type constraint synomyn for amend'
amend' :: forall smaller smaller' larger proxy. Amend' smaller smaller' larger => proxy smaller -> Many larger -> Many smaller' -> Many (Replaces smaller smaller' larger) Source #
amendL :: forall ls smaller larger proxy. (Amend smaller larger, smaller ~ KindsAtLabels ls larger, IsDistinct ls, UniqueLabels ls larger) => proxy ls -> Many larger -> Many smaller -> Many larger Source #
A variation of amend
which amends via labels.
let x = False . Tagged @"Hi" (5 :: Int) . Tagged @Foo False . Tagged @Bar 'X' . Tagged @"Bye" 'O' ./nil
amendL
@'[Foo, Bar] Proxy x (Tagged @Foo True . Tagged @Bar 'Y' . nil)shouldBe
False . Tagged @"Hi" (5 :: Int) . Tagged @Foo True . Tagged @Bar 'Y' . Tagged @"Bye" 'O' ./nil
amendL
@'["Hi", "Bye"] Proxy x (Tagged @"Hi" (6 :: Int) . Tagged @"Bye" 'P' . nil)shouldBe
False . Tagged @"Hi" (6 :: Int) . Tagged @Foo False . Tagged @Bar 'X' . Tagged @"Bye" 'P' ./nil
amendL' :: forall ls smaller smaller' larger proxy. (Amend' smaller smaller' larger, smaller ~ KindsAtLabels ls larger, IsDistinct ls, UniqueLabels ls larger) => proxy ls -> Many larger -> Many smaller' -> Many (Replaces smaller smaller' larger) Source #
A variation of amend
which amends via labels.
let x = False./
Tagged @"Hi" (5 :: Int)./
Tagged @Foo False./
Tagged @BarX
./
Tagged @"Bye" 'O'./
nil
amendL'
@'[Foo, Bar] Proxy x ('Y'./
True./
ni
l) `shouldBe` False./
Tagged @"Hi" (5 :: Int)./
'Y'./
True./
Tagged @"Bye" 'O'./
nil
amendL'
@'["Hi", "Bye"] Proxy x (True./
Tagged @"Changed" True./
nil
) `shouldBe` False./
True./
Tagged @Foo False./
Tagged @Bar 'X'./
Tagged @"Changed" True./
nil
type AmendN ns smaller larger = (AFoldable (CollectorAnyN (CaseAmendN ns larger) 0 smaller) (Int, WrappedAny), smaller ~ KindsAtIndices ns larger, IsDistinct ns) Source #
A friendlier type constraint synomyn for amendN
amendN :: forall ns smaller larger proxy. AmendN ns smaller larger => proxy ns -> Many larger -> Many smaller -> Many larger Source #
A variation of amend
which uses a Nat list n
to specify how to reorder the fields, where
indices[branch_idx] = tree_idx@
This variation allows smaller
or larger
to contain indistinct since
the mapping is specified by indicies
.
let x = (5 :: Int)./
False./
'X'./
Just 'O'./
(6 :: Int)./
Just 'A'./
nil
amendN
(Proxy @'[5, 4, 0]) x (Just 'B'./
(8 :: Int)./
(4 ::Int)./
nil
) `shouldBe` (4 :: Int)./
False./
'X'./
Just 'O'./
(8 :: Int)./
Just 'B'./
nil
type AmendN' ns smaller smaller' larger = (AFoldable (CollectorAnyN (CaseAmendN' ns larger) 0 (Zip smaller smaller')) (Int, WrappedAny), smaller ~ KindsAtIndices ns larger, IsDistinct ns) Source #
A friendlier type constraint synomyn for amendN
amendN' :: forall ns smaller smaller' larger proxy. AmendN' ns smaller smaller' larger => proxy ns -> Many larger -> Many smaller' -> Many (ReplacesIndex ns smaller' larger) Source #
A polymorphic variation of amendN
Destruction
By type
data Collector c xs r Source #
Collects the output from case'
ing each field in a Many
.
Uses Reiterate
to prepare the Case
to accept the next type in the xs
typelist.
Internally, this holds the left-over [(k, v)] from the original Many
for the remaining typelist xs
.
That is, the first v in the (k, v) is of type x
, and the length of the list is equal to the length of xs
.
(Case (c r) ((:) Type x xs), Reiterate (c r) ((:) Type x xs), AFoldable (Collector * c xs) r, (~) * r (CaseResult * Type (c r) x)) => AFoldable (Collector * c ((:) Type x xs)) r Source # | |
AFoldable (Collector * c ([] Type)) r Source # | nill case that doesn't even use |
forMany :: Collect c r xs => c r xs -> Many xs -> Collector c xs r Source #
Folds any Many
, even with indistinct types.
Given distinct handlers for the fields in Many
, create AFoldable
of the results of running the handlers over the fields in Many
.
let x = (5 :: Int)./
False./
'X'./
Just 'O'./
(6 :: Int)./
Just 'A'./
nil
y = show @Int./
show @Char./
show @(Maybe Char)./
show @Bool./
nil
afoldr
(:) [] (forMany
(cases
y) x) `shouldBe` ["5", "False", "'X'", "Just 'O'", "6", "Just 'A'"]
By Nat index offset
data CollectorN c n xs r Source #
A variation of Collector
which uses ReiterateN
instead of Reiterate
(Case (c r n) ((:) Type x xs), ReiterateN (c r) n ((:) Type x xs), AFoldable (CollectorN * c ((+) n 1) xs) r, (~) * r (CaseResult * Type (c r n) x)) => AFoldable (CollectorN * c n ((:) Type x xs)) r Source # | Folds values by |
AFoldable (CollectorN * c n ([] Type)) r Source # | nill case that doesn't even use |
forManyN :: CollectN c r n xs => c r n xs -> Many xs -> CollectorN c n xs r Source #
Folds any Many
, even with indistinct types.
Given index handlers for the fields in Many
, create AFoldable
of the results of running the handlers over the fields in Many
.
let x = (5 :: Int)./
False./
'X'./
Just 'O'./
(6 :: Int)./
Just 'A'./
nil
y = show @Int./
show @Bool./
show @Char./
show @(Maybe Char)./
show @Int./
show @(Maybe Char)./
nil
afoldr
(:) [] (forManyN
(casesN
y) x) `shouldBe` ["5", "False", "'X'", "Just 'O'", "6", "Just 'A'"]
collectN :: CollectN c r n xs => Many xs -> c r n xs -> CollectorN c n xs r Source #
This is flip
forManyN
let x = (5 :: Int)./
False./
'X'./
Just 'O'./
(6 :: Int)./
Just 'A'./
nil
y = show @Int./
show @Bool./
show @Char./
show @(Maybe Char)./
show @Int./
show @(Maybe Char)./
nil
afoldr
(:) [] (collectN
x (casesN
y)) `shouldBe` ["5", "False", "'X'", "Just 'O'", "6", "Just 'A'"]
Splitting operations
Splitting
splitBefore :: forall x xs proxy. UniqueMember x xs => proxy x -> Many xs -> (Many (Before x xs), Many (From x xs)) Source #
Split a Many into two, where the first type in the second Many is unique x
splitBeforeL :: forall l xs proxy x. (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => proxy l -> Many xs -> (Many (Before x xs), Many (From x xs)) Source #
Split a Many into two, where the first type in the second Many is unique label l
splitBeforeN :: forall n xs proxy. (KnownNat n, (n + 1) <= Length xs) => proxy n -> Many xs -> (Many (BeforeIndex n xs), Many (FromIndex n xs)) Source #
Split a Many into two, where the second Many starts at index n
splitAfter :: forall x xs proxy. UniqueMember x xs => proxy x -> Many xs -> (Many (To x xs), Many (After x xs)) Source #
Split a Many into two, where the last type in the first Many is unique x
splitAfterL :: forall l xs proxy x. (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => proxy l -> Many xs -> (Many (To x xs), Many (After x xs)) Source #
Split a Many into two, where the last type in the first Many is unique label l
splitAfterN :: forall n xs proxy. (KnownNat n, (n + 1) <= Length xs) => proxy n -> Many xs -> (Many (ToIndex n xs), Many (AfterIndex n xs)) Source #
Split a Many into two, where the second Many starts at index (n + 1)
inset multiple items
insetBefore :: forall x ys xs proxy. UniqueMember x xs => proxy x -> Many ys -> Many xs -> Many (Append (Before x xs) (Append ys (From x xs))) Source #
Insert a Many into another Many, inserting before a unique x
insetBeforeL :: forall l ys xs proxy x. (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => proxy l -> Many ys -> Many xs -> Many (Append (Before x xs) (Append ys (From x xs))) Source #
Insert a Many into another Many, inserting before a unique label l
insetBeforeN :: forall n ys xs proxy. (KnownNat n, (n + 1) <= Length xs) => proxy n -> Many ys -> Many xs -> Many (Append (BeforeIndex n xs) (Append ys (FromIndex n xs))) Source #
Insert a Many into another Many, starting at index n
insetAfter :: forall x ys xs proxy. UniqueMember x xs => proxy x -> Many ys -> Many xs -> Many (Append (To x xs) (Append ys (After x xs))) Source #
Insert a Many into another Many, inserting after a unique x
insetAfterL :: forall l ys xs proxy x. (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => proxy l -> Many ys -> Many xs -> Many (Append (To x xs) (Append ys (After x xs))) Source #
Insert a Many into another Many, inserting after a unique label l
insetAfterN :: forall n ys xs proxy. (KnownNat n, (n + 1) <= Length xs) => proxy n -> Many ys -> Many xs -> Many (Append (ToIndex n xs) (Append ys (AfterIndex n xs))) Source #
Insert a Many into another Many, starting at index (n + 1)
insert single item
insertBefore :: forall x y xs proxy. UniqueMember x xs => proxy x -> y -> Many xs -> Many (Append (Before x xs) (y ': From x xs)) Source #
Insert an item into a Many, inserting before unique type x
insertBeforeL :: forall l y xs proxy x. (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => proxy l -> y -> Many xs -> Many (Append (Before x xs) (y ': From x xs)) Source #
Insert an item into a Many, inserting before unique label l
insertBeforeN :: forall n y xs proxy. (KnownNat n, (n + 1) <= Length xs) => proxy n -> y -> Many xs -> Many (Append (BeforeIndex n xs) (y ': FromIndex n xs)) Source #
Insert an item into a Many, inserting before index n
insertAfter :: forall x y xs proxy. UniqueMember x xs => proxy x -> y -> Many xs -> Many (Append (To x xs) (y ': After x xs)) Source #
Insert an item into a Many, inserting after unique type x
insertAfterL :: forall l y xs proxy x. (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => proxy l -> y -> Many xs -> Many (Append (To x xs) (y ': After x xs)) Source #
Insert an item into a Many, inserting after unique label l
insertAfterN :: forall n y xs proxy. (KnownNat n, (n + 1) <= Length xs) => proxy n -> y -> Many xs -> Many (Append (ToIndex n xs) (y ': AfterIndex n xs)) Source #
Insert an item into a Many, inserting after index n
Deleting single item
remove :: forall x xs proxy. UniqueMember x xs => proxy x -> Many xs -> Many (Remove x xs) Source #
Remove the unique x
from a Many.
Not named delete
to avoid conflicts with delete
removeL :: forall l xs proxy x. (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => proxy l -> Many xs -> Many (Remove x xs) Source #
Remove the unique label l
from a Many.