Safe Haskell	None
Language	Haskell2010

Data.Vinyl.Curry

Contents

Currying
Uncurrying
Applicative Combinators
Curried Function Types

Description

Provides combinators for currying and uncurrying functions over arbitrary vinyl records.

Synopsis

class RecordCurry ts where
- rcurry :: (Rec f ts -> a) -> CurriedF f ts a
- rcurry' :: (Rec Identity ts -> a) -> Curried ts a
runcurry :: CurriedF f ts a -> Rec f ts -> a
runcurry' :: Curried ts a -> Rec Identity ts -> a
xruncurry :: CurriedX f ts a -> XRec f ts -> a
runcurryX :: IsoXRec f ts => CurriedX f ts a -> Rec f ts -> a
runcurryA' :: Applicative f => Curried ts a -> Rec f ts -> f a
runcurryA :: Applicative f => CurriedF g ts a -> Rec (Compose f g) ts -> f a
type family Curried ts a where ...
type family CurriedF (f :: u -> *) (ts :: [u]) a where ...
type family CurriedX (f :: u -> *) (ts :: [u]) a where ...

Currying

class RecordCurry ts where Source #

Methods

rcurry :: (Rec f ts -> a) -> CurriedF f ts a Source #

N-ary version of curry over functorial records.

Example specialized signatures:

 rcurry :: (Rec Maybe '[Int, Double] -> Bool) -> Maybe Int -> Maybe Double -> Bool
 rcurry :: (Rec (Either Int) '[Double, String, ()] -> Int) -> Either Int Double -> Either Int String -> Either Int () -> Int
 rcurry :: (Rec f '[] -> Bool) -> Bool

rcurry' :: (Rec Identity ts -> a) -> Curried ts a Source #

N-ary version of curry over pure records.

Example specialized signatures:

 rcurry' :: (Rec Identity '[Int, Double] -> Bool) -> Int -> Double -> Bool
 rcurry' :: (Rec Identity '[Double, String, ()] -> Int) -> Double -> String -> () -> Int
 rcurry' :: (Rec Identity '[] -> Bool) -> Bool

Instances

RecordCurry ([] :: [Type]) Source #
Instance details Defined in Data.Vinyl.Curry Methods rcurry :: (Rec f [] -> a) -> CurriedF f [] a Source # rcurry' :: (Rec Identity [] -> a) -> Curried [] a Source #
RecordCurry ts => RecordCurry (t ': ts) Source #
Instance details Defined in Data.Vinyl.Curry Methods rcurry :: (Rec f (t ': ts) -> a) -> CurriedF f (t ': ts) a Source # rcurry' :: (Rec Identity (t ': ts) -> a) -> Curried (t ': ts) a Source #

Uncurrying

runcurry :: CurriedF f ts a -> Rec f ts -> a Source #

N-ary version of uncurry over functorial records.

Example specialized signatures:

runcurry :: (Maybe Int -> Maybe Double -> String) -> Rec Maybe '[Int, Double] -> String
runcurry :: (IO FilePath -> String) -> Rec IO '[FilePath] -> String
runcurry :: Int -> Rec f '[] -> Int

runcurry' :: Curried ts a -> Rec Identity ts -> a Source #

N-ary version of uncurry over pure records.

Example specialized signatures:

runcurry' :: (Int -> Double -> String) -> Rec Identity '[Int, Double] -> String
runcurry' :: Int -> Rec Identity '[] -> Int

Example usage:

f :: Rec Identity '[Bool, Int, Double] -> Either Int Double
f = runcurry' $ b x y -> if b then Left x else Right y

xruncurry :: CurriedX f ts a -> XRec f ts -> a Source #

Apply an uncurried function to an XRec.

runcurryX :: IsoXRec f ts => CurriedX f ts a -> Rec f ts -> a Source #

Apply an uncurried function to a Rec like runcurry except the function enjoys a type simplified by the XData machinery that strips away type-induced noise like Identity, Compose, and ElField.

Applicative Combinators

runcurryA' :: Applicative f => Curried ts a -> Rec f ts -> f a Source #

Lift an N-ary function to work over a record of Applicative computations.

>>> runcurryA' (+) (Just 2 :& Just 3 :& RNil)
Just 5

>>> runcurryA' (+) (Nothing :& Just 3 :& RNil)
Nothing

runcurryA :: Applicative f => CurriedF g ts a -> Rec (Compose f g) ts -> f a Source #

Lift an N-ary function over types in g to work over a record of Composed Applicative computations. A more general version of runcurryA'.

Example specialized signatures:

runcurryA :: (g x -> g y -> a) -> Rec (Compose Maybe g) '[x, y] -> Maybe a

Curried Function Types

type family Curried ts a where ... Source #

For the list of types ts, Curried ts a is a curried function type from arguments of types in ts to a result of type a.

>>> :kind! Curried '[Int, Bool, String] Int
Curried '[Int, Bool, String] Int :: *
= Int -> Bool -> [Char] -> Int

Equations

Curried '[] a = a
Curried (t ': ts) a = t -> Curried ts a

type family CurriedF (f :: u -> *) (ts :: [u]) a where ... Source #

For the type-level list ts, CurriedF f ts a is a curried function type from arguments of type f t for t in ts, to a result of type a.

>>> :kind! CurriedF Maybe '[Int, Bool, String] Int
CurriedF Maybe '[Int, Bool, String] Int :: *
= Maybe Int -> Maybe Bool -> Maybe [Char] -> Int

Equations

CurriedF f '[] a = a
CurriedF f (t ': ts) a = f t -> CurriedF f ts a

type family CurriedX (f :: u -> *) (ts :: [u]) a where ... Source #

For the type-level list ts, CurriedX f ts a is a curried function type from arguments of type HKD f t for t in ts, to a result of type a.

>>> :set -XTypeOperators
>>> :kind! CurriedX (Maybe :. Identity) '[Int, Bool, String] Int
CurriedX (Maybe :. Identity) '[Int, Bool, String] Int :: *
= Maybe Int -> Maybe Bool -> Maybe [Char] -> Int

Equations

CurriedX f '[] a = a
CurriedX f (t ': ts) a = HKD f t -> CurriedX f ts a