Data.Fieldwise

Module Data.Fieldwise provides Fieldwise typeclass for operations of fields of records treated as independent components.

Documentation

class Fieldwise r where

Fieldwise class provides some operations for record fields treated as independent pieces of data. See individual methods.

Associated Types

type UnliftedRecord r

UnliftedRecord points to original data structures.

For example:

 data T = T Int String
 data T_f f = T (f Int) (f String)

Then r = T_f and UnliftedRecord r = T

Methods

sequenceR :: Applicative f => r f -> f (UnliftedRecord r)

This function is similar to sequenceA, it composes fields using <*> operator.

Example:

 sequenceR (T_f (Just 1) (Just "abc")) = Just (T 1 "abc")

hoistR :: (forall a. f a -> g a) -> r f -> r g

This function can replace field wrapper.

Example:

 hoistR maybeToList (T_f (Just 1) (Just "abc")) = T_f [1] ["abc"]

zipWithR :: (forall a. f a -> g a -> h a) -> r f -> r g -> r h

This function zips respective field values uzing zipper function,

Example:

 zipWithR mappend (T_f (Just 1) Nothing) (T_f Nothing (Just "c") =
                        T_f (Just 1) (Just "c")

appR :: (forall a. f a -> (UnliftedRecord r -> a) -> g a) -> r f -> r g

This function uses a function to compose fields of a lifted record with selectors of original record.

Note that this is so complicated to support records with many constructors.

liftR :: Applicative f => UnliftedRecord r -> r f

Wrap each value in a record in pure.

Example:

 liftR (T 123 "abc") = T_f (pure 123) (pure "abc")

deriveFieldwise :: Name -> (String -> String) -> Q [Dec]

Automatically derive lifted record type and Monoid and Fieldwise instances for it.

First argument is the name of Haskell data type that should serve as basis for derivation, second argument tell how to tranform names in that type. Names need to be transformed if you want to derive fieldwise in the same module as original data type.

Conceptually for a data type T a derived data T_f has type for each field wrapped in a type constructor. T is semantically equal to T_f Id.

For example for data type:

 data Test1 = Test1 Int String
            | Test2 { test2Char :: Char, test2IntList :: [Int], test2Func :: (Int -> Int) }

 $(deriveFieldwise ''Test1  (++ "_f"))

Will produce the following splice:

 data Test1_f f
   = Test1_f (f Int) (f String) |
     Test2_f {test2Char_f :: f Char,
              test2IntList_f :: f [Int],
              test2Func_f :: f (Int -> Int)}

 instance Alternative f => Monoid (Test1_f f) where
   mempty = Test1_f empty empty
   mappend (Test1_f l1 l2) (Test1_f r1 r2)
     = Test1_f (l1 <|> r1) (l2 <|> r2)
   mappend (Test2_f l1 l2 l3) (Test2_f r1 r2 r3)
     = Test2_f (l1 <|> r1) (l2 <|> r2) (l3 <|> r3)

 instance Fieldwise Test1_f where
   type instance UnliftedRecord Test1_f = Test1
   sequenceR (Test1_f l1 l2) = (((pure Test1) <*> l1) <*> l2)
   hoistR fg (Test1_f l1 l2) = Test1_f (fg l1) (fg l2)
   hoistR fg (Test2_f l1 l2 l3)
     = Test2_f (fg l1) (fg l2) (fg l3)
   zipWithR fg (Test1_f l1 l2) (Test1_f r1 r2)
     = Test1_f (fg l1 r1) (fg l2 r2)
   zipWithR fg (Test2_f l1 l2 l3) (Test2_f r1 r2 r3)
     = Test2_f (fg l1 r1) (fg l2 r2) (fg l3 r3)
   appR fg (Test1_f l1 l2)
     = Test1_f
         (fg l1 (\ (Test1 q_ahwb _) -> q_ahwb))
         (fg l2 (\ (Test1 _ q_ahwb) -> q_ahwb))
   appR fg (Test2_f l1 l2 l3)
     = Test2_f
         (fg l1 test2Char)
         (fg l2 test2IntList)
         (fg l3 test2Func)
   liftR (Test1 l1 l2) = Test1_f (pure l1) (pure l2)
   liftR (Test2 l1 l2 l3) = Test2_f (pure l1) (pure l2) (pure l3)