Skip to content

HORIZON HASKELL Docs lts/ghc-9.14.x99ffbb82026-10-19Search packagesCtrl K

Theme: |

GHC 9.14.1 · lts/ghc-9.14.x · 99ffbb8 · 2026-10-19

Modulesop-extras-0.4.1.1Haskell2010

Data.SOP.InPairs

Intended for qualified import

import           Data.SOP.InPairs (InPairs(..))
import qualified Data.SOP.InPairs as InPairs

Contents

InPairs
Convenience constructors
SOP-like operators
Requiring
Composing

Synopsis

data InPairs
value mk1
value mk2
value mk3
value hcmap
value hcpure
value hczipWith
value hmap
value hpure
newtype Requiring
newtype RequiringBoth
value ignoring
value ignoringBoth
value requiring
value requiringBoth
newtype Fn2
value composeFromTo

Packagesop-extras-0.4.1.1
Exports17
LanguageHaskell2010
LicenceApache-2.0
SourceInPairs.hs

InPairs

datadata InPairs (f :: k -> k -> Type) (xs :: [k]) where

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

valuemk1 :: InPairs f '[x]

valuemk2 :: f x y -> InPairs f '[x, y]

valuemk3 :: f x y -> f y z -> InPairs f '[x, y, z]

SOP-like operators

valuehcmap

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

valuehcpure

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

valuehczipWith

:: All c xs
=> proxy c
-> forall (x :: k) (y :: k). (c x, c y) => f x y -> f' x y -> f'' x y
-> InPairs f xs
-> InPairs f' xs
-> InPairs f'' xs

valuehmap

:: SListI xs
=> forall (x :: k) (y :: k). f x y -> g x y
-> InPairs f xs
-> InPairs g xs

valuehpure

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

Requiring

newtypenewtype Requiring (h :: k -> Type) (f :: k -> k1 -> Type) (x :: k) (y :: k1)

Constructors

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

newtypenewtype RequiringBoth (h :: k -> Type) (f :: k -> k -> Type) (x :: k) (y :: k)

Constructors

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

valueignoring :: f x y -> Requiring h f x y

valueignoringBoth :: f x y -> RequiringBoth h f x y

valuerequiring

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

valuerequiringBoth :: NP h xs -> InPairs (RequiringBoth h f) xs -> InPairs f xs

Composing

newtypenewtype Fn2 (f :: k -> Type) (x :: k) (y :: k)

Constructors

Fn2
- apFn2 :: f x -> f y

valuecomposeFromTo

:: Index xs x
-> Index xs y
-> InPairs (Fn2 f) xs
-> f x
-> Maybe (f y)