-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Split Epimorphisms and Monomorphisms
--   
--   Please see the README on GitHub at
--   <a>https://github.com/gvolpe/split-morphism#readme</a>
@package split-morphism
@version 0.1.0.0

module Control.Lens.Format

-- | A normalizing optic, isomorphic to Prism but with different laws,
--   specifically <a>getMaybe</a> needs not to be injective; i.e., distinct
--   inputs may have the same <a>getMaybe</a> result, which combined with a
--   subsequent <a>reverseGet</a> yields a normalized form for <tt>a</tt>.
--   Composition with stronger optics (<a>Prism</a> and <a>Iso</a>) yields
--   another <a>Format</a>.
data Format a b
Format :: (a -> Maybe b) -> (b -> a) -> Format a b
[getMaybe] :: Format a b -> a -> Maybe b
[reverseGet] :: Format a b -> b -> a

-- | <a>getMaybe</a> and <a>reverseGet</a>, yielding a normalized formatted
--   value. Subsequent getMaybe/reverseGet cycles are idempotent.
normalize :: Format a b -> a -> Maybe a

-- | Compose with a Prism.
composePrism :: Format a b -> Prism' b c -> Format a c

-- | Compose with an Iso.
composeIso :: Format a b -> Iso' b c -> Format a c

-- | A Prism is trivially a Format.
fromPrism :: Prism' a b -> Format a b

-- | An Isomorphism is trivially a Format.
fromIso :: Iso' a b -> Format a b
instance Data.Functor.Invariant.Invariant (Control.Lens.Format.Format a)

module Control.Lens.SplitEpi

-- | A split epimorphism, which we can think of as a weaker <a>Iso</a> a b
--   where <tt>b</tt> is a "smaller" type. So `get . reverseGet` remains an
--   identity but `reverseGet . get` is merely idempotent (i.e., it
--   normalizes values in <tt>a</tt>).
--   
--   The following statements hold: - <a>reverseGet</a> is a "section" of
--   <a>get</a>, - <a>get</a> is a "retraction" of <a>reverseGet</a>, -
--   <tt>b</tt> is a "retract" of <tt>a</tt>, - the pair `(get,
--   reverseGet)` is a "splitting" of the idempotent `reverseGet . get`.
data SplitEpi a b
SplitEpi :: (a -> b) -> (b -> a) -> SplitEpi a b
[get] :: SplitEpi a b -> a -> b
[reverseGet] :: SplitEpi a b -> b -> a

-- | `reverseGet . get`, yielding a normalized formatted value. Subsequent
--   get/reverseGet cycles are idempotent.
normalize :: SplitEpi a b -> a -> a

-- | Compose with another SplitEpi.
composeSplitEpi :: SplitEpi a b -> SplitEpi b c -> SplitEpi a c

-- | Compose with an Iso.
composeIso :: SplitEpi a b -> Iso' b c -> SplitEpi a c

-- | An Isomorphism is trivially a SplitEpi.
fromIso :: Iso' a b -> SplitEpi a b
instance Data.Functor.Invariant.Invariant (Control.Lens.SplitEpi.SplitEpi a)

module Control.Lens.SplitMono

-- | A split monomorphism, which we can think of as a weaker <a>Iso</a> a b
--   where <tt>a</tt> is a "smaller" type. So `reverseGet . get` remains an
--   identity but `get . reverseGet` is merely idempotent (i.e., it
--   normalizes values in <tt>b</tt>).
--   
--   The following statements hold: - <a>reverseGet</a> is a "retraction"
--   of <a>get</a>, - <a>get</a> is a "section" of <a>reverseGet</a>, -
--   <tt>a</tt> is a "retract" of <tt>b</tt>, - the pair `(reverseGet,
--   get)` is a "splitting" of the idempotent `get . reverseGet`.
data SplitMono a b
SplitMono :: (a -> b) -> (b -> a) -> SplitMono a b
[get] :: SplitMono a b -> a -> b
[reverseGet] :: SplitMono a b -> b -> a

-- | `reverseGet . get`, yielding a normalized formatted value. Subsequent
--   get/reverseGet cycles are idempotent.
normalize :: SplitMono a b -> b -> b

-- | Compose with another SplitMono.
composeSplitMono :: SplitMono a b -> SplitMono b c -> SplitMono a c

-- | Compose with an Iso.
composeIso :: SplitMono a b -> Iso' b c -> SplitMono a c

-- | An Isomorphism is trivially a SplitMono.
fromIso :: Iso' a b -> SplitMono a b
instance Data.Functor.Invariant.Invariant (Control.Lens.SplitMono.SplitMono a)

module Control.Lens.Wedge

-- | Composition of a <a>SplitMono</a> and a <a>SplitEpi</a>, yielding an
--   even weaker structure where neither `reverseGet . get` and `get .
--   reverseGet` is an identity but both are idempotent.
data Wedge a b
Wedge :: (a -> b) -> (b -> a) -> Wedge a b
[get] :: Wedge a b -> a -> b
[reverseGet] :: Wedge a b -> b -> a

-- | Normalize <tt>a</tt> via a round-trip through <tt>b</tt>.
normalizeA :: Wedge a b -> a -> a

-- | Normalize <tt>b</tt> via a round-trip through <tt>a</tt>.
normalizeB :: Wedge a b -> b -> b

-- | Swapping <a>get</a> and <a>reverseGet</a> yields a Wedge.
reverse :: Wedge a b -> Wedge b a

-- | Compose with another Wedge.
composeWedge :: Wedge a b -> Wedge b c -> Wedge a c

-- | Compose with an Iso.
composeIso :: Wedge a b -> Iso' b c -> Wedge a c

-- | An Isomorphism is trivially a Wedge.
fromIso :: Iso' a b -> Wedge a b
instance Data.Functor.Invariant.Invariant (Control.Lens.Wedge.Wedge a)

module Control.Lens.SplitMorphism

-- | Swapping <a>get</a> and <a>reverseGet</a> yields a <a>SplitMono</a>.
reverseEpi :: SplitEpi a b -> SplitMono b a

-- | Swapping <a>get</a> and <a>reverseGet</a> yields a <a>SplitEpi</a>.
reverseMono :: SplitMono a b -> SplitEpi b a

-- | Composition between <a>SplitEpi</a> and <a>SplitMono</a>.
composeSplitEpiMono :: SplitEpi a b -> SplitMono b c -> Wedge a c

-- | Composition between <a>SplitEpi</a> and <a>Prism</a>.
composeSplitEpiPrism :: SplitEpi a b -> Prism' b c -> Format a c

-- | Composition between <a>SplitMono</a> and <a>SplitEpi</a>.
composeSplitMonoEpi :: SplitMono a b -> SplitEpi b c -> Wedge a c

-- | Conversion from <a>SplitEpi</a> to <a>Wedge</a>.
epiAsWedge :: SplitEpi a b -> Wedge a b

-- | Conversion from <a>SplitMono</a> to <a>Wedge</a>.
monoAsWedge :: SplitMono a b -> Wedge a b