A Which is an anonymous sum type (also known as a polymorphic variant, or co-record) which can only contain one of the types in the typelist. This is essentially a typed version of Dynamic.

The following functions are available can be used to manipulate unique types in the typelist

• constructor: pick
• destructor: trial
• injection: diversify and reinterpret
• catamorphism: which or switch

These functions are type specified. This means labels are not required because the types themselves can be used to access the Which. It is a compile error to use those functions for duplicate fields.

For duplicate types in the list of possible types, Nat-indexed version of the functions are available:

• constructor: pickN
• destructor: trialN
• inejction: diversifyN and reinterpretN
• catamorphism: whichN or switchN

Encoding: The variant contains a value whose type is at the given position in the type list. This is the same encoding as Haskus.Util.Variant and Data.Hlist.Variant.

The constructor is only exported in the Data.Diverse.Which.Internal module

Analogous to absurd. Renamed impossible to avoid conflicts.

Since 'Which '[]' values logically don't exist, this witnesses the logical reasoning tool of "ex falso quodlibet", ie "from falsehood, anything follows".

A 'Which '[]' is a Which with no alternatives, which may occur as a Left-over from trialing a Which '[x] with one type. It is an uninhabited type, just like Void

Lift a value into a Which of possibly other types xs. xs can be inferred or specified with TypeApplications. NB. forall is used to specify xs first, so TypeApplications can be used to specify xs first

pick 'A' @_ @'[Int, Bool, Char, Maybe String] :: Which '[Int, Bool, Char, Maybe String]

A variation of pick into a Which where x is the first type.

pick0 'A' :: Which '[Char, Int, Bool]

A variation of pick into a Which of a single type.

pickOnly 'A' :: Which '[Char]

A variation of pick where x is specified via a label

let y = pickL @Foo (Tagged (5 :: Int)) :: Which '[Bool, Tagged Foo Int, Tagged Bar Char]
    x = trialL @Foo y
x shouldBe (Right (Tagged 5))

Variation of pickL specialized to Tagged that automatically tags the value.

Lift a value into a Which of possibly other (possibley indistinct) types, where the value is the n-th type.

pickN @4 (5 :: Int) :: Which '[Bool, Int, Char, Bool, Int, Char]

It is obvious what value is inside a Which of one type.

let x = pick' 'A' :: Which '[Char]
obvious x `shouldBe` 'A'

trial a type in a Which and Either get the Right value or the Left-over possibilities.

let x = pick 'A' @'[Int, Bool, Char, Maybe String] :: Which '[Int, Bool, Char, Maybe String]
trial @Char x `shouldBe` Right 'A'
trial @Int x `shouldBe` Left (pick 'A') :: Which '[Bool, Char, Maybe String]

Variation of trial which returns a Maybe

A variation of a Which trial which trials the first type in the type list.

let x = pick 'A' @'[Int, Bool, Char, Maybe String] :: Which '[Int, Bool, Char, Maybe String]
trial0 x `shouldBe` Left (pick 'A') :: Which '[Bool, Char, Maybe String]

Variation of trial0 which returns a Maybe

A variation of trial where x is specified via a label

let y = pickL @Foo (Tagged (5 :: Int)) :: Which '[Bool, Tagged Foo Int, Tagged Bar Char]
    x = trialL @Foo Proxy y
x shouldBe (Right (Tagged 5))

Variation of trialL which returns a Maybe

Variation of trialL specialized to Tagged which untags the field.

Variation of trialL' specialized to Tagged which untags the field.

trialN the n-th type of a Which, and get Either the Right value or the Left-over possibilities.

let x = pick 'A' @_ @'[Int, Bool, Char, Maybe String] :: Which '[Int, Bool, Char, Maybe String]
trialN @1 x `shouldBe` Left (pick 'A') :: Which '[Int, Char, Maybe String]

Variation of trialN which returns a Maybe

A friendlier constraint synonym for diversify.

Convert a Which to another Which that may include other possibilities. That is, branch is equal or is a subset of tree.

This can also be used to rearrange the order of the types in the Which.

It is a compile error if tree has duplicate types with branch.

NB. Use TypeApplications with _ to specify tree@.

let a = pick' (5 :: Int) :: Which '[Int]
    b = diversify @_ @[Int, Bool] a :: Which '[Int, Bool]
    c = diversify @_ @[Bool, Int] b :: Which '[Bool, Int]

