Safe Haskell	None
Language	Haskell2010

Ouroboros.Consensus.HardFork.Combinator.Util.InPairs

Contents

InPairs
Convenience constructors
SOP-like operators
Requiring

Description

Intended for qualified import

import Ouroboros.Consensus.HardFork.Combinator.Util.InPairs (InPairs(..))
import qualified Ouroboros.Consensus.HardFork.Combinator.Util.InPairs as InPairs

Synopsis

data InPairs (f :: k -> k -> Type ) (xs :: [k]) where
- PNil :: InPairs f '[x]
- PCons :: f x y -> InPairs f (y ': zs) -> InPairs f (x ': (y ': zs))
mk1 :: InPairs f '[x]
mk2 :: f x y -> InPairs f '[x, y]
mk3 :: f x y -> f y z -> InPairs f '[x, y, z]
hcmap :: forall proxy c f g xs. All c xs => proxy c -> ( forall x y. (c x, c y) => f x y -> g x y) -> InPairs f xs -> InPairs g xs
hcpure :: forall proxy c xs f. ( All c xs, IsNonEmpty xs) => proxy c -> ( forall x y. (c x, c y) => f x y) -> InPairs f xs
hmap :: SListI xs => ( forall x y. f x y -> g x y) -> InPairs f xs -> InPairs g xs
hpure :: ( SListI xs, IsNonEmpty xs) => ( forall x y. f x y) -> InPairs f xs
data Requiring h f x y = Require {
- provide :: h x -> f x y
}
data RequiringBoth h f x y = RequireBoth {
- provideBoth :: h x -> h y -> f x y
}
ignoring :: f x y -> Requiring h f x y
ignoringBoth :: f x y -> RequiringBoth h f x y
requiring :: SListI xs => NP h xs -> InPairs ( Requiring h f) xs -> InPairs f xs
requiringBoth :: NP h xs -> InPairs ( RequiringBoth h f) xs -> InPairs f xs

InPairs

data InPairs (f :: k -> k -> Type ) (xs :: [k]) where Source #

We have an f x y for each pair (x, y) of successive list elements

Constructors

PNil :: InPairs f '[x]
PCons :: f x y -> InPairs f (y ': zs) -> InPairs f (x ': (y ': zs))

Convenience constructors

mk1 :: InPairs f '[x] Source #

mk2 :: f x y -> InPairs f '[x, y] Source #

mk3 :: f x y -> f y z -> InPairs f '[x, y, z] Source #

SOP-like operators

hcmap :: forall proxy c f g xs. All c xs => proxy c -> ( forall x y. (c x, c y) => f x y -> g x y) -> InPairs f xs -> InPairs g xs Source #

hcpure :: forall proxy c xs f. ( All c xs, IsNonEmpty xs) => proxy c -> ( forall x y. (c x, c y) => f x y) -> InPairs f xs Source #

hmap :: SListI xs => ( forall x y. f x y -> g x y) -> InPairs f xs -> InPairs g xs Source #

hpure :: ( SListI xs, IsNonEmpty xs) => ( forall x y. f x y) -> InPairs f xs Source #

Requiring

data Requiring h f x y Source #

Constructors

Require
Fields provide :: h x -> f x y

data RequiringBoth h f x y Source #

Constructors

RequireBoth
Fields provideBoth :: h x -> h y -> f x y

ignoring :: f x y -> Requiring h f x y Source #

ignoringBoth :: f x y -> RequiringBoth h f x y Source #

requiring :: SListI xs => NP h xs -> InPairs ( Requiring h f) xs -> InPairs f xs Source #

requiringBoth :: NP h xs -> InPairs ( RequiringBoth h f) xs -> InPairs f xs Source #