Module

Data.Record.Fold

class Fold stepper a fold | stepper a -> fold where

(RowToList row list, RFold stepper list row fold) => Fold stepper (Record row) fold

class RFold stepper (list :: RowList) (row :: Row Type) fold | list -> fold where

(Step stepper lbl val (step a b), IsSymbol lbl, Cons lbl val rest row, Semigroupoid step, RFold stepper tail row (step b c)) => RFold stepper (Cons lbl val tail) row (step a c)
(Category step) => RFold name Nil r (step a a)

class Step stepper (lbl :: Symbol) val step | val -> step where

Step LenS lbl a (Int -> Int)
(Show a, IsSymbol lbl) => Step ShowS lbl a (Array (Tuple String String) -> Array (Tuple String String))
(IsSymbol lbl, Cons lbl (f a) tail row, Lacks lbl tail) => Step (MapS f) lbl a (Builder (Record tail) (Record row))
(IsSymbol lbl, Cons lbl b tail row, Lacks lbl tail) => Step (ApplyS a) lbl (a -> b) (Builder (Record tail) (Record row))
(IsSymbol lbl, Cons lbl a tail row, Lacks lbl tail, Apply f) => Step CollectS lbl (f a) (AppCat f Builder (Record tail) (Record row))
(Cons lbl a r' r, IsSymbol lbl, Eq a) => Step EqS lbl a (AppCat (Function (Record r)) Function Boolean Boolean)

newtype AppCat app cat a b

data ApplyS a

(IsSymbol lbl, Cons lbl b tail row, Lacks lbl tail) => Step (ApplyS a) lbl (a -> b) (Builder (Record tail) (Record row))

applyTo :: forall res list row a. RowToList row list => RFold (ApplyS a) list row (Builder (Record ()) (Record res)) => a -> Record row -> Record res

collect :: forall res r f. Applicative f => Fold CollectS r (AppCat f Builder (Record ()) (Record res)) => r -> f (Record res)

data CollectS

(IsSymbol lbl, Cons lbl a tail row, Lacks lbl tail, Apply f) => Step CollectS lbl (f a) (AppCat f Builder (Record tail) (Record row))

data EqS

data LenS

length :: forall r. Fold LenS r (Int -> Int) => r -> Int

data MapS (f :: Type -> Type)

(IsSymbol lbl, Cons lbl (f a) tail row, Lacks lbl tail) => Step (MapS f) lbl a (Builder (Record tail) (Record row))

rEq :: forall r. Fold EqS r (AppCat (Function r) Function Boolean Boolean) => r -> r -> Boolean

rMap :: forall res r f. Fold (MapS f) r (Builder (Record ()) (Record res)) => (forall a. a -> f a) -> r -> Record res

rShow :: forall r. Fold ShowS r (Res -> Res) => r -> Res

data ShowS