{-# OPTIONS_GHC -fno-warn-orphans #-}

module Pandora.Paradigm.Primary.Functor (module Exports, note, hush, left, right, this, that, here, there) where

import Pandora.Paradigm.Primary.Functor.Fix as Exports
import Pandora.Paradigm.Primary.Functor.Equivalence as Exports
import Pandora.Paradigm.Primary.Functor.Predicate as Exports
import Pandora.Paradigm.Primary.Functor.These as Exports
import Pandora.Paradigm.Primary.Functor.Validation as Exports
import Pandora.Paradigm.Primary.Functor.Wedge as Exports
import Pandora.Paradigm.Primary.Functor.Wye as Exports
import Pandora.Paradigm.Primary.Functor.Edges as Exports
import Pandora.Paradigm.Primary.Functor.Conclusion as Exports
import Pandora.Paradigm.Primary.Functor.Maybe as Exports
import Pandora.Paradigm.Primary.Functor.Endo as Exports
import Pandora.Paradigm.Primary.Functor.Proxy as Exports
import Pandora.Paradigm.Primary.Functor.Tagged as Exports
import Pandora.Paradigm.Primary.Functor.Product as Exports
import Pandora.Paradigm.Primary.Functor.Delta as Exports
import Pandora.Paradigm.Primary.Functor.Constant as Exports
import Pandora.Paradigm.Primary.Functor.Identity as Exports

import Pandora.Core.Morphism ((!))
import Pandora.Core.Functor (type (~>))
import Pandora.Pattern.Category (($))
import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))

instance Adjoint (Product s) ((->) s) where
	(-|) :: a -> ((s :*: a) -> b) -> (s -> b)
	a
x -| :: a -> ((s :*: a) -> b) -> s -> b
-| (s :*: a) -> b
f = \s
s -> (s :*: a) -> b
f ((s :*: a) -> b) -> (s :*: a) -> b
forall (m :: * -> * -> *) a b. Category m => m a b -> m a b
$ s
s s -> a -> s :*: a
forall s a. s -> a -> Product s a
:*: a
x
	(|-) :: (s :*: a) -> (a -> s -> b) -> b
	~(s
s :*: a
x) |- :: (s :*: a) -> (a -> s -> b) -> b
|- a -> s -> b
f = a -> s -> b
f a
x s
s

note :: e -> Maybe ~> Conclusion e
note :: e -> Maybe ~> Conclusion e
note e
x = Conclusion e a
-> (a -> Conclusion e a) -> Maybe a -> Conclusion e a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (e -> Conclusion e a
forall e a. e -> Conclusion e a
Failure e
x) a -> Conclusion e a
forall e a. a -> Conclusion e a
Success

hush :: Conclusion e ~> Maybe
hush :: Conclusion e a -> Maybe a
hush = (e -> Maybe a) -> (a -> Maybe a) -> Conclusion e a -> Maybe a
forall e r a. (e -> r) -> (a -> r) -> Conclusion e a -> r
conclusion (Maybe a
forall a. Maybe a
Nothing Maybe a -> e -> Maybe a
forall a b. a -> b -> a
!) a -> Maybe a
forall a. a -> Maybe a
Just

left :: Wye ~> Maybe
left :: Wye a -> Maybe a
left (Both a
ls a
_) = a -> Maybe a
forall a. a -> Maybe a
Just a
ls
left (Left a
ls) = a -> Maybe a
forall a. a -> Maybe a
Just a
ls
left (Right a
_) = Maybe a
forall a. Maybe a
Nothing
left Wye a
End = Maybe a
forall a. Maybe a
Nothing

right :: Wye ~> Maybe
right :: Wye a -> Maybe a
right (Both a
_ a
rs) = a -> Maybe a
forall a. a -> Maybe a
Just a
rs
right (Left a
_) = Maybe a
forall a. Maybe a
Nothing
right (Right a
rs) = a -> Maybe a
forall a. a -> Maybe a
Just a
rs
right Wye a
End = Maybe a
forall a. Maybe a
Nothing

this :: These e ~> Maybe
this :: These e a -> Maybe a
this (This a
x) = a -> Maybe a
forall a. a -> Maybe a
Just a
x
this (That e
_) = Maybe a
forall a. Maybe a
Nothing
this (These e
_ a
x) = a -> Maybe a
forall a. a -> Maybe a
Just a
x

that :: These e a -> Maybe e
that :: These e a -> Maybe e
that (This a
_) = Maybe e
forall a. Maybe a
Nothing
that (That e
x) = e -> Maybe e
forall a. a -> Maybe a
Just e
x
that (These e
y a
_) = e -> Maybe e
forall a. a -> Maybe a
Just e
y

here :: Wedge e a -> Maybe e
here :: Wedge e a -> Maybe e
here Wedge e a
Nowhere = Maybe e
forall a. Maybe a
Nothing
here (Here e
x) = e -> Maybe e
forall a. a -> Maybe a
Just e
x
here (There a
_) = Maybe e
forall a. Maybe a
Nothing

there :: Wedge e ~> Maybe
there :: Wedge e a -> Maybe a
there Wedge e a
Nowhere = Maybe a
forall a. Maybe a
Nothing
there (Here e
_) = Maybe a
forall a. Maybe a
Nothing
there (There a
x) = a -> Maybe a
forall a. a -> Maybe a
Just a
x