Safe Haskell | None |
---|---|

Language | Haskell2010 |

## Synopsis

- data Cases (fs :: [Type]) r (xs :: [Type])
- cases :: forall r xs fs. (AllConstrained ((~) r) (CaseResults (Cases fs r) fs), SameLength fs (Nub xs)) => Many fs -> Cases fs r xs
- cases' :: forall r xs fs. AllConstrained ((~) r) (CaseResults (Cases fs r) fs) => Many fs -> Cases fs r xs
- data CasesN (fs :: [Type]) r (n :: Nat) (xs :: [Type])
- casesN :: forall r xs fs. (AllConstrained ((~) r) (CaseResults (CasesN fs r 0) fs), SameLength fs xs) => Many fs -> CasesN fs r 0 xs
- casesN' :: forall r xs fs. AllConstrained ((~) r) (CaseResults (CasesN fs r 0) fs) => Many fs -> CasesN fs r 0 xs

# Documentation

data Cases (fs :: [Type]) r (xs :: [Type]) Source #

Contains a `Many`

of handlers/continuations for all the types in the `xs`

typelist.
This uses ** grab** to get the unique handler for the type at the

`Head`

of `xs`

.Use `cases`

to construct this with `SameLength`

constraint to reduce programming confusion.

## Instances

Reiterate (Cases fs r) xs Source # | |

UniqueMember (Head xs -> r) fs => Case (Cases fs r) xs Source # | UndecidableInstances because |

Defined in Data.Diverse.Cases | |

type CaseResult (Cases fs r :: [Type] -> Type) (x :: Type) Source # | |

Defined in Data.Diverse.Cases |

cases :: forall r xs fs. (AllConstrained ((~) r) (CaseResults (Cases fs r) fs), SameLength fs (Nub xs)) => Many fs -> Cases fs r xs Source #

Create an instance of `Case`

for either handling `switch`

ing a `Which`

.

let y =`pick`

(5 :: Int) ::`Which`

'[Int, Bool]`switch`

y (`cases`

(show @Bool`./`

show @Int`./`

`nul`

)) `shouldBe` "5"

Or for handling `collect`

from a `Many`

.

let x = (5 :: Int)`./`

False`./`

'X'`./`

Just 'O'`./`

(6 :: Int)`./`

Just 'A'`./`

`nul`

y = show @Int`./`

show @Char`./`

show @(Maybe Char)`./`

show @Bool`./`

`nul`

`afoldr`

(:) [] (`collect`

x (`cases`

y)) `shouldBe` ["5", "False", "`X`

", "Just 'O'", "6", "Just 'A'"]

This function imposes additional `SameLength`

constraints than when using the `Cases`

constructor directly.
It is better practice to use `cases`

to prevent programming confusion with dead code.
However, the `Cases`

constructor is still exported to allow creating a master-of-all-`Case`

.

cases' :: forall r xs fs. AllConstrained ((~) r) (CaseResults (Cases fs r) fs) => Many fs -> Cases fs r xs Source #

data CasesN (fs :: [Type]) r (n :: Nat) (xs :: [Type]) Source #

A variation of `Cases`

which uses ** grabN** to get the handler by index.
There may be different handlers for the same type, but the handlers must be in the same order
as the input

`xs`

typelist.
Use `casesN`

to construct this safely ensuring `n`

starts at 0.## Instances

ReiterateN (CasesN fs r) n xs Source # | |

Defined in Data.Diverse.Cases | |

MemberAt n (Head xs -> r) fs => Case (CasesN fs r n) xs Source # | UndecidableInstances because |

Defined in Data.Diverse.Cases | |

type CaseResult (CasesN fs r n :: [Type] -> Type) (x :: Type) Source # | |

Defined in Data.Diverse.Cases |

casesN :: forall r xs fs. (AllConstrained ((~) r) (CaseResults (CasesN fs r 0) fs), SameLength fs xs) => Many fs -> CasesN fs r 0 xs Source #

Safe Constructor for `CasesN`

ensuring that the `n`

Nat starts at 0.
It is an instance of `CaseN`

for either handling `switchN`

ing a `Which`

in index order.

let y =`pickN`

@0 Proxy (5 :: Int) :: Which '[Int, Bool, Bool, Int]`switchN`

y (`casesN`

(show @Int`./`

show @Bool`./`

show @Bool`./`

show @Int`./`

`nul`

)) `shouldBe` "5"

Or for handling `collectN`

from a `Many`

.

let x = (5 :: Int)`./`

False`./`

'X'`./`

Just 'O'`./`

(6 :: Int)`./`

Just 'A'`./`

`nul`

y = show @Int`./`

show @Bool`./`

show @Char`./`

show @(Maybe Char)`./`

show @Int`./`

show @(Maybe Char)`./`

`nul`

`afoldr`

(:) [] (`collectN`

x (`casesN`

y)) `shouldBe` ["5", "False", "`X`

", "Just 'O'", "6", "Just 'A'"]

casesN' :: forall r xs fs. AllConstrained ((~) r) (CaseResults (CasesN fs r 0) fs) => Many fs -> CasesN fs r 0 xs Source #