{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveDataTypeable #-}

#if __GLASGOW_HASKELL__ >= 702
{-# LANGUAGE DeriveGeneric #-}
#endif

#if __GLASGOW_HASKELL__ >= 704
{-# LANGUAGE Safe #-}
#elif __GLASGOW_HASKELL__ >= 702
{-# LANGUAGE Trustworthy #-}
#endif

#if __GLASGOW_HASKELL__ >= 706
{-# LANGUAGE PolyKinds #-}
#endif
#include "bifunctors-common.h"

-----------------------------------------------------------------------------
-- |
-- Module      :  Data.Bifunctor.Flip
-- Copyright   :  (C) 2008-2016 Edward Kmett
-- License     :  BSD-style (see the file LICENSE)
--
-- Maintainer  :  Edward Kmett <ekmett@gmail.com>
-- Stability   :  provisional
-- Portability :  portable
--
----------------------------------------------------------------------------
module Data.Bifunctor.Flip
  ( Flip(..)
  ) where

#if __GLASGOW_HASKELL__ < 710
import Control.Applicative
#endif

import Data.Biapplicative
import Data.Bifoldable
import Data.Bifunctor.Functor
import Data.Bitraversable

#if __GLASGOW_HASKELL__ < 710
import Data.Foldable
import Data.Monoid
import Data.Traversable
#endif

#if __GLASGOW_HASKELL__ >= 708
import Data.Typeable
#endif

#if __GLASGOW_HASKELL__ >= 702
import GHC.Generics
#endif

#if LIFTED_FUNCTOR_CLASSES
import Data.Functor.Classes
#endif

-- | Make a 'Bifunctor' flipping the arguments of a 'Bifunctor'.
newtype Flip p a b = Flip { forall {k} {k} (p :: k -> k -> *) (a :: k) (b :: k).
Flip p a b -> p b a
runFlip :: p b a }
  deriving ( Flip p a b -> Flip p a b -> Bool
(Flip p a b -> Flip p a b -> Bool)
-> (Flip p a b -> Flip p a b -> Bool) -> Eq (Flip p a b)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Eq (p b a) =>
Flip p a b -> Flip p a b -> Bool
$c== :: forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Eq (p b a) =>
Flip p a b -> Flip p a b -> Bool
== :: Flip p a b -> Flip p a b -> Bool
$c/= :: forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Eq (p b a) =>
Flip p a b -> Flip p a b -> Bool
/= :: Flip p a b -> Flip p a b -> Bool
Eq, Eq (Flip p a b)
Eq (Flip p a b)
-> (Flip p a b -> Flip p a b -> Ordering)
-> (Flip p a b -> Flip p a b -> Bool)
-> (Flip p a b -> Flip p a b -> Bool)
-> (Flip p a b -> Flip p a b -> Bool)
-> (Flip p a b -> Flip p a b -> Bool)
-> (Flip p a b -> Flip p a b -> Flip p a b)
-> (Flip p a b -> Flip p a b -> Flip p a b)
-> Ord (Flip p a b)
Flip p a b -> Flip p a b -> Bool
Flip p a b -> Flip p a b -> Ordering
Flip p a b -> Flip p a b -> Flip p a b
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {k} {k} {p :: k -> k -> *} {a :: k} {b :: k}.
Ord (p b a) =>
Eq (Flip p a b)
forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Ord (p b a) =>
Flip p a b -> Flip p a b -> Bool
forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Ord (p b a) =>
Flip p a b -> Flip p a b -> Ordering
forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Ord (p b a) =>
Flip p a b -> Flip p a b -> Flip p a b
$ccompare :: forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Ord (p b a) =>
Flip p a b -> Flip p a b -> Ordering
compare :: Flip p a b -> Flip p a b -> Ordering
$c< :: forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Ord (p b a) =>
Flip p a b -> Flip p a b -> Bool
< :: Flip p a b -> Flip p a b -> Bool
$c<= :: forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Ord (p b a) =>
Flip p a b -> Flip p a b -> Bool
<= :: Flip p a b -> Flip p a b -> Bool
$c> :: forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Ord (p b a) =>
Flip p a b -> Flip p a b -> Bool
> :: Flip p a b -> Flip p a b -> Bool
$c>= :: forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Ord (p b a) =>
Flip p a b -> Flip p a b -> Bool
>= :: Flip p a b -> Flip p a b -> Bool
$cmax :: forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Ord (p b a) =>
Flip p a b -> Flip p a b -> Flip p a b
max :: Flip p a b -> Flip p a b -> Flip p a b
$cmin :: forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Ord (p b a) =>
Flip p a b -> Flip p a b -> Flip p a b
min :: Flip p a b -> Flip p a b -> Flip p a b
Ord, Int -> Flip p a b -> ShowS
[Flip p a b] -> ShowS
Flip p a b -> String
(Int -> Flip p a b -> ShowS)
-> (Flip p a b -> String)
-> ([Flip p a b] -> ShowS)
-> Show (Flip p a b)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Show (p b a) =>
Int -> Flip p a b -> ShowS
forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Show (p b a) =>
[Flip p a b] -> ShowS
forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Show (p b a) =>
Flip p a b -> String
$cshowsPrec :: forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Show (p b a) =>
Int -> Flip p a b -> ShowS
showsPrec :: Int -> Flip p a b -> ShowS
$cshow :: forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Show (p b a) =>
Flip p a b -> String
show :: Flip p a b -> String
$cshowList :: forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Show (p b a) =>
[Flip p a b] -> ShowS
showList :: [Flip p a b] -> ShowS
Show, ReadPrec [Flip p a b]
ReadPrec (Flip p a b)
Int -> ReadS (Flip p a b)
ReadS [Flip p a b]
(Int -> ReadS (Flip p a b))
-> ReadS [Flip p a b]
-> ReadPrec (Flip p a b)
-> ReadPrec [Flip p a b]
-> Read (Flip p a b)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Read (p b a) =>
ReadPrec [Flip p a b]
forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Read (p b a) =>
ReadPrec (Flip p a b)
forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Read (p b a) =>
Int -> ReadS (Flip p a b)
forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Read (p b a) =>
ReadS [Flip p a b]
$creadsPrec :: forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Read (p b a) =>
Int -> ReadS (Flip p a b)
readsPrec :: Int -> ReadS (Flip p a b)
$creadList :: forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Read (p b a) =>
ReadS [Flip p a b]
readList :: ReadS [Flip p a b]
$creadPrec :: forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Read (p b a) =>
ReadPrec (Flip p a b)
readPrec :: ReadPrec (Flip p a b)
$creadListPrec :: forall k k (p :: k -> k -> *) (a :: k) (b :: k).
Read (p b a) =>
ReadPrec [Flip p a b]
readListPrec :: ReadPrec [Flip p a b]
Read
#if __GLASGOW_HASKELL__ >= 702
           , (forall x. Flip p a b -> Rep (Flip p a b) x)
-> (forall x. Rep (Flip p a b) x -> Flip p a b)
-> Generic (Flip p a b)
forall x. Rep (Flip p a b) x -> Flip p a b
forall x. Flip p a b -> Rep (Flip p a b) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall k k (p :: k -> k -> *) (a :: k) (b :: k) x.
Rep (Flip p a b) x -> Flip p a b
forall k k (p :: k -> k -> *) (a :: k) (b :: k) x.
Flip p a b -> Rep (Flip p a b) x
$cfrom :: forall k k (p :: k -> k -> *) (a :: k) (b :: k) x.
Flip p a b -> Rep (Flip p a b) x
from :: forall x. Flip p a b -> Rep (Flip p a b) x
$cto :: forall k k (p :: k -> k -> *) (a :: k) (b :: k) x.
Rep (Flip p a b) x -> Flip p a b
to :: forall x. Rep (Flip p a b) x -> Flip p a b
Generic
#endif
#if __GLASGOW_HASKELL__ >= 708
           , Typeable
#endif
           )

#if LIFTED_FUNCTOR_CLASSES
instance (Eq2 p, Eq a) => Eq1 (Flip p a) where
  liftEq :: forall a b. (a -> b -> Bool) -> Flip p a a -> Flip p a b -> Bool
liftEq = (a -> a -> Bool)
-> (a -> b -> Bool) -> Flip p a a -> Flip p a b -> Bool
forall a b c d.
(a -> b -> Bool)
-> (c -> d -> Bool) -> Flip p a c -> Flip p b d -> Bool
forall (f :: * -> * -> *) a b c d.
Eq2 f =>
(a -> b -> Bool) -> (c -> d -> Bool) -> f a c -> f b d -> Bool
liftEq2 a -> a -> Bool
forall a. Eq a => a -> a -> Bool
(==)
instance Eq2 p => Eq2 (Flip p) where
  liftEq2 :: forall a b c d.
(a -> b -> Bool)
-> (c -> d -> Bool) -> Flip p a c -> Flip p b d -> Bool
liftEq2 a -> b -> Bool
f c -> d -> Bool
g (Flip p c a
x) (Flip p d b
y) = (c -> d -> Bool) -> (a -> b -> Bool) -> p c a -> p d b -> Bool
forall a b c d.
(a -> b -> Bool) -> (c -> d -> Bool) -> p a c -> p b d -> Bool
forall (f :: * -> * -> *) a b c d.
Eq2 f =>
(a -> b -> Bool) -> (c -> d -> Bool) -> f a c -> f b d -> Bool
liftEq2 c -> d -> Bool
g a -> b -> Bool
f p c a
x p d b
y

instance (Ord2 p, Ord a) => Ord1 (Flip p a) where
  liftCompare :: forall a b.
(a -> b -> Ordering) -> Flip p a a -> Flip p a b -> Ordering
liftCompare = (a -> a -> Ordering)
-> (a -> b -> Ordering) -> Flip p a a -> Flip p a b -> Ordering
forall a b c d.
(a -> b -> Ordering)
-> (c -> d -> Ordering) -> Flip p a c -> Flip p b d -> Ordering
forall (f :: * -> * -> *) a b c d.
Ord2 f =>
(a -> b -> Ordering)
-> (c -> d -> Ordering) -> f a c -> f b d -> Ordering
liftCompare2 a -> a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare
instance Ord2 p => Ord2 (Flip p) where
  liftCompare2 :: forall a b c d.
(a -> b -> Ordering)
-> (c -> d -> Ordering) -> Flip p a c -> Flip p b d -> Ordering
liftCompare2 a -> b -> Ordering
f c -> d -> Ordering
g (Flip p c a
x) (Flip p d b
y) = (c -> d -> Ordering)
-> (a -> b -> Ordering) -> p c a -> p d b -> Ordering
forall a b c d.
(a -> b -> Ordering)
-> (c -> d -> Ordering) -> p a c -> p b d -> Ordering
forall (f :: * -> * -> *) a b c d.
Ord2 f =>
(a -> b -> Ordering)
-> (c -> d -> Ordering) -> f a c -> f b d -> Ordering
liftCompare2 c -> d -> Ordering
g a -> b -> Ordering
f p c a
x p d b
y

instance (Read2 p, Read a) => Read1 (Flip p a) where
  liftReadsPrec :: forall a.
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Flip p a a)
liftReadsPrec = (Int -> ReadS a)
-> ReadS [a]
-> (Int -> ReadS a)
-> ReadS [a]
-> Int
-> ReadS (Flip p a a)
forall a b.
(Int -> ReadS a)
-> ReadS [a]
-> (Int -> ReadS b)
-> ReadS [b]
-> Int
-> ReadS (Flip p a b)
forall (f :: * -> * -> *) a b.
Read2 f =>
(Int -> ReadS a)
-> ReadS [a]
-> (Int -> ReadS b)
-> ReadS [b]
-> Int
-> ReadS (f a b)
liftReadsPrec2 Int -> ReadS a
forall a. Read a => Int -> ReadS a
readsPrec ReadS [a]
forall a. Read a => ReadS [a]
readList
instance Read2 p => Read2 (Flip p) where
  liftReadsPrec2 :: forall a b.
(Int -> ReadS a)
-> ReadS [a]
-> (Int -> ReadS b)
-> ReadS [b]
-> Int
-> ReadS (Flip p a b)
liftReadsPrec2 Int -> ReadS a
rp1 ReadS [a]
rl1 Int -> ReadS b
rp2 ReadS [b]
rl2 Int
p = Bool -> ReadS (Flip p a b) -> ReadS (Flip p a b)
forall a. Bool -> ReadS a -> ReadS a
readParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (ReadS (Flip p a b) -> ReadS (Flip p a b))
-> ReadS (Flip p a b) -> ReadS (Flip p a b)
forall a b. (a -> b) -> a -> b
$ \String
s0 -> do
    (String
"Flip",    String
s1) <- ReadS String
lex String
s0
    (String
"{",       String
s2) <- ReadS String
lex String
s1
    (String
"runFlip", String
s3) <- ReadS String
lex String
s2
    (p b a
x,         String
s4) <- (Int -> ReadS b)
-> ReadS [b]
-> (Int -> ReadS a)
-> ReadS [a]
-> Int
-> ReadS (p b a)
forall a b.
(Int -> ReadS a)
-> ReadS [a]
-> (Int -> ReadS b)
-> ReadS [b]
-> Int
-> ReadS (p a b)
forall (f :: * -> * -> *) a b.
Read2 f =>
(Int -> ReadS a)
-> ReadS [a]
-> (Int -> ReadS b)
-> ReadS [b]
-> Int
-> ReadS (f a b)
liftReadsPrec2 Int -> ReadS b
rp2 ReadS [b]
rl2 Int -> ReadS a
rp1 ReadS [a]
rl1 Int
0 String
s3
    (String
"}",       String
s5) <- ReadS String
lex String
s4
    (Flip p a b, String) -> [(Flip p a b, String)]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return (p b a -> Flip p a b
forall {k} {k} (p :: k -> k -> *) (a :: k) (b :: k).
p b a -> Flip p a b
Flip p b a
x, String
s5)

instance (Show2 p, Show a) => Show1 (Flip p a) where
  liftShowsPrec :: forall a.
(Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Flip p a a -> ShowS
liftShowsPrec = (Int -> a -> ShowS)
-> ([a] -> ShowS)
-> (Int -> a -> ShowS)
-> ([a] -> ShowS)
-> Int
-> Flip p a a
-> ShowS
forall a b.
(Int -> a -> ShowS)
-> ([a] -> ShowS)
-> (Int -> b -> ShowS)
-> ([b] -> ShowS)
-> Int
-> Flip p a b
-> ShowS
forall (f :: * -> * -> *) a b.
Show2 f =>
(Int -> a -> ShowS)
-> ([a] -> ShowS)
-> (Int -> b -> ShowS)
-> ([b] -> ShowS)
-> Int
-> f a b
-> ShowS
liftShowsPrec2 Int -> a -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec [a] -> ShowS
forall a. Show a => [a] -> ShowS
showList
instance Show2 p => Show2 (Flip p) where
  liftShowsPrec2 :: forall a b.
(Int -> a -> ShowS)
-> ([a] -> ShowS)
-> (Int -> b -> ShowS)
-> ([b] -> ShowS)
-> Int
-> Flip p a b
-> ShowS
liftShowsPrec2 Int -> a -> ShowS
sp1 [a] -> ShowS
sl1 Int -> b -> ShowS
sp2 [b] -> ShowS
sl2 Int
p (Flip p b a
x) = Bool -> ShowS -> ShowS
showParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
      String -> ShowS
showString String
"Flip {runFlip = "
    ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> b -> ShowS)
-> ([b] -> ShowS)
-> (Int -> a -> ShowS)
-> ([a] -> ShowS)
-> Int
-> p b a
-> ShowS
forall a b.
(Int -> a -> ShowS)
-> ([a] -> ShowS)
-> (Int -> b -> ShowS)
-> ([b] -> ShowS)
-> Int
-> p a b
-> ShowS
forall (f :: * -> * -> *) a b.
Show2 f =>
(Int -> a -> ShowS)
-> ([a] -> ShowS)
-> (Int -> b -> ShowS)
-> ([b] -> ShowS)
-> Int
-> f a b
-> ShowS
liftShowsPrec2 Int -> b -> ShowS
sp2 [b] -> ShowS
sl2 Int -> a -> ShowS
sp1 [a] -> ShowS
sl1 Int
0 p b a
x
    ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
'}'
#endif

instance Bifunctor p => Bifunctor (Flip p) where
  first :: forall a b c. (a -> b) -> Flip p a c -> Flip p b c
first a -> b
f = p c b -> Flip p b c
forall {k} {k} (p :: k -> k -> *) (a :: k) (b :: k).
p b a -> Flip p a b
Flip (p c b -> Flip p b c)
-> (Flip p a c -> p c b) -> Flip p a c -> Flip p b c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> p c a -> p c b
forall b c a. (b -> c) -> p a b -> p a c
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second a -> b
f (p c a -> p c b) -> (Flip p a c -> p c a) -> Flip p a c -> p c b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Flip p a c -> p c a
forall {k} {k} (p :: k -> k -> *) (a :: k) (b :: k).
Flip p a b -> p b a
runFlip
  {-# INLINE first #-}
  second :: forall b c a. (b -> c) -> Flip p a b -> Flip p a c
second b -> c
f = p c a -> Flip p a c
forall {k} {k} (p :: k -> k -> *) (a :: k) (b :: k).
p b a -> Flip p a b
Flip (p c a -> Flip p a c)
-> (Flip p a b -> p c a) -> Flip p a b -> Flip p a c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> c) -> p b a -> p c a
forall a b c. (a -> b) -> p a c -> p b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first b -> c
f (p b a -> p c a) -> (Flip p a b -> p b a) -> Flip p a b -> p c a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Flip p a b -> p b a
forall {k} {k} (p :: k -> k -> *) (a :: k) (b :: k).
Flip p a b -> p b a
runFlip
  {-# INLINE second #-}
  bimap :: forall a b c d. (a -> b) -> (c -> d) -> Flip p a c -> Flip p b d
bimap a -> b
f c -> d
g = p d b -> Flip p b d
forall {k} {k} (p :: k -> k -> *) (a :: k) (b :: k).
p b a -> Flip p a b
Flip (p d b -> Flip p b d)
-> (Flip p a c -> p d b) -> Flip p a c -> Flip p b d
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> d) -> (a -> b) -> p c a -> p d b
forall a b c d. (a -> b) -> (c -> d) -> p a c -> p b d
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap c -> d
g a -> b
f (p c a -> p d b) -> (Flip p a c -> p c a) -> Flip p a c -> p d b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Flip p a c -> p c a
forall {k} {k} (p :: k -> k -> *) (a :: k) (b :: k).
Flip p a b -> p b a
runFlip
  {-# INLINE bimap #-}

instance Bifunctor p => Functor (Flip p a) where
  fmap :: forall a b. (a -> b) -> Flip p a a -> Flip p a b
fmap a -> b
f = p b a -> Flip p a b
forall {k} {k} (p :: k -> k -> *) (a :: k) (b :: k).
p b a -> Flip p a b
Flip (p b a -> Flip p a b)
-> (Flip p a a -> p b a) -> Flip p a a -> Flip p a b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> p a a -> p b a
forall a b c. (a -> b) -> p a c -> p b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
f (p a a -> p b a) -> (Flip p a a -> p a a) -> Flip p a a -> p b a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Flip p a a -> p a a
forall {k} {k} (p :: k -> k -> *) (a :: k) (b :: k).
Flip p a b -> p b a
runFlip
  {-# INLINE fmap #-}

instance Biapplicative p => Biapplicative (Flip p) where
  bipure :: forall a b. a -> b -> Flip p a b
bipure a
a b
b = p b a -> Flip p a b
forall {k} {k} (p :: k -> k -> *) (a :: k) (b :: k).
p b a -> Flip p a b
Flip (b -> a -> p b a
forall a b. a -> b -> p a b
forall (p :: * -> * -> *) a b. Biapplicative p => a -> b -> p a b
bipure b
b a
a)
  {-# INLINE bipure #-}

  Flip p (c -> d) (a -> b)
fg <<*>> :: forall a b c d.
Flip p (a -> b) (c -> d) -> Flip p a c -> Flip p b d
<<*>> Flip p c a
xy = p d b -> Flip p b d
forall {k} {k} (p :: k -> k -> *) (a :: k) (b :: k).
p b a -> Flip p a b
Flip (p (c -> d) (a -> b)
fg p (c -> d) (a -> b) -> p c a -> p d b
forall a b c d. p (a -> b) (c -> d) -> p a c -> p b d
forall (p :: * -> * -> *) a b c d.
Biapplicative p =>
p (a -> b) (c -> d) -> p a c -> p b d
<<*>> p c a
xy)
  {-# INLINE (<<*>>) #-}

instance Bifoldable p => Bifoldable (Flip p) where
  bifoldMap :: forall m a b. Monoid m => (a -> m) -> (b -> m) -> Flip p a b -> m
bifoldMap a -> m
f b -> m
g = (b -> m) -> (a -> m) -> p b a -> m
forall m a b. Monoid m => (a -> m) -> (b -> m) -> p a b -> m
forall (p :: * -> * -> *) m a b.
(Bifoldable p, Monoid m) =>
(a -> m) -> (b -> m) -> p a b -> m
bifoldMap b -> m
g a -> m
f (p b a -> m) -> (Flip p a b -> p b a) -> Flip p a b -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Flip p a b -> p b a
forall {k} {k} (p :: k -> k -> *) (a :: k) (b :: k).
Flip p a b -> p b a
runFlip
  {-# INLINE bifoldMap #-}

instance Bifoldable p => Foldable (Flip p a) where
  foldMap :: forall m a. Monoid m => (a -> m) -> Flip p a a -> m
foldMap a -> m
f = (a -> m) -> (a -> m) -> p a a -> m
forall m a b. Monoid m => (a -> m) -> (b -> m) -> p a b -> m
forall (p :: * -> * -> *) m a b.
(Bifoldable p, Monoid m) =>
(a -> m) -> (b -> m) -> p a b -> m
bifoldMap a -> m
f (m -> a -> m
forall a b. a -> b -> a
const m
forall a. Monoid a => a
mempty) (p a a -> m) -> (Flip p a a -> p a a) -> Flip p a a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Flip p a a -> p a a
forall {k} {k} (p :: k -> k -> *) (a :: k) (b :: k).
Flip p a b -> p b a
runFlip
  {-# INLINE foldMap #-}

instance Bitraversable p => Bitraversable (Flip p) where
  bitraverse :: forall (f :: * -> *) a c b d.
Applicative f =>
(a -> f c) -> (b -> f d) -> Flip p a b -> f (Flip p c d)
bitraverse a -> f c
f b -> f d
g = (p d c -> Flip p c d) -> f (p d c) -> f (Flip p c d)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap p d c -> Flip p c d
forall {k} {k} (p :: k -> k -> *) (a :: k) (b :: k).
p b a -> Flip p a b
Flip (f (p d c) -> f (Flip p c d))
-> (Flip p a b -> f (p d c)) -> Flip p a b -> f (Flip p c d)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> f d) -> (a -> f c) -> p b a -> f (p d c)
forall (f :: * -> *) a c b d.
Applicative f =>
(a -> f c) -> (b -> f d) -> p a b -> f (p c d)
forall (t :: * -> * -> *) (f :: * -> *) a c b d.
(Bitraversable t, Applicative f) =>
(a -> f c) -> (b -> f d) -> t a b -> f (t c d)
bitraverse b -> f d
g a -> f c
f (p b a -> f (p d c))
-> (Flip p a b -> p b a) -> Flip p a b -> f (p d c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Flip p a b -> p b a
forall {k} {k} (p :: k -> k -> *) (a :: k) (b :: k).
Flip p a b -> p b a
runFlip
  {-# INLINE bitraverse #-}

instance Bitraversable p => Traversable (Flip p a) where
  traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Flip p a a -> f (Flip p a b)
traverse a -> f b
f = (p b a -> Flip p a b) -> f (p b a) -> f (Flip p a b)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap p b a -> Flip p a b
forall {k} {k} (p :: k -> k -> *) (a :: k) (b :: k).
p b a -> Flip p a b
Flip (f (p b a) -> f (Flip p a b))
-> (Flip p a a -> f (p b a)) -> Flip p a a -> f (Flip p a b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f b) -> (a -> f a) -> p a a -> f (p b a)
forall (f :: * -> *) a c b d.
Applicative f =>
(a -> f c) -> (b -> f d) -> p a b -> f (p c d)
forall (t :: * -> * -> *) (f :: * -> *) a c b d.
(Bitraversable t, Applicative f) =>
(a -> f c) -> (b -> f d) -> t a b -> f (t c d)
bitraverse a -> f b
f a -> f a
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (p a a -> f (p b a))
-> (Flip p a a -> p a a) -> Flip p a a -> f (p b a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Flip p a a -> p a a
forall {k} {k} (p :: k -> k -> *) (a :: k) (b :: k).
Flip p a b -> p b a
runFlip
  {-# INLINE traverse #-}

instance BifunctorFunctor Flip where
  bifmap :: forall (p :: k3 -> k2 -> *) (q :: k3 -> k2 -> *).
(p :-> q) -> Flip p :-> Flip q
bifmap p :-> q
f (Flip p b a
p) = q b a -> Flip q a b
forall {k} {k} (p :: k -> k -> *) (a :: k) (b :: k).
p b a -> Flip p a b
Flip (p b a -> q b a
p :-> q
f p b a
p)