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 and replace
• getter/setter for multiple fields: select and amend
• folds: forMany or collect

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 and replaceN
• getter/setter for multiple fields: selectN and amendN
• folds: forManyN or collectN

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

This instance allows converting to and from Many There are instances for converting tuples of up to size 15.

Converts from a Many to a value (eg a tuple), via a Tagged wrapper

Converts from a value (eg a tuple) to a Many, via a Tagged wrapper

Analogous to null. Named nil to avoid conflicting with null.

Create a Many from a single value. Analogous to singleton

Add an element to the left of a Many. Not named cons to avoid conflict with cons

Infix version of prefix.

Mnemonic: Element on the left is smaller ./ than the larger Many to the right.

Add an element to the right of a Many Not named snoc to avoid conflict with snoc

Add an element to the right of a Many iff the field doesn't already exist.

Infix version of postfix.

Mnemonic: Many is larger \. than the smaller element

Appends two Manys together

Infix version of append.

Mnemonic: prefix ./ with an extra slash (meaning Many) in front.

Split a non-empty Many into the first element, then the rest of the Many. Analogous to viewl

Split a non-empty Many into initial part of Many, and the last element. Analogous to viewr

Extract the first element of a Many, which guaranteed to be non-empty. Analogous to head

Extract the back element of a Many, which guaranteed to be non-empty. Analogous to last

Extract the elements after the front of a Many, which guaranteed to be non-empty. Analogous to tail

Return all the elements of a Many except the back one, which guaranteed to be non-empty. Analogous to init

Getter by unique type. Get the field with type x.

let x = (5 :: Int) ./ False ./ 'X' ./ Just 'O' ./ nil
fetch @Int x `shouldBe` 5

Getter by label. Get the value of the field with tag label which can be any type not just KnownSymbol.

let y = False ./ Tagged @Foo 'X' ./ Tagged @Hi True ./ nil
fetchL @Foo y `shouldBe` Tagged @Foo 'X'
fetchL @Hi y `shouldBe` Tagged @Hi True

Variation of fetchL specialized for Tagged that untags the field.

Getter by index. Get the value of the field at index type-level Nat n

let x = (5 :: Int) ./ False ./ 'X' ./ Just 'O' ./ nil
fetchN @1 x `shouldBe` False

Polymorphic setter by unique type. Set the field with type x, and replace with type y

let x = (5 :: Int) ./ False ./ 'X' ./ Just 'O' ./ nil
replace @Int x (Just True) `shouldBe` Just True ./ False ./ 'X' ./ Just 'O' ./ nil

Setter by unique type. Set the field with type x.

let x = (5 :: Int) ./ False ./ 'X' ./ Just 'O' ./ nil
replace' @Int x 6 `shouldBe` (6 :: Int) ./ False ./ 'X' ./ Just 'O' ./ nil

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 y (Tagged @Bar 'Y') shouldBe
    (5 :: Int) ./ False ./ Tagged Bar Y ./ Tagged Hello (6 :: Int) ./ nil
replaceL @"Hello" y (Tagged @"Hello" False) `shouldBe`
    (5 :: Int) ./ False ./ Tagged @Foo 'X' ./ Tagged @"Hello" False ./ nil

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 y (Tagged @Foo 'Y') `shouldBe`
    (5 :: Int) ./ False ./ Tagged @Foo 'Y' ./ Tagged @"Hello" (6 :: Int) ./ nil
replaceL' @"Hello" y (Tagged @"Hello" 7) `shouldBe`
    (5 :: Int) ./ False ./ Tagged @Foo 'X' ./ Tagged @"Hello" (7 :: Int) ./ nil

Variation of replaceL specialized to Tagged that automatically tags the value to be replaced.

Variation of replaceL' specialized to Tagged that automatically tags the value to be replaced.

Polymorphic version of replaceN'

Setter by index. Set the value of the field at index type-level Nat n

let x = (5 :: Int) ./ False ./ 'X' ./ Just 'O' ./ nil
replaceN' @0 x 7 shouldBe

A friendlier type constraint synomyn for select

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

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] x `shouldBe` Tagged @Foo False ./ Tagged @Bar 'X' ./ nil
selectL @'["Hi", "Bye"] x `shouldBe` Tagged @"Hi" (5 :: Int) ./ Tagged @"Bye" 'O' ./ nil

A friendlier type constraint synomyn for selectN

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 @'[5, 4, 0] x `shouldBe` Just 'A' ./ (6 :: Int) ./ (5 ::Int) ./ nil

A friendlier type constraint synomyn for amend

Polymorphic version of amend'. Analogous to replace setter but for multiple fields.

A friendlier type constraint synomyn for amend'

Sets the subset of Many in the larger Many. Analogous to replace setter but for multiple fields.

let x = (5 :: Int) ./ False ./ 'X' ./ Just 'O' ./ nil
amend' @'[Int, Maybe Char] x ((6 :: Int) ./ Just 'P' ./ nil) `shouldBe`
    (6 :: Int) ./ False ./ 'X' ./ Just 'P' ./ nil

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] x ('Y' ./ True ./ nil) `shouldBe`
    False ./ Tagged @"Hi" (5 :: Int) ./ 'Y' ./ True ./ Tagged @"Bye" 'O' ./ nil
amendL @'["Hi", "Bye"] x (True ./ Tagged @"Changed" True ./ nil) `shouldBe`
    False ./ True ./ Tagged @Foo False ./ Tagged @Bar 'X' ./ Tagged @"Changed" True ./ nil

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] 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"] 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

A friendlier type constraint synomyn for amendN

A polymorphic variation of amendN'

A friendlier type constraint synomyn for amendN'

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' @'[5, 4, 0] x (Just 'B' ./ (8 :: Int) ./ (4 ::Int) ./ nil) `shouldBe`
    (4 :: Int) ./ False ./ 'X' ./ Just 'O' ./ (8 :: Int) ./ Just 'B' ./ nil

A friendlier type constraint synomyn for collect and forMany

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.

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'"]

This is flip forMany

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 (:) [] (collect x (cases y)) `shouldBe`
    ["5", "False", "'X'", "Just 'O'", "6", "Just 'A'"]

A friendlier type constraint synomyn for collect and forMany

A variation of Collector which uses ReiterateN instead of Reiterate

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'"]

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'"]