Data.Property

Data.Property new-style properties.

Generalized properties

class IsProp (prop :: PropertyKind) where

IsProp is a property class that allows you to extend fmr syntax. Now you can create new property types and use it with existing in set list of actions.

Since: 0.2

Methods

performProp :: Monad m => record -> prop m field record -> m ()

performProp record prop performs an action on record using prop.

type PropertyKind = (Type -> Type) -> FieldKind -> Type -> Type

@since 0.2 Service kind synonym.

type FieldKind = (Type -> Type) -> Type -> Type -> Type

@since 0.2 Service kind synonym.

data Prop m field record where

Prop is new, generalized and extensible property type (existential), which may contain any IsProp value.

Since: 0.2

Constructors

Prop :: (Monad m, IsProp prop) => prop m field record -> Prop m field record

Basic properties

class FieldGet field where

@since 0.2 Property getter class.

Methods

getRecord :: Monad m => field m record a -> record -> m a

getRecord field record return record's value using field.

Instances

FieldGet Field

Defined in Data.Field

Methods

getRecord :: Monad m => Field m record a -> record -> m a

FieldGet MField

Defined in Data.MField

Methods

getRecord :: Monad m => MField m record a -> record -> m a

FieldGet field => FieldGet (Observe field)

Defined in Data.Field.Observe

Methods

getRecord :: Monad m => Observe field m record a -> record -> m a

get :: (Monad m, FieldGet field) => field m record a -> record -> m a

The get function reads current value of a field.

gets' :: (Monad m, FieldGet field) => record -> [field m record a] -> m [a]

gets' fields record returns list of record fields values.

class FieldSet field where

@since 0.2 Property setter class.

Methods

setRecord :: Monad m => field m record a -> record -> a -> m ()

setRecord field record value sets new record value.

Instances

FieldSet Field

Defined in Data.Field

Methods

setRecord :: Monad m => Field m record a -> record -> a -> m ()

FieldSet MField

Defined in Data.MField

Methods

setRecord :: Monad m => MField m record a -> record -> a -> m ()

FieldSet field => FieldSet (Observe field)

Defined in Data.Field.Observe

Methods

setRecord :: Monad m => Observe field m record a -> record -> a -> m ()

set :: Monad m => record -> [Prop m field record] -> m ()

set is the main function in fmr, which allows you to describe changing the value of a record as a sequence of operations on its fields, e.g.

sets' :: Monad m => record -> [Prop m field record] -> m ()

Just synonym for set.

Set properties

pattern (:=) :: (Typeable m, Typeable field, Typeable record, Monad m, FieldSet field) => field m record a -> a -> Prop m field record

Pure value setter. set record [field := value] set value to record's field.

pattern (::=) :: (Typeable m, Typeable field, Typeable record, Monad m, FieldSet field) => field m record a -> (record -> a) -> Prop m field record

Pure value setter with record. set record [field ::= f] set f record to record's field.

   set record [field ::= const val] === set record [field := val]
 

pattern (:=$) :: (Typeable m, Typeable field, Typeable record, Monad m, FieldSet field) => [field m record a] -> a -> Prop m field record

Pure group setter. set record [fields :=$ value] set value to record's some fields.

   set record [[field] :=$ value] === set record [field := value]
 

Since: 0.2

pattern (::=$) :: (Typeable m, Typeable field, Typeable record, Monad m, FieldSet field) => [field m record a] -> (record -> a) -> Prop m field record

Pure group setter with record. set record [fields ::=$ f] set f record to record's some fields.

   set record [[field] ::=$ f] === set record [field ::= f]
   set record [fields ::=$ const val] === set record [fields :=$ val]
 

Since: 0.2

Monadic set properties

pattern (:<=) :: (Typeable m, Typeable field, Typeable record, Monad m, FieldSet field) => field m record a -> m a -> Prop m field record

Monadic value setter. set record [field :<= mvalue] set result of mvalue to record's field. Note that the mvalue is evaluated every time a field value is assigned.

   set record [field :<= return val] === set record [field := val]
   set record [field :<= mval] === do val <- mval; set record [field :<= val]
 

Since: 0.2

pattern (:<=$) :: (Typeable m, Typeable field, Typeable record, Monad m, FieldSet field) => [field m record a] -> m a -> Prop m field record