A restricted version of diversify which only rearranges the types

A simple version of diversify which add another type to the front of the typelist.

A variation of diversify where branchis additionally specified by a labels list.

let y = pickOnly (5 :: Tagged Bar Int)
    y' = diversifyL @'[Bar] y :: Which '[Tagged Bar Int, Tagged Foo Bool]
    y'' = diversifyL @'[Bar, Foo] y' :: Which '[Tagged Foo Bool, Tagged Bar Int]
switch y'' (CaseFunc @Typeable (show . typeRep . (pure @Proxy))) `shouldBe` "Tagged * Bar Int"

A friendlier constraint synonym for diversifyN.

A variation of diversify which uses a Nat list indices to specify how to reorder the fields, where

indices[branch_idx] = tree_idx

This variation allows tree to contain duplicate types with branch since the mapping is specified by indicies.

let y = pickOnly (5 :: Int)
    y' = diversifyN @'[0] @_ @[Int, Bool] y
    y'' = diversifyN @[1,0] @_ @[Bool, Int] y'
switch y'' (CaseFunc @Typeable (show . typeRep . (pure @Proxy))) `shouldBe` "Int"

A friendlier constraint synonym for reinterpret.

Convert a Which into possibly another Which with a totally different typelist. Returns either a Which with the Right value, or a Which with the Leftover compliment types.

It is a compile error if branch or compliment has duplicate types with tree.

NB. forall used to specify branch first, so TypeApplications can be used to specify branch first.

    let a = pick @[Int, Char, Bool] (5 :: Int) :: Which '[Int, Char, Bool]
    let  b = reinterpret [String, Char] y
    b `shouldBe` Left (pick (5 :: Int)) :: Which '[Int, Bool]
    let c = reinterpret [String, Int] a
    c `shouldBe` Right (pick (5 :: Int)) :: Which '[String, Int]

A friendlier constraint synonym for reinterpret'.

Variation of reinterpret which returns a Maybe.

A variation of reinterpret where the branch is additionally specified with a labels list.

let y = pick @[Tagged Bar Int, Tagged Foo Bool, Tagged Hi Char, Tagged Bye Bool] (5 :: Tagged Bar Int)
    y' = reinterpretL @[Foo, Bar] y
    x = pick @[Tagged Foo Bool, Tagged Bar Int] (5 :: Tagged Bar Int)
y' `shouldBe` Right x

Variation of reinterpretL which returns a Maybe.

A friendlier constraint synonym for reinterpretN.

A limited variation of reinterpret which uses a Nat list n to specify how to reorder the fields, where

indices[branch_idx] = tree_idx

This variation allows tree to contain duplicate types with branch since the mapping is specified by indicies.

However, unlike reinterpert, in this variation, branch must be a subset of tree instead of any arbitrary Which. Also it returns a Maybe instead of Either.

This is so that the same indices can be used in narrowN.

A friendlier constraint synonym for switch.

Switcher is an instance of Reduce for which reiterates through the possibilities in a Which, delegating handling to Case, ensuring termination when Which only contains one type.

Catamorphism for Which. This is equivalent to flip switch.

A switch/case statement for Which. This is equivalent to flip which

Use Case instances like Cases to apply a Which of functions to a variant of values.

let y = pick (5 :: Int) :: Which '[Int, Bool]
switch y (
    cases (show @Bool
        ./ show @Int
        ./ nil)) `shouldBe` "5"

Or CaseFunc @Typeable to apply a polymorphic function that work on all Typeables.

let y = pick (5 :: Int) :: Which '[Int, Bool]
switch y (CaseFunc @Typeable (show . typeRep . (pure @Proxy))) `shouldBe` Int

Or you may use your own custom instance of Case.

A friendlier constraint synonym for switch.

SwitcherN is a variation of Switcher which reiterateNs through the possibilities in a Which, delegating work to CaseN, ensuring termination when Which only contains one type.

Catamorphism for Which. This is equivalent to flip switchN.

A switch/case statement for Which. This is equivalent to flip whichN

Use Case instances like CasesN to apply a Which of functions to a variant of values in index order.

let y = pickN @0 (5 :: Int) :: Which '[Int, Bool, Bool, Int]
switchN y (
    casesN (show @Int
        ./ show @Bool
        ./ show @Bool
        ./ show @Int
        ./ nil)) `shouldBe` "5"

Or you may use your own custom instance of Case.