Safe Haskell | None |
---|---|

Language | Haskell2010 |

Contains general underlying monad for bidirectional TOML converion.

## Synopsis

- data Bijection r w c a = Bijection {}
- type Bi r w a = Bijection r w a a
- dimap :: (Functor r, Functor w) => (c -> d) -> (a -> b) -> Bijection r w d a -> Bijection r w c b
- (<!>) :: Alternative f => (a -> f x) -> (a -> f x) -> a -> f x
- (.=) :: Bijection r w field a -> (object -> field) -> Bijection r w object a

# Documentation

data Bijection r w c a Source #

Monad for bidirectional Toml conversion. Contains pair of functions:

- How to read value of type
`a`

from immutable environment context`r`

? - How to store value of type
`a`

in stateful context`w`

?

In practice instead of `r`

we will use some `Reader Toml`

and instead of `w`

we will
use `State Toml`

. This approach with the bunch of utility functions allows to
have single description for from/to `Toml`

conversion.

In practice this type will always be used in the following way:

type`Bi`

r w a =`Bijection`

r w a a

Type parameter `c`

if fictional. Here some trick is used. This trick is
implemented in codec and
described in more details in related blog post.

## Instances

(Monad r, Monad w) => Monad (Bijection r w c) Source # | |

(Functor r, Functor w) => Functor (Bijection r w c) Source # | |

(Applicative r, Applicative w) => Applicative (Bijection r w c) Source # | |

Defined in Toml.Bi.Monad pure :: a -> Bijection r w c a # (<*>) :: Bijection r w c (a -> b) -> Bijection r w c a -> Bijection r w c b # liftA2 :: (a -> b -> c0) -> Bijection r w c a -> Bijection r w c b -> Bijection r w c c0 # (*>) :: Bijection r w c a -> Bijection r w c b -> Bijection r w c b # (<*) :: Bijection r w c a -> Bijection r w c b -> Bijection r w c a # | |

(Alternative r, Alternative w) => Alternative (Bijection r w c) Source # | |

(MonadPlus r, MonadPlus w) => MonadPlus (Bijection r w c) Source # | |

type Bi r w a = Bijection r w a a Source #

Specialized version of `Bijection`

data type. This type alias is used in practice.

:: (Functor r, Functor w) | |

=> (c -> d) | Mapper for consumer |

-> (a -> b) | Mapper for producer |

-> Bijection r w d a | Source |

-> Bijection r w c b |

This is an instance of `Profunctor`

for `Bijection`

. But since there's no
`Profunctor`

type class in `base`

or package with no dependencies (and we don't
want to bring extra dependencies) this instance is implemented as a single
top-level function.

Useful when you want to parse `newtype`

s. For example, if you had data type like this:

data Example = Example { foo :: Bool , bar :: Text }

toml bidirectional converter for this type will look like this:

exampleT :: BiToml Example exampleT = Example $ bool "foo" .= foo * str "bar" .= bar

Now if you change your time in the following way:

newtype Email = Email { unEmail :: Text } data Example = Example { foo :: Bool , bar :: Email }

you need to patch your toml parser like this:

exampleT :: BiToml Example exampleT = Example $ bool "foo" .= foo * dimap unEmail Email (str "bar") .= bar

(<!>) :: Alternative f => (a -> f x) -> (a -> f x) -> a -> f x infixl 3 Source #

Alternative instance for function arrow but without `empty`

.