Monadic group setter. set record [fields :<=$ mvalue] set result of mvalue to record's fields. Note that mvalue is evaluated only once, on the first assignment. Thus, the values of all the listed fields will be identical.

   set record [[field] :<=$ const f] === set record [field :<= val]
   set record [fields :<=$ mval] === do val <- mval; set record [fields :<=$ val]
 

Since: 0.2

pattern (:=<) :: (Typeable m, Typeable field, Typeable record, Monad m, FieldSet field) => field m record a -> (record -> m a) -> Prop m field record

Monadic value setter with record. set record [field :=< mvalue] set result of mvalue record to record's field. Note that the mvalue is evaluated every time a field value is assigned.

   set record [field :=< const val] === set record [field :<= val]
   set record [field :=< f] === do val <- f record; set record [field := val]
 

Since: 0.2

pattern (:=<$) :: (Typeable m, Typeable field, Typeable record, Monad m, FieldSet field) => [field m record a] -> (record -> m a) -> Prop m field record

Monadic group setter with record. set record [fields :=<$ f] set result of f record to record's fields. Note that f record is evaluated only once, on the first assignment. Thus, the values of all the listed fields will be identical.

   set record [[field] :=<$ f] === set record [field :=< val]
   set record [fields :=<$ const val] = set record [fields :=$ val]
   set record [fields :=<$ f] === do val <- f record; set record [fields :=$ val]
 

Since: 0.2

Modify properties

class FieldSet field => FieldModify field where

Property modifier class.

Note that FieldModifier doesn't go well with write-only fields, because modifyRecord returns new value, and modifyRecordM also assumes the possibility of old value "leaking" (hence the FieldGet constraint is imposed on it).

Since: 0.2

Minimal complete definition

Nothing

Methods

modifyRecord :: Monad m => field m record a -> record -> (a -> a) -> m a

modifyRecord field record upd modifies record field using upd. Returns new value.

default modifyRecord :: (Monad m, FieldGet field) => field m record a -> record -> (a -> a) -> m a

modifyRecordM :: (Monad m, FieldGet field) => field m record a -> record -> (a -> m a) -> m a

modifyRecordM field record upd modifies record field using upd. Note that assumes the possibility of old value "leaking", e.g.:

       -- get value using modifyRecordM
       getLeak = do
         -- Some read-only fields
         x <- newWriteOnly
         y <- var Nothing
         -- write current value to y and do not modify.
         modifyRecordM this x ( val -> do set [this := Just val]; return val)
         -- leaking: return current value of "write-only" record
         get this y
     

So you cannot use it for write-only fields.

Instances

FieldModify Field

Defined in Data.Field

Methods

modifyRecord :: Monad m => Field m record a -> record -> (a -> a) -> m a

modifyRecordM :: (Monad m, FieldGet Field) => Field m record a -> record -> (a -> m a) -> m a

FieldModify MField

Defined in Data.MField

Methods

modifyRecord :: Monad m => MField m record a -> record -> (a -> a) -> m a

modifyRecordM :: (Monad m, FieldGet MField) => MField m record a -> record -> (a -> m a) -> m a

(FieldModify field, FieldGet field) => FieldModify (Observe field)

Defined in Data.Field.Observe

Methods

modifyRecord :: Monad m => Observe field m record a -> record -> (a -> a) -> m a

modifyRecordM :: (Monad m, FieldGet (Observe field)) => Observe field m record a -> record -> (a -> m a) -> m a

Modify properties

pattern (:~) :: (Typeable m, Typeable field, Typeable record, Monad m, FieldModify field) => field m record a -> (a -> a) -> Prop m field record

Pure value modifier. set record [field :~ f] modify value of record's field using f function.

   set record [field :~ const val] === set record [field := val]
 

pattern (:~$) :: (Typeable m, Typeable field, Typeable record, Monad m, FieldModify field) => [field m record a] -> (a -> a) -> Prop m field record

Pure group modifier. set record [fields :~$ f] modify values of record's fields using f function.

   set record [[field] :~$ val] === set record [field :~ val]
   set record [fields :~$ const val] === set record [field :=$ val]
 

Since: 0.2

