{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GeneralisedNewtypeDeriving #-}
{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE QuantifiedConstraints #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE StandaloneKindSignatures #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}

{-# OPTIONS_GHC -Wno-orphans #-}

-- | Ledger tables are barbie-types (see @barbies@ package), though unfortunately
-- we can not implement classes like 'FunctorB' for ledger tables because the
-- class expects a type that is indexed over a /(uni-)functor/. Ledger tables
-- are indexed over /bifunctors/ (mapkinds), so the kinds do not match. To cut
-- on boilerplate, we do not define variants of 'FunctorB' (and similar classes)
-- for types that are indexed over bifunctors. Instead, we define specialised
-- variants of class functions and utility functions. For example:
--
-- * 'ltmap' instead of 'bmap' or 'bmapC'
--
-- * 'lttraverse' instead of 'btraverse' or 'btraverseC'
--
-- * 'ltsequence' instead of 'bsequence'.
--
-- TODO: if we make mapkinds of kind @(k1, k2) -> Type@ instead of @k1 -> k2 ->
-- Type@, then we could reuse most of the @barbies@ machinery.
module Ouroboros.Consensus.Ledger.Tables.Combinators (
    -- * Common constraints
    LedgerTableConstraints
    -- * Functor
  , ltmap
    -- * Traversable
  , lttraverse
    -- ** Utility functions
  , ltsequence
    -- * Applicative
  , ltprod
  , ltpure
    -- ** Utility functions
  , ltap
  , ltliftA
  , ltliftA2
  , ltliftA3
  , ltliftA4
    -- * Applicative and Traversable
  , ltzipWith2A
    -- * Collapsing
  , ltcollapse
    -- * Lifted functions
  , fn2_1
  , fn2_2
  , fn2_3
  , fn2_4
  , type (-..->) (..)
    -- ** Re-exports of utils
  , (...:)
  , (..:)
  , (.:)
    -- * Basic bifunctors
  , K2 (..)
  , type (:..:) (..)
  ) where

import           Data.Bifunctor
import           Data.Kind
import           Data.SOP.Functors
import           Ouroboros.Consensus.Ledger.Tables.Basics
import           Ouroboros.Consensus.Ledger.Tables.MapKind
import           Ouroboros.Consensus.Util ((...:), (..:), (.:))
import           Ouroboros.Consensus.Util.IndexedMemPack

{-------------------------------------------------------------------------------
  Common constraints
-------------------------------------------------------------------------------}

-- | The @Eq (TxOut l)@ constraint is here only because of
-- 'Ouroboros.Consensus.Ledger.Tables.Diff.diff'. Once the ledger provides
-- deltas instead of us being the ones that compute them, we can probably drop
-- this constraint.
type LedgerTableConstraints l =
  ( Ord (TxIn l), Eq (TxOut l), MemPack (TxIn l)
  , IndexedMemPack (MemPackIdx l EmptyMK) (TxOut l)
  )

type LedgerTableConstraints' l k v =
  ( Ord k, Eq v
  , MemPack k
  , IndexedMemPack (MemPackIdx l EmptyMK) v
  )

{-------------------------------------------------------------------------------
  Functor
-------------------------------------------------------------------------------}

-- | Like 'bmap', but for ledger tables.
ltmap ::
     LedgerTableConstraints l
  => (forall k v. (LedgerTableConstraints' l k v) => mk1 k v -> mk2 k v)
  -> LedgerTables l mk1
  -> LedgerTables l mk2
ltmap :: forall (l :: LedgerStateKind) (mk1 :: MapKind) (mk2 :: MapKind).
LedgerTableConstraints l =>
(forall k v. LedgerTableConstraints' l k v => mk1 k v -> mk2 k v)
-> LedgerTables l mk1 -> LedgerTables l mk2
ltmap forall k v. LedgerTableConstraints' l k v => mk1 k v -> mk2 k v
f (LedgerTables mk1 (TxIn l) (TxOut l)
x) = mk2 (TxIn l) (TxOut l) -> LedgerTables l mk2
forall (l :: LedgerStateKind) (mk :: MapKind).
mk (TxIn l) (TxOut l) -> LedgerTables l mk
LedgerTables (mk2 (TxIn l) (TxOut l) -> LedgerTables l mk2)
-> mk2 (TxIn l) (TxOut l) -> LedgerTables l mk2
forall a b. (a -> b) -> a -> b
$ mk1 (TxIn l) (TxOut l) -> mk2 (TxIn l) (TxOut l)
forall k v. LedgerTableConstraints' l k v => mk1 k v -> mk2 k v
f mk1 (TxIn l) (TxOut l)
x

{-------------------------------------------------------------------------------
  Traversable
-------------------------------------------------------------------------------}

-- | Like 'btraverse', but for ledger tables.
lttraverse ::
     (Applicative f, LedgerTableConstraints l)
  => (forall k v. (LedgerTableConstraints' l k v) => mk1 k v -> f (mk2 k v))
  -> LedgerTables l mk1
  -> f (LedgerTables l mk2)
lttraverse :: forall (f :: * -> *) (l :: LedgerStateKind) (mk1 :: MapKind)
       (mk2 :: MapKind).
(Applicative f, LedgerTableConstraints l) =>
(forall k v.
 LedgerTableConstraints' l k v =>
 mk1 k v -> f (mk2 k v))
-> LedgerTables l mk1 -> f (LedgerTables l mk2)
lttraverse forall k v. LedgerTableConstraints' l k v => mk1 k v -> f (mk2 k v)
f (LedgerTables mk1 (TxIn l) (TxOut l)
x) = mk2 (TxIn l) (TxOut l) -> LedgerTables l mk2
forall (l :: LedgerStateKind) (mk :: MapKind).
mk (TxIn l) (TxOut l) -> LedgerTables l mk
LedgerTables (mk2 (TxIn l) (TxOut l) -> LedgerTables l mk2)
-> f (mk2 (TxIn l) (TxOut l)) -> f (LedgerTables l mk2)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> mk1 (TxIn l) (TxOut l) -> f (mk2 (TxIn l) (TxOut l))
forall k v. LedgerTableConstraints' l k v => mk1 k v -> f (mk2 k v)
f mk1 (TxIn l) (TxOut l)
x

--
-- Utility functions
--

ltsequence ::
     (Applicative f, LedgerTableConstraints l)
  => LedgerTables l (f :..: mk)
  -> f (LedgerTables l mk)
ltsequence :: forall (f :: * -> *) (l :: LedgerStateKind) (mk :: MapKind).
(Applicative f, LedgerTableConstraints l) =>
LedgerTables l (f :..: mk) -> f (LedgerTables l mk)
ltsequence = (forall k v.
 LedgerTableConstraints' l k v =>
 (:..:) f mk k v -> f (mk k v))
-> LedgerTables l (f :..: mk) -> f (LedgerTables l mk)
forall (f :: * -> *) (l :: LedgerStateKind) (mk1 :: MapKind)
       (mk2 :: MapKind).
(Applicative f, LedgerTableConstraints l) =>
(forall k v.
 LedgerTableConstraints' l k v =>
 mk1 k v -> f (mk2 k v))
-> LedgerTables l mk1 -> f (LedgerTables l mk2)
lttraverse (:..:) f mk k v -> f (mk k v)
forall k v.
LedgerTableConstraints' l k v =>
(:..:) f mk k v -> f (mk k v)
forall k3 k1 k2 (f :: k3 -> *) (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
(:..:) f g a b -> f (g a b)
unComp2

{-------------------------------------------------------------------------------
  Applicative
-------------------------------------------------------------------------------}

-- | Like 'bpure', but for ledger tables.
ltpure ::
       LedgerTableConstraints l
    => (forall k v. (LedgerTableConstraints' l k v) => mk k v)
    -> LedgerTables l mk
ltpure :: forall (l :: LedgerStateKind) (mk :: MapKind).
LedgerTableConstraints l =>
(forall k v. LedgerTableConstraints' l k v => mk k v)
-> LedgerTables l mk
ltpure = mk (TxIn l) (TxOut l) -> LedgerTables l mk
(forall k v. LedgerTableConstraints' l k v => mk k v)
-> LedgerTables l mk
forall (l :: LedgerStateKind) (mk :: MapKind).
mk (TxIn l) (TxOut l) -> LedgerTables l mk
LedgerTables

-- | Like 'bprod', but for ledger tables.
ltprod :: LedgerTables l f -> LedgerTables l g -> LedgerTables l (f `Product2` g)
ltprod :: forall (l :: LedgerStateKind) (f :: MapKind) (g :: MapKind).
LedgerTables l f
-> LedgerTables l g -> LedgerTables l (Product2 f g)
ltprod (LedgerTables f (TxIn l) (TxOut l)
x) (LedgerTables g (TxIn l) (TxOut l)
y) = Product2 f g (TxIn l) (TxOut l) -> LedgerTables l (Product2 f g)
forall (l :: LedgerStateKind) (mk :: MapKind).
mk (TxIn l) (TxOut l) -> LedgerTables l mk
LedgerTables (f (TxIn l) (TxOut l)
-> g (TxIn l) (TxOut l) -> Product2 f g (TxIn l) (TxOut l)
forall (f :: MapKind) (g :: MapKind) x y.
f x y -> g x y -> Product2 f g x y
Pair2 f (TxIn l) (TxOut l)
x g (TxIn l) (TxOut l)
y)

--
-- Utility functions
--

ltap ::
     LedgerTableConstraints l
  => LedgerTables l (mk1 -..-> mk2)
  -> LedgerTables l mk1
  -> LedgerTables l mk2
ltap :: forall (l :: LedgerStateKind) (mk1 :: MapKind) (mk2 :: MapKind).
LedgerTableConstraints l =>
LedgerTables l (mk1 -..-> mk2)
-> LedgerTables l mk1 -> LedgerTables l mk2
ltap LedgerTables l (mk1 -..-> mk2)
f LedgerTables l mk1
x = (forall k v.
 LedgerTableConstraints' l k v =>
 Product2 (mk1 -..-> mk2) mk1 k v -> mk2 k v)
-> LedgerTables l (Product2 (mk1 -..-> mk2) mk1)
-> LedgerTables l mk2
forall (l :: LedgerStateKind) (mk1 :: MapKind) (mk2 :: MapKind).
LedgerTableConstraints l =>
(forall k v. LedgerTableConstraints' l k v => mk1 k v -> mk2 k v)
-> LedgerTables l mk1 -> LedgerTables l mk2
ltmap Product2 (mk1 -..-> mk2) mk1 k v -> mk2 k v
forall k v.
LedgerTableConstraints' l k v =>
Product2 (mk1 -..-> mk2) mk1 k v -> mk2 k v
forall {f :: MapKind} {g :: MapKind} {a} {b}.
Product2 (f -..-> g) f a b -> g a b
g (LedgerTables l (Product2 (mk1 -..-> mk2) mk1)
 -> LedgerTables l mk2)
-> LedgerTables l (Product2 (mk1 -..-> mk2) mk1)
-> LedgerTables l mk2
forall a b. (a -> b) -> a -> b
$ LedgerTables l (mk1 -..-> mk2)
-> LedgerTables l mk1
-> LedgerTables l (Product2 (mk1 -..-> mk2) mk1)
forall (l :: LedgerStateKind) (f :: MapKind) (g :: MapKind).
LedgerTables l f
-> LedgerTables l g -> LedgerTables l (Product2 f g)
ltprod LedgerTables l (mk1 -..-> mk2)
f LedgerTables l mk1
x
  where g :: Product2 (f -..-> g) f a b -> g a b
g (Pair2 (-..->) f g a b
f' f a b
x') = (-..->) f g a b -> f a b -> g a b
forall k1 k2 (f :: k1 -> k2 -> *) (g :: k1 -> k2 -> *) (a :: k1)
       (b :: k2).
(-..->) f g a b -> f a b -> g a b
apFn2 (-..->) f g a b
f' f a b
x'

ltliftA ::
     LedgerTableConstraints l
  => (forall k v. (LedgerTableConstraints' l k v) => mk1 k v -> mk2 k v)
  -> LedgerTables l mk1
  -> LedgerTables l mk2
ltliftA :: forall (l :: LedgerStateKind) (mk1 :: MapKind) (mk2 :: MapKind).
LedgerTableConstraints l =>
(forall k v. LedgerTableConstraints' l k v => mk1 k v -> mk2 k v)
-> LedgerTables l mk1 -> LedgerTables l mk2
ltliftA forall k v. LedgerTableConstraints' l k v => mk1 k v -> mk2 k v
f LedgerTables l mk1
x = (forall k v. LedgerTableConstraints' l k v => (-..->) mk1 mk2 k v)
-> LedgerTables l (mk1 -..-> mk2)
forall (l :: LedgerStateKind) (mk :: MapKind).
LedgerTableConstraints l =>
(forall k v. LedgerTableConstraints' l k v => mk k v)
-> LedgerTables l mk
ltpure ((mk1 k v -> mk2 k v) -> (-..->) mk1 mk2 k v
forall {k1} {k2} (f :: k1 -> k2 -> *) (a :: k1) (b :: k2)
       (g :: k1 -> k2 -> *).
(f a b -> g a b) -> (-..->) f g a b
fn2_1 mk1 k v -> mk2 k v
forall k v. LedgerTableConstraints' l k v => mk1 k v -> mk2 k v
f) LedgerTables l (mk1 -..-> mk2)
-> LedgerTables l mk1 -> LedgerTables l mk2
forall (l :: LedgerStateKind) (mk1 :: MapKind) (mk2 :: MapKind).
LedgerTableConstraints l =>
LedgerTables l (mk1 -..-> mk2)
-> LedgerTables l mk1 -> LedgerTables l mk2
`ltap` LedgerTables l mk1
x

ltliftA2 ::
     LedgerTableConstraints l
  => (forall k v. (LedgerTableConstraints' l k v) => mk1 k v -> mk2 k v -> mk3 k v)
  -> LedgerTables l mk1
  -> LedgerTables l mk2
  -> LedgerTables l mk3
ltliftA2 :: forall (l :: LedgerStateKind) (mk1 :: MapKind) (mk2 :: MapKind)
       (mk3 :: MapKind).
LedgerTableConstraints l =>
(forall k v.
 LedgerTableConstraints' l k v =>
 mk1 k v -> mk2 k v -> mk3 k v)
-> LedgerTables l mk1 -> LedgerTables l mk2 -> LedgerTables l mk3
ltliftA2 forall k v.
LedgerTableConstraints' l k v =>
mk1 k v -> mk2 k v -> mk3 k v
f LedgerTables l mk1
x LedgerTables l mk2
x' = (forall k v.
 LedgerTableConstraints' l k v =>
 (-..->) mk1 (mk2 -..-> mk3) k v)
-> LedgerTables l (mk1 -..-> (mk2 -..-> mk3))
forall (l :: LedgerStateKind) (mk :: MapKind).
LedgerTableConstraints l =>
(forall k v. LedgerTableConstraints' l k v => mk k v)
-> LedgerTables l mk
ltpure ((mk1 k v -> mk2 k v -> mk3 k v) -> (-..->) mk1 (mk2 -..-> mk3) k v
forall {k1} {k2} (f :: k1 -> k2 -> *) (a :: k1) (b :: k2)
       (f' :: k1 -> k2 -> *) (f'' :: k1 -> k2 -> *).
(f a b -> f' a b -> f'' a b) -> (-..->) f (f' -..-> f'') a b
fn2_2 mk1 k v -> mk2 k v -> mk3 k v
forall k v.
LedgerTableConstraints' l k v =>
mk1 k v -> mk2 k v -> mk3 k v
f) LedgerTables l (mk1 -..-> (mk2 -..-> mk3))
-> LedgerTables l mk1 -> LedgerTables l (mk2 -..-> mk3)
forall (l :: LedgerStateKind) (mk1 :: MapKind) (mk2 :: MapKind).
LedgerTableConstraints l =>
LedgerTables l (mk1 -..-> mk2)
-> LedgerTables l mk1 -> LedgerTables l mk2
`ltap` LedgerTables l mk1
x LedgerTables l (mk2 -..-> mk3)
-> LedgerTables l mk2 -> LedgerTables l mk3
forall (l :: LedgerStateKind) (mk1 :: MapKind) (mk2 :: MapKind).
LedgerTableConstraints l =>
LedgerTables l (mk1 -..-> mk2)
-> LedgerTables l mk1 -> LedgerTables l mk2
`ltap` LedgerTables l mk2
x'

ltliftA3 ::
     LedgerTableConstraints l
  => (forall k v. (LedgerTableConstraints' l k v) => mk1 k v -> mk2 k v -> mk3 k v -> mk4 k v)
  -> LedgerTables l mk1
  -> LedgerTables l mk2
  -> LedgerTables l mk3
  -> LedgerTables l mk4
ltliftA3 :: forall (l :: LedgerStateKind) (mk1 :: MapKind) (mk2 :: MapKind)
       (mk3 :: MapKind) (mk4 :: MapKind).
LedgerTableConstraints l =>
(forall k v.
 LedgerTableConstraints' l k v =>
 mk1 k v -> mk2 k v -> mk3 k v -> mk4 k v)
-> LedgerTables l mk1
-> LedgerTables l mk2
-> LedgerTables l mk3
-> LedgerTables l mk4
ltliftA3 forall k v.
LedgerTableConstraints' l k v =>
mk1 k v -> mk2 k v -> mk3 k v -> mk4 k v
f LedgerTables l mk1
x LedgerTables l mk2
x' LedgerTables l mk3
x'' = (forall k v.
 LedgerTableConstraints' l k v =>
 (-..->) mk1 (mk2 -..-> (mk3 -..-> mk4)) k v)
-> LedgerTables l (mk1 -..-> (mk2 -..-> (mk3 -..-> mk4)))
forall (l :: LedgerStateKind) (mk :: MapKind).
LedgerTableConstraints l =>
(forall k v. LedgerTableConstraints' l k v => mk k v)
-> LedgerTables l mk
ltpure ((mk1 k v -> mk2 k v -> mk3 k v -> mk4 k v)
-> (-..->) mk1 (mk2 -..-> (mk3 -..-> mk4)) k v
forall {k1} {k2} (f :: k1 -> k2 -> *) (a :: k1) (b :: k2)
       (f' :: k1 -> k2 -> *) (f'' :: k1 -> k2 -> *)
       (f''' :: k1 -> k2 -> *).
(f a b -> f' a b -> f'' a b -> f''' a b)
-> (-..->) f (f' -..-> (f'' -..-> f''')) a b
fn2_3 mk1 k v -> mk2 k v -> mk3 k v -> mk4 k v
forall k v.
LedgerTableConstraints' l k v =>
mk1 k v -> mk2 k v -> mk3 k v -> mk4 k v
f) LedgerTables l (mk1 -..-> (mk2 -..-> (mk3 -..-> mk4)))
-> LedgerTables l mk1 -> LedgerTables l (mk2 -..-> (mk3 -..-> mk4))
forall (l :: LedgerStateKind) (mk1 :: MapKind) (mk2 :: MapKind).
LedgerTableConstraints l =>
LedgerTables l (mk1 -..-> mk2)
-> LedgerTables l mk1 -> LedgerTables l mk2
`ltap` LedgerTables l mk1
x LedgerTables l (mk2 -..-> (mk3 -..-> mk4))
-> LedgerTables l mk2 -> LedgerTables l (mk3 -..-> mk4)
forall (l :: LedgerStateKind) (mk1 :: MapKind) (mk2 :: MapKind).
LedgerTableConstraints l =>
LedgerTables l (mk1 -..-> mk2)
-> LedgerTables l mk1 -> LedgerTables l mk2
`ltap` LedgerTables l mk2
x' LedgerTables l (mk3 -..-> mk4)
-> LedgerTables l mk3 -> LedgerTables l mk4
forall (l :: LedgerStateKind) (mk1 :: MapKind) (mk2 :: MapKind).
LedgerTableConstraints l =>
LedgerTables l (mk1 -..-> mk2)
-> LedgerTables l mk1 -> LedgerTables l mk2
`ltap` LedgerTables l mk3
x''

ltliftA4 ::
     LedgerTableConstraints l
  => (    forall k v. (LedgerTableConstraints' l k v)
       => mk1 k v -> mk2 k v -> mk3 k v -> mk4 k v -> mk5 k v
     )
  -> LedgerTables l mk1
  -> LedgerTables l mk2
  -> LedgerTables l mk3
  -> LedgerTables l mk4
  -> LedgerTables l mk5
ltliftA4 :: forall (l :: LedgerStateKind) (mk1 :: MapKind) (mk2 :: MapKind)
       (mk3 :: MapKind) (mk4 :: MapKind) (mk5 :: MapKind).
LedgerTableConstraints l =>
(forall k v.
 LedgerTableConstraints' l k v =>
 mk1 k v -> mk2 k v -> mk3 k v -> mk4 k v -> mk5 k v)
-> LedgerTables l mk1
-> LedgerTables l mk2
-> LedgerTables l mk3
-> LedgerTables l mk4
-> LedgerTables l mk5
ltliftA4 forall k v.
LedgerTableConstraints' l k v =>
mk1 k v -> mk2 k v -> mk3 k v -> mk4 k v -> mk5 k v
f LedgerTables l mk1
x LedgerTables l mk2
x' LedgerTables l mk3
x'' LedgerTables l mk4
x''' =
  (forall k v.
 LedgerTableConstraints' l k v =>
 (-..->) mk1 (mk2 -..-> (mk3 -..-> (mk4 -..-> mk5))) k v)
-> LedgerTables
     l (mk1 -..-> (mk2 -..-> (mk3 -..-> (mk4 -..-> mk5))))
forall (l :: LedgerStateKind) (mk :: MapKind).
LedgerTableConstraints l =>
(forall k v. LedgerTableConstraints' l k v => mk k v)
-> LedgerTables l mk
ltpure ((mk1 k v -> mk2 k v -> mk3 k v -> mk4 k v -> mk5 k v)
-> (-..->) mk1 (mk2 -..-> (mk3 -..-> (mk4 -..-> mk5))) k v
forall {k1} {k2} (f :: k1 -> k2 -> *) (a :: k1) (b :: k2)
       (f' :: k1 -> k2 -> *) (f'' :: k1 -> k2 -> *)
       (f''' :: k1 -> k2 -> *) (f'''' :: k1 -> k2 -> *).
(f a b -> f' a b -> f'' a b -> f''' a b -> f'''' a b)
-> (-..->) f (f' -..-> (f'' -..-> (f''' -..-> f''''))) a b
fn2_4 mk1 k v -> mk2 k v -> mk3 k v -> mk4 k v -> mk5 k v
forall k v.
LedgerTableConstraints' l k v =>
mk1 k v -> mk2 k v -> mk3 k v -> mk4 k v -> mk5 k v
f) LedgerTables l (mk1 -..-> (mk2 -..-> (mk3 -..-> (mk4 -..-> mk5))))
-> LedgerTables l mk1
-> LedgerTables l (mk2 -..-> (mk3 -..-> (mk4 -..-> mk5)))
forall (l :: LedgerStateKind) (mk1 :: MapKind) (mk2 :: MapKind).
LedgerTableConstraints l =>
LedgerTables l (mk1 -..-> mk2)
-> LedgerTables l mk1 -> LedgerTables l mk2
`ltap` LedgerTables l mk1
x LedgerTables l (mk2 -..-> (mk3 -..-> (mk4 -..-> mk5)))
-> LedgerTables l mk2 -> LedgerTables l (mk3 -..-> (mk4 -..-> mk5))
forall (l :: LedgerStateKind) (mk1 :: MapKind) (mk2 :: MapKind).
LedgerTableConstraints l =>
LedgerTables l (mk1 -..-> mk2)
-> LedgerTables l mk1 -> LedgerTables l mk2
`ltap` LedgerTables l mk2
x' LedgerTables l (mk3 -..-> (mk4 -..-> mk5))
-> LedgerTables l mk3 -> LedgerTables l (mk4 -..-> mk5)
forall (l :: LedgerStateKind) (mk1 :: MapKind) (mk2 :: MapKind).
LedgerTableConstraints l =>
LedgerTables l (mk1 -..-> mk2)
-> LedgerTables l mk1 -> LedgerTables l mk2
`ltap` LedgerTables l mk3
x'' LedgerTables l (mk4 -..-> mk5)
-> LedgerTables l mk4 -> LedgerTables l mk5
forall (l :: LedgerStateKind) (mk1 :: MapKind) (mk2 :: MapKind).
LedgerTableConstraints l =>
LedgerTables l (mk1 -..-> mk2)
-> LedgerTables l mk1 -> LedgerTables l mk2
`ltap` LedgerTables l mk4
x'''

{-------------------------------------------------------------------------------
  Applicative and Traversable
-------------------------------------------------------------------------------}

ltzipWith2A ::
     (Applicative f, LedgerTableConstraints l)
  => (forall k v. LedgerTableConstraints' l k v => mk1 k v -> mk2 k v -> f (mk3 k v))
  -> LedgerTables l mk1
  -> LedgerTables l mk2
  -> f (LedgerTables l mk3)
ltzipWith2A :: forall (f :: * -> *) (l :: LedgerStateKind) (mk1 :: MapKind)
       (mk2 :: MapKind) (mk3 :: MapKind).
(Applicative f, LedgerTableConstraints l) =>
(forall k v.
 LedgerTableConstraints' l k v =>
 mk1 k v -> mk2 k v -> f (mk3 k v))
-> LedgerTables l mk1
-> LedgerTables l mk2
-> f (LedgerTables l mk3)
ltzipWith2A forall k v.
LedgerTableConstraints' l k v =>
mk1 k v -> mk2 k v -> f (mk3 k v)
f = LedgerTables l (f :..: mk3) -> f (LedgerTables l mk3)
forall (f :: * -> *) (l :: LedgerStateKind) (mk :: MapKind).
(Applicative f, LedgerTableConstraints l) =>
LedgerTables l (f :..: mk) -> f (LedgerTables l mk)
ltsequence (LedgerTables l (f :..: mk3) -> f (LedgerTables l mk3))
-> (LedgerTables l mk1
    -> LedgerTables l mk2 -> LedgerTables l (f :..: mk3))
-> LedgerTables l mk1
-> LedgerTables l mk2
-> f (LedgerTables l mk3)
forall y z x0 x1. (y -> z) -> (x0 -> x1 -> y) -> x0 -> x1 -> z
.: (forall k v.
 LedgerTableConstraints' l k v =>
 mk1 k v -> mk2 k v -> (:..:) f mk3 k v)
-> LedgerTables l mk1
-> LedgerTables l mk2
-> LedgerTables l (f :..: mk3)
forall (l :: LedgerStateKind) (mk1 :: MapKind) (mk2 :: MapKind)
       (mk3 :: MapKind).
LedgerTableConstraints l =>
(forall k v.
 LedgerTableConstraints' l k v =>
 mk1 k v -> mk2 k v -> mk3 k v)
-> LedgerTables l mk1 -> LedgerTables l mk2 -> LedgerTables l mk3
ltliftA2 (f (mk3 k v) -> (:..:) f mk3 k v
forall k3 k1 k2 (f :: k3 -> *) (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
f (g a b) -> (:..:) f g a b
Comp2 (f (mk3 k v) -> (:..:) f mk3 k v)
-> (mk1 k v -> mk2 k v -> f (mk3 k v))
-> mk1 k v
-> mk2 k v
-> (:..:) f mk3 k v
forall y z x0 x1. (y -> z) -> (x0 -> x1 -> y) -> x0 -> x1 -> z
.: mk1 k v -> mk2 k v -> f (mk3 k v)
forall k v.
LedgerTableConstraints' l k v =>
mk1 k v -> mk2 k v -> f (mk3 k v)
f)

{-------------------------------------------------------------------------------
  Collapsing
-------------------------------------------------------------------------------}

ltcollapse :: LedgerTables l (K2 a) -> a
ltcollapse :: forall (l :: LedgerStateKind) a. LedgerTables l (K2 a) -> a
ltcollapse = K2 a (TxIn l) (TxOut l) -> a
forall k1 k2 a (b :: k1) (c :: k2). K2 a b c -> a
unK2 (K2 a (TxIn l) (TxOut l) -> a)
-> (LedgerTables l (K2 a) -> K2 a (TxIn l) (TxOut l))
-> LedgerTables l (K2 a)
-> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LedgerTables l (K2 a) -> K2 a (TxIn l) (TxOut l)
forall (l :: LedgerStateKind) (mk :: MapKind).
LedgerTables l mk -> mk (TxIn l) (TxOut l)
getLedgerTables

{-------------------------------------------------------------------------------
  Semigroup and Monoid
-------------------------------------------------------------------------------}

instance ( forall k v. (LedgerTableConstraints' l k v) => Semigroup (mk k v)
         , LedgerTableConstraints l
         ) => Semigroup (LedgerTables l mk) where
  (<>) :: LedgerTables l mk -> LedgerTables l mk -> LedgerTables l mk
  <> :: LedgerTables l mk -> LedgerTables l mk -> LedgerTables l mk
(<>) = (forall k v.
 LedgerTableConstraints' l k v =>
 mk k v -> mk k v -> mk k v)
-> LedgerTables l mk -> LedgerTables l mk -> LedgerTables l mk
forall (l :: LedgerStateKind) (mk1 :: MapKind) (mk2 :: MapKind)
       (mk3 :: MapKind).
LedgerTableConstraints l =>
(forall k v.
 LedgerTableConstraints' l k v =>
 mk1 k v -> mk2 k v -> mk3 k v)
-> LedgerTables l mk1 -> LedgerTables l mk2 -> LedgerTables l mk3
ltliftA2 mk k v -> mk k v -> mk k v
forall a. Semigroup a => a -> a -> a
forall k v.
LedgerTableConstraints' l k v =>
mk k v -> mk k v -> mk k v
(<>)

instance ( forall k v. (LedgerTableConstraints' l k v) => Monoid (mk k v)
         , LedgerTableConstraints l
         ) => Monoid (LedgerTables l mk) where
  mempty :: LedgerTables l mk
  mempty :: LedgerTables l mk
mempty = (forall k v. LedgerTableConstraints' l k v => mk k v)
-> LedgerTables l mk
forall (l :: LedgerStateKind) (mk :: MapKind).
LedgerTableConstraints l =>
(forall k v. LedgerTableConstraints' l k v => mk k v)
-> LedgerTables l mk
ltpure mk k v
forall a. Monoid a => a
forall k v. LedgerTableConstraints' l k v => mk k v
mempty

{-------------------------------------------------------------------------------
  Lifted functions
-------------------------------------------------------------------------------}

-- | Lifted functions
--
-- Similar to '(-.->)', but for @f@ and @g@ that are bifunctors.
type (-..->) :: (k1 -> k2 -> Type) -> (k1 -> k2 -> Type) -> k1 -> k2 -> Type
newtype (f -..-> g) a b = Fn2 { forall k1 k2 (f :: k1 -> k2 -> *) (g :: k1 -> k2 -> *) (a :: k1)
       (b :: k2).
(-..->) f g a b -> f a b -> g a b
apFn2 :: f a b -> g a b }

infixr 1 -..->

-- | Construct a lifted function.
fn2_1 :: (f a b -> g a b) -> (f -..-> g) a b
fn2_1 :: forall {k1} {k2} (f :: k1 -> k2 -> *) (a :: k1) (b :: k2)
       (g :: k1 -> k2 -> *).
(f a b -> g a b) -> (-..->) f g a b
fn2_1 = (f a b -> g a b) -> (-..->) f g a b
forall k1 k2 (f :: k1 -> k2 -> *) (g :: k1 -> k2 -> *) (a :: k1)
       (b :: k2).
(f a b -> g a b) -> (-..->) f g a b
Fn2

-- | Construct a binary lifted function
fn2_2 :: (f a b -> f' a b -> f'' a b ) -> (f -..-> f' -..-> f'') a b
fn2_2 :: forall {k1} {k2} (f :: k1 -> k2 -> *) (a :: k1) (b :: k2)
       (f' :: k1 -> k2 -> *) (f'' :: k1 -> k2 -> *).
(f a b -> f' a b -> f'' a b) -> (-..->) f (f' -..-> f'') a b
fn2_2 f a b -> f' a b -> f'' a b
f = (f a b -> (-..->) f' f'' a b) -> (-..->) f (f' -..-> f'') a b
forall k1 k2 (f :: k1 -> k2 -> *) (g :: k1 -> k2 -> *) (a :: k1)
       (b :: k2).
(f a b -> g a b) -> (-..->) f g a b
Fn2 ((f a b -> (-..->) f' f'' a b) -> (-..->) f (f' -..-> f'') a b)
-> (f a b -> (-..->) f' f'' a b) -> (-..->) f (f' -..-> f'') a b
forall a b. (a -> b) -> a -> b
$ \f a b
x -> (f' a b -> f'' a b) -> (-..->) f' f'' a b
forall k1 k2 (f :: k1 -> k2 -> *) (g :: k1 -> k2 -> *) (a :: k1)
       (b :: k2).
(f a b -> g a b) -> (-..->) f g a b
Fn2 ((f' a b -> f'' a b) -> (-..->) f' f'' a b)
-> (f' a b -> f'' a b) -> (-..->) f' f'' a b
forall a b. (a -> b) -> a -> b
$ \f' a b
x' -> f a b -> f' a b -> f'' a b
f f a b
x f' a b
x'

-- | Construct a ternary lifted function.
fn2_3 ::
     (f a b -> f' a b -> f'' a b -> f''' a b)
  -> (f -..-> f' -..-> f'' -..-> f''') a b
fn2_3 :: forall {k1} {k2} (f :: k1 -> k2 -> *) (a :: k1) (b :: k2)
       (f' :: k1 -> k2 -> *) (f'' :: k1 -> k2 -> *)
       (f''' :: k1 -> k2 -> *).
(f a b -> f' a b -> f'' a b -> f''' a b)
-> (-..->) f (f' -..-> (f'' -..-> f''')) a b
fn2_3 f a b -> f' a b -> f'' a b -> f''' a b
f = (f a b -> (-..->) f' (f'' -..-> f''') a b)
-> (-..->) f (f' -..-> (f'' -..-> f''')) a b
forall k1 k2 (f :: k1 -> k2 -> *) (g :: k1 -> k2 -> *) (a :: k1)
       (b :: k2).
(f a b -> g a b) -> (-..->) f g a b
Fn2 ((f a b -> (-..->) f' (f'' -..-> f''') a b)
 -> (-..->) f (f' -..-> (f'' -..-> f''')) a b)
-> (f a b -> (-..->) f' (f'' -..-> f''') a b)
-> (-..->) f (f' -..-> (f'' -..-> f''')) a b
forall a b. (a -> b) -> a -> b
$ \f a b
x -> (f' a b -> (-..->) f'' f''' a b) -> (-..->) f' (f'' -..-> f''') a b
forall k1 k2 (f :: k1 -> k2 -> *) (g :: k1 -> k2 -> *) (a :: k1)
       (b :: k2).
(f a b -> g a b) -> (-..->) f g a b
Fn2 ((f' a b -> (-..->) f'' f''' a b)
 -> (-..->) f' (f'' -..-> f''') a b)
-> (f' a b -> (-..->) f'' f''' a b)
-> (-..->) f' (f'' -..-> f''') a b
forall a b. (a -> b) -> a -> b
$ \f' a b
x' -> (f'' a b -> f''' a b) -> (-..->) f'' f''' a b
forall k1 k2 (f :: k1 -> k2 -> *) (g :: k1 -> k2 -> *) (a :: k1)
       (b :: k2).
(f a b -> g a b) -> (-..->) f g a b
Fn2 ((f'' a b -> f''' a b) -> (-..->) f'' f''' a b)
-> (f'' a b -> f''' a b) -> (-..->) f'' f''' a b
forall a b. (a -> b) -> a -> b
$ \f'' a b
x'' -> f a b -> f' a b -> f'' a b -> f''' a b
f f a b
x f' a b
x' f'' a b
x''

-- | Construct a quaternary lifted function.
fn2_4 ::
     (f a b -> f' a b -> f'' a b -> f''' a b -> f'''' a b)
  -> (f -..-> f' -..-> f'' -..-> f''' -..-> f'''') a b
fn2_4 :: forall {k1} {k2} (f :: k1 -> k2 -> *) (a :: k1) (b :: k2)
       (f' :: k1 -> k2 -> *) (f'' :: k1 -> k2 -> *)
       (f''' :: k1 -> k2 -> *) (f'''' :: k1 -> k2 -> *).
(f a b -> f' a b -> f'' a b -> f''' a b -> f'''' a b)
-> (-..->) f (f' -..-> (f'' -..-> (f''' -..-> f''''))) a b
fn2_4 f a b -> f' a b -> f'' a b -> f''' a b -> f'''' a b
f = (f a b -> (-..->) f' (f'' -..-> (f''' -..-> f'''')) a b)
-> (-..->) f (f' -..-> (f'' -..-> (f''' -..-> f''''))) a b
forall k1 k2 (f :: k1 -> k2 -> *) (g :: k1 -> k2 -> *) (a :: k1)
       (b :: k2).
(f a b -> g a b) -> (-..->) f g a b
Fn2 ((f a b -> (-..->) f' (f'' -..-> (f''' -..-> f'''')) a b)
 -> (-..->) f (f' -..-> (f'' -..-> (f''' -..-> f''''))) a b)
-> (f a b -> (-..->) f' (f'' -..-> (f''' -..-> f'''')) a b)
-> (-..->) f (f' -..-> (f'' -..-> (f''' -..-> f''''))) a b
forall a b. (a -> b) -> a -> b
$ \f a b
x -> (f' a b -> (-..->) f'' (f''' -..-> f'''') a b)
-> (-..->) f' (f'' -..-> (f''' -..-> f'''')) a b
forall k1 k2 (f :: k1 -> k2 -> *) (g :: k1 -> k2 -> *) (a :: k1)
       (b :: k2).
(f a b -> g a b) -> (-..->) f g a b
Fn2 ((f' a b -> (-..->) f'' (f''' -..-> f'''') a b)
 -> (-..->) f' (f'' -..-> (f''' -..-> f'''')) a b)
-> (f' a b -> (-..->) f'' (f''' -..-> f'''') a b)
-> (-..->) f' (f'' -..-> (f''' -..-> f'''')) a b
forall a b. (a -> b) -> a -> b
$ \f' a b
x' -> (f'' a b -> (-..->) f''' f'''' a b)
-> (-..->) f'' (f''' -..-> f'''') a b
forall k1 k2 (f :: k1 -> k2 -> *) (g :: k1 -> k2 -> *) (a :: k1)
       (b :: k2).
(f a b -> g a b) -> (-..->) f g a b
Fn2 ((f'' a b -> (-..->) f''' f'''' a b)
 -> (-..->) f'' (f''' -..-> f'''') a b)
-> (f'' a b -> (-..->) f''' f'''' a b)
-> (-..->) f'' (f''' -..-> f'''') a b
forall a b. (a -> b) -> a -> b
$ \f'' a b
x'' -> (f''' a b -> f'''' a b) -> (-..->) f''' f'''' a b
forall k1 k2 (f :: k1 -> k2 -> *) (g :: k1 -> k2 -> *) (a :: k1)
       (b :: k2).
(f a b -> g a b) -> (-..->) f g a b
Fn2 ((f''' a b -> f'''' a b) -> (-..->) f''' f'''' a b)
-> (f''' a b -> f'''' a b) -> (-..->) f''' f'''' a b
forall a b. (a -> b) -> a -> b
$ \f''' a b
x''' -> f a b -> f' a b -> f'' a b -> f''' a b -> f'''' a b
f f a b
x f' a b
x' f'' a b
x'' f''' a b
x'''

{-------------------------------------------------------------------------------
  Basic bifunctors
-------------------------------------------------------------------------------}

-- | The constant type bifunctor.
type K2 :: Type -> k1 -> k2 -> Type
newtype K2 a b c = K2 { forall k1 k2 a (b :: k1) (c :: k2). K2 a b c -> a
unK2 :: a }
  deriving stock (Int -> K2 a b c -> ShowS
[K2 a b c] -> ShowS
K2 a b c -> String
(Int -> K2 a b c -> ShowS)
-> (K2 a b c -> String) -> ([K2 a b c] -> ShowS) -> Show (K2 a b c)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall a k1 (b :: k1) k2 (c :: k2).
Show a =>
Int -> K2 a b c -> ShowS
forall a k1 (b :: k1) k2 (c :: k2). Show a => [K2 a b c] -> ShowS
forall a k1 (b :: k1) k2 (c :: k2). Show a => K2 a b c -> String
$cshowsPrec :: forall a k1 (b :: k1) k2 (c :: k2).
Show a =>
Int -> K2 a b c -> ShowS
showsPrec :: Int -> K2 a b c -> ShowS
$cshow :: forall a k1 (b :: k1) k2 (c :: k2). Show a => K2 a b c -> String
show :: K2 a b c -> String
$cshowList :: forall a k1 (b :: k1) k2 (c :: k2). Show a => [K2 a b c] -> ShowS
showList :: [K2 a b c] -> ShowS
Show, K2 a b c -> K2 a b c -> Bool
(K2 a b c -> K2 a b c -> Bool)
-> (K2 a b c -> K2 a b c -> Bool) -> Eq (K2 a b c)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a k1 (b :: k1) k2 (c :: k2).
Eq a =>
K2 a b c -> K2 a b c -> Bool
$c== :: forall a k1 (b :: k1) k2 (c :: k2).
Eq a =>
K2 a b c -> K2 a b c -> Bool
== :: K2 a b c -> K2 a b c -> Bool
$c/= :: forall a k1 (b :: k1) k2 (c :: k2).
Eq a =>
K2 a b c -> K2 a b c -> Bool
/= :: K2 a b c -> K2 a b c -> Bool
Eq)
  deriving stock ((forall a b. (a -> b) -> K2 a b a -> K2 a b b)
-> (forall a b. a -> K2 a b b -> K2 a b a) -> Functor (K2 a b)
forall a b. a -> K2 a b b -> K2 a b a
forall a b. (a -> b) -> K2 a b a -> K2 a b b
forall a k1 (b :: k1) a b. a -> K2 a b b -> K2 a b a
forall a k1 (b :: k1) a b. (a -> b) -> K2 a b a -> K2 a b b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a k1 (b :: k1) a b. (a -> b) -> K2 a b a -> K2 a b b
fmap :: forall a b. (a -> b) -> K2 a b a -> K2 a b b
$c<$ :: forall a k1 (b :: k1) a b. a -> K2 a b b -> K2 a b a
<$ :: forall a b. a -> K2 a b b -> K2 a b a
Functor, (forall m. Monoid m => K2 a b m -> m)
-> (forall m a. Monoid m => (a -> m) -> K2 a b a -> m)
-> (forall m a. Monoid m => (a -> m) -> K2 a b a -> m)
-> (forall a b. (a -> b -> b) -> b -> K2 a b a -> b)
-> (forall a b. (a -> b -> b) -> b -> K2 a b a -> b)
-> (forall b a. (b -> a -> b) -> b -> K2 a b a -> b)
-> (forall b a. (b -> a -> b) -> b -> K2 a b a -> b)
-> (forall a. (a -> a -> a) -> K2 a b a -> a)
-> (forall a. (a -> a -> a) -> K2 a b a -> a)
-> (forall a. K2 a b a -> [a])
-> (forall a. K2 a b a -> Bool)
-> (forall a. K2 a b a -> Int)
-> (forall a. Eq a => a -> K2 a b a -> Bool)
-> (forall a. Ord a => K2 a b a -> a)
-> (forall a. Ord a => K2 a b a -> a)
-> (forall a. Num a => K2 a b a -> a)
-> (forall a. Num a => K2 a b a -> a)
-> Foldable (K2 a b)
forall a. Eq a => a -> K2 a b a -> Bool
forall a. Num a => K2 a b a -> a
forall a. Ord a => K2 a b a -> a
forall m. Monoid m => K2 a b m -> m
forall a. K2 a b a -> Bool
forall a. K2 a b a -> Int
forall a. K2 a b a -> [a]
forall a. (a -> a -> a) -> K2 a b a -> a
forall m a. Monoid m => (a -> m) -> K2 a b a -> m
forall b a. (b -> a -> b) -> b -> K2 a b a -> b
forall a b. (a -> b -> b) -> b -> K2 a b a -> b
forall a k1 (b :: k1) a. Eq a => a -> K2 a b a -> Bool
forall a k1 (b :: k1) a. Num a => K2 a b a -> a
forall a k1 (b :: k1) a. Ord a => K2 a b a -> a
forall a k1 (b :: k1) m. Monoid m => K2 a b m -> m
forall a k1 (b :: k1) a. K2 a b a -> Bool
forall a k1 (b :: k1) a. K2 a b a -> Int
forall a k1 (b :: k1) a. K2 a b a -> [a]
forall a k1 (b :: k1) a. (a -> a -> a) -> K2 a b a -> a
forall a k1 (b :: k1) m a. Monoid m => (a -> m) -> K2 a b a -> m
forall a k1 (b :: k1) b a. (b -> a -> b) -> b -> K2 a b a -> b
forall a k1 (b :: k1) a b. (a -> b -> b) -> b -> K2 a b a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall a k1 (b :: k1) m. Monoid m => K2 a b m -> m
fold :: forall m. Monoid m => K2 a b m -> m
$cfoldMap :: forall a k1 (b :: k1) m a. Monoid m => (a -> m) -> K2 a b a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> K2 a b a -> m
$cfoldMap' :: forall a k1 (b :: k1) m a. Monoid m => (a -> m) -> K2 a b a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> K2 a b a -> m
$cfoldr :: forall a k1 (b :: k1) a b. (a -> b -> b) -> b -> K2 a b a -> b
foldr :: forall a b. (a -> b -> b) -> b -> K2 a b a -> b
$cfoldr' :: forall a k1 (b :: k1) a b. (a -> b -> b) -> b -> K2 a b a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> K2 a b a -> b
$cfoldl :: forall a k1 (b :: k1) b a. (b -> a -> b) -> b -> K2 a b a -> b
foldl :: forall b a. (b -> a -> b) -> b -> K2 a b a -> b
$cfoldl' :: forall a k1 (b :: k1) b a. (b -> a -> b) -> b -> K2 a b a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> K2 a b a -> b
$cfoldr1 :: forall a k1 (b :: k1) a. (a -> a -> a) -> K2 a b a -> a
foldr1 :: forall a. (a -> a -> a) -> K2 a b a -> a
$cfoldl1 :: forall a k1 (b :: k1) a. (a -> a -> a) -> K2 a b a -> a
foldl1 :: forall a. (a -> a -> a) -> K2 a b a -> a
$ctoList :: forall a k1 (b :: k1) a. K2 a b a -> [a]
toList :: forall a. K2 a b a -> [a]
$cnull :: forall a k1 (b :: k1) a. K2 a b a -> Bool
null :: forall a. K2 a b a -> Bool
$clength :: forall a k1 (b :: k1) a. K2 a b a -> Int
length :: forall a. K2 a b a -> Int
$celem :: forall a k1 (b :: k1) a. Eq a => a -> K2 a b a -> Bool
elem :: forall a. Eq a => a -> K2 a b a -> Bool
$cmaximum :: forall a k1 (b :: k1) a. Ord a => K2 a b a -> a
maximum :: forall a. Ord a => K2 a b a -> a
$cminimum :: forall a k1 (b :: k1) a. Ord a => K2 a b a -> a
minimum :: forall a. Ord a => K2 a b a -> a
$csum :: forall a k1 (b :: k1) a. Num a => K2 a b a -> a
sum :: forall a. Num a => K2 a b a -> a
$cproduct :: forall a k1 (b :: k1) a. Num a => K2 a b a -> a
product :: forall a. Num a => K2 a b a -> a
Foldable, Functor (K2 a b)
Foldable (K2 a b)
(Functor (K2 a b), Foldable (K2 a b)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> K2 a b a -> f (K2 a b b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    K2 a b (f a) -> f (K2 a b a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> K2 a b a -> m (K2 a b b))
-> (forall (m :: * -> *) a.
    Monad m =>
    K2 a b (m a) -> m (K2 a b a))
-> Traversable (K2 a b)
forall a k1 (b :: k1). Functor (K2 a b)
forall a k1 (b :: k1). Foldable (K2 a b)
forall a k1 (b :: k1) (m :: * -> *) a.
Monad m =>
K2 a b (m a) -> m (K2 a b a)
forall a k1 (b :: k1) (f :: * -> *) a.
Applicative f =>
K2 a b (f a) -> f (K2 a b a)
forall a k1 (b :: k1) (m :: * -> *) a b.
Monad m =>
(a -> m b) -> K2 a b a -> m (K2 a b b)
forall a k1 (b :: k1) (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> K2 a b a -> f (K2 a b b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => K2 a b (m a) -> m (K2 a b a)
forall (f :: * -> *) a.
Applicative f =>
K2 a b (f a) -> f (K2 a b a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> K2 a b a -> m (K2 a b b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> K2 a b a -> f (K2 a b b)
$ctraverse :: forall a k1 (b :: k1) (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> K2 a b a -> f (K2 a b b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> K2 a b a -> f (K2 a b b)
$csequenceA :: forall a k1 (b :: k1) (f :: * -> *) a.
Applicative f =>
K2 a b (f a) -> f (K2 a b a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
K2 a b (f a) -> f (K2 a b a)
$cmapM :: forall a k1 (b :: k1) (m :: * -> *) a b.
Monad m =>
(a -> m b) -> K2 a b a -> m (K2 a b b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> K2 a b a -> m (K2 a b b)
$csequence :: forall a k1 (b :: k1) (m :: * -> *) a.
Monad m =>
K2 a b (m a) -> m (K2 a b a)
sequence :: forall (m :: * -> *) a. Monad m => K2 a b (m a) -> m (K2 a b a)
Traversable)
  deriving newtype (Semigroup (K2 a b c)
K2 a b c
Semigroup (K2 a b c) =>
K2 a b c
-> (K2 a b c -> K2 a b c -> K2 a b c)
-> ([K2 a b c] -> K2 a b c)
-> Monoid (K2 a b c)
[K2 a b c] -> K2 a b c
K2 a b c -> K2 a b c -> K2 a b c
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a k1 (b :: k1) k2 (c :: k2).
Monoid a =>
Semigroup (K2 a b c)
forall a k1 (b :: k1) k2 (c :: k2). Monoid a => K2 a b c
forall a k1 (b :: k1) k2 (c :: k2).
Monoid a =>
[K2 a b c] -> K2 a b c
forall a k1 (b :: k1) k2 (c :: k2).
Monoid a =>
K2 a b c -> K2 a b c -> K2 a b c
$cmempty :: forall a k1 (b :: k1) k2 (c :: k2). Monoid a => K2 a b c
mempty :: K2 a b c
$cmappend :: forall a k1 (b :: k1) k2 (c :: k2).
Monoid a =>
K2 a b c -> K2 a b c -> K2 a b c
mappend :: K2 a b c -> K2 a b c -> K2 a b c
$cmconcat :: forall a k1 (b :: k1) k2 (c :: k2).
Monoid a =>
[K2 a b c] -> K2 a b c
mconcat :: [K2 a b c] -> K2 a b c
Monoid, NonEmpty (K2 a b c) -> K2 a b c
K2 a b c -> K2 a b c -> K2 a b c
(K2 a b c -> K2 a b c -> K2 a b c)
-> (NonEmpty (K2 a b c) -> K2 a b c)
-> (forall b. Integral b => b -> K2 a b c -> K2 a b c)
-> Semigroup (K2 a b c)
forall b. Integral b => b -> K2 a b c -> K2 a b c
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall a k1 (b :: k1) k2 (c :: k2).
Semigroup a =>
NonEmpty (K2 a b c) -> K2 a b c
forall a k1 (b :: k1) k2 (c :: k2).
Semigroup a =>
K2 a b c -> K2 a b c -> K2 a b c
forall a k1 (b :: k1) k2 (c :: k2) b.
(Semigroup a, Integral b) =>
b -> K2 a b c -> K2 a b c
$c<> :: forall a k1 (b :: k1) k2 (c :: k2).
Semigroup a =>
K2 a b c -> K2 a b c -> K2 a b c
<> :: K2 a b c -> K2 a b c -> K2 a b c
$csconcat :: forall a k1 (b :: k1) k2 (c :: k2).
Semigroup a =>
NonEmpty (K2 a b c) -> K2 a b c
sconcat :: NonEmpty (K2 a b c) -> K2 a b c
$cstimes :: forall a k1 (b :: k1) k2 (c :: k2) b.
(Semigroup a, Integral b) =>
b -> K2 a b c -> K2 a b c
stimes :: forall b. Integral b => b -> K2 a b c -> K2 a b c
Semigroup)

instance Bifunctor (K2 a) where
  bimap :: forall a b c d. (a -> b) -> (c -> d) -> K2 a a c -> K2 a b d
bimap a -> b
_ c -> d
_ (K2 a
x) = a -> K2 a b d
forall k1 k2 a (b :: k1) (c :: k2). a -> K2 a b c
K2 a
x

-- | Composition of functor after bifunctor.
--
-- Example: @Comp2 (Just (17, True)) :: (Maybe :..: (,)) Int Bool@
type (:..:) :: (k3 -> Type) -> (k1 -> k2 -> k3) -> k1 -> k2 -> Type
newtype (:..:) f g a b = Comp2 { forall k3 k1 k2 (f :: k3 -> *) (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
(:..:) f g a b -> f (g a b)
unComp2 :: f (g a b) }
  deriving stock (Int -> (:..:) f g a b -> ShowS
[(:..:) f g a b] -> ShowS
(:..:) f g a b -> String
(Int -> (:..:) f g a b -> ShowS)
-> ((:..:) f g a b -> String)
-> ([(:..:) f g a b] -> ShowS)
-> Show ((:..:) f g a b)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
Show (f (g a b)) =>
Int -> (:..:) f g a b -> ShowS
forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
Show (f (g a b)) =>
[(:..:) f g a b] -> ShowS
forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
Show (f (g a b)) =>
(:..:) f g a b -> String
$cshowsPrec :: forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
Show (f (g a b)) =>
Int -> (:..:) f g a b -> ShowS
showsPrec :: Int -> (:..:) f g a b -> ShowS
$cshow :: forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
Show (f (g a b)) =>
(:..:) f g a b -> String
show :: (:..:) f g a b -> String
$cshowList :: forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
Show (f (g a b)) =>
[(:..:) f g a b] -> ShowS
showList :: [(:..:) f g a b] -> ShowS
Show, (:..:) f g a b -> (:..:) f g a b -> Bool
((:..:) f g a b -> (:..:) f g a b -> Bool)
-> ((:..:) f g a b -> (:..:) f g a b -> Bool)
-> Eq ((:..:) f g a b)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
Eq (f (g a b)) =>
(:..:) f g a b -> (:..:) f g a b -> Bool
$c== :: forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
Eq (f (g a b)) =>
(:..:) f g a b -> (:..:) f g a b -> Bool
== :: (:..:) f g a b -> (:..:) f g a b -> Bool
$c/= :: forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
Eq (f (g a b)) =>
(:..:) f g a b -> (:..:) f g a b -> Bool
/= :: (:..:) f g a b -> (:..:) f g a b -> Bool
Eq)
  deriving stock ((forall a b. (a -> b) -> (:..:) f g a a -> (:..:) f g a b)
-> (forall a b. a -> (:..:) f g a b -> (:..:) f g a a)
-> Functor ((:..:) f g a)
forall a b. a -> (:..:) f g a b -> (:..:) f g a a
forall a b. (a -> b) -> (:..:) f g a a -> (:..:) f g a b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a b.
(Functor f, Functor (g a)) =>
a -> (:..:) f g a b -> (:..:) f g a a
forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a b.
(Functor f, Functor (g a)) =>
(a -> b) -> (:..:) f g a a -> (:..:) f g a b
$cfmap :: forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a b.
(Functor f, Functor (g a)) =>
(a -> b) -> (:..:) f g a a -> (:..:) f g a b
fmap :: forall a b. (a -> b) -> (:..:) f g a a -> (:..:) f g a b
$c<$ :: forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a b.
(Functor f, Functor (g a)) =>
a -> (:..:) f g a b -> (:..:) f g a a
<$ :: forall a b. a -> (:..:) f g a b -> (:..:) f g a a
Functor, (forall m. Monoid m => (:..:) f g a m -> m)
-> (forall m a. Monoid m => (a -> m) -> (:..:) f g a a -> m)
-> (forall m a. Monoid m => (a -> m) -> (:..:) f g a a -> m)
-> (forall a b. (a -> b -> b) -> b -> (:..:) f g a a -> b)
-> (forall a b. (a -> b -> b) -> b -> (:..:) f g a a -> b)
-> (forall b a. (b -> a -> b) -> b -> (:..:) f g a a -> b)
-> (forall b a. (b -> a -> b) -> b -> (:..:) f g a a -> b)
-> (forall a. (a -> a -> a) -> (:..:) f g a a -> a)
-> (forall a. (a -> a -> a) -> (:..:) f g a a -> a)
-> (forall a. (:..:) f g a a -> [a])
-> (forall a. (:..:) f g a a -> Bool)
-> (forall a. (:..:) f g a a -> Int)
-> (forall a. Eq a => a -> (:..:) f g a a -> Bool)
-> (forall a. Ord a => (:..:) f g a a -> a)
-> (forall a. Ord a => (:..:) f g a a -> a)
-> (forall a. Num a => (:..:) f g a a -> a)
-> (forall a. Num a => (:..:) f g a a -> a)
-> Foldable ((:..:) f g a)
forall a. Eq a => a -> (:..:) f g a a -> Bool
forall a. Num a => (:..:) f g a a -> a
forall a. Ord a => (:..:) f g a a -> a
forall m. Monoid m => (:..:) f g a m -> m
forall a. (:..:) f g a a -> Bool
forall a. (:..:) f g a a -> Int
forall a. (:..:) f g a a -> [a]
forall a. (a -> a -> a) -> (:..:) f g a a -> a
forall m a. Monoid m => (a -> m) -> (:..:) f g a a -> m
forall b a. (b -> a -> b) -> b -> (:..:) f g a a -> b
forall a b. (a -> b -> b) -> b -> (:..:) f g a a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a.
(Foldable f, Foldable (g a), Eq a) =>
a -> (:..:) f g a a -> Bool
forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a.
(Foldable f, Foldable (g a), Num a) =>
(:..:) f g a a -> a
forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a.
(Foldable f, Foldable (g a), Ord a) =>
(:..:) f g a a -> a
forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) m.
(Foldable f, Foldable (g a), Monoid m) =>
(:..:) f g a m -> m
forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a.
(Foldable f, Foldable (g a)) =>
(:..:) f g a a -> Bool
forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a.
(Foldable f, Foldable (g a)) =>
(:..:) f g a a -> Int
forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a.
(Foldable f, Foldable (g a)) =>
(:..:) f g a a -> [a]
forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a.
(Foldable f, Foldable (g a)) =>
(a -> a -> a) -> (:..:) f g a a -> a
forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) m a.
(Foldable f, Foldable (g a), Monoid m) =>
(a -> m) -> (:..:) f g a a -> m
forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) b a.
(Foldable f, Foldable (g a)) =>
(b -> a -> b) -> b -> (:..:) f g a a -> b
forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a b.
(Foldable f, Foldable (g a)) =>
(a -> b -> b) -> b -> (:..:) f g a a -> b
$cfold :: forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) m.
(Foldable f, Foldable (g a), Monoid m) =>
(:..:) f g a m -> m
fold :: forall m. Monoid m => (:..:) f g a m -> m
$cfoldMap :: forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) m a.
(Foldable f, Foldable (g a), Monoid m) =>
(a -> m) -> (:..:) f g a a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> (:..:) f g a a -> m
$cfoldMap' :: forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) m a.
(Foldable f, Foldable (g a), Monoid m) =>
(a -> m) -> (:..:) f g a a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> (:..:) f g a a -> m
$cfoldr :: forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a b.
(Foldable f, Foldable (g a)) =>
(a -> b -> b) -> b -> (:..:) f g a a -> b
foldr :: forall a b. (a -> b -> b) -> b -> (:..:) f g a a -> b
$cfoldr' :: forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a b.
(Foldable f, Foldable (g a)) =>
(a -> b -> b) -> b -> (:..:) f g a a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> (:..:) f g a a -> b
$cfoldl :: forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) b a.
(Foldable f, Foldable (g a)) =>
(b -> a -> b) -> b -> (:..:) f g a a -> b
foldl :: forall b a. (b -> a -> b) -> b -> (:..:) f g a a -> b
$cfoldl' :: forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) b a.
(Foldable f, Foldable (g a)) =>
(b -> a -> b) -> b -> (:..:) f g a a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> (:..:) f g a a -> b
$cfoldr1 :: forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a.
(Foldable f, Foldable (g a)) =>
(a -> a -> a) -> (:..:) f g a a -> a
foldr1 :: forall a. (a -> a -> a) -> (:..:) f g a a -> a
$cfoldl1 :: forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a.
(Foldable f, Foldable (g a)) =>
(a -> a -> a) -> (:..:) f g a a -> a
foldl1 :: forall a. (a -> a -> a) -> (:..:) f g a a -> a
$ctoList :: forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a.
(Foldable f, Foldable (g a)) =>
(:..:) f g a a -> [a]
toList :: forall a. (:..:) f g a a -> [a]
$cnull :: forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a.
(Foldable f, Foldable (g a)) =>
(:..:) f g a a -> Bool
null :: forall a. (:..:) f g a a -> Bool
$clength :: forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a.
(Foldable f, Foldable (g a)) =>
(:..:) f g a a -> Int
length :: forall a. (:..:) f g a a -> Int
$celem :: forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a.
(Foldable f, Foldable (g a), Eq a) =>
a -> (:..:) f g a a -> Bool
elem :: forall a. Eq a => a -> (:..:) f g a a -> Bool
$cmaximum :: forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a.
(Foldable f, Foldable (g a), Ord a) =>
(:..:) f g a a -> a
maximum :: forall a. Ord a => (:..:) f g a a -> a
$cminimum :: forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a.
(Foldable f, Foldable (g a), Ord a) =>
(:..:) f g a a -> a
minimum :: forall a. Ord a => (:..:) f g a a -> a
$csum :: forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a.
(Foldable f, Foldable (g a), Num a) =>
(:..:) f g a a -> a
sum :: forall a. Num a => (:..:) f g a a -> a
$cproduct :: forall (f :: * -> *) k1 (g :: k1 -> * -> *) (a :: k1) a.
(Foldable f, Foldable (g a), Num a) =>
(:..:) f g a a -> a
product :: forall a. Num a => (:..:) f g a a -> a
Foldable)
  deriving newtype (Semigroup ((:..:) f g a b)
(:..:) f g a b
Semigroup ((:..:) f g a b) =>
(:..:) f g a b
-> ((:..:) f g a b -> (:..:) f g a b -> (:..:) f g a b)
-> ([(:..:) f g a b] -> (:..:) f g a b)
-> Monoid ((:..:) f g a b)
[(:..:) f g a b] -> (:..:) f g a b
(:..:) f g a b -> (:..:) f g a b -> (:..:) f g a b
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
Monoid (f (g a b)) =>
Semigroup ((:..:) f g a b)
forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
Monoid (f (g a b)) =>
(:..:) f g a b
forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
Monoid (f (g a b)) =>
[(:..:) f g a b] -> (:..:) f g a b
forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
Monoid (f (g a b)) =>
(:..:) f g a b -> (:..:) f g a b -> (:..:) f g a b
$cmempty :: forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
Monoid (f (g a b)) =>
(:..:) f g a b
mempty :: (:..:) f g a b
$cmappend :: forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
Monoid (f (g a b)) =>
(:..:) f g a b -> (:..:) f g a b -> (:..:) f g a b
mappend :: (:..:) f g a b -> (:..:) f g a b -> (:..:) f g a b
$cmconcat :: forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
Monoid (f (g a b)) =>
[(:..:) f g a b] -> (:..:) f g a b
mconcat :: [(:..:) f g a b] -> (:..:) f g a b
Monoid, NonEmpty ((:..:) f g a b) -> (:..:) f g a b
(:..:) f g a b -> (:..:) f g a b -> (:..:) f g a b
((:..:) f g a b -> (:..:) f g a b -> (:..:) f g a b)
-> (NonEmpty ((:..:) f g a b) -> (:..:) f g a b)
-> (forall b. Integral b => b -> (:..:) f g a b -> (:..:) f g a b)
-> Semigroup ((:..:) f g a b)
forall b. Integral b => b -> (:..:) f g a b -> (:..:) f g a b
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
Semigroup (f (g a b)) =>
NonEmpty ((:..:) f g a b) -> (:..:) f g a b
forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
Semigroup (f (g a b)) =>
(:..:) f g a b -> (:..:) f g a b -> (:..:) f g a b
forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2) b.
(Semigroup (f (g a b)), Integral b) =>
b -> (:..:) f g a b -> (:..:) f g a b
$c<> :: forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
Semigroup (f (g a b)) =>
(:..:) f g a b -> (:..:) f g a b -> (:..:) f g a b
<> :: (:..:) f g a b -> (:..:) f g a b -> (:..:) f g a b
$csconcat :: forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
Semigroup (f (g a b)) =>
NonEmpty ((:..:) f g a b) -> (:..:) f g a b
sconcat :: NonEmpty ((:..:) f g a b) -> (:..:) f g a b
$cstimes :: forall k3 (f :: k3 -> *) k1 k2 (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2) b.
(Semigroup (f (g a b)), Integral b) =>
b -> (:..:) f g a b -> (:..:) f g a b
stimes :: forall b. Integral b => b -> (:..:) f g a b -> (:..:) f g a b
Semigroup)

infixr 7 :..:

deriving stock instance (Traversable f, Traversable (g a))
                     => Traversable ((f :..: g) a)

instance (Functor f, Bifunctor g) => Bifunctor (f :..: g) where
  bimap :: forall a b c d.
(a -> b) -> (c -> d) -> (:..:) f g a c -> (:..:) f g b d
bimap a -> b
f c -> d
g (Comp2 f (g a c)
x) = f (g b d) -> (:..:) f g b d
forall k3 k1 k2 (f :: k3 -> *) (g :: k1 -> k2 -> k3) (a :: k1)
       (b :: k2).
f (g a b) -> (:..:) f g a b
Comp2 (f (g b d) -> (:..:) f g b d) -> f (g b d) -> (:..:) f g b d
forall a b. (a -> b) -> a -> b
$ (g a c -> g b d) -> f (g a c) -> f (g b d)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> (c -> d) -> g a c -> g b d
forall a b c d. (a -> b) -> (c -> d) -> g a c -> g b d
forall (p :: MapKind) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap a -> b
f c -> d
g) f (g a c)
x