pattern (::~) :: (Typeable m, Typeable field, Typeable record, Monad m, FieldModify field) => field m record a -> (record -> a -> a) -> Prop m field record

Pure value modifier with record. set record [field ::~ f] modify value of record's field using f record function.

   set record [field ::~ const f] === set record [field :~ f]
 

pattern (::~$) :: (Typeable m, Typeable field, Typeable record, Monad m, FieldModify field) => [field m record a] -> (record -> a -> a) -> Prop m field record

Pure group modifier with record. set record [fields ::~$ f] modify values of record's fields using f record function.

   set record [[field] ::~$ f] === set record [field ::~ f]
   set record [fields ::~$ const f] === set record [field :~$ f]
 

Since: 0.2

Monadic modify properties

pattern (:<~) :: (Typeable m, Typeable field, Typeable record, Monad m, FieldModify field, FieldGet field) => field m record a -> (a -> m a) -> Prop m field record

Monadic value modifier. set record [field :<~ f] modifies value of record's field using f procedure. Note that the mvalue is called every time a field value is assigned.

   set record [field :<~ return val] === set record [fields := val]
 

Since: 0.2

pattern (:<~$) :: (Typeable m, Typeable field, Typeable record, Monad m, FieldModify field, FieldGet field) => [field m record a] -> (a -> m a) -> Prop m field record

Monadic group modifier. set record [fields :<~$ f] modifies values of record's fields using f procedure.

   set record [[field] :<~$ f] === set record [field :<~ f]
   set record [fields :<~$ const mval] === set record [field :<=$ mval]
 

Since: 0.2

pattern (:~<) :: (Typeable m, Typeable field, Typeable record, Monad m, FieldModify field, FieldGet field) => field m record a -> (record -> a -> m a) -> Prop m field record

Monadic value modifier with record. set record [field :<~ f] modifies value of record's field using f record procedure. Note that the f record is called every time a field value is assigned.

   set record [field :~< const f] === set record [fields :<~ f]
 

Since: 0.2

pattern (:~<$) :: (Typeable m, Typeable field, Typeable record, Monad m, FieldModify field, FieldGet field) => [field m record a] -> (record -> a -> m a) -> Prop m field record

Monadic group modifier with record. set record [fields :~<$ f] modifies values of record's fields using f record procedure. Note that the f record is called every time a field value is assigned.

   set record [field :~<$ const f] === set record [fields :<~$ f]
 

Since: 0.2

Switch properties

class IsSwitch switch where

Service class for switchable types.

Methods

toggle :: Int -> switch -> switch

toggle s n "toggles" the state represented by the value s by n positions, for example:

       toggle n False = even n
       toggle n  True = odd  n
       toggle n  1234 = 1239 + n
     

Instances

IsSwitch Bool

Defined in Data.Property

Methods

toggle :: Int -> Bool -> Bool

Integral i => IsSwitch i

Defined in Data.Property

Methods

toggle :: Int -> i -> i

class FieldSwitch field where

Switch property modifier.

Note that FieldSwitch is designed for deterministic switches with a pre-known set of states and order of transitions between them, without branches. If you need more complex behavior, use FieldModify.

Methods

switchRecord :: (Monad m, IsSwitch a) => field m record a -> record -> Int -> m ()

Repeated increment or decrement.

Instances

FieldSwitch Field

Defined in Data.Field

Methods

switchRecord :: (Monad m, IsSwitch a) => Field m record a -> record -> Int -> m ()

FieldSwitch MField

Defined in Data.MField

Methods

switchRecord :: (Monad m, IsSwitch a) => MField m record a -> record -> Int -> m ()

FieldSwitch field => FieldSwitch (Observe field)

Defined in Data.Field.Observe

Methods

switchRecord :: (Monad m, IsSwitch a) => Observe field m record a -> record -> Int -> m ()

switch :: (Monad m, FieldSwitch field, IsSwitch a) => field m record a -> Int -> Prop m field record

switch changes the value by n steps.

incr :: (Monad m, FieldSwitch field, IsSwitch a) => field m record a -> Prop m field record

incr field is same as switch field 1.

decr :: (Monad m, FieldSwitch field, IsSwitch a) => field m record a -> Prop m field record

decr field is same as switch field (-1).