{-# LANGUAGE QuantifiedConstraints #-}
{-# LANGUAGE RankNTypes #-}

{- | This module is designed to be imported qualified, as many of its
identifiers clash with the Plutarch prelude.
-}
module Plutarch.LedgerApi.AssocMap (
  -- * Types
  PSortedMap,
  PUnsortedMap (..),
  PAssocMap (..),
  MergeHandler (..),
  BothPresentHandler (..),
  OnePresentHandler (..),

  -- * Functions

  -- ** Creation
  pempty,
  psingleton,
  psingletonData,
  punsortedMapFromFoldable,
  psortedMapFromFoldable,

  -- ** Transformation
  passertSorted,
  ppromoteToSortedMap,
  punsafeCoerceToSortedMap,
  pforgetSorted,
  pmap,
  pmapData,
  pmapWithKey,
  pmapMaybe,
  pmapMaybeData,
  pmapMaybeWithKey,
  pmapMaybeDataWithKey,

  -- ** Relational lift
  pcheckBinRel,

  -- ** Comparison
  pkeysEqual,
  pkeysEqualUnsorted,

  -- ** Fold
  pall,
  pany,
  pfoldMapWithKey,
  pfoldlWithKey,

  -- ** Combination
  zipWithBuilder,
  zipWithDataBuilder,
  punionWith,
  punionWithData,
  pleftBiasedUnion,
  pdifference,
  pdifferenceWith,
  pzipWithDefaults,
  pintersectionWith,
  pintersectionWithData,

  -- ** Query
  pnull,
  plookup,
  plookupData,
  plookupDataWith,
  pfindWithDefault,
  pfoldAt,
  pfoldAtData,
  ptryLookup,

  -- ** Modification
  pinsert,
  pdelete,
  pupdate,
  padjust,

  -- ** Key-value pair manipulation
  pkvPairKey,
  pkvPairValue,
  pkvPairLt,

  -- ** Conversion
  pkeys,
) where

import Data.Bifunctor (bimap)
import Data.Foldable (foldl')
import Data.Kind (Type)
import Data.Proxy (Proxy (Proxy))
import GHC.Generics (Generic)
import Generics.SOP qualified as SOP
import Plutarch.Internal.Lift (LiftError (CouldNotDecodeData))
import Plutarch.Internal.Term (punsafeBuiltin)
import Plutarch.Internal.Witness (witness)
import Plutarch.LedgerApi.AssocMap.Zip (
  BothPresentHandler (..),
  MergeHandler (..),
  OnePresentHandler (..),
 )
import Plutarch.LedgerApi.AssocMap.Zip qualified as Zip
import Plutarch.Prelude hiding (pall, pany, pmap, pnull, psingleton, pzipWith)
import Plutarch.Prelude qualified as PPrelude
import Plutarch.Unsafe (punsafeCoerce, punsafeDowncast)
import PlutusCore qualified as PLC
import PlutusLedgerApi.V3 qualified as Plutus
import PlutusTx.AssocMap qualified as PlutusMap
import Prelude hiding (pred)

{- NOTE for developers:

Both 'PUnsortedMap' and 'PSortedMap' use 'PAssocMap' as their underlying type.

When adding new functions, please follow these guidelines:

1. If a function should only operate on sorted maps, restrict it to 'PSortedMap'.

2. If a function should work with both sorted and unsorted maps but does not
   return a map (see 'pnull'), use 'PUnsortedMap'. Any 'PSortedMap' can be
   safely downgraded to 'PUnsortedMap' using 'pforgetSorted' without any runtime
   cost.

3. If a function can return either a sorted or unsorted map (see 'pmap'), use
   the constraint 'PInner (t k v) ~ PAssocMap k v'. Using 'PUnsortedMap' for
   such functions would require the user to unsafely cast the resulting map,
   which is obviously undesirable.
-}

----------------------------------------------------------------------

-- | @since 3.5.0
newtype PAssocMap (k :: S -> Type) (v :: S -> Type) (s :: S)
  = PAssocMap (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
  deriving stock
    ( -- | @since 3.5.0
      (forall x. PAssocMap k v s -> Rep (PAssocMap k v s) x)
-> (forall x. Rep (PAssocMap k v s) x -> PAssocMap k v s)
-> Generic (PAssocMap k v s)
forall x. Rep (PAssocMap k v s) x -> PAssocMap k v s
forall x. PAssocMap k v s -> Rep (PAssocMap k v s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (k :: S -> Type) (v :: S -> Type) (s :: S) x.
Rep (PAssocMap k v s) x -> PAssocMap k v s
forall (k :: S -> Type) (v :: S -> Type) (s :: S) x.
PAssocMap k v s -> Rep (PAssocMap k v s) x
$cfrom :: forall (k :: S -> Type) (v :: S -> Type) (s :: S) x.
PAssocMap k v s -> Rep (PAssocMap k v s) x
from :: forall x. PAssocMap k v s -> Rep (PAssocMap k v s) x
$cto :: forall (k :: S -> Type) (v :: S -> Type) (s :: S) x.
Rep (PAssocMap k v s) x -> PAssocMap k v s
to :: forall x. Rep (PAssocMap k v s) x -> PAssocMap k v s
Generic
    )
  deriving anyclass
    ( -- | @since 3.5.0
      All SListI (Code (PAssocMap k v s))
All SListI (Code (PAssocMap k v s)) =>
(PAssocMap k v s -> Rep (PAssocMap k v s))
-> (Rep (PAssocMap k v s) -> PAssocMap k v s)
-> Generic (PAssocMap k v s)
Rep (PAssocMap k v s) -> PAssocMap k v s
PAssocMap k v s -> Rep (PAssocMap k v s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
All SListI (Code (PAssocMap k v s))
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Rep (PAssocMap k v s) -> PAssocMap k v s
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PAssocMap k v s -> Rep (PAssocMap k v s)
$cfrom :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PAssocMap k v s -> Rep (PAssocMap k v s)
from :: PAssocMap k v s -> Rep (PAssocMap k v s)
$cto :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Rep (PAssocMap k v s) -> PAssocMap k v s
to :: Rep (PAssocMap k v s) -> PAssocMap k v s
SOP.Generic
    , -- | @since 3.5.0
      (forall (s :: S). Bool -> Term s (PAssocMap k v) -> Term s PString)
-> PShow (PAssocMap k v)
forall (s :: S). Bool -> Term s (PAssocMap k v) -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PIsData k, PIsData v, PShow k, PShow v) =>
Bool -> Term s (PAssocMap k v) -> Term s PString
$cpshow' :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PIsData k, PIsData v, PShow k, PShow v) =>
Bool -> Term s (PAssocMap k v) -> Term s PString
pshow' :: forall (s :: S). Bool -> Term s (PAssocMap k v) -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.5.0
      (forall (s :: S).
 PAssocMap k v s -> Term s (PInner (PAssocMap k v)))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner (PAssocMap k v))
    -> (PAssocMap k v s -> Term s b) -> Term s b)
-> PlutusType (PAssocMap k v)
forall (s :: S). PAssocMap k v s -> Term s (PInner (PAssocMap k v))
forall (s :: S) (b :: S -> Type).
Term s (PInner (PAssocMap k v))
-> (PAssocMap k v s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PAssocMap k v s -> Term s (PInner (PAssocMap k v))
forall (k :: S -> Type) (v :: S -> Type) (s :: S) (b :: S -> Type).
Term s (PInner (PAssocMap k v))
-> (PAssocMap k v s -> Term s b) -> Term s b
$cpcon' :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PAssocMap k v s -> Term s (PInner (PAssocMap k v))
pcon' :: forall (s :: S). PAssocMap k v s -> Term s (PInner (PAssocMap k v))
$cpmatch' :: forall (k :: S -> Type) (v :: S -> Type) (s :: S) (b :: S -> Type).
Term s (PInner (PAssocMap k v))
-> (PAssocMap k v s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner (PAssocMap k v))
-> (PAssocMap k v s -> Term s b) -> Term s b
PlutusType
    )
    via (DeriveNewtypePlutusType (PAssocMap k v))
  deriving
    ( -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData (PAssocMap k v)
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PValidateData k, PValidateData v) =>
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
$cpwithValidated :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PValidateData k, PValidateData v) =>
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via ( DeriveNewtypePValidateData
            (PAssocMap k v)
            (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
        )

-- | @since 3.6.0
instance PIsData (PAssocMap k v) where
  pfromDataImpl :: forall (s :: S).
Term s (PAsData (PAssocMap k v)) -> Term s (PAssocMap k v)
pfromDataImpl Term s (PAsData (PAssocMap k v))
x = Term s (PBuiltinList (PBuiltinPair PData PData))
-> Term s (PAssocMap k v)
forall (b :: S -> Type) (a :: S -> Type) (s :: S).
Term s a -> Term s b
punsafeCoerce (Term s (PBuiltinList (PBuiltinPair PData PData))
 -> Term s (PAssocMap k v))
-> Term s (PBuiltinList (PBuiltinPair PData PData))
-> Term s (PAssocMap k v)
forall a b. (a -> b) -> a -> b
$ Term s (PData :--> PBuiltinList (PBuiltinPair PData PData))
forall (s :: S).
Term s (PData :--> PBuiltinList (PBuiltinPair PData PData))
pasMap Term s (PData :--> PBuiltinList (PBuiltinPair PData PData))
-> Term s PData -> Term s (PBuiltinList (PBuiltinPair PData PData))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PAsData (PAssocMap k v)) -> Term s PData
forall (s :: S) (a :: S -> Type).
Term s (PAsData a) -> Term s PData
pforgetData Term s (PAsData (PAssocMap k v))
x
  pdataImpl :: forall (s :: S). Term s (PAssocMap k v) -> Term s PData
pdataImpl Term s (PAssocMap k v)
x = DefaultFun -> Term s (PAssocMap k v :--> PData)
forall (s :: S) (a :: S -> Type). DefaultFun -> Term s a
punsafeBuiltin DefaultFun
PLC.MapData Term s (PAssocMap k v :--> PData)
-> Term s (PAssocMap k v) -> Term s PData
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PAssocMap k v)
x

----------------------------------------------------------------------
-- Unsorted Map

-- | @since 3.5.0
newtype PUnsortedMap (k :: S -> Type) (v :: S -> Type) (s :: S)
  = PUnsortedMap (Term s (PAssocMap k v))
  deriving stock
    ( -- | @since 3.5.0
      (forall x. PUnsortedMap k v s -> Rep (PUnsortedMap k v s) x)
-> (forall x. Rep (PUnsortedMap k v s) x -> PUnsortedMap k v s)
-> Generic (PUnsortedMap k v s)
forall x. Rep (PUnsortedMap k v s) x -> PUnsortedMap k v s
forall x. PUnsortedMap k v s -> Rep (PUnsortedMap k v s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (k :: S -> Type) (v :: S -> Type) (s :: S) x.
Rep (PUnsortedMap k v s) x -> PUnsortedMap k v s
forall (k :: S -> Type) (v :: S -> Type) (s :: S) x.
PUnsortedMap k v s -> Rep (PUnsortedMap k v s) x
$cfrom :: forall (k :: S -> Type) (v :: S -> Type) (s :: S) x.
PUnsortedMap k v s -> Rep (PUnsortedMap k v s) x
from :: forall x. PUnsortedMap k v s -> Rep (PUnsortedMap k v s) x
$cto :: forall (k :: S -> Type) (v :: S -> Type) (s :: S) x.
Rep (PUnsortedMap k v s) x -> PUnsortedMap k v s
to :: forall x. Rep (PUnsortedMap k v s) x -> PUnsortedMap k v s
Generic
    )
  deriving anyclass
    ( -- | @since 3.5.0
      All SListI (Code (PUnsortedMap k v s))
All SListI (Code (PUnsortedMap k v s)) =>
(PUnsortedMap k v s -> Rep (PUnsortedMap k v s))
-> (Rep (PUnsortedMap k v s) -> PUnsortedMap k v s)
-> Generic (PUnsortedMap k v s)
Rep (PUnsortedMap k v s) -> PUnsortedMap k v s
PUnsortedMap k v s -> Rep (PUnsortedMap k v s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
All SListI (Code (PUnsortedMap k v s))
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Rep (PUnsortedMap k v s) -> PUnsortedMap k v s
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PUnsortedMap k v s -> Rep (PUnsortedMap k v s)
$cfrom :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PUnsortedMap k v s -> Rep (PUnsortedMap k v s)
from :: PUnsortedMap k v s -> Rep (PUnsortedMap k v s)
$cto :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Rep (PUnsortedMap k v s) -> PUnsortedMap k v s
to :: Rep (PUnsortedMap k v s) -> PUnsortedMap k v s
SOP.Generic
    , -- | @since 3.5.0
      (forall (s :: S).
 Bool -> Term s (PUnsortedMap k v) -> Term s PString)
-> PShow (PUnsortedMap k v)
forall (s :: S).
Bool -> Term s (PUnsortedMap k v) -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PIsData k, PIsData v, PShow k, PShow v) =>
Bool -> Term s (PUnsortedMap k v) -> Term s PString
$cpshow' :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PIsData k, PIsData v, PShow k, PShow v) =>
Bool -> Term s (PUnsortedMap k v) -> Term s PString
pshow' :: forall (s :: S).
Bool -> Term s (PUnsortedMap k v) -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.5.0
      (forall (s :: S).
 PUnsortedMap k v s -> Term s (PInner (PUnsortedMap k v)))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner (PUnsortedMap k v))
    -> (PUnsortedMap k v s -> Term s b) -> Term s b)
-> PlutusType (PUnsortedMap k v)
forall (s :: S).
PUnsortedMap k v s -> Term s (PInner (PUnsortedMap k v))
forall (s :: S) (b :: S -> Type).
Term s (PInner (PUnsortedMap k v))
-> (PUnsortedMap k v s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PUnsortedMap k v s -> Term s (PInner (PUnsortedMap k v))
forall (k :: S -> Type) (v :: S -> Type) (s :: S) (b :: S -> Type).
Term s (PInner (PUnsortedMap k v))
-> (PUnsortedMap k v s -> Term s b) -> Term s b
$cpcon' :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PUnsortedMap k v s -> Term s (PInner (PUnsortedMap k v))
pcon' :: forall (s :: S).
PUnsortedMap k v s -> Term s (PInner (PUnsortedMap k v))
$cpmatch' :: forall (k :: S -> Type) (v :: S -> Type) (s :: S) (b :: S -> Type).
Term s (PInner (PUnsortedMap k v))
-> (PUnsortedMap k v s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner (PUnsortedMap k v))
-> (PUnsortedMap k v s -> Term s b) -> Term s b
PlutusType
    )
    via (DeriveNewtypePlutusType (PUnsortedMap k v))
  deriving
    ( -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData (PUnsortedMap k v)
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PValidateData k, PValidateData v) =>
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
$cpwithValidated :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PValidateData k, PValidateData v) =>
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via (DeriveNewtypePValidateData (PUnsortedMap k v) (PAssocMap k v))

-- | @since 3.5.0
instance PIsData (PUnsortedMap k v) where
  pfromDataImpl :: forall (s :: S).
Term s (PAsData (PUnsortedMap k v)) -> Term s (PUnsortedMap k v)
pfromDataImpl Term s (PAsData (PUnsortedMap k v))
x = Term s (PBuiltinList (PBuiltinPair PData PData))
-> Term s (PUnsortedMap k v)
forall (b :: S -> Type) (a :: S -> Type) (s :: S).
Term s a -> Term s b
punsafeCoerce (Term s (PBuiltinList (PBuiltinPair PData PData))
 -> Term s (PUnsortedMap k v))
-> Term s (PBuiltinList (PBuiltinPair PData PData))
-> Term s (PUnsortedMap k v)
forall a b. (a -> b) -> a -> b
$ Term s (PData :--> PBuiltinList (PBuiltinPair PData PData))
forall (s :: S).
Term s (PData :--> PBuiltinList (PBuiltinPair PData PData))
pasMap Term s (PData :--> PBuiltinList (PBuiltinPair PData PData))
-> Term s PData -> Term s (PBuiltinList (PBuiltinPair PData PData))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PAsData (PUnsortedMap k v)) -> Term s PData
forall (s :: S) (a :: S -> Type).
Term s (PAsData a) -> Term s PData
pforgetData Term s (PAsData (PUnsortedMap k v))
x
  pdataImpl :: forall (s :: S). Term s (PUnsortedMap k v) -> Term s PData
pdataImpl Term s (PUnsortedMap k v)
x = DefaultFun -> Term s (PUnsortedMap k v :--> PData)
forall (s :: S) (a :: S -> Type). DefaultFun -> Term s a
punsafeBuiltin DefaultFun
PLC.MapData Term s (PUnsortedMap k v :--> PData)
-> Term s (PUnsortedMap k v) -> Term s PData
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PUnsortedMap k v)
x

-- | @since 3.5.0
instance
  ( PTryFrom PData (PAsData k)
  , PTryFrom PData (PAsData v)
  ) =>
  PTryFrom PData (PAsData (PUnsortedMap k v))
  where
  ptryFrom' :: forall (s :: S) (r :: S -> Type).
Term s PData
-> ((Term s (PAsData (PUnsortedMap k v)),
     Reduce (PTryFromExcess PData (PAsData (PUnsortedMap k v)) s))
    -> Term s r)
-> Term s r
ptryFrom' Term s PData
opq = TermCont
  s
  (Term s (PAsData (PUnsortedMap k v)),
   Reduce (PTryFromExcess PData (PAsData (PUnsortedMap k v)) s))
-> ((Term s (PAsData (PUnsortedMap k v)),
     Reduce (PTryFromExcess PData (PAsData (PUnsortedMap k v)) s))
    -> Term s r)
-> Term s r
forall (r :: S -> Type) (s :: S) a.
TermCont s a -> (a -> Term s r) -> Term s r
runTermCont (TermCont
   s
   (Term s (PAsData (PUnsortedMap k v)),
    Reduce (PTryFromExcess PData (PAsData (PUnsortedMap k v)) s))
 -> ((Term s (PAsData (PUnsortedMap k v)),
      Reduce (PTryFromExcess PData (PAsData (PUnsortedMap k v)) s))
     -> Term s r)
 -> Term s r)
-> TermCont
     s
     (Term s (PAsData (PUnsortedMap k v)),
      Reduce (PTryFromExcess PData (PAsData (PUnsortedMap k v)) s))
-> ((Term s (PAsData (PUnsortedMap k v)),
     Reduce (PTryFromExcess PData (PAsData (PUnsortedMap k v)) s))
    -> Term s r)
-> Term s r
forall a b. (a -> b) -> a -> b
$ do
    Term s (PBuiltinList (PBuiltinPair PData PData))
opq' <- ((Term s (PBuiltinList (PBuiltinPair PData PData)) -> Term s r)
 -> Term s r)
-> TermCont s (Term s (PBuiltinList (PBuiltinPair PData PData)))
forall a (s :: S) (r :: S -> Type).
((a -> Term s r) -> Term s r) -> TermCont s a
tcont (((Term s (PBuiltinList (PBuiltinPair PData PData)) -> Term s r)
  -> Term s r)
 -> TermCont s (Term s (PBuiltinList (PBuiltinPair PData PData))))
-> (Term s (PBuiltinList (PBuiltinPair PData PData))
    -> (Term s (PBuiltinList (PBuiltinPair PData PData)) -> Term s r)
    -> Term s r)
-> Term s (PBuiltinList (PBuiltinPair PData PData))
-> TermCont s (Term s (PBuiltinList (PBuiltinPair PData PData)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s (PBuiltinList (PBuiltinPair PData PData))
-> (Term s (PBuiltinList (PBuiltinPair PData PData)) -> Term s r)
-> Term s r
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s a -> (Term s a -> Term s b) -> Term s b
plet (Term s (PBuiltinList (PBuiltinPair PData PData))
 -> TermCont s (Term s (PBuiltinList (PBuiltinPair PData PData))))
-> Term s (PBuiltinList (PBuiltinPair PData PData))
-> TermCont s (Term s (PBuiltinList (PBuiltinPair PData PData)))
forall a b. (a -> b) -> a -> b
$ Term s (PData :--> PBuiltinList (PBuiltinPair PData PData))
forall (s :: S).
Term s (PData :--> PBuiltinList (PBuiltinPair PData PData))
pasMap Term s (PData :--> PBuiltinList (PBuiltinPair PData PData))
-> Term s PData -> Term s (PBuiltinList (PBuiltinPair PData PData))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s PData
opq
    Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
unwrapped <- ((Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
  -> Term s r)
 -> Term s r)
-> TermCont
     s (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
forall a (s :: S) (r :: S -> Type).
((a -> Term s r) -> Term s r) -> TermCont s a
tcont (((Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
   -> Term s r)
  -> Term s r)
 -> TermCont
      s (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))))
-> (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
    -> (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
        -> Term s r)
    -> Term s r)
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> TermCont
     s (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
    -> Term s r)
-> Term s r
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s a -> (Term s a -> Term s b) -> Term s b
plet (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> TermCont
      s (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))))
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> TermCont
     s (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
forall a b. (a -> b) -> a -> b
$ Term
  s
  ((PBuiltinPair PData PData
    :--> PBuiltinPair (PAsData k) (PAsData v))
   :--> (PBuiltinList (PBuiltinPair PData PData)
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (b :: S -> Type) (s :: S).
(PListLike list, PElemConstraint list a, PElemConstraint list b) =>
Term s ((a :--> b) :--> (list a :--> list b))
PPrelude.pmap Term
  s
  ((PBuiltinPair PData PData
    :--> PBuiltinPair (PAsData k) (PAsData v))
   :--> (PBuiltinList (PBuiltinPair PData PData)
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> Term
     s
     (PBuiltinPair PData PData
      :--> PBuiltinPair (PAsData k) (PAsData v))
-> Term
     s
     (PBuiltinList (PBuiltinPair PData PData)
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term
  s
  (PBuiltinPair PData PData
   :--> PBuiltinPair (PAsData k) (PAsData v))
forall (s :: S).
Term
  s
  (PBuiltinPair PData PData
   :--> PBuiltinPair (PAsData k) (PAsData v))
ptryFromPair Term
  s
  (PBuiltinList (PBuiltinPair PData PData)
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s (PBuiltinList (PBuiltinPair PData PData))
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PBuiltinList (PBuiltinPair PData PData))
opq'
    (Term s (PAsData (PUnsortedMap k v)), ())
-> TermCont s (Term s (PAsData (PUnsortedMap k v)), ())
forall a. a -> TermCont s a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure (Term s (PUnsortedMap k v) -> Term s (PAsData (PUnsortedMap k v))
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s a -> Term s (PAsData a)
pdata (Term s (PUnsortedMap k v) -> Term s (PAsData (PUnsortedMap k v)))
-> (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
    -> Term s (PUnsortedMap k v))
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s (PAsData (PUnsortedMap k v))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PUnsortedMap k v s -> Term s (PUnsortedMap k v)
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon (PUnsortedMap k v s -> Term s (PUnsortedMap k v))
-> (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
    -> PUnsortedMap k v s)
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s (PUnsortedMap k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s (PAssocMap k v) -> PUnsortedMap k v s
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Term s (PAssocMap k v) -> PUnsortedMap k v s
PUnsortedMap (Term s (PAssocMap k v) -> PUnsortedMap k v s)
-> (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
    -> Term s (PAssocMap k v))
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> PUnsortedMap k v s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PAssocMap k v s -> Term s (PAssocMap k v)
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon (PAssocMap k v s -> Term s (PAssocMap k v))
-> (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
    -> PAssocMap k v s)
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s (PAssocMap k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> PAssocMap k v s
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> PAssocMap k v s
PAssocMap (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term s (PAsData (PUnsortedMap k v)))
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s (PAsData (PUnsortedMap k v))
forall a b. (a -> b) -> a -> b
$ Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
unwrapped, ())
    where
      ptryFromPair ::
        forall (s :: S).
        Term s (PBuiltinPair PData PData :--> PBuiltinPair (PAsData k) (PAsData v))
      ptryFromPair :: forall (s :: S).
Term
  s
  (PBuiltinPair PData PData
   :--> PBuiltinPair (PAsData k) (PAsData v))
ptryFromPair = (Term s (PBuiltinPair PData PData)
 -> Term s (PBuiltinPair (PAsData k) (PAsData v)))
-> Term
     s
     (PBuiltinPair PData PData
      :--> PBuiltinPair (PAsData k) (PAsData v))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s c -> Term s (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s (c :--> PBuiltinPair (PAsData k) (PAsData v))
plam ((Term s (PBuiltinPair PData PData)
  -> Term s (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term
      s
      (PBuiltinPair PData PData
       :--> PBuiltinPair (PAsData k) (PAsData v)))
-> (Term s (PBuiltinPair PData PData)
    -> Term s (PBuiltinPair (PAsData k) (PAsData v)))
-> Term
     s
     (PBuiltinPair PData PData
      :--> PBuiltinPair (PAsData k) (PAsData v))
forall a b. (a -> b) -> a -> b
$ \Term s (PBuiltinPair PData PData)
p ->
        Term s (PBuiltinPair PData PData)
-> (PBuiltinPair PData PData s
    -> Term s (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s (PBuiltinPair (PAsData k) (PAsData v))
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s (PBuiltinPair PData PData)
p ((PBuiltinPair PData PData s
  -> Term s (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term s (PBuiltinPair (PAsData k) (PAsData v)))
-> (PBuiltinPair PData PData s
    -> Term s (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s (PBuiltinPair (PAsData k) (PAsData v))
forall a b. (a -> b) -> a -> b
$ \(PBuiltinPair Term s PData
x Term s PData
y) ->
          Term
  s
  (PAsData k
   :--> (PAsData v :--> PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term
  s
  (PAsData a
   :--> (PAsData b :--> PBuiltinPair (PAsData a) (PAsData b)))
ppairDataBuiltin
            # ptryFrom x fst
            # ptryFrom y fst

-- | @since 3.5.0
instance
  ( Plutus.ToData (AsHaskell k)
  , Plutus.ToData (AsHaskell v)
  , Plutus.FromData (AsHaskell k)
  , Plutus.FromData (AsHaskell v)
  ) =>
  PLiftable (PUnsortedMap k v)
  where
  type AsHaskell (PUnsortedMap k v) = PlutusMap.Map (AsHaskell k) (AsHaskell v)
  type PlutusRepr (PUnsortedMap k v) = [(Plutus.Data, Plutus.Data)]
  {-# INLINEABLE haskToRepr #-}
  haskToRepr :: AsHaskell (PUnsortedMap k v) -> PlutusRepr (PUnsortedMap k v)
haskToRepr = ((AsHaskell k, AsHaskell v) -> (Data, Data))
-> [(AsHaskell k, AsHaskell v)] -> [(Data, Data)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap ((AsHaskell k -> Data)
-> (AsHaskell v -> Data)
-> (AsHaskell k, AsHaskell v)
-> (Data, Data)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: Type -> Type -> Type) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap AsHaskell k -> Data
forall a. ToData a => a -> Data
Plutus.toData AsHaskell v -> Data
forall a. ToData a => a -> Data
Plutus.toData) ([(AsHaskell k, AsHaskell v)] -> [(Data, Data)])
-> (Map (AsHaskell k) (AsHaskell v)
    -> [(AsHaskell k, AsHaskell v)])
-> Map (AsHaskell k) (AsHaskell v)
-> [(Data, Data)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map (AsHaskell k) (AsHaskell v) -> [(AsHaskell k, AsHaskell v)]
forall k v. Map k v -> [(k, v)]
PlutusMap.toList
  {-# INLINEABLE reprToHask #-}
  reprToHask :: PlutusRepr (PUnsortedMap k v)
-> Either LiftError (AsHaskell (PUnsortedMap k v))
reprToHask PlutusRepr (PUnsortedMap k v)
x =
    [(AsHaskell k, AsHaskell v)] -> Map (AsHaskell k) (AsHaskell v)
forall k v. [(k, v)] -> Map k v
PlutusMap.unsafeFromList
      ([(AsHaskell k, AsHaskell v)] -> Map (AsHaskell k) (AsHaskell v))
-> Either LiftError [(AsHaskell k, AsHaskell v)]
-> Either LiftError (Map (AsHaskell k) (AsHaskell v))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Data, Data) -> Either LiftError (AsHaskell k, AsHaskell v))
-> [(Data, Data)] -> Either LiftError [(AsHaskell k, AsHaskell v)]
forall (t :: Type -> Type) (f :: Type -> Type) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: Type -> Type) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse
        ( \(Data
k, Data
v) ->
            (,)
              (AsHaskell k -> AsHaskell v -> (AsHaskell k, AsHaskell v))
-> Either LiftError (AsHaskell k)
-> Either LiftError (AsHaskell v -> (AsHaskell k, AsHaskell v))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> (Either LiftError (AsHaskell k)
-> (AsHaskell k -> Either LiftError (AsHaskell k))
-> Maybe (AsHaskell k)
-> Either LiftError (AsHaskell k)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (LiftError -> Either LiftError (AsHaskell k)
forall a b. a -> Either a b
Left LiftError
CouldNotDecodeData) AsHaskell k -> Either LiftError (AsHaskell k)
forall a b. b -> Either a b
Right (Maybe (AsHaskell k) -> Either LiftError (AsHaskell k))
-> (Data -> Maybe (AsHaskell k))
-> Data
-> Either LiftError (AsHaskell k)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Data -> Maybe (AsHaskell k)
forall a. FromData a => Data -> Maybe a
Plutus.fromData) Data
k
              Either LiftError (AsHaskell v -> (AsHaskell k, AsHaskell v))
-> Either LiftError (AsHaskell v)
-> Either LiftError (AsHaskell k, AsHaskell v)
forall a b.
Either LiftError (a -> b)
-> Either LiftError a -> Either LiftError b
forall (f :: Type -> Type) a b.
Applicative f =>
f (a -> b) -> f a -> f b
<*> (Either LiftError (AsHaskell v)
-> (AsHaskell v -> Either LiftError (AsHaskell v))
-> Maybe (AsHaskell v)
-> Either LiftError (AsHaskell v)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (LiftError -> Either LiftError (AsHaskell v)
forall a b. a -> Either a b
Left LiftError
CouldNotDecodeData) AsHaskell v -> Either LiftError (AsHaskell v)
forall a b. b -> Either a b
Right (Maybe (AsHaskell v) -> Either LiftError (AsHaskell v))
-> (Data -> Maybe (AsHaskell v))
-> Data
-> Either LiftError (AsHaskell v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Data -> Maybe (AsHaskell v)
forall a. FromData a => Data -> Maybe a
Plutus.fromData) Data
v
        )
        [(Data, Data)]
PlutusRepr (PUnsortedMap k v)
x
  {-# INLINEABLE reprToPlut #-}
  reprToPlut :: forall (s :: S).
PlutusRepr (PUnsortedMap k v) -> PLifted s (PUnsortedMap k v)
reprToPlut = PlutusRepr (PUnsortedMap k v) -> PLifted s (PUnsortedMap k v)
forall (a :: S -> Type) (s :: S).
Includes DefaultUni (PlutusRepr a) =>
PlutusRepr a -> PLifted s a
reprToPlutUni
  {-# INLINEABLE plutToRepr #-}
  plutToRepr :: (forall (s :: S). PLifted s (PUnsortedMap k v))
-> Either LiftError (PlutusRepr (PUnsortedMap k v))
plutToRepr = (forall (s :: S). PLifted s (PUnsortedMap k v))
-> Either LiftError (PlutusRepr (PUnsortedMap k v))
forall (a :: S -> Type).
KnownBuiltinType
  (Term DeBruijn DefaultUni DefaultFun ()) (PlutusRepr a) =>
(forall (s :: S). PLifted s a) -> Either LiftError (PlutusRepr a)
plutToReprUni

----------------------------------------------------------------------
-- Sorted Map

newtype PSortedMap (k :: S -> Type) (v :: S -> Type) (s :: S)
  = PSortedMap (Term s (PAssocMap k v))
  deriving stock
    ( -- | @since 3.5.0
      (forall x. PSortedMap k v s -> Rep (PSortedMap k v s) x)
-> (forall x. Rep (PSortedMap k v s) x -> PSortedMap k v s)
-> Generic (PSortedMap k v s)
forall x. Rep (PSortedMap k v s) x -> PSortedMap k v s
forall x. PSortedMap k v s -> Rep (PSortedMap k v s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (k :: S -> Type) (v :: S -> Type) (s :: S) x.
Rep (PSortedMap k v s) x -> PSortedMap k v s
forall (k :: S -> Type) (v :: S -> Type) (s :: S) x.
PSortedMap k v s -> Rep (PSortedMap k v s) x
$cfrom :: forall (k :: S -> Type) (v :: S -> Type) (s :: S) x.
PSortedMap k v s -> Rep (PSortedMap k v s) x
from :: forall x. PSortedMap k v s -> Rep (PSortedMap k v s) x
$cto :: forall (k :: S -> Type) (v :: S -> Type) (s :: S) x.
Rep (PSortedMap k v s) x -> PSortedMap k v s
to :: forall x. Rep (PSortedMap k v s) x -> PSortedMap k v s
Generic
    )
  deriving anyclass
    ( -- | @since 3.5.0
      All SListI (Code (PSortedMap k v s))
All SListI (Code (PSortedMap k v s)) =>
(PSortedMap k v s -> Rep (PSortedMap k v s))
-> (Rep (PSortedMap k v s) -> PSortedMap k v s)
-> Generic (PSortedMap k v s)
Rep (PSortedMap k v s) -> PSortedMap k v s
PSortedMap k v s -> Rep (PSortedMap k v s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
All SListI (Code (PSortedMap k v s))
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Rep (PSortedMap k v s) -> PSortedMap k v s
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PSortedMap k v s -> Rep (PSortedMap k v s)
$cfrom :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PSortedMap k v s -> Rep (PSortedMap k v s)
from :: PSortedMap k v s -> Rep (PSortedMap k v s)
$cto :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Rep (PSortedMap k v s) -> PSortedMap k v s
to :: Rep (PSortedMap k v s) -> PSortedMap k v s
SOP.Generic
    , -- | @since 3.5.0
      (forall (s :: S).
 Bool -> Term s (PSortedMap k v) -> Term s PString)
-> PShow (PSortedMap k v)
forall (s :: S). Bool -> Term s (PSortedMap k v) -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PIsData k, PIsData v, PShow k, PShow v) =>
Bool -> Term s (PSortedMap k v) -> Term s PString
$cpshow' :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PIsData k, PIsData v, PShow k, PShow v) =>
Bool -> Term s (PSortedMap k v) -> Term s PString
pshow' :: forall (s :: S). Bool -> Term s (PSortedMap k v) -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.5.0
      (forall (s :: S).
 PSortedMap k v s -> Term s (PInner (PSortedMap k v)))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner (PSortedMap k v))
    -> (PSortedMap k v s -> Term s b) -> Term s b)
-> PlutusType (PSortedMap k v)
forall (s :: S).
PSortedMap k v s -> Term s (PInner (PSortedMap k v))
forall (s :: S) (b :: S -> Type).
Term s (PInner (PSortedMap k v))
-> (PSortedMap k v s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PSortedMap k v s -> Term s (PInner (PSortedMap k v))
forall (k :: S -> Type) (v :: S -> Type) (s :: S) (b :: S -> Type).
Term s (PInner (PSortedMap k v))
-> (PSortedMap k v s -> Term s b) -> Term s b
$cpcon' :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PSortedMap k v s -> Term s (PInner (PSortedMap k v))
pcon' :: forall (s :: S).
PSortedMap k v s -> Term s (PInner (PSortedMap k v))
$cpmatch' :: forall (k :: S -> Type) (v :: S -> Type) (s :: S) (b :: S -> Type).
Term s (PInner (PSortedMap k v))
-> (PSortedMap k v s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner (PSortedMap k v))
-> (PSortedMap k v s -> Term s b) -> Term s b
PlutusType
    )
    via (DeriveNewtypePlutusType (PSortedMap k v))

-- | @since 3.5.0
instance PIsData (PSortedMap k v) where
  pfromDataImpl :: forall (s :: S).
Term s (PAsData (PSortedMap k v)) -> Term s (PSortedMap k v)
pfromDataImpl Term s (PAsData (PSortedMap k v))
x = Term s (PBuiltinList (PBuiltinPair PData PData))
-> Term s (PSortedMap k v)
forall (b :: S -> Type) (a :: S -> Type) (s :: S).
Term s a -> Term s b
punsafeCoerce (Term s (PBuiltinList (PBuiltinPair PData PData))
 -> Term s (PSortedMap k v))
-> Term s (PBuiltinList (PBuiltinPair PData PData))
-> Term s (PSortedMap k v)
forall a b. (a -> b) -> a -> b
$ Term s (PData :--> PBuiltinList (PBuiltinPair PData PData))
forall (s :: S).
Term s (PData :--> PBuiltinList (PBuiltinPair PData PData))
pasMap Term s (PData :--> PBuiltinList (PBuiltinPair PData PData))
-> Term s PData -> Term s (PBuiltinList (PBuiltinPair PData PData))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PAsData (PSortedMap k v)) -> Term s PData
forall (s :: S) (a :: S -> Type).
Term s (PAsData a) -> Term s PData
pforgetData Term s (PAsData (PSortedMap k v))
x
  pdataImpl :: forall (s :: S). Term s (PSortedMap k v) -> Term s PData
pdataImpl Term s (PSortedMap k v)
x = DefaultFun -> Term s (PSortedMap k v :--> PData)
forall (s :: S) (a :: S -> Type). DefaultFun -> Term s a
punsafeBuiltin DefaultFun
PLC.MapData Term s (PSortedMap k v :--> PData)
-> Term s (PSortedMap k v) -> Term s PData
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PSortedMap k v)
x

-- | @since 3.5.0
instance PEq (PSortedMap k v) where
  Term s (PSortedMap k v)
x #== :: forall (s :: S).
Term s (PSortedMap k v) -> Term s (PSortedMap k v) -> Term s PBool
#== Term s (PSortedMap k v)
y = Term s (PSortedMap k v :--> (PSortedMap k v :--> PBool))
forall (s :: S).
Term s (PSortedMap k v :--> (PSortedMap k v :--> PBool))
peqViaData Term s (PSortedMap k v :--> (PSortedMap k v :--> PBool))
-> Term s (PSortedMap k v) -> Term s (PSortedMap k v :--> PBool)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PSortedMap k v)
x Term s (PSortedMap k v :--> PBool)
-> Term s (PSortedMap k v) -> Term s PBool
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PSortedMap k v)
y
    where
      peqViaData ::
        forall (s :: S).
        Term s (PSortedMap k v :--> PSortedMap k v :--> PBool)
      peqViaData :: forall (s :: S).
Term s (PSortedMap k v :--> (PSortedMap k v :--> PBool))
peqViaData = (forall (s :: S).
 Term s (PSortedMap k v :--> (PSortedMap k v :--> PBool)))
-> Term s (PSortedMap k v :--> (PSortedMap k v :--> PBool))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s :: S).
  Term s (PSortedMap k v :--> (PSortedMap k v :--> PBool)))
 -> Term s (PSortedMap k v :--> (PSortedMap k v :--> PBool)))
-> (forall (s :: S).
    Term s (PSortedMap k v :--> (PSortedMap k v :--> PBool)))
-> Term s (PSortedMap k v :--> (PSortedMap k v :--> PBool))
forall a b. (a -> b) -> a -> b
$ (Term s' (PSortedMap k v)
 -> Term s' (PSortedMap k v) -> Term s' PBool)
-> Term s' (PSortedMap k v :--> (PSortedMap k v :--> PBool))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PSortedMap k v) -> Term s' PBool)
-> Term s' (c :--> (PSortedMap k v :--> PBool))
plam ((Term s' (PSortedMap k v)
  -> Term s' (PSortedMap k v) -> Term s' PBool)
 -> Term s' (PSortedMap k v :--> (PSortedMap k v :--> PBool)))
-> (Term s' (PSortedMap k v)
    -> Term s' (PSortedMap k v) -> Term s' PBool)
-> Term s' (PSortedMap k v :--> (PSortedMap k v :--> PBool))
forall a b. (a -> b) -> a -> b
$ \Term s' (PSortedMap k v)
m0 Term s' (PSortedMap k v)
m1 -> Term s' (PSortedMap k v) -> Term s' (PAsData (PSortedMap k v))
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s a -> Term s (PAsData a)
pdata Term s' (PSortedMap k v)
m0 Term s' (PAsData (PSortedMap k v))
-> Term s' (PAsData (PSortedMap k v)) -> Term s' PBool
forall (s :: S).
Term s (PAsData (PSortedMap k v))
-> Term s (PAsData (PSortedMap k v)) -> Term s PBool
forall (t :: S -> Type) (s :: S).
PEq t =>
Term s t -> Term s t -> Term s PBool
#== Term s' (PSortedMap k v) -> Term s' (PAsData (PSortedMap k v))
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s a -> Term s (PAsData a)
pdata Term s' (PSortedMap k v)
m1

-- | @since 3.5.0
instance
  ( POrd k
  , PIsData k
  , PTryFrom PData (PAsData k)
  , PTryFrom PData (PAsData v)
  ) =>
  PTryFrom PData (PAsData (PSortedMap k v))
  where
  ptryFrom' :: forall (s :: S) (r :: S -> Type).
Term s PData
-> ((Term s (PAsData (PSortedMap k v)),
     Reduce (PTryFromExcess PData (PAsData (PSortedMap k v)) s))
    -> Term s r)
-> Term s r
ptryFrom' Term s PData
opq = TermCont
  s
  (Term s (PAsData (PSortedMap k v)),
   Reduce (PTryFromExcess PData (PAsData (PSortedMap k v)) s))
-> ((Term s (PAsData (PSortedMap k v)),
     Reduce (PTryFromExcess PData (PAsData (PSortedMap k v)) s))
    -> Term s r)
-> Term s r
forall (r :: S -> Type) (s :: S) a.
TermCont s a -> (a -> Term s r) -> Term s r
runTermCont (TermCont
   s
   (Term s (PAsData (PSortedMap k v)),
    Reduce (PTryFromExcess PData (PAsData (PSortedMap k v)) s))
 -> ((Term s (PAsData (PSortedMap k v)),
      Reduce (PTryFromExcess PData (PAsData (PSortedMap k v)) s))
     -> Term s r)
 -> Term s r)
-> TermCont
     s
     (Term s (PAsData (PSortedMap k v)),
      Reduce (PTryFromExcess PData (PAsData (PSortedMap k v)) s))
-> ((Term s (PAsData (PSortedMap k v)),
     Reduce (PTryFromExcess PData (PAsData (PSortedMap k v)) s))
    -> Term s r)
-> Term s r
forall a b. (a -> b) -> a -> b
$ do
    (Term s (PAsData (PUnsortedMap k v))
opq', ()
_) <- (((Term s (PAsData (PUnsortedMap k v)), ()) -> Term s r)
 -> Term s r)
-> TermCont s (Term s (PAsData (PUnsortedMap k v)), ())
forall a (s :: S) (r :: S -> Type).
((a -> Term s r) -> Term s r) -> TermCont s a
tcont ((((Term s (PAsData (PUnsortedMap k v)), ()) -> Term s r)
  -> Term s r)
 -> TermCont s (Term s (PAsData (PUnsortedMap k v)), ()))
-> (((Term s (PAsData (PUnsortedMap k v)), ()) -> Term s r)
    -> Term s r)
-> TermCont s (Term s (PAsData (PUnsortedMap k v)), ())
forall a b. (a -> b) -> a -> b
$ forall (b :: S -> Type) (a :: S -> Type) (s :: S) (r :: S -> Type).
PTryFrom a b =>
Term s a
-> ((Term s b, Reduce (PTryFromExcess a b s)) -> Term s r)
-> Term s r
ptryFrom @(PAsData (PUnsortedMap k v)) Term s PData
opq
    Term s (PSortedMap k v)
unwrapped <- ((Term s (PSortedMap k v) -> Term s r) -> Term s r)
-> TermCont s (Term s (PSortedMap k v))
forall a (s :: S) (r :: S -> Type).
((a -> Term s r) -> Term s r) -> TermCont s a
tcont (((Term s (PSortedMap k v) -> Term s r) -> Term s r)
 -> TermCont s (Term s (PSortedMap k v)))
-> ((Term s (PSortedMap k v) -> Term s r) -> Term s r)
-> TermCont s (Term s (PSortedMap k v))
forall a b. (a -> b) -> a -> b
$ Term s (PSortedMap k v)
-> (Term s (PSortedMap k v) -> Term s r) -> Term s r
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s a -> (Term s a -> Term s b) -> Term s b
plet (Term s (PSortedMap k v)
 -> (Term s (PSortedMap k v) -> Term s r) -> Term s r)
-> (Term s (PAsData (PUnsortedMap k v)) -> Term s (PSortedMap k v))
-> Term s (PAsData (PUnsortedMap k v))
-> (Term s (PSortedMap k v) -> Term s r)
-> Term s r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s (PUnsortedMap k v :--> PSortedMap k v)
-> Term s (PUnsortedMap k v) -> Term s (PSortedMap k v)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
papp Term s (PUnsortedMap k v :--> PSortedMap k v)
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(POrd k, PIsData k) =>
Term s (PUnsortedMap k v :--> PSortedMap k v)
ppromoteToSortedMap (Term s (PUnsortedMap k v) -> Term s (PSortedMap k v))
-> (Term s (PAsData (PUnsortedMap k v))
    -> Term s (PUnsortedMap k v))
-> Term s (PAsData (PUnsortedMap k v))
-> Term s (PSortedMap k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s (PAsData (PUnsortedMap k v)) -> Term s (PUnsortedMap k v)
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData (Term s (PAsData (PUnsortedMap k v))
 -> (Term s (PSortedMap k v) -> Term s r) -> Term s r)
-> Term s (PAsData (PUnsortedMap k v))
-> (Term s (PSortedMap k v) -> Term s r)
-> Term s r
forall a b. (a -> b) -> a -> b
$ Term s (PAsData (PUnsortedMap k v))
opq'
    (Term s (PAsData (PSortedMap k v)), ())
-> TermCont s (Term s (PAsData (PSortedMap k v)), ())
forall a. a -> TermCont s a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure (Term s (PSortedMap k v) -> Term s (PAsData (PSortedMap k v))
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s a -> Term s (PAsData a)
pdata Term s (PSortedMap k v)
unwrapped, ())

{- | Checks that we have a valid 'PSortedMap' with keys sorted in ascending
order.

@since 3.6.0
-}
instance (PValidateData k, PValidateData v, POrd k, PIsData k) => PValidateData (PSortedMap k v) where
  pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated Term s PData
opq Term s r
x =
    -- the PUnsortedMap validation should run before the sortedness check
    forall (a :: S -> Type) (s :: S).
PValidateData a =>
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated @(PUnsortedMap k v) Term s PData
opq (Term s r -> Term s r) -> Term s r -> Term s r
forall a b. (a -> b) -> a -> b
$
      Term s (PSortedMap k v)
-> (Term s (PSortedMap k v) -> Term s r) -> Term s r
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s a -> (Term s a -> Term s b) -> Term s b
plet
        (Term s (PUnsortedMap k v :--> PSortedMap k v)
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(POrd k, PIsData k) =>
Term s (PUnsortedMap k v :--> PSortedMap k v)
ppromoteToSortedMap Term s (PUnsortedMap k v :--> PSortedMap k v)
-> Term s (PUnsortedMap k v) -> Term s (PSortedMap k v)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
#$ Term s (PAsData (PUnsortedMap k v)) -> Term s (PUnsortedMap k v)
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData (Term s (PAsData (PUnsortedMap k v)) -> Term s (PUnsortedMap k v))
-> Term s (PAsData (PUnsortedMap k v)) -> Term s (PUnsortedMap k v)
forall a b. (a -> b) -> a -> b
$ forall (b :: S -> Type) (a :: S -> Type) (s :: S).
Term s a -> Term s b
punsafeCoerce @(PAsData (PUnsortedMap k v)) Term s PData
opq)
        (Term s r -> Term s (PSortedMap k v) -> Term s r
forall a b. a -> b -> a
const Term s r
x)

----------------------------------------------------------------------
-- Creation

{- | Construct an empty map.

@since 2.0.0
-}
pempty ::
  forall
    (t :: (S -> Type) -> (S -> Type) -> S -> Type)
    (k :: S -> Type)
    (v :: S -> Type)
    (s :: S).
  PInner (t k v) ~ PAssocMap k v =>
  Term s (t k v)
pempty :: forall (t :: (S -> Type) -> (S -> Type) -> S -> Type)
       (k :: S -> Type) (v :: S -> Type) (s :: S).
(PInner (t k v) ~ PAssocMap k v) =>
Term s (t k v)
pempty = Term s (PInner (t k v)) -> Term s (t k v)
forall (s :: S) (a :: S -> Type). Term s (PInner a) -> Term s a
punsafeDowncast (Term s (PInner (t k v)) -> Term s (t k v))
-> Term s (PInner (t k v)) -> Term s (t k v)
forall a b. (a -> b) -> a -> b
$ Term s (PInner (PAssocMap k v)) -> Term s (PAssocMap k v)
forall (s :: S) (a :: S -> Type). Term s (PInner a) -> Term s a
punsafeDowncast Term s (PInner (PAssocMap k v))
Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (a :: S -> Type) (s :: S).
PElemConstraint PBuiltinList a =>
Term s (PBuiltinList a)
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
(PListLike list, PElemConstraint list a) =>
Term s (list a)
pnil

{- | Construct a singleton map with the given key and value.

@since 2.1.1
-}
psingleton ::
  forall
    (t :: (S -> Type) -> (S -> Type) -> S -> Type)
    (k :: S -> Type)
    (v :: S -> Type)
    (s :: S).
  ( PInner (t k v) ~ PAssocMap k v
  , PIsData k
  , PIsData v
  ) =>
  Term s (k :--> v :--> t k v)
psingleton :: forall (t :: (S -> Type) -> (S -> Type) -> S -> Type)
       (k :: S -> Type) (v :: S -> Type) (s :: S).
(PInner (t k v) ~ PAssocMap k v, PIsData k, PIsData v) =>
Term s (k :--> (v :--> t k v))
psingleton =
  (forall (s' :: S). Term s' (k :--> (v :--> t k v)))
-> Term s (k :--> (v :--> t k v))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S). Term s' (k :--> (v :--> t k v)))
 -> Term s (k :--> (v :--> t k v)))
-> (forall (s' :: S). Term s' (k :--> (v :--> t k v)))
-> Term s (k :--> (v :--> t k v))
forall a b. (a -> b) -> a -> b
$
    (Term s' k -> Term s' v -> Term s' (t k v))
-> Term s' (k :--> (v :--> t k v))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' v -> Term s' (t k v))
-> Term s' (c :--> (v :--> t k v))
plam ((Term s' k -> Term s' v -> Term s' (t k v))
 -> Term s' (k :--> (v :--> t k v)))
-> (Term s' k -> Term s' v -> Term s' (t k v))
-> Term s' (k :--> (v :--> t k v))
forall a b. (a -> b) -> a -> b
$ \Term s' k
key Term s' v
value ->
      Term s' (PAsData k :--> (PAsData v :--> t k v))
forall (t :: (S -> Type) -> (S -> Type) -> S -> Type)
       (k :: S -> Type) (v :: S -> Type) (s :: S).
(PInner (t k v) ~ PAssocMap k v) =>
Term s (PAsData k :--> (PAsData v :--> t k v))
psingletonData Term s' (PAsData k :--> (PAsData v :--> t k v))
-> Term s' (PAsData k) -> Term s' (PAsData v :--> t k v)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' k -> Term s' (PAsData k)
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s a -> Term s (PAsData a)
pdata Term s' k
key Term s' (PAsData v :--> t k v)
-> Term s' (PAsData v) -> Term s' (t k v)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' v -> Term s' (PAsData v)
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s a -> Term s (PAsData a)
pdata Term s' v
value

{- | Construct a singleton map with the given data-encoded key and value.

@since 2.1.1
-}
psingletonData ::
  forall
    (t :: (S -> Type) -> (S -> Type) -> S -> Type)
    (k :: S -> Type)
    (v :: S -> Type)
    (s :: S).
  PInner (t k v) ~ PAssocMap k v =>
  Term s (PAsData k :--> PAsData v :--> t k v)
psingletonData :: forall (t :: (S -> Type) -> (S -> Type) -> S -> Type)
       (k :: S -> Type) (v :: S -> Type) (s :: S).
(PInner (t k v) ~ PAssocMap k v) =>
Term s (PAsData k :--> (PAsData v :--> t k v))
psingletonData =
  (forall (s' :: S). Term s' (PAsData k :--> (PAsData v :--> t k v)))
-> Term s (PAsData k :--> (PAsData v :--> t k v))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term s' (PAsData k :--> (PAsData v :--> t k v)))
 -> Term s (PAsData k :--> (PAsData v :--> t k v)))
-> (forall (s' :: S).
    Term s' (PAsData k :--> (PAsData v :--> t k v)))
-> Term s (PAsData k :--> (PAsData v :--> t k v))
forall a b. (a -> b) -> a -> b
$
    (Term s' (PAsData k) -> Term s' (PAsData v) -> Term s' (t k v))
-> Term s' (PAsData k :--> (PAsData v :--> t k v))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PAsData v) -> Term s' (t k v))
-> Term s' (c :--> (PAsData v :--> t k v))
plam ((Term s' (PAsData k) -> Term s' (PAsData v) -> Term s' (t k v))
 -> Term s' (PAsData k :--> (PAsData v :--> t k v)))
-> (Term s' (PAsData k) -> Term s' (PAsData v) -> Term s' (t k v))
-> Term s' (PAsData k :--> (PAsData v :--> t k v))
forall a b. (a -> b) -> a -> b
$ \Term s' (PAsData k)
key Term s' (PAsData v)
value ->
      Term s' (PInner (t k v)) -> Term s' (t k v)
forall (s :: S) (a :: S -> Type). Term s (PInner a) -> Term s a
punsafeDowncast (Term s' (PInner (t k v)) -> Term s' (t k v))
-> (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
    -> Term s' (PInner (t k v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (t k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' (PInner (PInner (t k v))) -> Term s' (PInner (t k v))
Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PInner (t k v))
forall (s :: S) (a :: S -> Type). Term s (PInner a) -> Term s a
punsafeDowncast (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term s' (t k v))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (t k v)
forall a b. (a -> b) -> a -> b
$
        Term
  s'
  (PBuiltinPair (PAsData k) (PAsData v)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
forall (a :: S -> Type) (s :: S).
PElemConstraint PBuiltinList a =>
Term s (a :--> (PBuiltinList a :--> PBuiltinList a))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
(PListLike list, PElemConstraint list a) =>
Term s (a :--> (list a :--> list a))
pcons
          # (ppairDataBuiltin # key # value)
          # pnil

-- | @since 2.1.1
punsortedMapFromFoldable ::
  forall (k :: S -> Type) (v :: S -> Type) (f :: Type -> Type) (s :: S).
  ( Foldable f
  , PIsData k
  , PIsData v
  ) =>
  f (Term s k, Term s v) ->
  Term s (PUnsortedMap k v)
punsortedMapFromFoldable :: forall (k :: S -> Type) (v :: S -> Type) (f :: Type -> Type)
       (s :: S).
(Foldable f, PIsData k, PIsData v) =>
f (Term s k, Term s v) -> Term s (PUnsortedMap k v)
punsortedMapFromFoldable =
  PUnsortedMap k v s -> Term s (PUnsortedMap k v)
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon (PUnsortedMap k v s -> Term s (PUnsortedMap k v))
-> (f (Term s k, Term s v) -> PUnsortedMap k v s)
-> f (Term s k, Term s v)
-> Term s (PUnsortedMap k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s (PAssocMap k v) -> PUnsortedMap k v s
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Term s (PAssocMap k v) -> PUnsortedMap k v s
PUnsortedMap (Term s (PAssocMap k v) -> PUnsortedMap k v s)
-> (f (Term s k, Term s v) -> Term s (PAssocMap k v))
-> f (Term s k, Term s v)
-> PUnsortedMap k v s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PAssocMap k v s -> Term s (PAssocMap k v)
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon (PAssocMap k v s -> Term s (PAssocMap k v))
-> (f (Term s k, Term s v) -> PAssocMap k v s)
-> f (Term s k, Term s v)
-> Term s (PAssocMap k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> PAssocMap k v s
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> PAssocMap k v s
PAssocMap (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> PAssocMap k v s)
-> (f (Term s k, Term s v)
    -> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> f (Term s k, Term s v)
-> PAssocMap k v s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> (Term s k, Term s v)
 -> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> f (Term s k, Term s v)
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall b a. (b -> a -> b) -> b -> f a -> b
forall (t :: Type -> Type) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> (Term s k, Term s v)
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s' :: S).
Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> (Term s' k, Term s' v)
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
go (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) s
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) s
forall (a :: S -> Type) (s :: S). PBuiltinList a s
PNil)
  where
    go ::
      forall (s' :: S).
      Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))) ->
      (Term s' k, Term s' v) ->
      Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
    go :: forall (s' :: S).
Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> (Term s' k, Term s' v)
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
go Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
acc (Term s' k
key, Term s' v
val) =
      PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) s'
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) s'
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
    -> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) s')
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) s'
forall (a :: S -> Type) (s :: S).
Term s a -> Term s (PBuiltinList a) -> PBuiltinList a s
PCons (Term
  s'
  (PAsData k
   :--> (PAsData v :--> PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term
  s
  (PAsData a
   :--> (PAsData b :--> PBuiltinPair (PAsData a) (PAsData b)))
ppairDataBuiltin Term
  s'
  (PAsData k
   :--> (PAsData v :--> PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PAsData k)
-> Term s' (PAsData v :--> PBuiltinPair (PAsData k) (PAsData v))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' k -> Term s' (PAsData k)
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s a -> Term s (PAsData a)
pdata Term s' k
key Term s' (PAsData v :--> PBuiltinPair (PAsData k) (PAsData v))
-> Term s' (PAsData v)
-> Term s' (PBuiltinPair (PAsData k) (PAsData v))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' v -> Term s' (PAsData v)
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s a -> Term s (PAsData a)
pdata Term s' v
val) (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall a b. (a -> b) -> a -> b
$ Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
acc

-- | @since 2.1.1
psortedMapFromFoldable ::
  forall (k :: S -> Type) (v :: S -> Type) (f :: Type -> Type) (s :: S).
  ( Foldable f
  , POrd k
  , PIsData k
  , PIsData v
  ) =>
  f (Term s k, Term s v) ->
  Term s (PSortedMap k v)
psortedMapFromFoldable :: forall (k :: S -> Type) (v :: S -> Type) (f :: Type -> Type)
       (s :: S).
(Foldable f, POrd k, PIsData k, PIsData v) =>
f (Term s k, Term s v) -> Term s (PSortedMap k v)
psortedMapFromFoldable = (Term s (PSortedMap k v)
 -> (Term s k, Term s v) -> Term s (PSortedMap k v))
-> Term s (PSortedMap k v)
-> f (Term s k, Term s v)
-> Term s (PSortedMap k v)
forall b a. (b -> a -> b) -> b -> f a -> b
forall (t :: Type -> Type) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' Term s (PSortedMap k v)
-> (Term s k, Term s v) -> Term s (PSortedMap k v)
forall (s' :: S).
Term s' (PSortedMap k v)
-> (Term s' k, Term s' v) -> Term s' (PSortedMap k v)
go Term s (PSortedMap k v)
forall (t :: (S -> Type) -> (S -> Type) -> S -> Type)
       (k :: S -> Type) (v :: S -> Type) (s :: S).
(PInner (t k v) ~ PAssocMap k v) =>
Term s (t k v)
pempty
  where
    go ::
      forall (s' :: S).
      Term s' (PSortedMap k v) ->
      (Term s' k, Term s' v) ->
      Term s' (PSortedMap k v)
    go :: forall (s' :: S).
Term s' (PSortedMap k v)
-> (Term s' k, Term s' v) -> Term s' (PSortedMap k v)
go Term s' (PSortedMap k v)
acc (Term s' k
key, Term s' v
val) = Term s' (k :--> (v :--> (PSortedMap k v :--> PSortedMap k v)))
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(POrd k, PIsData k, PIsData v) =>
Term s (k :--> (v :--> (PSortedMap k v :--> PSortedMap k v)))
pinsert Term s' (k :--> (v :--> (PSortedMap k v :--> PSortedMap k v)))
-> Term s' k
-> Term s' (v :--> (PSortedMap k v :--> PSortedMap k v))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' k
key Term s' (v :--> (PSortedMap k v :--> PSortedMap k v))
-> Term s' v -> Term s' (PSortedMap k v :--> PSortedMap k v)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' v
val Term s' (PSortedMap k v :--> PSortedMap k v)
-> Term s' (PSortedMap k v) -> Term s' (PSortedMap k v)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PSortedMap k v)
acc

----------------------------------------------------------------------
-- Transformation

{- | Attempt to promote `PUnsortedMap` to `PSortedMap`. This function checks
that the keys in the input map are in strictly ascending order and fails with
an error if they are not. Duplicate keys are not allowed.

@since 2.0.0
-}
{-# DEPRECATED passertSorted "Use ppromoteToSortedMap instead" #-}
passertSorted ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  ( POrd k
  , PIsData k
  ) =>
  Term s (PUnsortedMap k v :--> PSortedMap k v)
passertSorted :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(POrd k, PIsData k) =>
Term s (PUnsortedMap k v :--> PSortedMap k v)
passertSorted =
  let ()
_ = Proxy (k ~ k) -> ()
forall (c :: Constraint). c => Proxy c -> ()
witness (Proxy (k ~ k)
forall {k} (t :: k). Proxy t
Proxy :: Proxy (k ~ k))
   in (forall (s' :: S). Term s' (PUnsortedMap k v :--> PSortedMap k v))
-> Term s (PUnsortedMap k v :--> PSortedMap k v)
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S). Term s' (PUnsortedMap k v :--> PSortedMap k v))
 -> Term s (PUnsortedMap k v :--> PSortedMap k v))
-> (forall (s' :: S).
    Term s' (PUnsortedMap k v :--> PSortedMap k v))
-> Term s (PUnsortedMap k v :--> PSortedMap k v)
forall a b. (a -> b) -> a -> b
$
        (Term s' (PUnsortedMap k v) -> Term s' (PSortedMap k v))
-> Term s' (PUnsortedMap k v :--> PSortedMap k v)
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PSortedMap k v))
-> Term s' (c :--> PSortedMap k v)
plam ((Term s' (PUnsortedMap k v) -> Term s' (PSortedMap k v))
 -> Term s' (PUnsortedMap k v :--> PSortedMap k v))
-> (Term s' (PUnsortedMap k v) -> Term s' (PSortedMap k v))
-> Term s' (PUnsortedMap k v :--> PSortedMap k v)
forall a b. (a -> b) -> a -> b
$ \Term s' (PUnsortedMap k v)
m ->
          (Term
   s'
   (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
    :--> ((k :--> PBool) :--> PSortedMap k v))
 -> Term s' (PBuiltinPair (PAsData k) (PAsData v))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term s' ((k :--> PBool) :--> PSortedMap k v))
-> (Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> ((k :--> PBool) :--> PSortedMap k v))
    -> Term s' ((k :--> PBool) :--> PSortedMap k v))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> ((k :--> PBool) :--> PSortedMap k v))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S)
       (r :: S -> Type).
PIsListLike list a =>
(Term s (list a :--> r) -> Term s a -> Term s (list a) -> Term s r)
-> (Term s (list a :--> r) -> Term s r) -> Term s (list a :--> r)
precList
            ( \Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> ((k :--> PBool) :--> PSortedMap k v))
self Term s' (PBuiltinPair (PAsData k) (PAsData v))
x Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
xs ->
                Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> (PBuiltinPair (PAsData k) (PAsData v) s'
    -> Term s' ((k :--> PBool) :--> PSortedMap k v))
-> Term s' ((k :--> PBool) :--> PSortedMap k v)
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' (PBuiltinPair (PAsData k) (PAsData v))
x ((PBuiltinPair (PAsData k) (PAsData v) s'
  -> Term s' ((k :--> PBool) :--> PSortedMap k v))
 -> Term s' ((k :--> PBool) :--> PSortedMap k v))
-> (PBuiltinPair (PAsData k) (PAsData v) s'
    -> Term s' ((k :--> PBool) :--> PSortedMap k v))
-> Term s' ((k :--> PBool) :--> PSortedMap k v)
forall a b. (a -> b) -> a -> b
$ \(PBuiltinPair Term s' (PAsData k)
k' Term s' (PAsData v)
_) ->
                  Term s' k
-> (Term s' k -> Term s' ((k :--> PBool) :--> PSortedMap k v))
-> Term s' ((k :--> PBool) :--> PSortedMap k v)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s a -> (Term s a -> Term s b) -> Term s b
plet (Term s' (PAsData k) -> Term s' k
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData Term s' (PAsData k)
k') ((Term s' k -> Term s' ((k :--> PBool) :--> PSortedMap k v))
 -> Term s' ((k :--> PBool) :--> PSortedMap k v))
-> (Term s' k -> Term s' ((k :--> PBool) :--> PSortedMap k v))
-> Term s' ((k :--> PBool) :--> PSortedMap k v)
forall a b. (a -> b) -> a -> b
$ \Term s' k
k ->
                    (Term s' (k :--> PBool) -> Term s' (PSortedMap k v))
-> Term s' ((k :--> PBool) :--> PSortedMap k v)
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PSortedMap k v))
-> Term s' (c :--> PSortedMap k v)
plam ((Term s' (k :--> PBool) -> Term s' (PSortedMap k v))
 -> Term s' ((k :--> PBool) :--> PSortedMap k v))
-> (Term s' (k :--> PBool) -> Term s' (PSortedMap k v))
-> Term s' ((k :--> PBool) :--> PSortedMap k v)
forall a b. (a -> b) -> a -> b
$ \Term s' (k :--> PBool)
badKey ->
                      Term s' PBool
-> Term s' (PSortedMap k v)
-> Term s' (PSortedMap k v)
-> Term s' (PSortedMap k v)
forall (a :: S -> Type) (s :: S).
Term s PBool -> Term s a -> Term s a -> Term s a
pif
                        (Term s' (k :--> PBool)
badKey Term s' (k :--> PBool) -> Term s' k -> Term s' PBool
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' k
k)
                        (Term s' PString -> Term s' (PSortedMap k v)
forall (a :: S -> Type) (s :: S). Term s PString -> Term s a
ptraceInfoError Term s' PString
"unsorted map")
                        (Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> ((k :--> PBool) :--> PSortedMap k v))
self Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> ((k :--> PBool) :--> PSortedMap k v))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' ((k :--> PBool) :--> PSortedMap k v)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
xs Term s' ((k :--> PBool) :--> PSortedMap k v)
-> Term s' (k :--> PBool) -> Term s' (PSortedMap k v)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# (Term s' k -> Term s' PBool) -> Term s' (k :--> PBool)
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' PBool) -> Term s' (c :--> PBool)
plam (Term s' k -> Term s' k -> Term s' PBool
forall (s :: S). Term s k -> Term s k -> Term s PBool
forall (t :: S -> Type) (s :: S).
POrd t =>
Term s t -> Term s t -> Term s PBool
#<= Term s' k
k))
            )
            -- this is actually the empty map so we can
            -- safely assume that it is sorted
            (Term s' ((k :--> PBool) :--> PSortedMap k v)
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> ((k :--> PBool) :--> PSortedMap k v))
-> Term s' ((k :--> PBool) :--> PSortedMap k v)
forall a b. a -> b -> a
const (Term s' ((k :--> PBool) :--> PSortedMap k v)
 -> Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> ((k :--> PBool) :--> PSortedMap k v))
 -> Term s' ((k :--> PBool) :--> PSortedMap k v))
-> (Term s' (PInner (PSortedMap k v))
    -> Term s' ((k :--> PBool) :--> PSortedMap k v))
-> Term s' (PInner (PSortedMap k v))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> ((k :--> PBool) :--> PSortedMap k v))
-> Term s' ((k :--> PBool) :--> PSortedMap k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Term s' (k :--> PBool) -> Term s' (PSortedMap k v))
-> Term s' ((k :--> PBool) :--> PSortedMap k v)
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PSortedMap k v))
-> Term s' (c :--> PSortedMap k v)
plam ((Term s' (k :--> PBool) -> Term s' (PSortedMap k v))
 -> Term s' ((k :--> PBool) :--> PSortedMap k v))
-> (Term s' (PInner (PSortedMap k v))
    -> Term s' (k :--> PBool) -> Term s' (PSortedMap k v))
-> Term s' (PInner (PSortedMap k v))
-> Term s' ((k :--> PBool) :--> PSortedMap k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' (PSortedMap k v)
-> Term s' (k :--> PBool) -> Term s' (PSortedMap k v)
forall a b. a -> b -> a
const (Term s' (PSortedMap k v)
 -> Term s' (k :--> PBool) -> Term s' (PSortedMap k v))
-> (Term s' (PInner (PSortedMap k v)) -> Term s' (PSortedMap k v))
-> Term s' (PInner (PSortedMap k v))
-> Term s' (k :--> PBool)
-> Term s' (PSortedMap k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' (PInner (PSortedMap k v)) -> Term s' (PSortedMap k v)
forall (s :: S) (a :: S -> Type). Term s (PInner a) -> Term s a
punsafeDowncast (Term s' (PInner (PSortedMap k v))
 -> Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> ((k :--> PBool) :--> PSortedMap k v))
 -> Term s' ((k :--> PBool) :--> PSortedMap k v))
-> Term s' (PInner (PSortedMap k v))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> ((k :--> PBool) :--> PSortedMap k v))
-> Term s' ((k :--> PBool) :--> PSortedMap k v)
forall a b. (a -> b) -> a -> b
$ Term s' (PUnsortedMap k v) -> Term s' (PInner (PUnsortedMap k v))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto Term s' (PUnsortedMap k v)
m)
            # pto (pto m)
            # plam (const $ pcon PFalse)

{- | Attempt to promote `PUnsortedMap` to `PSortedMap`. This function checks
that the keys in the input map are in strictly ascending order and fails with
an error if they are not. Duplicate keys are not allowed.

@since 3.6.0
-}
ppromoteToSortedMap ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  ( POrd k
  , PIsData k
  ) =>
  Term s (PUnsortedMap k v :--> PSortedMap k v)
ppromoteToSortedMap :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(POrd k, PIsData k) =>
Term s (PUnsortedMap k v :--> PSortedMap k v)
ppromoteToSortedMap = Term s (PUnsortedMap k v :--> PSortedMap k v)
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(POrd k, PIsData k) =>
Term s (PUnsortedMap k v :--> PSortedMap k v)
passertSorted

{- | Coerce 'PUnsortedMap' to 'PSortedMap'. Unsafe.

@since 3.6.0
-}
punsafeCoerceToSortedMap ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  Term s (PUnsortedMap k v) ->
  Term s (PSortedMap k v)
punsafeCoerceToSortedMap :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Term s (PUnsortedMap k v) -> Term s (PSortedMap k v)
punsafeCoerceToSortedMap = Term s (PInner (PSortedMap k v)) -> Term s (PSortedMap k v)
Term s (PAssocMap k v) -> Term s (PSortedMap k v)
forall (s :: S) (a :: S -> Type). Term s (PInner a) -> Term s a
punsafeDowncast (Term s (PAssocMap k v) -> Term s (PSortedMap k v))
-> (Term s (PUnsortedMap k v) -> Term s (PAssocMap k v))
-> Term s (PUnsortedMap k v)
-> Term s (PSortedMap k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s (PUnsortedMap k v) -> Term s (PInner (PUnsortedMap k v))
Term s (PUnsortedMap k v) -> Term s (PAssocMap k v)
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto

{- | Forget the knowledge that keys were sorted.

@since 2.1.1
-}
pforgetSorted ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  Term s (PSortedMap k v) ->
  Term s (PUnsortedMap k v)
pforgetSorted :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Term s (PSortedMap k v) -> Term s (PUnsortedMap k v)
pforgetSorted = Term s (PInner (PUnsortedMap k v)) -> Term s (PUnsortedMap k v)
Term s (PAssocMap k v) -> Term s (PUnsortedMap k v)
forall (s :: S) (a :: S -> Type). Term s (PInner a) -> Term s a
punsafeDowncast (Term s (PAssocMap k v) -> Term s (PUnsortedMap k v))
-> (Term s (PSortedMap k v) -> Term s (PAssocMap k v))
-> Term s (PSortedMap k v)
-> Term s (PUnsortedMap k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s (PSortedMap k v) -> Term s (PInner (PSortedMap k v))
Term s (PSortedMap k v) -> Term s (PAssocMap k v)
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto

{- | Applies a function to every value in the map, much like 'Data.PPrelude.map'.

@since 2.0.0
-}
pmap ::
  forall
    (t :: (S -> Type) -> (S -> Type) -> S -> Type)
    (k :: S -> Type)
    (a :: S -> Type)
    (b :: S -> Type)
    (s :: S).
  ( PInner (t k a) ~ PAssocMap k a
  , PInner (t k b) ~ PAssocMap k b
  , PIsData a
  , PIsData b
  ) =>
  Term s ((a :--> b) :--> t k a :--> t k b)
pmap :: forall (t :: (S -> Type) -> (S -> Type) -> S -> Type)
       (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (s :: S).
(PInner (t k a) ~ PAssocMap k a, PInner (t k b) ~ PAssocMap k b,
 PIsData a, PIsData b) =>
Term s ((a :--> b) :--> (t k a :--> t k b))
pmap = (forall (s' :: S). Term s' ((a :--> b) :--> (t k a :--> t k b)))
-> Term s ((a :--> b) :--> (t k a :--> t k b))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S). Term s' ((a :--> b) :--> (t k a :--> t k b)))
 -> Term s ((a :--> b) :--> (t k a :--> t k b)))
-> (forall (s' :: S). Term s' ((a :--> b) :--> (t k a :--> t k b)))
-> Term s ((a :--> b) :--> (t k a :--> t k b))
forall a b. (a -> b) -> a -> b
$
  (Term s' (a :--> b) -> Term s' (t k a :--> t k b))
-> Term s' ((a :--> b) :--> (t k a :--> t k b))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (t k a :--> t k b))
-> Term s' (c :--> (t k a :--> t k b))
plam ((Term s' (a :--> b) -> Term s' (t k a :--> t k b))
 -> Term s' ((a :--> b) :--> (t k a :--> t k b)))
-> (Term s' (a :--> b) -> Term s' (t k a :--> t k b))
-> Term s' ((a :--> b) :--> (t k a :--> t k b))
forall a b. (a -> b) -> a -> b
$
    \Term s' (a :--> b)
f -> Term s' ((PAsData a :--> PAsData b) :--> (t k a :--> t k b))
forall (t :: (S -> Type) -> (S -> Type) -> S -> Type)
       (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (s :: S).
(PInner (t k a) ~ PAssocMap k a, PInner (t k b) ~ PAssocMap k b) =>
Term s ((PAsData a :--> PAsData b) :--> (t k a :--> t k b))
pmapData Term s' ((PAsData a :--> PAsData b) :--> (t k a :--> t k b))
-> Term s' (PAsData a :--> PAsData b) -> Term s' (t k a :--> t k b)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
#$ (Term s' (PAsData a) -> Term s' (PAsData b))
-> Term s' (PAsData a :--> PAsData b)
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PAsData b)) -> Term s' (c :--> PAsData b)
plam ((Term s' (PAsData a) -> Term s' (PAsData b))
 -> Term s' (PAsData a :--> PAsData b))
-> (Term s' (PAsData a) -> Term s' (PAsData b))
-> Term s' (PAsData a :--> PAsData b)
forall a b. (a -> b) -> a -> b
$ \Term s' (PAsData a)
v -> Term s' b -> Term s' (PAsData b)
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s a -> Term s (PAsData a)
pdata (Term s' (a :--> b)
f Term s' (a :--> b) -> Term s' a -> Term s' b
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAsData a) -> Term s' a
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData Term s' (PAsData a)
v)

{- | As 'pmap', but over Data representations.

@since 2.0.0
-}
pmapData ::
  forall
    (t :: (S -> Type) -> (S -> Type) -> S -> Type)
    (k :: S -> Type)
    (a :: S -> Type)
    (b :: S -> Type)
    (s :: S).
  ( PInner (t k a) ~ PAssocMap k a
  , PInner (t k b) ~ PAssocMap k b
  ) =>
  Term s ((PAsData a :--> PAsData b) :--> t k a :--> t k b)
pmapData :: forall (t :: (S -> Type) -> (S -> Type) -> S -> Type)
       (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (s :: S).
(PInner (t k a) ~ PAssocMap k a, PInner (t k b) ~ PAssocMap k b) =>
Term s ((PAsData a :--> PAsData b) :--> (t k a :--> t k b))
pmapData = (forall (s' :: S).
 Term s' ((PAsData a :--> PAsData b) :--> (t k a :--> t k b)))
-> Term s ((PAsData a :--> PAsData b) :--> (t k a :--> t k b))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term s' ((PAsData a :--> PAsData b) :--> (t k a :--> t k b)))
 -> Term s ((PAsData a :--> PAsData b) :--> (t k a :--> t k b)))
-> (forall (s' :: S).
    Term s' ((PAsData a :--> PAsData b) :--> (t k a :--> t k b)))
-> Term s ((PAsData a :--> PAsData b) :--> (t k a :--> t k b))
forall a b. (a -> b) -> a -> b
$
  (Term s' (PAsData a :--> PAsData b)
 -> Term s' (t k a) -> Term s' (t k b))
-> Term s' ((PAsData a :--> PAsData b) :--> (t k a :--> t k b))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (t k a) -> Term s' (t k b))
-> Term s' (c :--> (t k a :--> t k b))
plam ((Term s' (PAsData a :--> PAsData b)
  -> Term s' (t k a) -> Term s' (t k b))
 -> Term s' ((PAsData a :--> PAsData b) :--> (t k a :--> t k b)))
-> (Term s' (PAsData a :--> PAsData b)
    -> Term s' (t k a) -> Term s' (t k b))
-> Term s' ((PAsData a :--> PAsData b) :--> (t k a :--> t k b))
forall a b. (a -> b) -> a -> b
$ \Term s' (PAsData a :--> PAsData b)
f Term s' (t k a)
m ->
    Term s' (PInner (t k b)) -> Term s' (t k b)
forall (s :: S) (a :: S -> Type). Term s (PInner a) -> Term s a
punsafeDowncast (Term s' (PInner (t k b)) -> Term s' (t k b))
-> (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
    -> Term s' (PInner (t k b)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (t k b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' (PInner (PInner (t k b))) -> Term s' (PInner (t k b))
Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (PInner (t k b))
forall (s :: S) (a :: S -> Type). Term s (PInner a) -> Term s a
punsafeDowncast (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
 -> Term s' (t k b))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (t k b)
forall a b. (a -> b) -> a -> b
$
      (Term
   s'
   (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
    :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
 -> Term s' (PBuiltinPair (PAsData k) (PAsData a))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> (Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
       :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S)
       (r :: S -> Type).
PIsListLike list a =>
(Term s (list a :--> r) -> Term s a -> Term s (list a) -> Term s r)
-> (Term s (list a :--> r) -> Term s r) -> Term s (list a :--> r)
precList
        ( \Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
self Term s' (PBuiltinPair (PAsData k) (PAsData a))
x Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
xs ->
            Term s' (PBuiltinPair (PAsData k) (PAsData a))
-> (PBuiltinPair (PAsData k) (PAsData a) s'
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' (PBuiltinPair (PAsData k) (PAsData a))
x ((PBuiltinPair (PAsData k) (PAsData a) s'
  -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> (PBuiltinPair (PAsData k) (PAsData a) s'
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall a b. (a -> b) -> a -> b
$ \(PBuiltinPair Term s' (PAsData k)
y Term s' (PAsData a)
z) ->
              Term
  s'
  (PBuiltinPair (PAsData k) (PAsData b)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
forall (a :: S -> Type) (s :: S).
PElemConstraint PBuiltinList a =>
Term s (a :--> (PBuiltinList a :--> PBuiltinList a))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
(PListLike list, PElemConstraint list a) =>
Term s (a :--> (list a :--> list a))
pcons
                # (ppairDataBuiltin # y # (f # z))
                # (self # xs)
        )
        (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall a b. a -> b -> a
const Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall (a :: S -> Type) (s :: S).
PElemConstraint PBuiltinList a =>
Term s (PBuiltinList a)
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
(PListLike list, PElemConstraint list a) =>
Term s (list a)
pnil)
        # pto (pto m)

{- | As 'pmap', but gives key access as well.

@since 2.1.1
-}
pmapWithKey ::
  forall
    (t :: (S -> Type) -> (S -> Type) -> S -> Type)
    (k :: S -> Type)
    (a :: S -> Type)
    (b :: S -> Type)
    (s :: S).
  ( PInner (t k a) ~ PAssocMap k a
  , PInner (t k b) ~ PAssocMap k b
  , PIsData k
  , PIsData a
  , PIsData b
  ) =>
  Term s ((k :--> a :--> b) :--> t k a :--> t k b)
pmapWithKey :: forall (t :: (S -> Type) -> (S -> Type) -> S -> Type)
       (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (s :: S).
(PInner (t k a) ~ PAssocMap k a, PInner (t k b) ~ PAssocMap k b,
 PIsData k, PIsData a, PIsData b) =>
Term s ((k :--> (a :--> b)) :--> (t k a :--> t k b))
pmapWithKey = (forall (s' :: S).
 Term s' ((k :--> (a :--> b)) :--> (t k a :--> t k b)))
-> Term s ((k :--> (a :--> b)) :--> (t k a :--> t k b))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term s' ((k :--> (a :--> b)) :--> (t k a :--> t k b)))
 -> Term s ((k :--> (a :--> b)) :--> (t k a :--> t k b)))
-> (forall (s' :: S).
    Term s' ((k :--> (a :--> b)) :--> (t k a :--> t k b)))
-> Term s ((k :--> (a :--> b)) :--> (t k a :--> t k b))
forall a b. (a -> b) -> a -> b
$
  (Term s' (k :--> (a :--> b)) -> Term s' (t k a) -> Term s' (t k b))
-> Term s' ((k :--> (a :--> b)) :--> (t k a :--> t k b))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (t k a) -> Term s' (t k b))
-> Term s' (c :--> (t k a :--> t k b))
plam ((Term s' (k :--> (a :--> b))
  -> Term s' (t k a) -> Term s' (t k b))
 -> Term s' ((k :--> (a :--> b)) :--> (t k a :--> t k b)))
-> (Term s' (k :--> (a :--> b))
    -> Term s' (t k a) -> Term s' (t k b))
-> Term s' ((k :--> (a :--> b)) :--> (t k a :--> t k b))
forall a b. (a -> b) -> a -> b
$ \Term s' (k :--> (a :--> b))
f Term s' (t k a)
kvs ->
    Term s' (PInner (t k b)) -> Term s' (t k b)
forall (s :: S) (a :: S -> Type). Term s (PInner a) -> Term s a
punsafeDowncast (Term s' (PInner (t k b)) -> Term s' (t k b))
-> (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
    -> Term s' (PInner (t k b)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (t k b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' (PInner (PInner (t k b))) -> Term s' (PInner (t k b))
Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (PInner (t k b))
forall (s :: S) (a :: S -> Type). Term s (PInner a) -> Term s a
punsafeDowncast (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
 -> Term s' (t k b))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (t k b)
forall a b. (a -> b) -> a -> b
$
      Term
  s'
  ((PBuiltinPair (PAsData k) (PAsData a)
    :--> PBuiltinPair (PAsData k) (PAsData b))
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (b :: S -> Type) (s :: S).
(PListLike list, PElemConstraint list a, PElemConstraint list b) =>
Term s ((a :--> b) :--> (list a :--> list b))
PPrelude.pmap
        # plam
          ( \x ->
              plet (pkvPairKey # x) $ \key ->
                ppairDataBuiltin
                  # pdata key
                  #$ pdata
                  $ f # key # (pkvPairValue # x)
          )
        # pto (pto kvs)

{- | Maps and filters the map, much like 'Data.PPrelude.mapMaybe'.

@since 2.0.0
-}
pmapMaybe ::
  forall
    (t :: (S -> Type) -> (S -> Type) -> S -> Type)
    (k :: S -> Type)
    (a :: S -> Type)
    (b :: S -> Type)
    (s :: S).
  ( PInner (t k a) ~ PAssocMap k a
  , PInner (t k b) ~ PAssocMap k b
  , PIsData a
  , PIsData b
  ) =>
  Term s ((a :--> PMaybe b) :--> t k a :--> t k b)
pmapMaybe :: forall (t :: (S -> Type) -> (S -> Type) -> S -> Type)
       (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (s :: S).
(PInner (t k a) ~ PAssocMap k a, PInner (t k b) ~ PAssocMap k b,
 PIsData a, PIsData b) =>
Term s ((a :--> PMaybe b) :--> (t k a :--> t k b))
pmapMaybe = (forall (s' :: S).
 Term s' ((a :--> PMaybe b) :--> (t k a :--> t k b)))
-> Term s ((a :--> PMaybe b) :--> (t k a :--> t k b))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term s' ((a :--> PMaybe b) :--> (t k a :--> t k b)))
 -> Term s ((a :--> PMaybe b) :--> (t k a :--> t k b)))
-> (forall (s' :: S).
    Term s' ((a :--> PMaybe b) :--> (t k a :--> t k b)))
-> Term s ((a :--> PMaybe b) :--> (t k a :--> t k b))
forall a b. (a -> b) -> a -> b
$
  (Term s' (a :--> PMaybe b) -> Term s' (t k a :--> t k b))
-> Term s' ((a :--> PMaybe b) :--> (t k a :--> t k b))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (t k a :--> t k b))
-> Term s' (c :--> (t k a :--> t k b))
plam ((Term s' (a :--> PMaybe b) -> Term s' (t k a :--> t k b))
 -> Term s' ((a :--> PMaybe b) :--> (t k a :--> t k b)))
-> (Term s' (a :--> PMaybe b) -> Term s' (t k a :--> t k b))
-> Term s' ((a :--> PMaybe b) :--> (t k a :--> t k b))
forall a b. (a -> b) -> a -> b
$ \Term s' (a :--> PMaybe b)
f -> Term
  s' ((PAsData a :--> PMaybe (PAsData b)) :--> (t k a :--> t k b))
forall (t :: (S -> Type) -> (S -> Type) -> S -> Type)
       (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (s :: S).
(PInner (t k a) ~ PAssocMap k a, PInner (t k b) ~ PAssocMap k b) =>
Term
  s ((PAsData a :--> PMaybe (PAsData b)) :--> (t k a :--> t k b))
pmapMaybeData Term
  s' ((PAsData a :--> PMaybe (PAsData b)) :--> (t k a :--> t k b))
-> Term s' (PAsData a :--> PMaybe (PAsData b))
-> Term s' (t k a :--> t k b)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
#$ (Term s' (PAsData a) -> Term s' (PMaybe (PAsData b)))
-> Term s' (PAsData a :--> PMaybe (PAsData b))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PMaybe (PAsData b)))
-> Term s' (c :--> PMaybe (PAsData b))
plam ((Term s' (PAsData a) -> Term s' (PMaybe (PAsData b)))
 -> Term s' (PAsData a :--> PMaybe (PAsData b)))
-> (Term s' (PAsData a) -> Term s' (PMaybe (PAsData b)))
-> Term s' (PAsData a :--> PMaybe (PAsData b))
forall a b. (a -> b) -> a -> b
$ \Term s' (PAsData a)
v -> Term s' (PMaybe b)
-> (PMaybe b s' -> Term s' (PMaybe (PAsData b)))
-> Term s' (PMaybe (PAsData b))
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term s' (a :--> PMaybe b)
f Term s' (a :--> PMaybe b) -> Term s' a -> Term s' (PMaybe b)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAsData a) -> Term s' a
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData Term s' (PAsData a)
v) ((PMaybe b s' -> Term s' (PMaybe (PAsData b)))
 -> Term s' (PMaybe (PAsData b)))
-> (PMaybe b s' -> Term s' (PMaybe (PAsData b)))
-> Term s' (PMaybe (PAsData b))
forall a b. (a -> b) -> a -> b
$ \case
    PMaybe b s'
PNothing -> PMaybe (PAsData b) s' -> Term s' (PMaybe (PAsData b))
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon PMaybe (PAsData b) s'
forall (a :: S -> Type) (s :: S). PMaybe a s
PNothing
    PJust Term s' b
v' -> PMaybe (PAsData b) s' -> Term s' (PMaybe (PAsData b))
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon (PMaybe (PAsData b) s' -> Term s' (PMaybe (PAsData b)))
-> PMaybe (PAsData b) s' -> Term s' (PMaybe (PAsData b))
forall a b. (a -> b) -> a -> b
$ Term s' (PAsData b) -> PMaybe (PAsData b) s'
forall (a :: S -> Type) (s :: S). Term s a -> PMaybe a s
PJust (Term s' b -> Term s' (PAsData b)
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s a -> Term s (PAsData a)
pdata Term s' b
v')

{- | As 'pmapMaybe', but over Data representation.

@since 2.0.0
-}
pmapMaybeData ::
  forall
    (t :: (S -> Type) -> (S -> Type) -> S -> Type)
    (k :: S -> Type)
    (a :: S -> Type)
    (b :: S -> Type)
    (s :: S).
  ( PInner (t k a) ~ PAssocMap k a
  , PInner (t k b) ~ PAssocMap k b
  ) =>
  Term s ((PAsData a :--> PMaybe (PAsData b)) :--> t k a :--> t k b)
pmapMaybeData :: forall (t :: (S -> Type) -> (S -> Type) -> S -> Type)
       (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (s :: S).
(PInner (t k a) ~ PAssocMap k a, PInner (t k b) ~ PAssocMap k b) =>
Term
  s ((PAsData a :--> PMaybe (PAsData b)) :--> (t k a :--> t k b))
pmapMaybeData = (forall (s' :: S).
 Term
   s' ((PAsData a :--> PMaybe (PAsData b)) :--> (t k a :--> t k b)))
-> Term
     s ((PAsData a :--> PMaybe (PAsData b)) :--> (t k a :--> t k b))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term
    s' ((PAsData a :--> PMaybe (PAsData b)) :--> (t k a :--> t k b)))
 -> Term
      s ((PAsData a :--> PMaybe (PAsData b)) :--> (t k a :--> t k b)))
-> (forall (s' :: S).
    Term
      s' ((PAsData a :--> PMaybe (PAsData b)) :--> (t k a :--> t k b)))
-> Term
     s ((PAsData a :--> PMaybe (PAsData b)) :--> (t k a :--> t k b))
forall a b. (a -> b) -> a -> b
$
  (Term s' (PAsData a :--> PMaybe (PAsData b))
 -> Term s' (t k a) -> Term s' (t k b))
-> Term
     s' ((PAsData a :--> PMaybe (PAsData b)) :--> (t k a :--> t k b))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (t k a) -> Term s' (t k b))
-> Term s' (c :--> (t k a :--> t k b))
plam ((Term s' (PAsData a :--> PMaybe (PAsData b))
  -> Term s' (t k a) -> Term s' (t k b))
 -> Term
      s' ((PAsData a :--> PMaybe (PAsData b)) :--> (t k a :--> t k b)))
-> (Term s' (PAsData a :--> PMaybe (PAsData b))
    -> Term s' (t k a) -> Term s' (t k b))
-> Term
     s' ((PAsData a :--> PMaybe (PAsData b)) :--> (t k a :--> t k b))
forall a b. (a -> b) -> a -> b
$ \Term s' (PAsData a :--> PMaybe (PAsData b))
f Term s' (t k a)
m ->
    Term s' (PInner (t k b)) -> Term s' (t k b)
forall (s :: S) (a :: S -> Type). Term s (PInner a) -> Term s a
punsafeDowncast (Term s' (PInner (t k b)) -> Term s' (t k b))
-> (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
    -> Term s' (PInner (t k b)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (t k b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' (PInner (PInner (t k b))) -> Term s' (PInner (t k b))
Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (PInner (t k b))
forall (s :: S) (a :: S -> Type). Term s (PInner a) -> Term s a
punsafeDowncast (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
 -> Term s' (t k b))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (t k b)
forall a b. (a -> b) -> a -> b
$
      (Term
   s'
   (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
    :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
 -> Term s' (PBuiltinPair (PAsData k) (PAsData a))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> (Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
       :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S)
       (r :: S -> Type).
PIsListLike list a =>
(Term s (list a :--> r) -> Term s a -> Term s (list a) -> Term s r)
-> (Term s (list a :--> r) -> Term s r) -> Term s (list a :--> r)
precList
        ( \Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
self Term s' (PBuiltinPair (PAsData k) (PAsData a))
x Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
xs ->
            Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s a -> (Term s a -> Term s b) -> Term s b
plet (Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
self Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
xs) ((Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
  -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall a b. (a -> b) -> a -> b
$ \Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
xs' ->
              Term s' (PBuiltinPair (PAsData k) (PAsData a))
-> (PBuiltinPair (PAsData k) (PAsData a) s'
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' (PBuiltinPair (PAsData k) (PAsData a))
x ((PBuiltinPair (PAsData k) (PAsData a) s'
  -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> (PBuiltinPair (PAsData k) (PAsData a) s'
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall a b. (a -> b) -> a -> b
$ \(PBuiltinPair Term s' (PAsData k)
y Term s' (PAsData a)
z) ->
                Term s' (PMaybe (PAsData b))
-> (PMaybe (PAsData b) s'
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term s' (PAsData a :--> PMaybe (PAsData b))
f Term s' (PAsData a :--> PMaybe (PAsData b))
-> Term s' (PAsData a) -> Term s' (PMaybe (PAsData b))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAsData a)
z) ((PMaybe (PAsData b) s'
  -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> (PMaybe (PAsData b) s'
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall a b. (a -> b) -> a -> b
$ \case
                  PMaybe (PAsData b) s'
PNothing -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
xs'
                  PJust Term s' (PAsData b)
v -> Term
  s'
  (PBuiltinPair (PAsData k) (PAsData b)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
forall (a :: S -> Type) (s :: S).
PElemConstraint PBuiltinList a =>
Term s (a :--> (PBuiltinList a :--> PBuiltinList a))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
(PListLike list, PElemConstraint list a) =>
Term s (a :--> (list a :--> list a))
pcons Term
  s'
  (PBuiltinPair (PAsData k) (PAsData b)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> Term s' (PBuiltinPair (PAsData k) (PAsData b))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# (Term
  s'
  (PAsData k
   :--> (PAsData b :--> PBuiltinPair (PAsData k) (PAsData b)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term
  s
  (PAsData a
   :--> (PAsData b :--> PBuiltinPair (PAsData a) (PAsData b)))
ppairDataBuiltin Term
  s'
  (PAsData k
   :--> (PAsData b :--> PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (PAsData k)
-> Term s' (PAsData b :--> PBuiltinPair (PAsData k) (PAsData b))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAsData k)
y Term s' (PAsData b :--> PBuiltinPair (PAsData k) (PAsData b))
-> Term s' (PAsData b)
-> Term s' (PBuiltinPair (PAsData k) (PAsData b))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAsData b)
v) Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
xs'
        )
        (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall a b. a -> b -> a
const Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall (a :: S -> Type) (s :: S).
PElemConstraint PBuiltinList a =>
Term s (PBuiltinList a)
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
(PListLike list, PElemConstraint list a) =>
Term s (list a)
pnil)
        # pto (pto m)

{- | As 'pmapMaybe', but gives key access as well.

@since 3.5.0
-}
pmapMaybeWithKey ::
  forall
    (t :: (S -> Type) -> (S -> Type) -> S -> Type)
    (k :: S -> Type)
    (a :: S -> Type)
    (b :: S -> Type)
    (s :: S).
  ( PInner (t k a) ~ PAssocMap k a
  , PInner (t k b) ~ PAssocMap k b
  , PIsData k
  , PIsData a
  , PIsData b
  ) =>
  Term s ((k :--> a :--> PMaybe b) :--> t k a :--> t k b)
pmapMaybeWithKey :: forall (t :: (S -> Type) -> (S -> Type) -> S -> Type)
       (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (s :: S).
(PInner (t k a) ~ PAssocMap k a, PInner (t k b) ~ PAssocMap k b,
 PIsData k, PIsData a, PIsData b) =>
Term s ((k :--> (a :--> PMaybe b)) :--> (t k a :--> t k b))
pmapMaybeWithKey = (forall (s' :: S).
 Term s' ((k :--> (a :--> PMaybe b)) :--> (t k a :--> t k b)))
-> Term s ((k :--> (a :--> PMaybe b)) :--> (t k a :--> t k b))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term s' ((k :--> (a :--> PMaybe b)) :--> (t k a :--> t k b)))
 -> Term s ((k :--> (a :--> PMaybe b)) :--> (t k a :--> t k b)))
-> (forall (s' :: S).
    Term s' ((k :--> (a :--> PMaybe b)) :--> (t k a :--> t k b)))
-> Term s ((k :--> (a :--> PMaybe b)) :--> (t k a :--> t k b))
forall a b. (a -> b) -> a -> b
$
  (Term s' (k :--> (a :--> PMaybe b)) -> Term s' (t k a :--> t k b))
-> Term s' ((k :--> (a :--> PMaybe b)) :--> (t k a :--> t k b))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (t k a :--> t k b))
-> Term s' (c :--> (t k a :--> t k b))
plam ((Term s' (k :--> (a :--> PMaybe b)) -> Term s' (t k a :--> t k b))
 -> Term s' ((k :--> (a :--> PMaybe b)) :--> (t k a :--> t k b)))
-> (Term s' (k :--> (a :--> PMaybe b))
    -> Term s' (t k a :--> t k b))
-> Term s' ((k :--> (a :--> PMaybe b)) :--> (t k a :--> t k b))
forall a b. (a -> b) -> a -> b
$ \Term s' (k :--> (a :--> PMaybe b))
f ->
    Term
  s'
  ((PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
   :--> (t k a :--> t k b))
forall (t :: (S -> Type) -> (S -> Type) -> S -> Type)
       (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (s :: S).
(PInner (t k a) ~ PAssocMap k a, PInner (t k b) ~ PAssocMap k b) =>
Term
  s
  ((PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
   :--> (t k a :--> t k b))
pmapMaybeDataWithKey Term
  s'
  ((PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
   :--> (t k a :--> t k b))
-> Term s' (PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
-> Term s' (t k a :--> t k b)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
#$ (Term s' (PAsData k)
 -> Term s' (PAsData a) -> Term s' (PMaybe (PAsData b)))
-> Term s' (PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PAsData a) -> Term s' (PMaybe (PAsData b)))
-> Term s' (c :--> (PAsData a :--> PMaybe (PAsData b)))
plam ((Term s' (PAsData k)
  -> Term s' (PAsData a) -> Term s' (PMaybe (PAsData b)))
 -> Term s' (PAsData k :--> (PAsData a :--> PMaybe (PAsData b))))
-> (Term s' (PAsData k)
    -> Term s' (PAsData a) -> Term s' (PMaybe (PAsData b)))
-> Term s' (PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
forall a b. (a -> b) -> a -> b
$ \Term s' (PAsData k)
k Term s' (PAsData a)
v -> Term s' (PMaybe b)
-> (PMaybe b s' -> Term s' (PMaybe (PAsData b)))
-> Term s' (PMaybe (PAsData b))
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term s' (k :--> (a :--> PMaybe b))
f Term s' (k :--> (a :--> PMaybe b))
-> Term s' k -> Term s' (a :--> PMaybe b)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAsData k) -> Term s' k
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData Term s' (PAsData k)
k Term s' (a :--> PMaybe b) -> Term s' a -> Term s' (PMaybe b)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAsData a) -> Term s' a
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData Term s' (PAsData a)
v) ((PMaybe b s' -> Term s' (PMaybe (PAsData b)))
 -> Term s' (PMaybe (PAsData b)))
-> (PMaybe b s' -> Term s' (PMaybe (PAsData b)))
-> Term s' (PMaybe (PAsData b))
forall a b. (a -> b) -> a -> b
$ \case
      PMaybe b s'
PNothing -> PMaybe (PAsData b) s' -> Term s' (PMaybe (PAsData b))
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon PMaybe (PAsData b) s'
forall (a :: S -> Type) (s :: S). PMaybe a s
PNothing
      PJust Term s' b
v' -> PMaybe (PAsData b) s' -> Term s' (PMaybe (PAsData b))
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon (PMaybe (PAsData b) s' -> Term s' (PMaybe (PAsData b)))
-> PMaybe (PAsData b) s' -> Term s' (PMaybe (PAsData b))
forall a b. (a -> b) -> a -> b
$ Term s' (PAsData b) -> PMaybe (PAsData b) s'
forall (a :: S -> Type) (s :: S). Term s a -> PMaybe a s
PJust (Term s' b -> Term s' (PAsData b)
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s a -> Term s (PAsData a)
pdata Term s' b
v')

{- | As 'pmapMaybeData', but gives key access as well.

@since 3.5.0
-}
pmapMaybeDataWithKey ::
  forall
    (t :: (S -> Type) -> (S -> Type) -> S -> Type)
    (k :: S -> Type)
    (a :: S -> Type)
    (b :: S -> Type)
    (s :: S).
  ( PInner (t k a) ~ PAssocMap k a
  , PInner (t k b) ~ PAssocMap k b
  ) =>
  Term s ((PAsData k :--> PAsData a :--> PMaybe (PAsData b)) :--> t k a :--> t k b)
pmapMaybeDataWithKey :: forall (t :: (S -> Type) -> (S -> Type) -> S -> Type)
       (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (s :: S).
(PInner (t k a) ~ PAssocMap k a, PInner (t k b) ~ PAssocMap k b) =>
Term
  s
  ((PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
   :--> (t k a :--> t k b))
pmapMaybeDataWithKey = (forall (s' :: S).
 Term
   s'
   ((PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
    :--> (t k a :--> t k b)))
-> Term
     s
     ((PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
      :--> (t k a :--> t k b))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term
    s'
    ((PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
     :--> (t k a :--> t k b)))
 -> Term
      s
      ((PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
       :--> (t k a :--> t k b)))
-> (forall (s' :: S).
    Term
      s'
      ((PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
       :--> (t k a :--> t k b)))
-> Term
     s
     ((PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
      :--> (t k a :--> t k b))
forall a b. (a -> b) -> a -> b
$
  (Term s' (PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
 -> Term s' (t k a) -> Term s' (t k b))
-> Term
     s'
     ((PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
      :--> (t k a :--> t k b))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (t k a) -> Term s' (t k b))
-> Term s' (c :--> (t k a :--> t k b))
plam ((Term s' (PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
  -> Term s' (t k a) -> Term s' (t k b))
 -> Term
      s'
      ((PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
       :--> (t k a :--> t k b)))
-> (Term s' (PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
    -> Term s' (t k a) -> Term s' (t k b))
-> Term
     s'
     ((PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
      :--> (t k a :--> t k b))
forall a b. (a -> b) -> a -> b
$ \Term s' (PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
f Term s' (t k a)
m ->
    Term s' (PInner (t k b)) -> Term s' (t k b)
forall (s :: S) (a :: S -> Type). Term s (PInner a) -> Term s a
punsafeDowncast (Term s' (PInner (t k b)) -> Term s' (t k b))
-> (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
    -> Term s' (PInner (t k b)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (t k b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' (PInner (PInner (t k b))) -> Term s' (PInner (t k b))
Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (PInner (t k b))
forall (s :: S) (a :: S -> Type). Term s (PInner a) -> Term s a
punsafeDowncast (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
 -> Term s' (t k b))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (t k b)
forall a b. (a -> b) -> a -> b
$
      (Term
   s'
   (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
    :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
 -> Term s' (PBuiltinPair (PAsData k) (PAsData a))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> (Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
       :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S)
       (r :: S -> Type).
PIsListLike list a =>
(Term s (list a :--> r) -> Term s a -> Term s (list a) -> Term s r)
-> (Term s (list a :--> r) -> Term s r) -> Term s (list a :--> r)
precList
        ( \Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
self Term s' (PBuiltinPair (PAsData k) (PAsData a))
x Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
xs ->
            Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s a -> (Term s a -> Term s b) -> Term s b
plet (Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
self Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
xs) ((Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
  -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall a b. (a -> b) -> a -> b
$ \Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
xs' ->
              Term s' (PBuiltinPair (PAsData k) (PAsData a))
-> (PBuiltinPair (PAsData k) (PAsData a) s'
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' (PBuiltinPair (PAsData k) (PAsData a))
x ((PBuiltinPair (PAsData k) (PAsData a) s'
  -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> (PBuiltinPair (PAsData k) (PAsData a) s'
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall a b. (a -> b) -> a -> b
$ \(PBuiltinPair Term s' (PAsData k)
y Term s' (PAsData a)
z) ->
                Term s' (PMaybe (PAsData b))
-> (PMaybe (PAsData b) s'
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term s' (PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
f Term s' (PAsData k :--> (PAsData a :--> PMaybe (PAsData b)))
-> Term s' (PAsData k)
-> Term s' (PAsData a :--> PMaybe (PAsData b))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAsData k)
y Term s' (PAsData a :--> PMaybe (PAsData b))
-> Term s' (PAsData a) -> Term s' (PMaybe (PAsData b))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAsData a)
z) ((PMaybe (PAsData b) s'
  -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> (PMaybe (PAsData b) s'
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall a b. (a -> b) -> a -> b
$ \case
                  PMaybe (PAsData b) s'
PNothing -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
xs'
                  PJust Term s' (PAsData b)
v -> Term
  s'
  (PBuiltinPair (PAsData k) (PAsData b)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
forall (a :: S -> Type) (s :: S).
PElemConstraint PBuiltinList a =>
Term s (a :--> (PBuiltinList a :--> PBuiltinList a))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
(PListLike list, PElemConstraint list a) =>
Term s (a :--> (list a :--> list a))
pcons Term
  s'
  (PBuiltinPair (PAsData k) (PAsData b)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> Term s' (PBuiltinPair (PAsData k) (PAsData b))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# (Term
  s'
  (PAsData k
   :--> (PAsData b :--> PBuiltinPair (PAsData k) (PAsData b)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term
  s
  (PAsData a
   :--> (PAsData b :--> PBuiltinPair (PAsData a) (PAsData b)))
ppairDataBuiltin Term
  s'
  (PAsData k
   :--> (PAsData b :--> PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (PAsData k)
-> Term s' (PAsData b :--> PBuiltinPair (PAsData k) (PAsData b))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAsData k)
y Term s' (PAsData b :--> PBuiltinPair (PAsData k) (PAsData b))
-> Term s' (PAsData b)
-> Term s' (PBuiltinPair (PAsData k) (PAsData b))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAsData b)
v) Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
xs'
        )
        (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall a b. a -> b -> a
const Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
forall (a :: S -> Type) (s :: S).
PElemConstraint PBuiltinList a =>
Term s (PBuiltinList a)
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
(PListLike list, PElemConstraint list a) =>
Term s (list a)
pnil)
        # pto (pto m)

----------------------------------------------------------------------
-- Relational lift

{- | Given a comparison function and a "zero" value, check whether a binary
relation holds over two 'PSortedMap's.

= Important note

This is primarily intended to be used with 'PValue'. We assume that the comparison behaves like
a comparison would (thus, being at least a partial order, or possibly a total order or
equivalence), and that the starting value does not break it. Use with extreme care.

@since 2.0.0
-}
pcheckBinRel ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  ( POrd k
  , PIsData k
  , PIsData v
  ) =>
  Term
    s
    ( (v :--> v :--> PBool)
        :--> v
        :--> PSortedMap k v
        :--> PSortedMap k v
        :--> PBool
    )
pcheckBinRel :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(POrd k, PIsData k, PIsData v) =>
Term
  s
  ((v :--> (v :--> PBool))
   :--> (v :--> (PSortedMap k v :--> (PSortedMap k v :--> PBool))))
pcheckBinRel = (forall (s' :: S).
 Term
   s'
   ((v :--> (v :--> PBool))
    :--> (v :--> (PSortedMap k v :--> (PSortedMap k v :--> PBool)))))
-> Term
     s
     ((v :--> (v :--> PBool))
      :--> (v :--> (PSortedMap k v :--> (PSortedMap k v :--> PBool))))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term
    s'
    ((v :--> (v :--> PBool))
     :--> (v :--> (PSortedMap k v :--> (PSortedMap k v :--> PBool)))))
 -> Term
      s
      ((v :--> (v :--> PBool))
       :--> (v :--> (PSortedMap k v :--> (PSortedMap k v :--> PBool)))))
-> (forall (s' :: S).
    Term
      s'
      ((v :--> (v :--> PBool))
       :--> (v :--> (PSortedMap k v :--> (PSortedMap k v :--> PBool)))))
-> Term
     s
     ((v :--> (v :--> PBool))
      :--> (v :--> (PSortedMap k v :--> (PSortedMap k v :--> PBool))))
forall a b. (a -> b) -> a -> b
$
  (Term s' (v :--> (v :--> PBool))
 -> Term s' v
 -> Term s' (PSortedMap k v)
 -> Term s' (PSortedMap k v)
 -> Term s' PBool)
-> Term
     s'
     ((v :--> (v :--> PBool))
      :--> (v :--> (PSortedMap k v :--> (PSortedMap k v :--> PBool))))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c
 -> Term s' v
 -> Term s' (PSortedMap k v)
 -> Term s' (PSortedMap k v)
 -> Term s' PBool)
-> Term
     s'
     (c :--> (v :--> (PSortedMap k v :--> (PSortedMap k v :--> PBool))))
plam ((Term s' (v :--> (v :--> PBool))
  -> Term s' v
  -> Term s' (PSortedMap k v)
  -> Term s' (PSortedMap k v)
  -> Term s' PBool)
 -> Term
      s'
      ((v :--> (v :--> PBool))
       :--> (v :--> (PSortedMap k v :--> (PSortedMap k v :--> PBool)))))
-> (Term s' (v :--> (v :--> PBool))
    -> Term s' v
    -> Term s' (PSortedMap k v)
    -> Term s' (PSortedMap k v)
    -> Term s' PBool)
-> Term
     s'
     ((v :--> (v :--> PBool))
      :--> (v :--> (PSortedMap k v :--> (PSortedMap k v :--> PBool))))
forall a b. (a -> b) -> a -> b
$ \Term s' (v :--> (v :--> PBool))
f Term s' v
z Term s' (PSortedMap k v)
m1 Term s' (PSortedMap k v)
m2 ->
    let inner :: Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBool))
inner = (Term
   s'
   (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
    :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
          :--> PBool))
 -> Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
             :--> PBool)))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
            :--> PBool))
forall (a :: S -> Type) (b :: S -> Type) (s :: S).
(Term s (a :--> b) -> Term s (a :--> b)) -> Term s (a :--> b)
pfix ((Term
    s'
    (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
     :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
           :--> PBool))
  -> Term
       s'
       (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
        :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
              :--> PBool)))
 -> Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
             :--> PBool)))
-> (Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
             :--> PBool))
    -> Term
         s'
         (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
          :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
                :--> PBool)))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
            :--> PBool))
forall a b. (a -> b) -> a -> b
$ \Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBool))
self -> (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term s' PBool)
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
            :--> PBool))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term s' PBool)
-> Term
     s'
     (c
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
            :--> PBool))
plam ((Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
  -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
  -> Term s' PBool)
 -> Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
             :--> PBool)))
-> (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
    -> Term s' PBool)
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
            :--> PBool))
forall a b. (a -> b) -> a -> b
$ \Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
l1 Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
l2 ->
          (Term s' (PBuiltinPair (PAsData k) (PAsData v))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term s' PBool)
-> Term s' PBool
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' PBool
forall (a :: S -> Type) (s :: S) (r :: S -> Type).
PElemConstraint PBuiltinList a =>
(Term s a -> Term s (PBuiltinList a) -> Term s r)
-> Term s r -> Term s (PBuiltinList a) -> Term s r
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S)
       (r :: S -> Type).
(PListLike list, PElemConstraint list a) =>
(Term s a -> Term s (list a) -> Term s r)
-> Term s r -> Term s (list a) -> Term s r
pelimList
            ( \Term s' (PBuiltinPair (PAsData k) (PAsData v))
x Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
xs ->
                Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> (PBuiltinPair (PAsData k) (PAsData v) s' -> Term s' PBool)
-> Term s' PBool
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' (PBuiltinPair (PAsData k) (PAsData v))
x ((PBuiltinPair (PAsData k) (PAsData v) s' -> Term s' PBool)
 -> Term s' PBool)
-> (PBuiltinPair (PAsData k) (PAsData v) s' -> Term s' PBool)
-> Term s' PBool
forall a b. (a -> b) -> a -> b
$ \(PBuiltinPair Term s' (PAsData k)
k1' Term s' (PAsData v)
v1') ->
                  Term s' v -> (Term s' v -> Term s' PBool) -> Term s' PBool
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s a -> (Term s a -> Term s b) -> Term s b
plet (Term s' (PAsData v) -> Term s' v
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData Term s' (PAsData v)
v1') ((Term s' v -> Term s' PBool) -> Term s' PBool)
-> (Term s' v -> Term s' PBool) -> Term s' PBool
forall a b. (a -> b) -> a -> b
$ \Term s' v
v1 ->
                    (Term s' (PBuiltinPair (PAsData k) (PAsData v))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term s' PBool)
-> Term s' PBool
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' PBool
forall (a :: S -> Type) (s :: S) (r :: S -> Type).
PElemConstraint PBuiltinList a =>
(Term s a -> Term s (PBuiltinList a) -> Term s r)
-> Term s r -> Term s (PBuiltinList a) -> Term s r
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S)
       (r :: S -> Type).
(PListLike list, PElemConstraint list a) =>
(Term s a -> Term s (list a) -> Term s r)
-> Term s r -> Term s (list a) -> Term s r
pelimList
                      ( \Term s' (PBuiltinPair (PAsData k) (PAsData v))
y Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
ys -> TermCont s' (Term s' PBool) -> Term s' PBool
forall (a :: S -> Type) (s :: S). TermCont s (Term s a) -> Term s a
unTermCont (TermCont s' (Term s' PBool) -> Term s' PBool)
-> TermCont s' (Term s' PBool) -> Term s' PBool
forall a b. (a -> b) -> a -> b
$ do
                          PBuiltinPair Term s' (PAsData k)
k2' Term s' (PAsData v)
v2' <- Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> TermCont s' (PBuiltinPair (PAsData k) (PAsData v) s')
forall {r :: S -> Type} (a :: S -> Type) (s :: S).
PlutusType a =>
Term s a -> TermCont s (a s)
pmatchC Term s' (PBuiltinPair (PAsData k) (PAsData v))
y
                          Term s' v
v2 <- ((Term s' v -> Term s' PBool) -> Term s' PBool)
-> TermCont s' (Term s' v)
forall a (s :: S) (r :: S -> Type).
((a -> Term s r) -> Term s r) -> TermCont s a
tcont (((Term s' v -> Term s' PBool) -> Term s' PBool)
 -> TermCont s' (Term s' v))
-> (Term s' (PAsData v)
    -> (Term s' v -> Term s' PBool) -> Term s' PBool)
-> Term s' (PAsData v)
-> TermCont s' (Term s' v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' v -> (Term s' v -> Term s' PBool) -> Term s' PBool
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s a -> (Term s a -> Term s b) -> Term s b
plet (Term s' v -> (Term s' v -> Term s' PBool) -> Term s' PBool)
-> (Term s' (PAsData v) -> Term s' v)
-> Term s' (PAsData v)
-> (Term s' v -> Term s' PBool)
-> Term s' PBool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' (PAsData v) -> Term s' v
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData (Term s' (PAsData v) -> TermCont s' (Term s' v))
-> Term s' (PAsData v) -> TermCont s' (Term s' v)
forall a b. (a -> b) -> a -> b
$ Term s' (PAsData v)
v2'
                          Term s' k
k1 <- ((Term s' k -> Term s' PBool) -> Term s' PBool)
-> TermCont s' (Term s' k)
forall a (s :: S) (r :: S -> Type).
((a -> Term s r) -> Term s r) -> TermCont s a
tcont (((Term s' k -> Term s' PBool) -> Term s' PBool)
 -> TermCont s' (Term s' k))
-> (Term s' (PAsData k)
    -> (Term s' k -> Term s' PBool) -> Term s' PBool)
-> Term s' (PAsData k)
-> TermCont s' (Term s' k)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' k -> (Term s' k -> Term s' PBool) -> Term s' PBool
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s a -> (Term s a -> Term s b) -> Term s b
plet (Term s' k -> (Term s' k -> Term s' PBool) -> Term s' PBool)
-> (Term s' (PAsData k) -> Term s' k)
-> Term s' (PAsData k)
-> (Term s' k -> Term s' PBool)
-> Term s' PBool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' (PAsData k) -> Term s' k
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData (Term s' (PAsData k) -> TermCont s' (Term s' k))
-> Term s' (PAsData k) -> TermCont s' (Term s' k)
forall a b. (a -> b) -> a -> b
$ Term s' (PAsData k)
k1'
                          Term s' k
k2 <- ((Term s' k -> Term s' PBool) -> Term s' PBool)
-> TermCont s' (Term s' k)
forall a (s :: S) (r :: S -> Type).
((a -> Term s r) -> Term s r) -> TermCont s a
tcont (((Term s' k -> Term s' PBool) -> Term s' PBool)
 -> TermCont s' (Term s' k))
-> (Term s' (PAsData k)
    -> (Term s' k -> Term s' PBool) -> Term s' PBool)
-> Term s' (PAsData k)
-> TermCont s' (Term s' k)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' k -> (Term s' k -> Term s' PBool) -> Term s' PBool
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s a -> (Term s a -> Term s b) -> Term s b
plet (Term s' k -> (Term s' k -> Term s' PBool) -> Term s' PBool)
-> (Term s' (PAsData k) -> Term s' k)
-> Term s' (PAsData k)
-> (Term s' k -> Term s' PBool)
-> Term s' PBool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' (PAsData k) -> Term s' k
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData (Term s' (PAsData k) -> TermCont s' (Term s' k))
-> Term s' (PAsData k) -> TermCont s' (Term s' k)
forall a b. (a -> b) -> a -> b
$ Term s' (PAsData k)
k2'
                          Term s' PBool -> TermCont s' (Term s' PBool)
forall a. a -> TermCont s' a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure
                            (Term s' PBool -> TermCont s' (Term s' PBool))
-> Term s' PBool -> TermCont s' (Term s' PBool)
forall a b. (a -> b) -> a -> b
$ Term s' PBool -> Term s' PBool -> Term s' PBool -> Term s' PBool
forall (a :: S -> Type) (s :: S).
Term s PBool -> Term s a -> Term s a -> Term s a
pif
                              (Term s' k
k1 Term s' k -> Term s' k -> Term s' PBool
forall (s :: S). Term s k -> Term s k -> Term s PBool
forall (t :: S -> Type) (s :: S).
PEq t =>
Term s t -> Term s t -> Term s PBool
#== Term s' k
k2)
                              ( Term s' (v :--> (v :--> PBool))
f
                                  # v1
                                  # v2
                                  #&& self
                                  # xs
                                  # ys
                              )
                            (Term s' PBool -> Term s' PBool) -> Term s' PBool -> Term s' PBool
forall a b. (a -> b) -> a -> b
$ Term s' PBool -> Term s' PBool -> Term s' PBool -> Term s' PBool
forall (a :: S -> Type) (s :: S).
Term s PBool -> Term s a -> Term s a -> Term s a
pif
                              (Term s' k
k1 Term s' k -> Term s' k -> Term s' PBool
forall (s :: S). Term s k -> Term s k -> Term s PBool
forall (t :: S -> Type) (s :: S).
POrd t =>
Term s t -> Term s t -> Term s PBool
#< Term s' k
k2)
                              (Term s' (v :--> (v :--> PBool))
f Term s' (v :--> (v :--> PBool))
-> Term s' v -> Term s' (v :--> PBool)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' v
v1 Term s' (v :--> PBool) -> Term s' v -> Term s' PBool
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' v
z Term s' PBool -> Term s' PBool -> Term s' PBool
forall (s :: S). Term s PBool -> Term s PBool -> Term s PBool
#&& Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBool))
self Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBool))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term
     s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> PBool)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
xs Term
  s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> PBool)
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' PBool
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
l2)
                            (Term s' PBool -> Term s' PBool) -> Term s' PBool -> Term s' PBool
forall a b. (a -> b) -> a -> b
$ Term s' (v :--> (v :--> PBool))
f
                              # z
                              # v2
                              #&& self
                              # l1
                              # ys
                      )
                      ( Term s' (v :--> (v :--> PBool))
f
                          # v1
                          # z
                          #&& PPrelude.pall
                          # plam (\p -> pmatch p $ \(PBuiltinPair _ y) -> f # pfromData y # z)
                          # xs
                      )
                      Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
l2
            )
            (Term
  s'
  ((PBuiltinPair (PAsData k) (PAsData v) :--> PBool)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBool))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
PIsListLike list a =>
Term s ((a :--> PBool) :--> (list a :--> PBool))
PPrelude.pall Term
  s'
  ((PBuiltinPair (PAsData k) (PAsData v) :--> PBool)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBool))
-> Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> PBool)
-> Term
     s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> PBool)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# (Term s' (PBuiltinPair (PAsData k) (PAsData v)) -> Term s' PBool)
-> Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> PBool)
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' PBool) -> Term s' (c :--> PBool)
plam (\Term s' (PBuiltinPair (PAsData k) (PAsData v))
p -> Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> (PBuiltinPair (PAsData k) (PAsData v) s' -> Term s' PBool)
-> Term s' PBool
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' (PBuiltinPair (PAsData k) (PAsData v))
p ((PBuiltinPair (PAsData k) (PAsData v) s' -> Term s' PBool)
 -> Term s' PBool)
-> (PBuiltinPair (PAsData k) (PAsData v) s' -> Term s' PBool)
-> Term s' PBool
forall a b. (a -> b) -> a -> b
$ \(PBuiltinPair Term s' (PAsData k)
_ Term s' (PAsData v)
y) -> Term s' (v :--> (v :--> PBool))
f Term s' (v :--> (v :--> PBool))
-> Term s' v -> Term s' (v :--> PBool)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' v
z Term s' (v :--> PBool) -> Term s' v -> Term s' PBool
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAsData v) -> Term s' v
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData Term s' (PAsData v)
y) Term
  s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> PBool)
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' PBool
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
l2)
            Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
l1
     in Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBool))
inner Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBool))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term
     s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> PBool)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PInner (PSortedMap k v))
-> Term s' (PInner (PInner (PSortedMap k v)))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto (Term s' (PSortedMap k v) -> Term s' (PInner (PSortedMap k v))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto Term s' (PSortedMap k v)
m1) Term
  s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> PBool)
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' PBool
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PInner (PSortedMap k v))
-> Term s' (PInner (PInner (PSortedMap k v)))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto (Term s' (PSortedMap k v) -> Term s' (PInner (PSortedMap k v))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto Term s' (PSortedMap k v)
m2)

----------------------------------------------------------------------
-- Comparison

{- | Gives 'PTrue' if both argument 'PSortedMap's contain mappings for exactly
the same set of keys. Requires a number of equality comparisons between keys
proportional to the length of the shorter argument.

@since 2.1.1
-}
pkeysEqual ::
  forall (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (s :: S).
  ( PEq k
  , PIsData k
  ) =>
  Term s (PSortedMap k a :--> PSortedMap k b :--> PBool)
pkeysEqual :: forall (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (s :: S).
(PEq k, PIsData k) =>
Term s (PSortedMap k a :--> (PSortedMap k b :--> PBool))
pkeysEqual = (forall (s' :: S).
 Term s' (PSortedMap k a :--> (PSortedMap k b :--> PBool)))
-> Term s (PSortedMap k a :--> (PSortedMap k b :--> PBool))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term s' (PSortedMap k a :--> (PSortedMap k b :--> PBool)))
 -> Term s (PSortedMap k a :--> (PSortedMap k b :--> PBool)))
-> (forall (s' :: S).
    Term s' (PSortedMap k a :--> (PSortedMap k b :--> PBool)))
-> Term s (PSortedMap k a :--> (PSortedMap k b :--> PBool))
forall a b. (a -> b) -> a -> b
$
  (Term s' (PSortedMap k a)
 -> Term s' (PSortedMap k b) -> Term s' PBool)
-> Term s' (PSortedMap k a :--> (PSortedMap k b :--> PBool))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PSortedMap k b) -> Term s' PBool)
-> Term s' (c :--> (PSortedMap k b :--> PBool))
plam ((Term s' (PSortedMap k a)
  -> Term s' (PSortedMap k b) -> Term s' PBool)
 -> Term s' (PSortedMap k a :--> (PSortedMap k b :--> PBool)))
-> (Term s' (PSortedMap k a)
    -> Term s' (PSortedMap k b) -> Term s' PBool)
-> Term s' (PSortedMap k a :--> (PSortedMap k b :--> PBool))
forall a b. (a -> b) -> a -> b
$ \Term s' (PSortedMap k a)
kvs Term s' (PSortedMap k b)
kvs' ->
    Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
         :--> PBool))
forall (s' :: S).
Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
         :--> PBool))
go Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
         :--> PBool))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
-> Term
     s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)) :--> PBool)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAssocMap k a) -> Term s' (PInner (PAssocMap k a))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto (Term s' (PSortedMap k a) -> Term s' (PInner (PSortedMap k a))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto Term s' (PSortedMap k a)
kvs) Term
  s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)) :--> PBool)
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' PBool
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PInner (PSortedMap k b))
-> Term s' (PInner (PInner (PSortedMap k b)))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto (Term s' (PSortedMap k b) -> Term s' (PInner (PSortedMap k b))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto Term s' (PSortedMap k b)
kvs')
  where
    go ::
      forall (s' :: S).
      Term
        s'
        ( PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
            :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
            :--> PBool
        )
    go :: forall (s' :: S).
Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
         :--> PBool))
go = (forall (s' :: S).
 Term
   s'
   (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
    :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
          :--> PBool)))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
            :--> PBool))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term
    s'
    (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
     :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
           :--> PBool)))
 -> Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
       :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
             :--> PBool)))
-> (forall (s' :: S).
    Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
       :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
             :--> PBool)))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
            :--> PBool))
forall a b. (a -> b) -> a -> b
$
      (Term
   s'
   (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
    :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
          :--> PBool))
 -> Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
       :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
             :--> PBool)))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
            :--> PBool))
forall (a :: S -> Type) (b :: S -> Type) (s :: S).
(Term s (a :--> b) -> Term s (a :--> b)) -> Term s (a :--> b)
pfix ((Term
    s'
    (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
     :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
           :--> PBool))
  -> Term
       s'
       (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
        :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
              :--> PBool)))
 -> Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
       :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
             :--> PBool)))
-> (Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
       :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
             :--> PBool))
    -> Term
         s'
         (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
          :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                :--> PBool)))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
            :--> PBool))
forall a b. (a -> b) -> a -> b
$ \Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
         :--> PBool))
self -> (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
 -> Term s' PBool)
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
            :--> PBool))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
 -> Term s' PBool)
-> Term
     s'
     (c
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
            :--> PBool))
plam ((Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
  -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
  -> Term s' PBool)
 -> Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
       :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
             :--> PBool)))
-> (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
    -> Term s' PBool)
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
            :--> PBool))
forall a b. (a -> b) -> a -> b
$ \Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
ell Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
ell' ->
        Term
  s'
  (PMaybe
     (PPair
        (PBuiltinPair (PAsData k) (PAsData a))
        (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))))
-> (PMaybe
      (PPair
         (PBuiltinPair (PAsData k) (PAsData a))
         (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> PMaybe
          (PPair
             (PBuiltinPair (PAsData k) (PAsData a))
             (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
PIsListLike list a =>
Term s (list a :--> PMaybe (PPair a (list a)))
PPrelude.puncons Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> PMaybe
          (PPair
             (PBuiltinPair (PAsData k) (PAsData a))
             (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
-> Term
     s'
     (PMaybe
        (PPair
           (PBuiltinPair (PAsData k) (PAsData a))
           (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
ell) ((PMaybe
    (PPair
       (PBuiltinPair (PAsData k) (PAsData a))
       (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))))
    s'
  -> Term s' PBool)
 -> Term s' PBool)
-> (PMaybe
      (PPair
         (PBuiltinPair (PAsData k) (PAsData a))
         (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall a b. (a -> b) -> a -> b
$ \case
          PMaybe
  (PPair
     (PBuiltinPair (PAsData k) (PAsData a))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))))
  s'
PNothing -> Term
  s'
  (PMaybe
     (PPair
        (PBuiltinPair (PAsData k) (PAsData b))
        (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))))
-> (PMaybe
      (PPair
         (PBuiltinPair (PAsData k) (PAsData b))
         (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
   :--> PMaybe
          (PPair
             (PBuiltinPair (PAsData k) (PAsData b))
             (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
PIsListLike list a =>
Term s (list a :--> PMaybe (PPair a (list a)))
PPrelude.puncons Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
   :--> PMaybe
          (PPair
             (PBuiltinPair (PAsData k) (PAsData b))
             (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term
     s'
     (PMaybe
        (PPair
           (PBuiltinPair (PAsData k) (PAsData b))
           (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
ell') ((PMaybe
    (PPair
       (PBuiltinPair (PAsData k) (PAsData b))
       (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
    s'
  -> Term s' PBool)
 -> Term s' PBool)
-> (PMaybe
      (PPair
         (PBuiltinPair (PAsData k) (PAsData b))
         (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall a b. (a -> b) -> a -> b
$ \case
            PMaybe
  (PPair
     (PBuiltinPair (PAsData k) (PAsData b))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
  s'
PNothing -> PBool s' -> Term s' PBool
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon PBool s'
forall (s :: S). PBool s
PTrue -- no mismatches found
            PJust Term
  s'
  (PPair
     (PBuiltinPair (PAsData k) (PAsData b))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
_ -> PBool s' -> Term s' PBool
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon PBool s'
forall (s :: S). PBool s
PFalse -- one argument too long
          PJust Term
  s'
  (PPair
     (PBuiltinPair (PAsData k) (PAsData a))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))))
kv -> Term
  s'
  (PMaybe
     (PPair
        (PBuiltinPair (PAsData k) (PAsData b))
        (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))))
-> (PMaybe
      (PPair
         (PBuiltinPair (PAsData k) (PAsData b))
         (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
   :--> PMaybe
          (PPair
             (PBuiltinPair (PAsData k) (PAsData b))
             (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
PIsListLike list a =>
Term s (list a :--> PMaybe (PPair a (list a)))
PPrelude.puncons Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
   :--> PMaybe
          (PPair
             (PBuiltinPair (PAsData k) (PAsData b))
             (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term
     s'
     (PMaybe
        (PPair
           (PBuiltinPair (PAsData k) (PAsData b))
           (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
ell') ((PMaybe
    (PPair
       (PBuiltinPair (PAsData k) (PAsData b))
       (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
    s'
  -> Term s' PBool)
 -> Term s' PBool)
-> (PMaybe
      (PPair
         (PBuiltinPair (PAsData k) (PAsData b))
         (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall a b. (a -> b) -> a -> b
$ \case
            PMaybe
  (PPair
     (PBuiltinPair (PAsData k) (PAsData b))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
  s'
PNothing -> PBool s' -> Term s' PBool
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon PBool s'
forall (s :: S). PBool s
PFalse -- one argument too long
            PJust Term
  s'
  (PPair
     (PBuiltinPair (PAsData k) (PAsData b))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
kv' -> Term
  s'
  (PPair
     (PBuiltinPair (PAsData k) (PAsData a))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))))
-> (PPair
      (PBuiltinPair (PAsData k) (PAsData a))
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term
  s'
  (PPair
     (PBuiltinPair (PAsData k) (PAsData a))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))))
kv ((PPair
    (PBuiltinPair (PAsData k) (PAsData a))
    (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
    s'
  -> Term s' PBool)
 -> Term s' PBool)
-> (PPair
      (PBuiltinPair (PAsData k) (PAsData a))
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall a b. (a -> b) -> a -> b
$ \(PPair Term s' (PBuiltinPair (PAsData k) (PAsData a))
h Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
t) ->
              Term
  s'
  (PPair
     (PBuiltinPair (PAsData k) (PAsData b))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> (PPair
      (PBuiltinPair (PAsData k) (PAsData b))
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term
  s'
  (PPair
     (PBuiltinPair (PAsData k) (PAsData b))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
kv' ((PPair
    (PBuiltinPair (PAsData k) (PAsData b))
    (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
    s'
  -> Term s' PBool)
 -> Term s' PBool)
-> (PPair
      (PBuiltinPair (PAsData k) (PAsData b))
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall a b. (a -> b) -> a -> b
$ \(PPair Term s' (PBuiltinPair (PAsData k) (PAsData b))
h' Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
t') ->
                Term s' PBool -> Term s' PBool -> Term s' PBool -> Term s' PBool
forall (a :: S -> Type) (s :: S).
Term s PBool -> Term s a -> Term s a -> Term s a
pif
                  ((Term s' (PBuiltinPair (PAsData k) (PAsData a) :--> k)
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PIsData k =>
Term s (PBuiltinPair (PAsData k) (PAsData v) :--> k)
pkvPairKey Term s' (PBuiltinPair (PAsData k) (PAsData a) :--> k)
-> Term s' (PBuiltinPair (PAsData k) (PAsData a)) -> Term s' k
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinPair (PAsData k) (PAsData a))
h) Term s' k -> Term s' k -> Term s' PBool
forall (s :: S). Term s k -> Term s k -> Term s PBool
forall (t :: S -> Type) (s :: S).
PEq t =>
Term s t -> Term s t -> Term s PBool
#== (Term s' (PBuiltinPair (PAsData k) (PAsData b) :--> k)
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PIsData k =>
Term s (PBuiltinPair (PAsData k) (PAsData v) :--> k)
pkvPairKey Term s' (PBuiltinPair (PAsData k) (PAsData b) :--> k)
-> Term s' (PBuiltinPair (PAsData k) (PAsData b)) -> Term s' k
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinPair (PAsData k) (PAsData b))
h'))
                  (Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
         :--> PBool))
self Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
         :--> PBool))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
-> Term
     s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)) :--> PBool)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
t Term
  s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)) :--> PBool)
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' PBool
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
t') -- continue
                  (PBool s' -> Term s' PBool
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon PBool s'
forall (s :: S). PBool s
PFalse) -- key mismatch

{- | As 'pkeysEqual', but requires only 'PEq' constraints for the keys, and
works for 'PUnsortedMap's. This requires a number of equality comparisons
between keys proportional to the product of the lengths of both arguments:
that is, this function is quadratic.

= NOTE

This function does not handle duplicate keys in unsorted maps. For example, if
one map contains duplicate keys while the other does not, the function may still
return 'PTrue' as long as each key appears at least once in both maps.

Use with caution - or preferably avoid using this function entirely - as it may
be deprecated in a future release due to its non-obvious behavior.

@since 2.1.1
-}
pkeysEqualUnsorted ::
  forall (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (s :: S).
  ( PIsData k
  , PIsData a
  , PIsData b
  ) =>
  Term s (PUnsortedMap k a :--> PUnsortedMap k b :--> PBool)
pkeysEqualUnsorted :: forall (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (s :: S).
(PIsData k, PIsData a, PIsData b) =>
Term s (PUnsortedMap k a :--> (PUnsortedMap k b :--> PBool))
pkeysEqualUnsorted = (forall (s' :: S).
 Term s' (PUnsortedMap k a :--> (PUnsortedMap k b :--> PBool)))
-> Term s (PUnsortedMap k a :--> (PUnsortedMap k b :--> PBool))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term s' (PUnsortedMap k a :--> (PUnsortedMap k b :--> PBool)))
 -> Term s (PUnsortedMap k a :--> (PUnsortedMap k b :--> PBool)))
-> (forall (s' :: S).
    Term s' (PUnsortedMap k a :--> (PUnsortedMap k b :--> PBool)))
-> Term s (PUnsortedMap k a :--> (PUnsortedMap k b :--> PBool))
forall a b. (a -> b) -> a -> b
$
  (Term s' (PUnsortedMap k a)
 -> Term s' (PUnsortedMap k b) -> Term s' PBool)
-> Term s' (PUnsortedMap k a :--> (PUnsortedMap k b :--> PBool))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PUnsortedMap k b) -> Term s' PBool)
-> Term s' (c :--> (PUnsortedMap k b :--> PBool))
plam ((Term s' (PUnsortedMap k a)
  -> Term s' (PUnsortedMap k b) -> Term s' PBool)
 -> Term s' (PUnsortedMap k a :--> (PUnsortedMap k b :--> PBool)))
-> (Term s' (PUnsortedMap k a)
    -> Term s' (PUnsortedMap k b) -> Term s' PBool)
-> Term s' (PUnsortedMap k a :--> (PUnsortedMap k b :--> PBool))
forall a b. (a -> b) -> a -> b
$ \Term s' (PUnsortedMap k a)
kvs Term s' (PUnsortedMap k b)
kvs' ->
    Term
  s'
  (PUnsortedMap k a
   :--> (PUnsortedMap k b
         :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
               :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                     :--> PBool))))
forall (s' :: S).
Term
  s'
  (PUnsortedMap k a
   :--> (PUnsortedMap k b
         :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
               :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                     :--> PBool))))
go Term
  s'
  (PUnsortedMap k a
   :--> (PUnsortedMap k b
         :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
               :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                     :--> PBool))))
-> Term s' (PUnsortedMap k a)
-> Term
     s'
     (PUnsortedMap k b
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
            :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                  :--> PBool)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PUnsortedMap k a)
kvs Term
  s'
  (PUnsortedMap k b
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
         :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
               :--> PBool)))
-> Term s' (PUnsortedMap k b)
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
            :--> PBool))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PUnsortedMap k b)
kvs' Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
         :--> PBool))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
-> Term
     s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)) :--> PBool)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAssocMap k a) -> Term s' (PInner (PAssocMap k a))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto (Term s' (PUnsortedMap k a) -> Term s' (PInner (PUnsortedMap k a))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto Term s' (PUnsortedMap k a)
kvs) Term
  s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)) :--> PBool)
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' PBool
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAssocMap k b) -> Term s' (PInner (PAssocMap k b))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto (Term s' (PUnsortedMap k b) -> Term s' (PInner (PUnsortedMap k b))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto Term s' (PUnsortedMap k b)
kvs')
  where
    go ::
      forall (s' :: S).
      Term
        s'
        ( PUnsortedMap k a
            :--> PUnsortedMap k b
            :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
            :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
            :--> PBool
        )
    go :: forall (s' :: S).
Term
  s'
  (PUnsortedMap k a
   :--> (PUnsortedMap k b
         :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
               :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                     :--> PBool))))
go = (forall (s' :: S).
 Term
   s'
   (PUnsortedMap k a
    :--> (PUnsortedMap k b
          :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
                :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                      :--> PBool)))))
-> Term
     s'
     (PUnsortedMap k a
      :--> (PUnsortedMap k b
            :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
                  :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                        :--> PBool))))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term
    s'
    (PUnsortedMap k a
     :--> (PUnsortedMap k b
           :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
                 :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                       :--> PBool)))))
 -> Term
      s'
      (PUnsortedMap k a
       :--> (PUnsortedMap k b
             :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
                   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                         :--> PBool)))))
-> (forall (s' :: S).
    Term
      s'
      (PUnsortedMap k a
       :--> (PUnsortedMap k b
             :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
                   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                         :--> PBool)))))
-> Term
     s'
     (PUnsortedMap k a
      :--> (PUnsortedMap k b
            :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
                  :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                        :--> PBool))))
forall a b. (a -> b) -> a -> b
$
      (Term
   s'
   (PUnsortedMap k a
    :--> (PUnsortedMap k b
          :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
                :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                      :--> PBool))))
 -> Term
      s'
      (PUnsortedMap k a
       :--> (PUnsortedMap k b
             :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
                   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                         :--> PBool)))))
-> Term
     s'
     (PUnsortedMap k a
      :--> (PUnsortedMap k b
            :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
                  :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                        :--> PBool))))
forall (a :: S -> Type) (b :: S -> Type) (s :: S).
(Term s (a :--> b) -> Term s (a :--> b)) -> Term s (a :--> b)
pfix ((Term
    s'
    (PUnsortedMap k a
     :--> (PUnsortedMap k b
           :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
                 :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                       :--> PBool))))
  -> Term
       s'
       (PUnsortedMap k a
        :--> (PUnsortedMap k b
              :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
                    :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                          :--> PBool)))))
 -> Term
      s'
      (PUnsortedMap k a
       :--> (PUnsortedMap k b
             :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
                   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                         :--> PBool)))))
-> (Term
      s'
      (PUnsortedMap k a
       :--> (PUnsortedMap k b
             :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
                   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                         :--> PBool))))
    -> Term
         s'
         (PUnsortedMap k a
          :--> (PUnsortedMap k b
                :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
                      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                            :--> PBool)))))
-> Term
     s'
     (PUnsortedMap k a
      :--> (PUnsortedMap k b
            :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
                  :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                        :--> PBool))))
forall a b. (a -> b) -> a -> b
$ \Term
  s'
  (PUnsortedMap k a
   :--> (PUnsortedMap k b
         :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
               :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                     :--> PBool))))
self -> (Term s' (PUnsortedMap k a)
 -> Term s' (PUnsortedMap k b)
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
 -> Term s' PBool)
-> Term
     s'
     (PUnsortedMap k a
      :--> (PUnsortedMap k b
            :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
                  :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                        :--> PBool))))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c
 -> Term s' (PUnsortedMap k b)
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
 -> Term s' PBool)
-> Term
     s'
     (c
      :--> (PUnsortedMap k b
            :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
                  :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                        :--> PBool))))
plam ((Term s' (PUnsortedMap k a)
  -> Term s' (PUnsortedMap k b)
  -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
  -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
  -> Term s' PBool)
 -> Term
      s'
      (PUnsortedMap k a
       :--> (PUnsortedMap k b
             :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
                   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                         :--> PBool)))))
-> (Term s' (PUnsortedMap k a)
    -> Term s' (PUnsortedMap k b)
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
    -> Term s' PBool)
-> Term
     s'
     (PUnsortedMap k a
      :--> (PUnsortedMap k b
            :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
                  :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                        :--> PBool))))
forall a b. (a -> b) -> a -> b
$ \Term s' (PUnsortedMap k a)
kvs Term s' (PUnsortedMap k b)
kvs' Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
ell Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
ell' ->
        Term
  s'
  (PMaybe
     (PPair
        (PBuiltinPair (PAsData k) (PAsData a))
        (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))))
-> (PMaybe
      (PPair
         (PBuiltinPair (PAsData k) (PAsData a))
         (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> PMaybe
          (PPair
             (PBuiltinPair (PAsData k) (PAsData a))
             (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
PIsListLike list a =>
Term s (list a :--> PMaybe (PPair a (list a)))
PPrelude.puncons Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> PMaybe
          (PPair
             (PBuiltinPair (PAsData k) (PAsData a))
             (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
-> Term
     s'
     (PMaybe
        (PPair
           (PBuiltinPair (PAsData k) (PAsData a))
           (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
ell) ((PMaybe
    (PPair
       (PBuiltinPair (PAsData k) (PAsData a))
       (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))))
    s'
  -> Term s' PBool)
 -> Term s' PBool)
-> (PMaybe
      (PPair
         (PBuiltinPair (PAsData k) (PAsData a))
         (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall a b. (a -> b) -> a -> b
$ \case
          PMaybe
  (PPair
     (PBuiltinPair (PAsData k) (PAsData a))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))))
  s'
PNothing -> Term
  s'
  (PMaybe
     (PPair
        (PBuiltinPair (PAsData k) (PAsData b))
        (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))))
-> (PMaybe
      (PPair
         (PBuiltinPair (PAsData k) (PAsData b))
         (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
   :--> PMaybe
          (PPair
             (PBuiltinPair (PAsData k) (PAsData b))
             (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
PIsListLike list a =>
Term s (list a :--> PMaybe (PPair a (list a)))
PPrelude.puncons Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
   :--> PMaybe
          (PPair
             (PBuiltinPair (PAsData k) (PAsData b))
             (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term
     s'
     (PMaybe
        (PPair
           (PBuiltinPair (PAsData k) (PAsData b))
           (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
ell') ((PMaybe
    (PPair
       (PBuiltinPair (PAsData k) (PAsData b))
       (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
    s'
  -> Term s' PBool)
 -> Term s' PBool)
-> (PMaybe
      (PPair
         (PBuiltinPair (PAsData k) (PAsData b))
         (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall a b. (a -> b) -> a -> b
$ \case
            -- We reached the end, so we match
            PMaybe
  (PPair
     (PBuiltinPair (PAsData k) (PAsData b))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
  s'
PNothing -> PBool s' -> Term s' PBool
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon PBool s'
forall (s :: S). PBool s
PTrue
            PJust Term
  s'
  (PPair
     (PBuiltinPair (PAsData k) (PAsData b))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
ht' -> Term
  s'
  (PPair
     (PBuiltinPair (PAsData k) (PAsData b))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> (PPair
      (PBuiltinPair (PAsData k) (PAsData b))
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term
  s'
  (PPair
     (PBuiltinPair (PAsData k) (PAsData b))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
ht' ((PPair
    (PBuiltinPair (PAsData k) (PAsData b))
    (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
    s'
  -> Term s' PBool)
 -> Term s' PBool)
-> (PPair
      (PBuiltinPair (PAsData k) (PAsData b))
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall a b. (a -> b) -> a -> b
$ \(PPair Term s' (PBuiltinPair (PAsData k) (PAsData b))
h' Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
t') ->
              Term s' (PMaybe a)
-> (PMaybe a s' -> Term s' PBool) -> Term s' PBool
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term s' (k :--> (PSortedMap k a :--> PMaybe a))
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PIsData k, PIsData v) =>
Term s (k :--> (PSortedMap k v :--> PMaybe v))
plookup Term s' (k :--> (PSortedMap k a :--> PMaybe a))
-> Term s' k -> Term s' (PSortedMap k a :--> PMaybe a)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# (Term s' (PBuiltinPair (PAsData k) (PAsData b) :--> k)
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PIsData k =>
Term s (PBuiltinPair (PAsData k) (PAsData v) :--> k)
pkvPairKey Term s' (PBuiltinPair (PAsData k) (PAsData b) :--> k)
-> Term s' (PBuiltinPair (PAsData k) (PAsData b)) -> Term s' k
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinPair (PAsData k) (PAsData b))
h') Term s' (PSortedMap k a :--> PMaybe a)
-> Term s' (PSortedMap k a) -> Term s' (PMaybe a)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PUnsortedMap k a) -> Term s' (PSortedMap k a)
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Term s (PUnsortedMap k v) -> Term s (PSortedMap k v)
punsafeCoerceToSortedMap Term s' (PUnsortedMap k a)
kvs) ((PMaybe a s' -> Term s' PBool) -> Term s' PBool)
-> (PMaybe a s' -> Term s' PBool) -> Term s' PBool
forall a b. (a -> b) -> a -> b
$ \case
                -- We mismatch, so fail
                PMaybe a s'
PNothing -> PBool s' -> Term s' PBool
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon PBool s'
forall (s :: S). PBool s
PFalse
                -- We match, so continue
                PJust Term s' a
_ -> Term
  s'
  (PUnsortedMap k a
   :--> (PUnsortedMap k b
         :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
               :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                     :--> PBool))))
self Term
  s'
  (PUnsortedMap k a
   :--> (PUnsortedMap k b
         :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
               :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                     :--> PBool))))
-> Term s' (PUnsortedMap k a)
-> Term
     s'
     (PUnsortedMap k b
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
            :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                  :--> PBool)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PUnsortedMap k a)
kvs Term
  s'
  (PUnsortedMap k b
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
         :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
               :--> PBool)))
-> Term s' (PUnsortedMap k b)
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
            :--> PBool))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PUnsortedMap k b)
kvs' Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
         :--> PBool))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
-> Term
     s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)) :--> PBool)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
ell Term
  s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)) :--> PBool)
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' PBool
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
t'
          PJust Term
  s'
  (PPair
     (PBuiltinPair (PAsData k) (PAsData a))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))))
ht -> Term
  s'
  (PPair
     (PBuiltinPair (PAsData k) (PAsData a))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))))
-> (PPair
      (PBuiltinPair (PAsData k) (PAsData a))
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term
  s'
  (PPair
     (PBuiltinPair (PAsData k) (PAsData a))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))))
ht ((PPair
    (PBuiltinPair (PAsData k) (PAsData a))
    (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
    s'
  -> Term s' PBool)
 -> Term s' PBool)
-> (PPair
      (PBuiltinPair (PAsData k) (PAsData a))
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall a b. (a -> b) -> a -> b
$ \(PPair Term s' (PBuiltinPair (PAsData k) (PAsData a))
h Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
t) ->
            Term
  s'
  (PMaybe
     (PPair
        (PBuiltinPair (PAsData k) (PAsData b))
        (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))))
-> (PMaybe
      (PPair
         (PBuiltinPair (PAsData k) (PAsData b))
         (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
   :--> PMaybe
          (PPair
             (PBuiltinPair (PAsData k) (PAsData b))
             (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
PIsListLike list a =>
Term s (list a :--> PMaybe (PPair a (list a)))
PPrelude.puncons Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
   :--> PMaybe
          (PPair
             (PBuiltinPair (PAsData k) (PAsData b))
             (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term
     s'
     (PMaybe
        (PPair
           (PBuiltinPair (PAsData k) (PAsData b))
           (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
ell') ((PMaybe
    (PPair
       (PBuiltinPair (PAsData k) (PAsData b))
       (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
    s'
  -> Term s' PBool)
 -> Term s' PBool)
-> (PMaybe
      (PPair
         (PBuiltinPair (PAsData k) (PAsData b))
         (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall a b. (a -> b) -> a -> b
$ \case
              PMaybe
  (PPair
     (PBuiltinPair (PAsData k) (PAsData b))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
  s'
PNothing -> Term s' (PMaybe b)
-> (PMaybe b s' -> Term s' PBool) -> Term s' PBool
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term s' (k :--> (PSortedMap k b :--> PMaybe b))
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PIsData k, PIsData v) =>
Term s (k :--> (PSortedMap k v :--> PMaybe v))
plookup Term s' (k :--> (PSortedMap k b :--> PMaybe b))
-> Term s' k -> Term s' (PSortedMap k b :--> PMaybe b)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# (Term s' (PBuiltinPair (PAsData k) (PAsData a) :--> k)
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PIsData k =>
Term s (PBuiltinPair (PAsData k) (PAsData v) :--> k)
pkvPairKey Term s' (PBuiltinPair (PAsData k) (PAsData a) :--> k)
-> Term s' (PBuiltinPair (PAsData k) (PAsData a)) -> Term s' k
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinPair (PAsData k) (PAsData a))
h) Term s' (PSortedMap k b :--> PMaybe b)
-> Term s' (PSortedMap k b) -> Term s' (PMaybe b)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PUnsortedMap k b) -> Term s' (PSortedMap k b)
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Term s (PUnsortedMap k v) -> Term s (PSortedMap k v)
punsafeCoerceToSortedMap Term s' (PUnsortedMap k b)
kvs') ((PMaybe b s' -> Term s' PBool) -> Term s' PBool)
-> (PMaybe b s' -> Term s' PBool) -> Term s' PBool
forall a b. (a -> b) -> a -> b
$ \case
                -- We mismatch, so fail
                PMaybe b s'
PNothing -> PBool s' -> Term s' PBool
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon PBool s'
forall (s :: S). PBool s
PFalse
                -- We match, so continue
                PJust Term s' b
_ -> Term
  s'
  (PUnsortedMap k a
   :--> (PUnsortedMap k b
         :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
               :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                     :--> PBool))))
self Term
  s'
  (PUnsortedMap k a
   :--> (PUnsortedMap k b
         :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
               :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                     :--> PBool))))
-> Term s' (PUnsortedMap k a)
-> Term
     s'
     (PUnsortedMap k b
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
            :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                  :--> PBool)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PUnsortedMap k a)
kvs Term
  s'
  (PUnsortedMap k b
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
         :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
               :--> PBool)))
-> Term s' (PUnsortedMap k b)
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
            :--> PBool))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PUnsortedMap k b)
kvs' Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
         :--> PBool))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
-> Term
     s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)) :--> PBool)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
t Term
  s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)) :--> PBool)
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' PBool
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
ell'
              -- To save some effort, we try both matches in one shot
              PJust Term
  s'
  (PPair
     (PBuiltinPair (PAsData k) (PAsData b))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
ht' -> Term
  s'
  (PPair
     (PBuiltinPair (PAsData k) (PAsData b))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
-> (PPair
      (PBuiltinPair (PAsData k) (PAsData b))
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term
  s'
  (PPair
     (PBuiltinPair (PAsData k) (PAsData b))
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))))
ht' ((PPair
    (PBuiltinPair (PAsData k) (PAsData b))
    (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
    s'
  -> Term s' PBool)
 -> Term s' PBool)
-> (PPair
      (PBuiltinPair (PAsData k) (PAsData b))
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
      s'
    -> Term s' PBool)
-> Term s' PBool
forall a b. (a -> b) -> a -> b
$ \(PPair Term s' (PBuiltinPair (PAsData k) (PAsData b))
h' Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
t') ->
                Term s' (PMaybe b)
-> (PMaybe b s' -> Term s' PBool) -> Term s' PBool
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term s' (k :--> (PSortedMap k b :--> PMaybe b))
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PIsData k, PIsData v) =>
Term s (k :--> (PSortedMap k v :--> PMaybe v))
plookup Term s' (k :--> (PSortedMap k b :--> PMaybe b))
-> Term s' k -> Term s' (PSortedMap k b :--> PMaybe b)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# (Term s' (PBuiltinPair (PAsData k) (PAsData a) :--> k)
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PIsData k =>
Term s (PBuiltinPair (PAsData k) (PAsData v) :--> k)
pkvPairKey Term s' (PBuiltinPair (PAsData k) (PAsData a) :--> k)
-> Term s' (PBuiltinPair (PAsData k) (PAsData a)) -> Term s' k
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinPair (PAsData k) (PAsData a))
h) Term s' (PSortedMap k b :--> PMaybe b)
-> Term s' (PSortedMap k b) -> Term s' (PMaybe b)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PUnsortedMap k b) -> Term s' (PSortedMap k b)
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Term s (PUnsortedMap k v) -> Term s (PSortedMap k v)
punsafeCoerceToSortedMap Term s' (PUnsortedMap k b)
kvs') ((PMaybe b s' -> Term s' PBool) -> Term s' PBool)
-> (PMaybe b s' -> Term s' PBool) -> Term s' PBool
forall a b. (a -> b) -> a -> b
$ \case
                  -- We mismatch, so fail
                  PMaybe b s'
PNothing -> PBool s' -> Term s' PBool
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon PBool s'
forall (s :: S). PBool s
PFalse
                  -- Try the other direction
                  PJust Term s' b
_ -> Term s' (PMaybe a)
-> (PMaybe a s' -> Term s' PBool) -> Term s' PBool
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term s' (k :--> (PSortedMap k a :--> PMaybe a))
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PIsData k, PIsData v) =>
Term s (k :--> (PSortedMap k v :--> PMaybe v))
plookup Term s' (k :--> (PSortedMap k a :--> PMaybe a))
-> Term s' k -> Term s' (PSortedMap k a :--> PMaybe a)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# (Term s' (PBuiltinPair (PAsData k) (PAsData b) :--> k)
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PIsData k =>
Term s (PBuiltinPair (PAsData k) (PAsData v) :--> k)
pkvPairKey Term s' (PBuiltinPair (PAsData k) (PAsData b) :--> k)
-> Term s' (PBuiltinPair (PAsData k) (PAsData b)) -> Term s' k
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinPair (PAsData k) (PAsData b))
h') Term s' (PSortedMap k a :--> PMaybe a)
-> Term s' (PSortedMap k a) -> Term s' (PMaybe a)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PUnsortedMap k a) -> Term s' (PSortedMap k a)
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Term s (PUnsortedMap k v) -> Term s (PSortedMap k v)
punsafeCoerceToSortedMap Term s' (PUnsortedMap k a)
kvs) ((PMaybe a s' -> Term s' PBool) -> Term s' PBool)
-> (PMaybe a s' -> Term s' PBool) -> Term s' PBool
forall a b. (a -> b) -> a -> b
$ \case
                    -- We mismatch, so fail
                    PMaybe a s'
PNothing -> PBool s' -> Term s' PBool
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon PBool s'
forall (s :: S). PBool s
PFalse
                    -- Both succeeded, so continue on tails
                    PJust Term s' a
_ -> Term
  s'
  (PUnsortedMap k a
   :--> (PUnsortedMap k b
         :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
               :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                     :--> PBool))))
self Term
  s'
  (PUnsortedMap k a
   :--> (PUnsortedMap k b
         :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
               :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                     :--> PBool))))
-> Term s' (PUnsortedMap k a)
-> Term
     s'
     (PUnsortedMap k b
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
            :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
                  :--> PBool)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PUnsortedMap k a)
kvs Term
  s'
  (PUnsortedMap k b
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
         :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
               :--> PBool)))
-> Term s' (PUnsortedMap k b)
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
            :--> PBool))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PUnsortedMap k b)
kvs' Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
         :--> PBool))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
-> Term
     s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)) :--> PBool)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
t Term
  s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)) :--> PBool)
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s' PBool
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
t'

----------------------------------------------------------------------
-- Fold

{- | Verifies all values in the map satisfy the given predicate.

@since 2.0.0
-}
pall ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  PIsData v =>
  Term s ((v :--> PBool) :--> PUnsortedMap k v :--> PBool)
pall :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PIsData v =>
Term s ((v :--> PBool) :--> (PUnsortedMap k v :--> PBool))
pall = (forall (s' :: S).
 Term s' ((v :--> PBool) :--> (PUnsortedMap k v :--> PBool)))
-> Term s ((v :--> PBool) :--> (PUnsortedMap k v :--> PBool))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term s' ((v :--> PBool) :--> (PUnsortedMap k v :--> PBool)))
 -> Term s ((v :--> PBool) :--> (PUnsortedMap k v :--> PBool)))
-> (forall (s' :: S).
    Term s' ((v :--> PBool) :--> (PUnsortedMap k v :--> PBool)))
-> Term s ((v :--> PBool) :--> (PUnsortedMap k v :--> PBool))
forall a b. (a -> b) -> a -> b
$
  (Term s' (v :--> PBool)
 -> Term s' (PUnsortedMap k v) -> Term s' PBool)
-> Term s' ((v :--> PBool) :--> (PUnsortedMap k v :--> PBool))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PUnsortedMap k v) -> Term s' PBool)
-> Term s' (c :--> (PUnsortedMap k v :--> PBool))
plam ((Term s' (v :--> PBool)
  -> Term s' (PUnsortedMap k v) -> Term s' PBool)
 -> Term s' ((v :--> PBool) :--> (PUnsortedMap k v :--> PBool)))
-> (Term s' (v :--> PBool)
    -> Term s' (PUnsortedMap k v) -> Term s' PBool)
-> Term s' ((v :--> PBool) :--> (PUnsortedMap k v :--> PBool))
forall a b. (a -> b) -> a -> b
$ \Term s' (v :--> PBool)
pred Term s' (PUnsortedMap k v)
m ->
    Term
  s'
  ((PBuiltinPair (PAsData k) (PAsData v) :--> PBool)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBool))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
PIsListLike list a =>
Term s ((a :--> PBool) :--> (list a :--> PBool))
PPrelude.pall
      # plam (\pair -> pmatch pair $ \(PBuiltinPair _ y) -> pred # pfromData y)
      # pto (pto m)

{- | Tests if any value in the map satisfies the given predicate.

@since 2.1.1
-}
pany ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  PIsData v =>
  Term s ((v :--> PBool) :--> PUnsortedMap k v :--> PBool)
pany :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PIsData v =>
Term s ((v :--> PBool) :--> (PUnsortedMap k v :--> PBool))
pany = (forall (s' :: S).
 Term s' ((v :--> PBool) :--> (PUnsortedMap k v :--> PBool)))
-> Term s ((v :--> PBool) :--> (PUnsortedMap k v :--> PBool))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term s' ((v :--> PBool) :--> (PUnsortedMap k v :--> PBool)))
 -> Term s ((v :--> PBool) :--> (PUnsortedMap k v :--> PBool)))
-> (forall (s' :: S).
    Term s' ((v :--> PBool) :--> (PUnsortedMap k v :--> PBool)))
-> Term s ((v :--> PBool) :--> (PUnsortedMap k v :--> PBool))
forall a b. (a -> b) -> a -> b
$
  (Term s' (v :--> PBool)
 -> Term s' (PUnsortedMap k v) -> Term s' PBool)
-> Term s' ((v :--> PBool) :--> (PUnsortedMap k v :--> PBool))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PUnsortedMap k v) -> Term s' PBool)
-> Term s' (c :--> (PUnsortedMap k v :--> PBool))
plam ((Term s' (v :--> PBool)
  -> Term s' (PUnsortedMap k v) -> Term s' PBool)
 -> Term s' ((v :--> PBool) :--> (PUnsortedMap k v :--> PBool)))
-> (Term s' (v :--> PBool)
    -> Term s' (PUnsortedMap k v) -> Term s' PBool)
-> Term s' ((v :--> PBool) :--> (PUnsortedMap k v :--> PBool))
forall a b. (a -> b) -> a -> b
$ \Term s' (v :--> PBool)
pred Term s' (PUnsortedMap k v)
m ->
    Term
  s'
  ((PBuiltinPair (PAsData k) (PAsData v) :--> PBool)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBool))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
PIsListLike list a =>
Term s ((a :--> PBool) :--> (list a :--> PBool))
PPrelude.pany
      # plam (\pair -> pmatch pair $ \(PBuiltinPair _ y) -> pred # pfromData y)
      # pto (pto m)

{- | Project all key-value pairs into a 'Monoid', then combine. Keys and values
will be presented in key order.

@since 3.6.0
-}
pfoldMapWithKey ::
  forall (m :: S -> Type) (k :: S -> Type) (v :: S -> Type) (s :: S).
  ( PIsData k
  , PIsData v
  , forall (s' :: S). Monoid (Term s' m)
  ) =>
  Term s ((k :--> v :--> m) :--> PUnsortedMap k v :--> m)
pfoldMapWithKey :: forall (m :: S -> Type) (k :: S -> Type) (v :: S -> Type) (s :: S).
(PIsData k, PIsData v, forall (s' :: S). Monoid (Term s' m)) =>
Term s ((k :--> (v :--> m)) :--> (PUnsortedMap k v :--> m))
pfoldMapWithKey = (forall (s' :: S).
 Term s' ((k :--> (v :--> m)) :--> (PUnsortedMap k v :--> m)))
-> Term s ((k :--> (v :--> m)) :--> (PUnsortedMap k v :--> m))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term s' ((k :--> (v :--> m)) :--> (PUnsortedMap k v :--> m)))
 -> Term s ((k :--> (v :--> m)) :--> (PUnsortedMap k v :--> m)))
-> (forall (s' :: S).
    Term s' ((k :--> (v :--> m)) :--> (PUnsortedMap k v :--> m)))
-> Term s ((k :--> (v :--> m)) :--> (PUnsortedMap k v :--> m))
forall a b. (a -> b) -> a -> b
$
  (Term s' (k :--> (v :--> m))
 -> Term s' (PUnsortedMap k v) -> Term s' m)
-> Term s' ((k :--> (v :--> m)) :--> (PUnsortedMap k v :--> m))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PUnsortedMap k v) -> Term s' m)
-> Term s' (c :--> (PUnsortedMap k v :--> m))
plam ((Term s' (k :--> (v :--> m))
  -> Term s' (PUnsortedMap k v) -> Term s' m)
 -> Term s' ((k :--> (v :--> m)) :--> (PUnsortedMap k v :--> m)))
-> (Term s' (k :--> (v :--> m))
    -> Term s' (PUnsortedMap k v) -> Term s' m)
-> Term s' ((k :--> (v :--> m)) :--> (PUnsortedMap k v :--> m))
forall a b. (a -> b) -> a -> b
$ \Term s' (k :--> (v :--> m))
f Term s' (PUnsortedMap k v)
kvs ->
    Term
  s'
  ((m :--> (k :--> (v :--> m)))
   :--> (m :--> (PUnsortedMap k v :--> m)))
forall (a :: S -> Type) (k :: S -> Type) (v :: S -> Type) (s :: S).
(PIsData k, PIsData v) =>
Term
  s
  ((a :--> (k :--> (v :--> a)))
   :--> (a :--> (PUnsortedMap k v :--> a)))
pfoldlWithKey Term
  s'
  ((m :--> (k :--> (v :--> m)))
   :--> (m :--> (PUnsortedMap k v :--> m)))
-> Term s' (m :--> (k :--> (v :--> m)))
-> Term s' (m :--> (PUnsortedMap k v :--> m))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# (Term s' m -> Term s' k -> Term s' v -> Term s' m)
-> Term s' (m :--> (k :--> (v :--> m)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' k -> Term s' v -> Term s' m)
-> Term s' (c :--> (k :--> (v :--> m)))
plam (\Term s' m
acc Term s' k
k Term s' v
v -> Term s' m
acc Term s' m -> Term s' m -> Term s' m
forall a. Semigroup a => a -> a -> a
<> (Term s' (k :--> (v :--> m))
f Term s' (k :--> (v :--> m)) -> Term s' k -> Term s' (v :--> m)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' k
k Term s' (v :--> m) -> Term s' v -> Term s' m
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' v
v)) Term s' (m :--> (PUnsortedMap k v :--> m))
-> Term s' m -> Term s' (PUnsortedMap k v :--> m)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' m
forall a. Monoid a => a
mempty Term s' (PUnsortedMap k v :--> m)
-> Term s' (PUnsortedMap k v) -> Term s' m
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PUnsortedMap k v)
kvs

{- | Left-associative fold with keys. Keys and values will be
presented in key order.

@since 3.6.0
-}
pfoldlWithKey ::
  forall (a :: S -> Type) (k :: S -> Type) (v :: S -> Type) (s :: S).
  ( PIsData k
  , PIsData v
  ) =>
  Term s ((a :--> k :--> v :--> a) :--> a :--> PUnsortedMap k v :--> a)
pfoldlWithKey :: forall (a :: S -> Type) (k :: S -> Type) (v :: S -> Type) (s :: S).
(PIsData k, PIsData v) =>
Term
  s
  ((a :--> (k :--> (v :--> a)))
   :--> (a :--> (PUnsortedMap k v :--> a)))
pfoldlWithKey = (forall (s' :: S).
 Term
   s'
   ((a :--> (k :--> (v :--> a)))
    :--> (a :--> (PUnsortedMap k v :--> a))))
-> Term
     s
     ((a :--> (k :--> (v :--> a)))
      :--> (a :--> (PUnsortedMap k v :--> a)))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term
    s'
    ((a :--> (k :--> (v :--> a)))
     :--> (a :--> (PUnsortedMap k v :--> a))))
 -> Term
      s
      ((a :--> (k :--> (v :--> a)))
       :--> (a :--> (PUnsortedMap k v :--> a))))
-> (forall (s' :: S).
    Term
      s'
      ((a :--> (k :--> (v :--> a)))
       :--> (a :--> (PUnsortedMap k v :--> a))))
-> Term
     s
     ((a :--> (k :--> (v :--> a)))
      :--> (a :--> (PUnsortedMap k v :--> a)))
forall a b. (a -> b) -> a -> b
$
  (Term s' (a :--> (k :--> (v :--> a)))
 -> Term s' a -> Term s' (PUnsortedMap k v) -> Term s' a)
-> Term
     s'
     ((a :--> (k :--> (v :--> a)))
      :--> (a :--> (PUnsortedMap k v :--> a)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' a -> Term s' (PUnsortedMap k v) -> Term s' a)
-> Term s' (c :--> (a :--> (PUnsortedMap k v :--> a)))
plam ((Term s' (a :--> (k :--> (v :--> a)))
  -> Term s' a -> Term s' (PUnsortedMap k v) -> Term s' a)
 -> Term
      s'
      ((a :--> (k :--> (v :--> a)))
       :--> (a :--> (PUnsortedMap k v :--> a))))
-> (Term s' (a :--> (k :--> (v :--> a)))
    -> Term s' a -> Term s' (PUnsortedMap k v) -> Term s' a)
-> Term
     s'
     ((a :--> (k :--> (v :--> a)))
      :--> (a :--> (PUnsortedMap k v :--> a)))
forall a b. (a -> b) -> a -> b
$ \Term s' (a :--> (k :--> (v :--> a)))
f Term s' a
x Term s' (PUnsortedMap k v)
kvs ->
    Term
  s'
  ((a :--> (PBuiltinPair (PAsData k) (PAsData v) :--> a))
   :--> (a
         :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> a)))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S)
       (b :: S -> Type).
PIsListLike list a =>
Term s ((b :--> (a :--> b)) :--> (b :--> (list a :--> b)))
pfoldl
      # plam (\acc kv -> f # acc # (pkvPairKey # kv) # (pkvPairValue # kv))
      # x
      # pto (pto kvs)

----------------------------------------------------------------------
-- Combination

{- | Build a function that zips two 'PSortedMap's together using a custom 'MergeHandler'.

The provided 'MergeHandler' determines how to merge entries based on whether a
key is present in the left map, the right map, or both.

= NOTE

This function itself cannot be hoisted with 'phoistAcyclic' because it
depends on the supplied 'MergeHandler'. However, once you specialize it
by providing a specific merge handler, the resulting function /should/ be
hoisted if it will be reused, to avoid duplication.

@since 3.5.0
-}
zipWithBuilder ::
  forall (s :: S) (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (c :: S -> Type).
  ( POrd k
  , PIsData k
  , PIsData a
  , PIsData b
  , PIsData c
  ) =>
  MergeHandler s k a b c ->
  Term
    s
    ( PSortedMap k a
        :--> PSortedMap k b
        :--> PSortedMap k c
    )
zipWithBuilder :: forall (s :: S) (k :: S -> Type) (a :: S -> Type) (b :: S -> Type)
       (c :: S -> Type).
(POrd k, PIsData k, PIsData a, PIsData b, PIsData c) =>
MergeHandler s k a b c
-> Term
     s (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))
zipWithBuilder MergeHandler s k a b c
mergeHandler =
  MergeHandler s (PAsData k) (PAsData a) (PAsData b) (PAsData c)
-> Term
     s (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))
forall (s :: S) (k :: S -> Type) (a :: S -> Type) (b :: S -> Type)
       (c :: S -> Type).
(POrd k, PIsData k) =>
MergeHandler s (PAsData k) (PAsData a) (PAsData b) (PAsData c)
-> Term
     s (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))
zipWithDataBuilder (MergeHandler s k a b c
-> MergeHandler s (PAsData k) (PAsData a) (PAsData b) (PAsData c)
forall (s :: S) (k :: S -> Type) (a :: S -> Type) (b :: S -> Type)
       (c :: S -> Type).
(PIsData k, PIsData a, PIsData b, PIsData c) =>
MergeHandler s k a b c
-> MergeHandler s (PAsData k) (PAsData a) (PAsData b) (PAsData c)
Zip.mergeHandlerOnData MergeHandler s k a b c
mergeHandler)

{- | Build a function that zips two 'PSortedMap's together using a custom 'MergeHandler'.

The provided 'MergeHandler' determines how to merge entries based on whether a
key is present in the left map, the right map, or both.

Unlike 'zipWithBuilder', 'zipWithDataBuilder' operates on values wrapped in
'PAsData' (typed BuiltinData).

= NOTE

This function itself cannot be hoisted with 'phoistAcyclic' because it
depends on the supplied 'MergeHandler'. However, once you specialize it
by providing a specific merge handler, the resulting function /should/ be
hoisted if it will be reused, to avoid duplication.

@since 3.5.0
-}
zipWithDataBuilder ::
  forall (s :: S) (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (c :: S -> Type).
  ( POrd k
  , PIsData k
  ) =>
  MergeHandler s (PAsData k) (PAsData a) (PAsData b) (PAsData c) ->
  Term
    s
    ( PSortedMap k a
        :--> PSortedMap k b
        :--> PSortedMap k c
    )
zipWithDataBuilder :: forall (s :: S) (k :: S -> Type) (a :: S -> Type) (b :: S -> Type)
       (c :: S -> Type).
(POrd k, PIsData k) =>
MergeHandler s (PAsData k) (PAsData a) (PAsData b) (PAsData c)
-> Term
     s (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))
zipWithDataBuilder MergeHandler s (PAsData k) (PAsData a) (PAsData b) (PAsData c)
mergeHandler =
  (Term s (PSortedMap k a)
 -> Term s (PSortedMap k b) -> Term s (PSortedMap k c))
-> Term
     s (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s c -> Term s (PSortedMap k b) -> Term s (PSortedMap k c))
-> Term s (c :--> (PSortedMap k b :--> PSortedMap k c))
plam ((Term s (PSortedMap k a)
  -> Term s (PSortedMap k b) -> Term s (PSortedMap k c))
 -> Term
      s (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
-> (Term s (PSortedMap k a)
    -> Term s (PSortedMap k b) -> Term s (PSortedMap k c))
-> Term
     s (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))
forall a b. (a -> b) -> a -> b
$ \Term s (PSortedMap k a)
mapL Term s (PSortedMap k b)
mapR ->
    PSortedMap k c s -> Term s (PSortedMap k c)
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon (PSortedMap k c s -> Term s (PSortedMap k c))
-> (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData c)))
    -> PSortedMap k c s)
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData c)))
-> Term s (PSortedMap k c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s (PAssocMap k c) -> PSortedMap k c s
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Term s (PAssocMap k v) -> PSortedMap k v s
PSortedMap (Term s (PAssocMap k c) -> PSortedMap k c s)
-> (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData c)))
    -> Term s (PAssocMap k c))
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData c)))
-> PSortedMap k c s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PAssocMap k c s -> Term s (PAssocMap k c)
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon (PAssocMap k c s -> Term s (PAssocMap k c))
-> (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData c)))
    -> PAssocMap k c s)
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData c)))
-> Term s (PAssocMap k c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData c)))
-> PAssocMap k c s
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> PAssocMap k v s
PAssocMap (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData c)))
 -> Term s (PSortedMap k c))
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData c)))
-> Term s (PSortedMap k c)
forall a b. (a -> b) -> a -> b
$
      MergeHandler s (PAsData k) (PAsData a) (PAsData b) (PAsData c)
-> Term
     s
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
            :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData c))))
forall (s :: S) (k :: S -> Type) (a :: S -> Type) (b :: S -> Type)
       (c :: S -> Type).
(POrd k, PIsData k) =>
MergeHandler s (PAsData k) (PAsData a) (PAsData b) (PAsData c)
-> Term
     s
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
      :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
            :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData c))))
Zip.zipWorker MergeHandler s (PAsData k) (PAsData a) (PAsData b) (PAsData c)
mergeHandler Term
  s
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a))
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData c))))
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData a)))
-> Term
     s
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData c)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PAssocMap k a) -> Term s (PInner (PAssocMap k a))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto (Term s (PSortedMap k a) -> Term s (PInner (PSortedMap k a))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto Term s (PSortedMap k a)
mapL) Term
  s
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData c)))
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData b)))
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData c)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PInner (PSortedMap k b))
-> Term s (PInner (PInner (PSortedMap k b)))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto (Term s (PSortedMap k b) -> Term s (PInner (PSortedMap k b))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto Term s (PSortedMap k b)
mapR)

{- | Build the union of two 'PSortedMap's, merging values that share the same
key using the given function.

@since 3.5.0
-}
punionWith ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  ( POrd k
  , PIsData k
  , PIsData v
  ) =>
  Term
    s
    ( (v :--> v :--> v)
        :--> PSortedMap k v
        :--> PSortedMap k v
        :--> PSortedMap k v
    )
punionWith :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(POrd k, PIsData k, PIsData v) =>
Term
  s
  ((v :--> (v :--> v))
   :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
punionWith =
  (forall (s' :: S).
 Term
   s'
   ((v :--> (v :--> v))
    :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v))))
-> Term
     s
     ((v :--> (v :--> v))
      :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term
    s'
    ((v :--> (v :--> v))
     :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v))))
 -> Term
      s
      ((v :--> (v :--> v))
       :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v))))
-> (forall (s' :: S).
    Term
      s'
      ((v :--> (v :--> v))
       :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v))))
-> Term
     s
     ((v :--> (v :--> v))
      :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
forall a b. (a -> b) -> a -> b
$
    (Term s' (v :--> (v :--> v))
 -> Term
      s' (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
-> Term
     s'
     ((v :--> (v :--> v))
      :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c
 -> Term
      s' (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
-> Term
     s'
     (c :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
plam ((Term s' (v :--> (v :--> v))
  -> Term
       s' (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
 -> Term
      s'
      ((v :--> (v :--> v))
       :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v))))
-> (Term s' (v :--> (v :--> v))
    -> Term
         s' (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
-> Term
     s'
     ((v :--> (v :--> v))
      :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
forall a b. (a -> b) -> a -> b
$
      MergeHandler s' k v v v
-> Term
     s' (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v))
forall (s :: S) (k :: S -> Type) (a :: S -> Type) (b :: S -> Type)
       (c :: S -> Type).
(POrd k, PIsData k, PIsData a, PIsData b, PIsData c) =>
MergeHandler s k a b c
-> Term
     s (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))
zipWithBuilder (MergeHandler s' k v v v
 -> Term
      s' (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
-> (Term s' (v :--> (v :--> v)) -> MergeHandler s' k v v v)
-> Term s' (v :--> (v :--> v))
-> Term
     s' (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' (v :--> (v :--> v)) -> MergeHandler s' k v v v
forall (s :: S) (k :: S -> Type) (v :: S -> Type).
Term s (v :--> (v :--> v)) -> MergeHandler s k v v v
Zip.unionMergeHandler

{- | Build the union of two 'PSortedMap's, merging values that share the same
key using the given function.

@since 3.5.0
-}
punionWithData ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  ( POrd k
  , PIsData k
  ) =>
  Term
    s
    ( (PAsData v :--> PAsData v :--> PAsData v)
        :--> PSortedMap k v
        :--> PSortedMap k v
        :--> PSortedMap k v
    )
punionWithData :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(POrd k, PIsData k) =>
Term
  s
  ((PAsData v :--> (PAsData v :--> PAsData v))
   :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
punionWithData =
  (forall (s' :: S).
 Term
   s'
   ((PAsData v :--> (PAsData v :--> PAsData v))
    :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v))))
-> Term
     s
     ((PAsData v :--> (PAsData v :--> PAsData v))
      :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term
    s'
    ((PAsData v :--> (PAsData v :--> PAsData v))
     :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v))))
 -> Term
      s
      ((PAsData v :--> (PAsData v :--> PAsData v))
       :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v))))
-> (forall (s' :: S).
    Term
      s'
      ((PAsData v :--> (PAsData v :--> PAsData v))
       :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v))))
-> Term
     s
     ((PAsData v :--> (PAsData v :--> PAsData v))
      :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
forall a b. (a -> b) -> a -> b
$
    (Term s' (PAsData v :--> (PAsData v :--> PAsData v))
 -> Term
      s' (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
-> Term
     s'
     ((PAsData v :--> (PAsData v :--> PAsData v))
      :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c
 -> Term
      s' (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
-> Term
     s'
     (c :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
plam ((Term s' (PAsData v :--> (PAsData v :--> PAsData v))
  -> Term
       s' (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
 -> Term
      s'
      ((PAsData v :--> (PAsData v :--> PAsData v))
       :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v))))
-> (Term s' (PAsData v :--> (PAsData v :--> PAsData v))
    -> Term
         s' (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
-> Term
     s'
     ((PAsData v :--> (PAsData v :--> PAsData v))
      :--> (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
forall a b. (a -> b) -> a -> b
$
      MergeHandler s' (PAsData k) (PAsData v) (PAsData v) (PAsData v)
-> Term
     s' (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v))
forall (s :: S) (k :: S -> Type) (a :: S -> Type) (b :: S -> Type)
       (c :: S -> Type).
(POrd k, PIsData k) =>
MergeHandler s (PAsData k) (PAsData a) (PAsData b) (PAsData c)
-> Term
     s (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))
zipWithDataBuilder (MergeHandler s' (PAsData k) (PAsData v) (PAsData v) (PAsData v)
 -> Term
      s' (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
-> (Term s' (PAsData v :--> (PAsData v :--> PAsData v))
    -> MergeHandler s' (PAsData k) (PAsData v) (PAsData v) (PAsData v))
-> Term s' (PAsData v :--> (PAsData v :--> PAsData v))
-> Term
     s' (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' (PAsData v :--> (PAsData v :--> PAsData v))
-> MergeHandler s' (PAsData k) (PAsData v) (PAsData v) (PAsData v)
forall (s :: S) (k :: S -> Type) (v :: S -> Type).
Term s (v :--> (v :--> v)) -> MergeHandler s k v v v
Zip.unionMergeHandler

{- | Build the union of two 'PSortedMap's. Take the value from the left argument
for colliding keys.

@since 2.1.1
-}
pleftBiasedUnion ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  ( POrd k
  , PIsData k
  , PIsData v
  ) =>
  Term
    s
    ( PSortedMap k v
        :--> PSortedMap k v
        :--> PSortedMap k v
    )
pleftBiasedUnion :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(POrd k, PIsData k, PIsData v) =>
Term s (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v))
pleftBiasedUnion =
  (forall (s' :: S).
 Term s' (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
-> Term
     s (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term s' (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
 -> Term
      s (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
-> (forall (s' :: S).
    Term s' (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v)))
-> Term
     s (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v))
forall a b. (a -> b) -> a -> b
$
    MergeHandler s' k v v v
-> Term
     s' (PSortedMap k v :--> (PSortedMap k v :--> PSortedMap k v))
forall (s :: S) (k :: S -> Type) (a :: S -> Type) (b :: S -> Type)
       (c :: S -> Type).
(POrd k, PIsData k, PIsData a, PIsData b, PIsData c) =>
MergeHandler s k a b c
-> Term
     s (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))
zipWithBuilder MergeHandler s' k v v v
forall (s :: S) (k :: S -> Type) (v :: S -> Type).
MergeHandler s k v v v
Zip.leftBiasedUnionMergeHandler

{- Difference of two 'PSortedMap's. Return elements of the first map not
existing in the second map.

@since 2.1.1
-}
pdifference ::
  forall (b :: S -> Type) (a :: S -> Type) (k :: S -> Type) (s :: S).
  ( POrd k
  , PIsData k
  , PIsData a
  , PIsData b
  ) =>
  Term
    s
    ( PSortedMap k a
        :--> PSortedMap k b
        :--> PSortedMap k a
    )
pdifference :: forall (b :: S -> Type) (a :: S -> Type) (k :: S -> Type) (s :: S).
(POrd k, PIsData k, PIsData a, PIsData b) =>
Term s (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a))
pdifference =
  (forall (s' :: S).
 Term s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a)))
-> Term
     s (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a)))
 -> Term
      s (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a)))
-> (forall (s' :: S).
    Term s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a)))
-> Term
     s (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a))
forall a b. (a -> b) -> a -> b
$
    MergeHandler s' k a b a
-> Term
     s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a))
forall (s :: S) (k :: S -> Type) (a :: S -> Type) (b :: S -> Type)
       (c :: S -> Type).
(POrd k, PIsData k, PIsData a, PIsData b, PIsData c) =>
MergeHandler s k a b c
-> Term
     s (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))
zipWithBuilder MergeHandler s' k a b a
forall (s :: S) (k :: S -> Type) (a :: S -> Type) (b :: S -> Type).
MergeHandler s k a b a
Zip.differenceMergeHandler

{- Difference with a combining function. When two equal keys are encountered,
the combining function is applied to the values of these keys. If it returns
'PNothing', the element is discarded.

@since 3.5.0
-}
pdifferenceWith ::
  forall (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (s :: S).
  ( POrd k
  , PIsData k
  , PIsData a
  , PIsData b
  ) =>
  Term
    s
    ( (a :--> b :--> PMaybe a)
        :--> PSortedMap k a
        :--> PSortedMap k b
        :--> PSortedMap k a
    )
pdifferenceWith :: forall (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (s :: S).
(POrd k, PIsData k, PIsData a, PIsData b) =>
Term
  s
  ((a :--> (b :--> PMaybe a))
   :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a)))
pdifferenceWith =
  (forall (s' :: S).
 Term
   s'
   ((a :--> (b :--> PMaybe a))
    :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a))))
-> Term
     s
     ((a :--> (b :--> PMaybe a))
      :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a)))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term
    s'
    ((a :--> (b :--> PMaybe a))
     :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a))))
 -> Term
      s
      ((a :--> (b :--> PMaybe a))
       :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a))))
-> (forall (s' :: S).
    Term
      s'
      ((a :--> (b :--> PMaybe a))
       :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a))))
-> Term
     s
     ((a :--> (b :--> PMaybe a))
      :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a)))
forall a b. (a -> b) -> a -> b
$
    (Term s' (a :--> (b :--> PMaybe a))
 -> Term
      s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a)))
-> Term
     s'
     ((a :--> (b :--> PMaybe a))
      :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c
 -> Term
      s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a)))
-> Term
     s'
     (c :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a)))
plam ((Term s' (a :--> (b :--> PMaybe a))
  -> Term
       s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a)))
 -> Term
      s'
      ((a :--> (b :--> PMaybe a))
       :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a))))
-> (Term s' (a :--> (b :--> PMaybe a))
    -> Term
         s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a)))
-> Term
     s'
     ((a :--> (b :--> PMaybe a))
      :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a)))
forall a b. (a -> b) -> a -> b
$ \Term s' (a :--> (b :--> PMaybe a))
combine ->
      MergeHandler s' k a b a
-> Term
     s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a))
forall (s :: S) (k :: S -> Type) (a :: S -> Type) (b :: S -> Type)
       (c :: S -> Type).
(POrd k, PIsData k, PIsData a, PIsData b, PIsData c) =>
MergeHandler s k a b c
-> Term
     s (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))
zipWithBuilder (MergeHandler s' k a b a
 -> Term
      s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a)))
-> MergeHandler s' k a b a
-> Term
     s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k a))
forall a b. (a -> b) -> a -> b
$
        MergeHandler s' k a b a
forall (s :: S) (k :: S -> Type) (a :: S -> Type) (b :: S -> Type).
MergeHandler s k a b a
Zip.differenceMergeHandler
          { mhBothPresent = HandleOrDropBoth $ plam (\Term s' k
_ Term s' a
valL Term s' b
valR -> Term s' (a :--> (b :--> PMaybe a))
combine Term s' (a :--> (b :--> PMaybe a))
-> Term s' a -> Term s' (b :--> PMaybe a)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' a
valL Term s' (b :--> PMaybe a) -> Term s' b -> Term s' (PMaybe a)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' b
valR)
          }

{- | Zip two 'PSortedMap's, using the given value merge function for key
collisions, and different values for the sides.

@since 2.1.1
-}
pzipWithDefaults ::
  forall (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (c :: S -> Type) (s :: S).
  ( POrd k
  , PIsData k
  , PIsData a
  , PIsData b
  , PIsData c
  ) =>
  (forall (s' :: S). Term s' a) ->
  (forall (s' :: S). Term s' b) ->
  Term
    s
    ( (a :--> b :--> c)
        :--> PSortedMap k a
        :--> PSortedMap k b
        :--> PSortedMap k c
    )
pzipWithDefaults :: forall (k :: S -> Type) (a :: S -> Type) (b :: S -> Type)
       (c :: S -> Type) (s :: S).
(POrd k, PIsData k, PIsData a, PIsData b, PIsData c) =>
(forall (s' :: S). Term s' a)
-> (forall (s' :: S). Term s' b)
-> Term
     s
     ((a :--> (b :--> c))
      :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
pzipWithDefaults forall (s' :: S). Term s' a
defLeft forall (s' :: S). Term s' b
defRight =
  (forall (s' :: S).
 Term
   s'
   ((a :--> (b :--> c))
    :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))))
-> Term
     s
     ((a :--> (b :--> c))
      :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term
    s'
    ((a :--> (b :--> c))
     :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))))
 -> Term
      s
      ((a :--> (b :--> c))
       :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))))
-> (forall (s' :: S).
    Term
      s'
      ((a :--> (b :--> c))
       :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))))
-> Term
     s
     ((a :--> (b :--> c))
      :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
forall a b. (a -> b) -> a -> b
$
    (Term s' (a :--> (b :--> c))
 -> Term
      s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
-> Term
     s'
     ((a :--> (b :--> c))
      :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c
 -> Term
      s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
-> Term
     s'
     (c :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
plam ((Term s' (a :--> (b :--> c))
  -> Term
       s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
 -> Term
      s'
      ((a :--> (b :--> c))
       :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))))
-> (Term s' (a :--> (b :--> c))
    -> Term
         s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
-> Term
     s'
     ((a :--> (b :--> c))
      :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
forall a b. (a -> b) -> a -> b
$
      MergeHandler s' k a b c
-> Term
     s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))
forall (s :: S) (k :: S -> Type) (a :: S -> Type) (b :: S -> Type)
       (c :: S -> Type).
(POrd k, PIsData k, PIsData a, PIsData b, PIsData c) =>
MergeHandler s k a b c
-> Term
     s (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))
zipWithBuilder (MergeHandler s' k a b c
 -> Term
      s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
-> (Term s' (a :--> (b :--> c)) -> MergeHandler s' k a b c)
-> Term s' (a :--> (b :--> c))
-> Term
     s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' a
-> Term s' b
-> Term s' (a :--> (b :--> c))
-> MergeHandler s' k a b c
forall (s :: S) (k :: S -> Type) (a :: S -> Type) (b :: S -> Type)
       (c :: S -> Type).
Term s a
-> Term s b -> Term s (a :--> (b :--> c)) -> MergeHandler s k a b c
Zip.zipMergeHandler Term s' a
forall (s' :: S). Term s' a
defLeft Term s' b
forall (s' :: S). Term s' b
defRight

{- | Build the intersection of two 'PSortedMap's, merging values that share the
same key using the given function.

@since 2.1.1
-}
pintersectionWith ::
  forall (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (c :: S -> Type) (s :: S).
  ( POrd k
  , PIsData k
  , PIsData a
  , PIsData b
  , PIsData c
  ) =>
  Term
    s
    ( (a :--> b :--> c)
        :--> PSortedMap k a
        :--> PSortedMap k b
        :--> PSortedMap k c
    )
pintersectionWith :: forall (k :: S -> Type) (a :: S -> Type) (b :: S -> Type)
       (c :: S -> Type) (s :: S).
(POrd k, PIsData k, PIsData a, PIsData b, PIsData c) =>
Term
  s
  ((a :--> (b :--> c))
   :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
pintersectionWith =
  (forall (s' :: S).
 Term
   s'
   ((a :--> (b :--> c))
    :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))))
-> Term
     s
     ((a :--> (b :--> c))
      :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term
    s'
    ((a :--> (b :--> c))
     :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))))
 -> Term
      s
      ((a :--> (b :--> c))
       :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))))
-> (forall (s' :: S).
    Term
      s'
      ((a :--> (b :--> c))
       :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))))
-> Term
     s
     ((a :--> (b :--> c))
      :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
forall a b. (a -> b) -> a -> b
$
    (Term s' (a :--> (b :--> c))
 -> Term
      s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
-> Term
     s'
     ((a :--> (b :--> c))
      :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c
 -> Term
      s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
-> Term
     s'
     (c :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
plam ((Term s' (a :--> (b :--> c))
  -> Term
       s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
 -> Term
      s'
      ((a :--> (b :--> c))
       :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))))
-> (Term s' (a :--> (b :--> c))
    -> Term
         s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
-> Term
     s'
     ((a :--> (b :--> c))
      :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
forall a b. (a -> b) -> a -> b
$
      MergeHandler s' k a b c
-> Term
     s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))
forall (s :: S) (k :: S -> Type) (a :: S -> Type) (b :: S -> Type)
       (c :: S -> Type).
(POrd k, PIsData k, PIsData a, PIsData b, PIsData c) =>
MergeHandler s k a b c
-> Term
     s (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))
zipWithBuilder (MergeHandler s' k a b c
 -> Term
      s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
-> (Term s' (a :--> (b :--> c)) -> MergeHandler s' k a b c)
-> Term s' (a :--> (b :--> c))
-> Term
     s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' (a :--> (b :--> c)) -> MergeHandler s' k a b c
forall (s :: S) (k :: S -> Type) (a :: S -> Type) (b :: S -> Type)
       (c :: S -> Type).
Term s (a :--> (b :--> c)) -> MergeHandler s k a b c
Zip.intersectionMergeHandler

{- | Build the intersection of two 'PSortedMap's, merging data-encoded values
that share the same key using the given function.

@since 2.1.1
-}
pintersectionWithData ::
  forall (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (c :: S -> Type) (s :: S).
  ( POrd k
  , PIsData k
  ) =>
  Term
    s
    ( (PAsData a :--> PAsData b :--> PAsData c)
        :--> PSortedMap k a
        :--> PSortedMap k b
        :--> PSortedMap k c
    )
pintersectionWithData :: forall (k :: S -> Type) (a :: S -> Type) (b :: S -> Type)
       (c :: S -> Type) (s :: S).
(POrd k, PIsData k) =>
Term
  s
  ((PAsData a :--> (PAsData b :--> PAsData c))
   :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
pintersectionWithData =
  (forall (s' :: S).
 Term
   s'
   ((PAsData a :--> (PAsData b :--> PAsData c))
    :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))))
-> Term
     s
     ((PAsData a :--> (PAsData b :--> PAsData c))
      :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term
    s'
    ((PAsData a :--> (PAsData b :--> PAsData c))
     :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))))
 -> Term
      s
      ((PAsData a :--> (PAsData b :--> PAsData c))
       :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))))
-> (forall (s' :: S).
    Term
      s'
      ((PAsData a :--> (PAsData b :--> PAsData c))
       :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))))
-> Term
     s
     ((PAsData a :--> (PAsData b :--> PAsData c))
      :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
forall a b. (a -> b) -> a -> b
$
    (Term s' (PAsData a :--> (PAsData b :--> PAsData c))
 -> Term
      s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
-> Term
     s'
     ((PAsData a :--> (PAsData b :--> PAsData c))
      :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c
 -> Term
      s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
-> Term
     s'
     (c :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
plam ((Term s' (PAsData a :--> (PAsData b :--> PAsData c))
  -> Term
       s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
 -> Term
      s'
      ((PAsData a :--> (PAsData b :--> PAsData c))
       :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))))
-> (Term s' (PAsData a :--> (PAsData b :--> PAsData c))
    -> Term
         s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
-> Term
     s'
     ((PAsData a :--> (PAsData b :--> PAsData c))
      :--> (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
forall a b. (a -> b) -> a -> b
$
      MergeHandler s' (PAsData k) (PAsData a) (PAsData b) (PAsData c)
-> Term
     s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))
forall (s :: S) (k :: S -> Type) (a :: S -> Type) (b :: S -> Type)
       (c :: S -> Type).
(POrd k, PIsData k) =>
MergeHandler s (PAsData k) (PAsData a) (PAsData b) (PAsData c)
-> Term
     s (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))
zipWithDataBuilder (MergeHandler s' (PAsData k) (PAsData a) (PAsData b) (PAsData c)
 -> Term
      s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c)))
-> (Term s' (PAsData a :--> (PAsData b :--> PAsData c))
    -> MergeHandler s' (PAsData k) (PAsData a) (PAsData b) (PAsData c))
-> Term s' (PAsData a :--> (PAsData b :--> PAsData c))
-> Term
     s' (PSortedMap k a :--> (PSortedMap k b :--> PSortedMap k c))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' (PAsData a :--> (PAsData b :--> PAsData c))
-> MergeHandler s' (PAsData k) (PAsData a) (PAsData b) (PAsData c)
forall (s :: S) (k :: S -> Type) (a :: S -> Type) (b :: S -> Type)
       (c :: S -> Type).
Term s (a :--> (b :--> c)) -> MergeHandler s k a b c
Zip.intersectionMergeHandler

----------------------------------------------------------------------
-- Query

{- | Tests whether the map is empty.

@since 2.0.0
-}
pnull ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  Term s (PUnsortedMap k v :--> PBool)
pnull :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Term s (PUnsortedMap k v :--> PBool)
pnull = (Term s (PUnsortedMap k v) -> Term s PBool)
-> Term s (PUnsortedMap k v :--> PBool)
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s c -> Term s PBool) -> Term s (c :--> PBool)
plam ((Term s (PUnsortedMap k v) -> Term s PBool)
 -> Term s (PUnsortedMap k v :--> PBool))
-> (Term s (PUnsortedMap k v) -> Term s PBool)
-> Term s (PUnsortedMap k v :--> PBool)
forall a b. (a -> b) -> a -> b
$ \Term s (PUnsortedMap k v)
m -> Term
  s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> PBool)
forall (a :: S -> Type) (s :: S).
PElemConstraint PBuiltinList a =>
Term s (PBuiltinList a :--> PBool)
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
(PListLike list, PElemConstraint list a) =>
Term s (list a :--> PBool)
PPrelude.pnull Term
  s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> PBool)
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s PBool
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PAssocMap k v) -> Term s (PInner (PAssocMap k v))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto (Term s (PUnsortedMap k v) -> Term s (PInner (PUnsortedMap k v))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto Term s (PUnsortedMap k v)
m)

{- | Look up the given key in a 'PSortedMap'.

@since 3.6.0
-}
plookup ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  ( PIsData k
  , PIsData v
  ) =>
  Term s (k :--> PSortedMap k v :--> PMaybe v)
plookup :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PIsData k, PIsData v) =>
Term s (k :--> (PSortedMap k v :--> PMaybe v))
plookup = (forall (s' :: S). Term s' (k :--> (PSortedMap k v :--> PMaybe v)))
-> Term s (k :--> (PSortedMap k v :--> PMaybe v))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term s' (k :--> (PSortedMap k v :--> PMaybe v)))
 -> Term s (k :--> (PSortedMap k v :--> PMaybe v)))
-> (forall (s' :: S).
    Term s' (k :--> (PSortedMap k v :--> PMaybe v)))
-> Term s (k :--> (PSortedMap k v :--> PMaybe v))
forall a b. (a -> b) -> a -> b
$
  (Term s' k -> Term s' (PSortedMap k v :--> PMaybe v))
-> Term s' (k :--> (PSortedMap k v :--> PMaybe v))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PSortedMap k v :--> PMaybe v))
-> Term s' (c :--> (PSortedMap k v :--> PMaybe v))
plam ((Term s' k -> Term s' (PSortedMap k v :--> PMaybe v))
 -> Term s' (k :--> (PSortedMap k v :--> PMaybe v)))
-> (Term s' k -> Term s' (PSortedMap k v :--> PMaybe v))
-> Term s' (k :--> (PSortedMap k v :--> PMaybe v))
forall a b. (a -> b) -> a -> b
$ \Term s' k
key ->
    Term
  s'
  ((PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe v)
   :--> (PAsData k :--> (PSortedMap k v :--> PMaybe v)))
forall (k :: S -> Type) (v :: S -> Type) (x :: S -> Type) (s :: S).
Term
  s
  ((PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe x)
   :--> (PAsData k :--> (PSortedMap k v :--> PMaybe x)))
plookupDataWith
      # phoistAcyclic (plam $ \pair -> pmatch pair $ \(PBuiltinPair _ y) -> pcon $ PJust $ pfromData y)
      # pdata key

{- | As 'plookup', except over Data representation.

@since 3.6.0
-}
plookupData ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  Term s (PAsData k :--> PSortedMap k v :--> PMaybe (PAsData v))
plookupData :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Term s (PAsData k :--> (PSortedMap k v :--> PMaybe (PAsData v)))
plookupData =
  Term
  s
  ((PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe (PAsData v))
   :--> (PAsData k :--> (PSortedMap k v :--> PMaybe (PAsData v))))
forall (k :: S -> Type) (v :: S -> Type) (x :: S -> Type) (s :: S).
Term
  s
  ((PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe x)
   :--> (PAsData k :--> (PSortedMap k v :--> PMaybe x)))
plookupDataWith Term
  s
  ((PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe (PAsData v))
   :--> (PAsData k :--> (PSortedMap k v :--> PMaybe (PAsData v))))
-> Term
     s (PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe (PAsData v))
-> Term s (PAsData k :--> (PSortedMap k v :--> PMaybe (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# (forall (s' :: S).
 Term
   s' (PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe (PAsData v)))
-> Term
     s (PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe (PAsData v))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((Term s' (PBuiltinPair (PAsData k) (PAsData v))
 -> Term s' (PMaybe (PAsData v)))
-> Term
     s' (PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe (PAsData v))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PMaybe (PAsData v)))
-> Term s' (c :--> PMaybe (PAsData v))
plam ((Term s' (PBuiltinPair (PAsData k) (PAsData v))
  -> Term s' (PMaybe (PAsData v)))
 -> Term
      s' (PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe (PAsData v)))
-> (Term s' (PBuiltinPair (PAsData k) (PAsData v))
    -> Term s' (PMaybe (PAsData v)))
-> Term
     s' (PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe (PAsData v))
forall a b. (a -> b) -> a -> b
$ \Term s' (PBuiltinPair (PAsData k) (PAsData v))
pair -> Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> (PBuiltinPair (PAsData k) (PAsData v) s'
    -> Term s' (PMaybe (PAsData v)))
-> Term s' (PMaybe (PAsData v))
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' (PBuiltinPair (PAsData k) (PAsData v))
pair ((PBuiltinPair (PAsData k) (PAsData v) s'
  -> Term s' (PMaybe (PAsData v)))
 -> Term s' (PMaybe (PAsData v)))
-> (PBuiltinPair (PAsData k) (PAsData v) s'
    -> Term s' (PMaybe (PAsData v)))
-> Term s' (PMaybe (PAsData v))
forall a b. (a -> b) -> a -> b
$ \(PBuiltinPair Term s' (PAsData k)
_ Term s' (PAsData v)
y) -> PMaybe (PAsData v) s' -> Term s' (PMaybe (PAsData v))
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon (PMaybe (PAsData v) s' -> Term s' (PMaybe (PAsData v)))
-> PMaybe (PAsData v) s' -> Term s' (PMaybe (PAsData v))
forall a b. (a -> b) -> a -> b
$ Term s' (PAsData v) -> PMaybe (PAsData v) s'
forall (a :: S -> Type) (s :: S). Term s a -> PMaybe a s
PJust Term s' (PAsData v)
y)

{- | Look up the given key data in a 'PSortedMap', applying the given function
to the found key-value pair.

@since 3.6.0
-}
plookupDataWith ::
  forall (k :: S -> Type) (v :: S -> Type) (x :: S -> Type) (s :: S).
  Term
    s
    ( (PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe x)
        :--> PAsData k
        :--> PSortedMap k v
        :--> PMaybe x
    )
plookupDataWith :: forall (k :: S -> Type) (v :: S -> Type) (x :: S -> Type) (s :: S).
Term
  s
  ((PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe x)
   :--> (PAsData k :--> (PSortedMap k v :--> PMaybe x)))
plookupDataWith = (forall (s' :: S).
 Term
   s'
   ((PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe x)
    :--> (PAsData k :--> (PSortedMap k v :--> PMaybe x))))
-> Term
     s
     ((PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe x)
      :--> (PAsData k :--> (PSortedMap k v :--> PMaybe x)))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term
    s'
    ((PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe x)
     :--> (PAsData k :--> (PSortedMap k v :--> PMaybe x))))
 -> Term
      s
      ((PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe x)
       :--> (PAsData k :--> (PSortedMap k v :--> PMaybe x))))
-> (forall (s' :: S).
    Term
      s'
      ((PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe x)
       :--> (PAsData k :--> (PSortedMap k v :--> PMaybe x))))
-> Term
     s
     ((PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe x)
      :--> (PAsData k :--> (PSortedMap k v :--> PMaybe x)))
forall a b. (a -> b) -> a -> b
$
  (Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe x)
 -> Term s' (PAsData k)
 -> Term s' (PSortedMap k v)
 -> Term s' (PMaybe x))
-> Term
     s'
     ((PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe x)
      :--> (PAsData k :--> (PSortedMap k v :--> PMaybe x)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c
 -> Term s' (PAsData k)
 -> Term s' (PSortedMap k v)
 -> Term s' (PMaybe x))
-> Term s' (c :--> (PAsData k :--> (PSortedMap k v :--> PMaybe x)))
plam ((Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe x)
  -> Term s' (PAsData k)
  -> Term s' (PSortedMap k v)
  -> Term s' (PMaybe x))
 -> Term
      s'
      ((PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe x)
       :--> (PAsData k :--> (PSortedMap k v :--> PMaybe x))))
-> (Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe x)
    -> Term s' (PAsData k)
    -> Term s' (PSortedMap k v)
    -> Term s' (PMaybe x))
-> Term
     s'
     ((PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe x)
      :--> (PAsData k :--> (PSortedMap k v :--> PMaybe x)))
forall a b. (a -> b) -> a -> b
$ \Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe x)
unwrap Term s' (PAsData k)
key Term s' (PSortedMap k v)
m ->
    (Term
   s'
   (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> PMaybe x)
 -> Term s' (PBuiltinPair (PAsData k) (PAsData v))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term s' (PMaybe x))
-> (Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> PMaybe x)
    -> Term s' (PMaybe x))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> PMaybe x)
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S)
       (r :: S -> Type).
PIsListLike list a =>
(Term s (list a :--> r) -> Term s a -> Term s (list a) -> Term s r)
-> (Term s (list a :--> r) -> Term s r) -> Term s (list a :--> r)
precList
      ( \Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> PMaybe x)
self Term s' (PBuiltinPair (PAsData k) (PAsData v))
x Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
xs ->
          Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> (PBuiltinPair (PAsData k) (PAsData v) s' -> Term s' (PMaybe x))
-> Term s' (PMaybe x)
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' (PBuiltinPair (PAsData k) (PAsData v))
x ((PBuiltinPair (PAsData k) (PAsData v) s' -> Term s' (PMaybe x))
 -> Term s' (PMaybe x))
-> (PBuiltinPair (PAsData k) (PAsData v) s' -> Term s' (PMaybe x))
-> Term s' (PMaybe x)
forall a b. (a -> b) -> a -> b
$ \(PBuiltinPair Term s' (PAsData k)
y Term s' (PAsData v)
_) ->
            Term s' PBool
-> Term s' (PMaybe x) -> Term s' (PMaybe x) -> Term s' (PMaybe x)
forall (a :: S -> Type) (s :: S).
Term s PBool -> Term s a -> Term s a -> Term s a
pif
              (Term s' (PAsData k)
y Term s' (PAsData k) -> Term s' (PAsData k) -> Term s' PBool
forall (s :: S).
Term s (PAsData k) -> Term s (PAsData k) -> Term s PBool
forall (t :: S -> Type) (s :: S).
PEq t =>
Term s t -> Term s t -> Term s PBool
#== Term s' (PAsData k)
key)
              (Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe x)
unwrap Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> PMaybe x)
-> Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> Term s' (PMaybe x)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinPair (PAsData k) (PAsData v))
x)
              (Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> PMaybe x)
self Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> PMaybe x)
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PMaybe x)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
xs)
      )
      (Term s' (PMaybe x)
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> PMaybe x)
-> Term s' (PMaybe x)
forall a b. a -> b -> a
const (Term s' (PMaybe x)
 -> Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> PMaybe x)
 -> Term s' (PMaybe x))
-> Term s' (PMaybe x)
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> PMaybe x)
-> Term s' (PMaybe x)
forall a b. (a -> b) -> a -> b
$ PMaybe x s' -> Term s' (PMaybe x)
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon PMaybe x s'
forall (a :: S -> Type) (s :: S). PMaybe a s
PNothing)
      # pto (pto m)

{- | Look up the given key in a 'PSortedMap', returning the default value
if the key is absent.

@since 3.6.0
-}
pfindWithDefault ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  ( PIsData k
  , PIsData v
  ) =>
  Term s (v :--> k :--> PSortedMap k v :--> v)
pfindWithDefault :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PIsData k, PIsData v) =>
Term s (v :--> (k :--> (PSortedMap k v :--> v)))
pfindWithDefault =
  (forall (s' :: S).
 Term s' (v :--> (k :--> (PSortedMap k v :--> v))))
-> Term s (v :--> (k :--> (PSortedMap k v :--> v)))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term s' (v :--> (k :--> (PSortedMap k v :--> v))))
 -> Term s (v :--> (k :--> (PSortedMap k v :--> v))))
-> (forall (s' :: S).
    Term s' (v :--> (k :--> (PSortedMap k v :--> v))))
-> Term s (v :--> (k :--> (PSortedMap k v :--> v)))
forall a b. (a -> b) -> a -> b
$
    (Term s' v -> Term s' k -> Term s' (PSortedMap k v :--> v))
-> Term s' (v :--> (k :--> (PSortedMap k v :--> v)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' k -> Term s' (PSortedMap k v :--> v))
-> Term s' (c :--> (k :--> (PSortedMap k v :--> v)))
plam ((Term s' v -> Term s' k -> Term s' (PSortedMap k v :--> v))
 -> Term s' (v :--> (k :--> (PSortedMap k v :--> v))))
-> (Term s' v -> Term s' k -> Term s' (PSortedMap k v :--> v))
-> Term s' (v :--> (k :--> (PSortedMap k v :--> v)))
forall a b. (a -> b) -> a -> b
$ \Term s' v
def Term s' k
key ->
      Term
  s'
  (PAsData k
   :--> (v :--> ((PAsData v :--> v) :--> (PSortedMap k v :--> v))))
forall (k :: S -> Type) (v :: S -> Type) (r :: S -> Type) (s :: S).
Term
  s
  (PAsData k
   :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r))))
pfoldAtData Term
  s'
  (PAsData k
   :--> (v :--> ((PAsData v :--> v) :--> (PSortedMap k v :--> v))))
-> Term s' (PAsData k)
-> Term
     s' (v :--> ((PAsData v :--> v) :--> (PSortedMap k v :--> v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' k -> Term s' (PAsData k)
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s a -> Term s (PAsData a)
pdata Term s' k
key Term s' (v :--> ((PAsData v :--> v) :--> (PSortedMap k v :--> v)))
-> Term s' v
-> Term s' ((PAsData v :--> v) :--> (PSortedMap k v :--> v))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' v
def Term s' ((PAsData v :--> v) :--> (PSortedMap k v :--> v))
-> Term s' (PAsData v :--> v) -> Term s' (PSortedMap k v :--> v)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# (Term s' (PAsData v) -> Term s' v) -> Term s' (PAsData v :--> v)
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' v) -> Term s' (c :--> v)
plam Term s' (PAsData v) -> Term s' v
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData

{- | Look up the given key in a 'PSortedMap'; return the default if the key is
absent or apply the argument function to the value data if present.

@since 3.6.0
-}
pfoldAt ::
  forall (k :: S -> Type) (v :: S -> Type) (r :: S -> Type) (s :: S).
  PIsData k =>
  Term s (k :--> r :--> (PAsData v :--> r) :--> PSortedMap k v :--> r)
pfoldAt :: forall (k :: S -> Type) (v :: S -> Type) (r :: S -> Type) (s :: S).
PIsData k =>
Term
  s
  (k :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r))))
pfoldAt = (forall (s' :: S).
 Term
   s'
   (k
    :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r)))))
-> Term
     s
     (k :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r))))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term
    s'
    (k
     :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r)))))
 -> Term
      s
      (k
       :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r)))))
-> (forall (s' :: S).
    Term
      s'
      (k
       :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r)))))
-> Term
     s
     (k :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r))))
forall a b. (a -> b) -> a -> b
$
  (Term s' k
 -> Term
      s' (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r))))
-> Term
     s'
     (k :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r))))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c
 -> Term
      s' (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r))))
-> Term
     s'
     (c :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r))))
plam ((Term s' k
  -> Term
       s' (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r))))
 -> Term
      s'
      (k
       :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r)))))
-> (Term s' k
    -> Term
         s' (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r))))
-> Term
     s'
     (k :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r))))
forall a b. (a -> b) -> a -> b
$
    \Term s' k
key -> Term
  s'
  (PAsData k
   :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r))))
forall (k :: S -> Type) (v :: S -> Type) (r :: S -> Type) (s :: S).
Term
  s
  (PAsData k
   :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r))))
pfoldAtData Term
  s'
  (PAsData k
   :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r))))
-> Term s' (PAsData k)
-> Term
     s' (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' k -> Term s' (PAsData k)
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s a -> Term s (PAsData a)
pdata Term s' k
key

{- | Look up the given key data in a 'PSortedMap'; return the default if the key
is absent or apply the argument function to the value data if present.

@since 3.6.0
-}
pfoldAtData ::
  forall (k :: S -> Type) (v :: S -> Type) (r :: S -> Type) (s :: S).
  Term s (PAsData k :--> r :--> (PAsData v :--> r) :--> PSortedMap k v :--> r)
pfoldAtData :: forall (k :: S -> Type) (v :: S -> Type) (r :: S -> Type) (s :: S).
Term
  s
  (PAsData k
   :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r))))
pfoldAtData = (forall (s' :: S).
 Term
   s'
   (PAsData k
    :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r)))))
-> Term
     s
     (PAsData k
      :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r))))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term
    s'
    (PAsData k
     :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r)))))
 -> Term
      s
      (PAsData k
       :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r)))))
-> (forall (s' :: S).
    Term
      s'
      (PAsData k
       :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r)))))
-> Term
     s
     (PAsData k
      :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r))))
forall a b. (a -> b) -> a -> b
$
  (Term s' (PAsData k)
 -> Term s' r
 -> Term s' (PAsData v :--> r)
 -> Term s' (PSortedMap k v)
 -> Term s' r)
-> Term
     s'
     (PAsData k
      :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r))))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c
 -> Term s' r
 -> Term s' (PAsData v :--> r)
 -> Term s' (PSortedMap k v)
 -> Term s' r)
-> Term
     s'
     (c :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r))))
plam ((Term s' (PAsData k)
  -> Term s' r
  -> Term s' (PAsData v :--> r)
  -> Term s' (PSortedMap k v)
  -> Term s' r)
 -> Term
      s'
      (PAsData k
       :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r)))))
-> (Term s' (PAsData k)
    -> Term s' r
    -> Term s' (PAsData v :--> r)
    -> Term s' (PSortedMap k v)
    -> Term s' r)
-> Term
     s'
     (PAsData k
      :--> (r :--> ((PAsData v :--> r) :--> (PSortedMap k v :--> r))))
forall a b. (a -> b) -> a -> b
$ \Term s' (PAsData k)
key Term s' r
def Term s' (PAsData v :--> r)
apply Term s' (PSortedMap k v)
m ->
    (Term
   s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> r)
 -> Term s' (PBuiltinPair (PAsData k) (PAsData v))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term s' r)
-> (Term
      s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> r)
    -> Term s' r)
-> Term
     s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> r)
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S)
       (r :: S -> Type).
PIsListLike list a =>
(Term s (list a :--> r) -> Term s a -> Term s (list a) -> Term s r)
-> (Term s (list a :--> r) -> Term s r) -> Term s (list a :--> r)
precList
      ( \Term
  s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> r)
self Term s' (PBuiltinPair (PAsData k) (PAsData v))
x Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
xs ->
          Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> (PBuiltinPair (PAsData k) (PAsData v) s' -> Term s' r)
-> Term s' r
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' (PBuiltinPair (PAsData k) (PAsData v))
x ((PBuiltinPair (PAsData k) (PAsData v) s' -> Term s' r)
 -> Term s' r)
-> (PBuiltinPair (PAsData k) (PAsData v) s' -> Term s' r)
-> Term s' r
forall a b. (a -> b) -> a -> b
$ \(PBuiltinPair Term s' (PAsData k)
y Term s' (PAsData v)
z) ->
            Term s' PBool -> Term s' r -> Term s' r -> Term s' r
forall (a :: S -> Type) (s :: S).
Term s PBool -> Term s a -> Term s a -> Term s a
pif
              (Term s' (PAsData k)
y Term s' (PAsData k) -> Term s' (PAsData k) -> Term s' PBool
forall (s :: S).
Term s (PAsData k) -> Term s (PAsData k) -> Term s PBool
forall (t :: S -> Type) (s :: S).
PEq t =>
Term s t -> Term s t -> Term s PBool
#== Term s' (PAsData k)
key)
              (Term s' (PAsData v :--> r)
apply Term s' (PAsData v :--> r) -> Term s' (PAsData v) -> Term s' r
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAsData v)
z)
              (Term
  s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> r)
self Term
  s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> r)
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' r
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
xs)
      )
      (Term s' r
-> Term
     s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> r)
-> Term s' r
forall a b. a -> b -> a
const Term s' r
def)
      # pto (pto m)

{- | As 'plookup', but errors when the key is missing.

@since 3.6.0
-}
ptryLookup ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  ( PIsData k
  , PIsData v
  ) =>
  Term s (k :--> PSortedMap k v :--> v)
ptryLookup :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PIsData k, PIsData v) =>
Term s (k :--> (PSortedMap k v :--> v))
ptryLookup = (forall (s' :: S). Term s' (k :--> (PSortedMap k v :--> v)))
-> Term s (k :--> (PSortedMap k v :--> v))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S). Term s' (k :--> (PSortedMap k v :--> v)))
 -> Term s (k :--> (PSortedMap k v :--> v)))
-> (forall (s' :: S). Term s' (k :--> (PSortedMap k v :--> v)))
-> Term s (k :--> (PSortedMap k v :--> v))
forall a b. (a -> b) -> a -> b
$
  (Term s' k -> Term s' (PSortedMap k v) -> Term s' v)
-> Term s' (k :--> (PSortedMap k v :--> v))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PSortedMap k v) -> Term s' v)
-> Term s' (c :--> (PSortedMap k v :--> v))
plam ((Term s' k -> Term s' (PSortedMap k v) -> Term s' v)
 -> Term s' (k :--> (PSortedMap k v :--> v)))
-> (Term s' k -> Term s' (PSortedMap k v) -> Term s' v)
-> Term s' (k :--> (PSortedMap k v :--> v))
forall a b. (a -> b) -> a -> b
$ \Term s' k
k Term s' (PSortedMap k v)
kvs ->
    Term s' (PString :--> (PMaybe v :--> v))
forall (a :: S -> Type) (s :: S).
Term s (PString :--> (PMaybe a :--> a))
passertPJust
      # "plookupPartial: No value found for key."
      # (plookup # k # kvs)

----------------------------------------------------------------------
-- Modification

{- | Insert a new key/value pair into the map, overriding the previous if any.

@since 2.1.1
-}
pinsert ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  ( POrd k
  , PIsData k
  , PIsData v
  ) =>
  Term s (k :--> v :--> PSortedMap k v :--> PSortedMap k v)
pinsert :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(POrd k, PIsData k, PIsData v) =>
Term s (k :--> (v :--> (PSortedMap k v :--> PSortedMap k v)))
pinsert = (forall (s' :: S).
 Term s' (k :--> (v :--> (PSortedMap k v :--> PSortedMap k v))))
-> Term s (k :--> (v :--> (PSortedMap k v :--> PSortedMap k v)))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term s' (k :--> (v :--> (PSortedMap k v :--> PSortedMap k v))))
 -> Term s (k :--> (v :--> (PSortedMap k v :--> PSortedMap k v))))
-> (forall (s' :: S).
    Term s' (k :--> (v :--> (PSortedMap k v :--> PSortedMap k v))))
-> Term s (k :--> (v :--> (PSortedMap k v :--> PSortedMap k v)))
forall a b. (a -> b) -> a -> b
$
  (Term s' k
 -> Term s' v -> Term s' (PSortedMap k v :--> PSortedMap k v))
-> Term s' (k :--> (v :--> (PSortedMap k v :--> PSortedMap k v)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c
 -> Term s' v -> Term s' (PSortedMap k v :--> PSortedMap k v))
-> Term s' (c :--> (v :--> (PSortedMap k v :--> PSortedMap k v)))
plam ((Term s' k
  -> Term s' v -> Term s' (PSortedMap k v :--> PSortedMap k v))
 -> Term s' (k :--> (v :--> (PSortedMap k v :--> PSortedMap k v))))
-> (Term s' k
    -> Term s' v -> Term s' (PSortedMap k v :--> PSortedMap k v))
-> Term s' (k :--> (v :--> (PSortedMap k v :--> PSortedMap k v)))
forall a b. (a -> b) -> a -> b
$ \Term s' k
key Term s' v
val ->
    Term
  s'
  ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
    :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
   :--> (k :--> (PSortedMap k v :--> PSortedMap k v)))
forall (t :: (S -> Type) -> (S -> Type) -> S -> Type)
       (k :: S -> Type) (v :: S -> Type) (s :: S).
(PInner (t k v) ~ PAssocMap k v, POrd k, PIsData k) =>
Term
  s
  ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
    :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
   :--> (k :--> (t k v :--> t k v)))
rebuildAtKey Term
  s'
  ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
    :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
   :--> (k :--> (PSortedMap k v :--> PSortedMap k v)))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (k :--> (PSortedMap k v :--> PSortedMap k v))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> Term
     s' (c :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
plam (Term
  s'
  (PBuiltinPair (PAsData k) (PAsData v)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
forall (a :: S -> Type) (s :: S).
PElemConstraint PBuiltinList a =>
Term s (a :--> (PBuiltinList a :--> PBuiltinList a))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
(PListLike list, PElemConstraint list a) =>
Term s (a :--> (list a :--> list a))
pcons Term
  s'
  (PBuiltinPair (PAsData k) (PAsData v)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# (Term
  s'
  (PAsData k
   :--> (PAsData v :--> PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term
  s
  (PAsData a
   :--> (PAsData b :--> PBuiltinPair (PAsData a) (PAsData b)))
ppairDataBuiltin Term
  s'
  (PAsData k
   :--> (PAsData v :--> PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PAsData k)
-> Term s' (PAsData v :--> PBuiltinPair (PAsData k) (PAsData v))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' k -> Term s' (PAsData k)
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s a -> Term s (PAsData a)
pdata Term s' k
key Term s' (PAsData v :--> PBuiltinPair (PAsData k) (PAsData v))
-> Term s' (PAsData v)
-> Term s' (PBuiltinPair (PAsData k) (PAsData v))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' v -> Term s' (PAsData v)
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s a -> Term s (PAsData a)
pdata Term s' v
val) Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
#) Term s' (k :--> (PSortedMap k v :--> PSortedMap k v))
-> Term s' k -> Term s' (PSortedMap k v :--> PSortedMap k v)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' k
key

{- | Delete a key from the map.

@since 2.1.1
-}
pdelete ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  ( POrd k
  , PIsData k
  ) =>
  Term s (k :--> PSortedMap k v :--> PSortedMap k v)
pdelete :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(POrd k, PIsData k) =>
Term s (k :--> (PSortedMap k v :--> PSortedMap k v))
pdelete = Term
  s
  ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
    :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
   :--> (k :--> (PSortedMap k v :--> PSortedMap k v)))
forall (t :: (S -> Type) -> (S -> Type) -> S -> Type)
       (k :: S -> Type) (v :: S -> Type) (s :: S).
(PInner (t k v) ~ PAssocMap k v, POrd k, PIsData k) =>
Term
  s
  ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
    :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
   :--> (k :--> (t k v :--> t k v)))
rebuildAtKey Term
  s
  ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
    :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
   :--> (k :--> (PSortedMap k v :--> PSortedMap k v)))
-> Term
     s
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s (k :--> (PSortedMap k v :--> PSortedMap k v))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# (Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> Term
     s
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s c
 -> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> Term
     s (c :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
plam Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall a. a -> a
id

{- | Given an \'updater\' and a key, if the key exists in the 'PMap', apply the
 \'updater\' to it, otherwise do nothing. If the \'updater\' produces
 'PNothing', the value is deleted; otherwise, it is modified to the result.

 Performance will be equivalent to a lookup followed by an insert (or delete),
 as well as the cost of calling the \'updater\'.

 @since 2.1.1
-}
pupdate ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  ( PIsData k
  , PIsData v
  , POrd k
  ) =>
  Term s ((v :--> PMaybe v) :--> k :--> PSortedMap k v :--> PSortedMap k v)
pupdate :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PIsData k, PIsData v, POrd k) =>
Term
  s
  ((v :--> PMaybe v)
   :--> (k :--> (PSortedMap k v :--> PSortedMap k v)))
pupdate = (forall (s' :: S).
 Term
   s'
   ((v :--> PMaybe v)
    :--> (k :--> (PSortedMap k v :--> PSortedMap k v))))
-> Term
     s
     ((v :--> PMaybe v)
      :--> (k :--> (PSortedMap k v :--> PSortedMap k v)))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term
    s'
    ((v :--> PMaybe v)
     :--> (k :--> (PSortedMap k v :--> PSortedMap k v))))
 -> Term
      s
      ((v :--> PMaybe v)
       :--> (k :--> (PSortedMap k v :--> PSortedMap k v))))
-> (forall (s' :: S).
    Term
      s'
      ((v :--> PMaybe v)
       :--> (k :--> (PSortedMap k v :--> PSortedMap k v))))
-> Term
     s
     ((v :--> PMaybe v)
      :--> (k :--> (PSortedMap k v :--> PSortedMap k v)))
forall a b. (a -> b) -> a -> b
$
  (Term s' (v :--> PMaybe v)
 -> Term s' k
 -> Term s' (PSortedMap k v)
 -> Term s' (PSortedMap k v))
-> Term
     s'
     ((v :--> PMaybe v)
      :--> (k :--> (PSortedMap k v :--> PSortedMap k v)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c
 -> Term s' k
 -> Term s' (PSortedMap k v)
 -> Term s' (PSortedMap k v))
-> Term s' (c :--> (k :--> (PSortedMap k v :--> PSortedMap k v)))
plam ((Term s' (v :--> PMaybe v)
  -> Term s' k
  -> Term s' (PSortedMap k v)
  -> Term s' (PSortedMap k v))
 -> Term
      s'
      ((v :--> PMaybe v)
       :--> (k :--> (PSortedMap k v :--> PSortedMap k v))))
-> (Term s' (v :--> PMaybe v)
    -> Term s' k
    -> Term s' (PSortedMap k v)
    -> Term s' (PSortedMap k v))
-> Term
     s'
     ((v :--> PMaybe v)
      :--> (k :--> (PSortedMap k v :--> PSortedMap k v)))
forall a b. (a -> b) -> a -> b
$ \Term s' (v :--> PMaybe v)
updater Term s' k
key Term s' (PSortedMap k v)
kvs -> Term s' (PSortedMap k v)
-> (PSortedMap k v s' -> Term s' (PSortedMap k v))
-> Term s' (PSortedMap k v)
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' (PSortedMap k v)
kvs ((PSortedMap k v s' -> Term s' (PSortedMap k v))
 -> Term s' (PSortedMap k v))
-> (PSortedMap k v s' -> Term s' (PSortedMap k v))
-> Term s' (PSortedMap k v)
forall a b. (a -> b) -> a -> b
$ \(PSortedMap Term s' (PAssocMap k v)
kvs') ->
    PSortedMap k v s' -> Term s' (PSortedMap k v)
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon (PSortedMap k v s' -> Term s' (PSortedMap k v))
-> (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
    -> PSortedMap k v s')
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PSortedMap k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' (PAssocMap k v) -> PSortedMap k v s'
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Term s (PAssocMap k v) -> PSortedMap k v s
PSortedMap (Term s' (PAssocMap k v) -> PSortedMap k v s')
-> (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
    -> Term s' (PAssocMap k v))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> PSortedMap k v s'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PAssocMap k v s' -> Term s' (PAssocMap k v)
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon (PAssocMap k v s' -> Term s' (PAssocMap k v))
-> (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
    -> PAssocMap k v s')
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PAssocMap k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> PAssocMap k v s'
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Term s (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> PAssocMap k v s
PAssocMap (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term s' (PSortedMap k v))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PSortedMap k v)
forall a b. (a -> b) -> a -> b
$
      ( (Term
   s'
   (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
    :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term s' (PBuiltinPair (PAsData k) (PAsData v))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> (Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S)
       (r :: S -> Type).
PIsListLike list a =>
(Term s (list a :--> r) -> Term s a -> Term s (list a) -> Term s r)
-> (Term s (list a :--> r) -> Term s r) -> Term s (list a :--> r)
precList
          ( \Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
self Term s' (PBuiltinPair (PAsData k) (PAsData v))
x Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
xs ->
              Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> (PBuiltinPair (PAsData k) (PAsData v) s'
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' (PBuiltinPair (PAsData k) (PAsData v))
x ((PBuiltinPair (PAsData k) (PAsData v) s'
  -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> (PBuiltinPair (PAsData k) (PAsData v) s'
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall a b. (a -> b) -> a -> b
$ \(PBuiltinPair Term s' (PAsData k)
k' Term s' (PAsData v)
z) ->
                Term s' k
-> (Term s' k
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s a -> (Term s a -> Term s b) -> Term s b
plet (Term s' (PAsData k) -> Term s' k
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData Term s' (PAsData k)
k') ((Term s' k
  -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> (Term s' k
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall a b. (a -> b) -> a -> b
$ \Term s' k
k ->
                  Term s' PBool
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (a :: S -> Type) (s :: S).
Term s PBool -> Term s a -> Term s a -> Term s a
pif
                    (Term s' k
k Term s' k -> Term s' k -> Term s' PBool
forall (s :: S). Term s k -> Term s k -> Term s PBool
forall (t :: S -> Type) (s :: S).
PEq t =>
Term s t -> Term s t -> Term s PBool
#== Term s' k
key)
                    ( Term s' (PMaybe v)
-> (PMaybe v s'
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term s' (v :--> PMaybe v)
updater Term s' (v :--> PMaybe v) -> Term s' v -> Term s' (PMaybe v)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAsData v) -> Term s' v
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData Term s' (PAsData v)
z) ((PMaybe v s'
  -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> (PMaybe v s'
    -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall a b. (a -> b) -> a -> b
$ \case
                        PMaybe v s'
PNothing -> Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
self Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
xs
                        PJust Term s' v
v -> Term
  s'
  (PBuiltinPair (PAsData k) (PAsData v)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
forall (a :: S -> Type) (s :: S).
PElemConstraint PBuiltinList a =>
Term s (a :--> (PBuiltinList a :--> PBuiltinList a))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
(PListLike list, PElemConstraint list a) =>
Term s (a :--> (list a :--> list a))
pcons Term
  s'
  (PBuiltinPair (PAsData k) (PAsData v)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# (Term
  s'
  (PAsData k
   :--> (PAsData v :--> PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term
  s
  (PAsData a
   :--> (PAsData b :--> PBuiltinPair (PAsData a) (PAsData b)))
ppairDataBuiltin Term
  s'
  (PAsData k
   :--> (PAsData v :--> PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PAsData k)
-> Term s' (PAsData v :--> PBuiltinPair (PAsData k) (PAsData v))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' k -> Term s' (PAsData k)
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s a -> Term s (PAsData a)
pdata Term s' k
k Term s' (PAsData v :--> PBuiltinPair (PAsData k) (PAsData v))
-> Term s' (PAsData v)
-> Term s' (PBuiltinPair (PAsData k) (PAsData v))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' v -> Term s' (PAsData v)
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s a -> Term s (PAsData a)
pdata Term s' v
v) Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
#$ Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
self Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
xs
                    )
                    (Term s' PBool
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (a :: S -> Type) (s :: S).
Term s PBool -> Term s a -> Term s a -> Term s a
pif (Term s' k
key Term s' k -> Term s' k -> Term s' PBool
forall (s :: S). Term s k -> Term s k -> Term s PBool
forall (t :: S -> Type) (s :: S).
POrd t =>
Term s t -> Term s t -> Term s PBool
#<= Term s' k
k) (Term
  s'
  (PBuiltinPair (PAsData k) (PAsData v)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
forall (a :: S -> Type) (s :: S).
PElemConstraint PBuiltinList a =>
Term s (a :--> (PBuiltinList a :--> PBuiltinList a))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
(PListLike list, PElemConstraint list a) =>
Term s (a :--> (list a :--> list a))
pcons Term
  s'
  (PBuiltinPair (PAsData k) (PAsData v)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinPair (PAsData k) (PAsData v))
x Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
xs) (Term
  s'
  (PBuiltinPair (PAsData k) (PAsData v)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
forall (a :: S -> Type) (s :: S).
PElemConstraint PBuiltinList a =>
Term s (a :--> (PBuiltinList a :--> PBuiltinList a))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
(PListLike list, PElemConstraint list a) =>
Term s (a :--> (list a :--> list a))
pcons Term
  s'
  (PBuiltinPair (PAsData k) (PAsData v)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinPair (PAsData k) (PAsData v))
x Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
#$ Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
self Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
xs))
          )
          (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall a b. a -> b -> a
const Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (a :: S -> Type) (s :: S).
PElemConstraint PBuiltinList a =>
Term s (PBuiltinList a)
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
(PListLike list, PElemConstraint list a) =>
Term s (list a)
pnil)
          # pto kvs'
      )

{- | If a value exists at the specified key, apply the function argument to it;
 otherwise, do nothing.

 @since 2.1.1
-}
padjust ::
  forall
    (t :: (S -> Type) -> (S -> Type) -> S -> Type)
    (k :: S -> Type)
    (v :: S -> Type)
    (s :: S).
  ( PInner (t k v) ~ PAssocMap k v
  , PIsData k
  , PEq k
  , PIsData v
  ) =>
  Term s ((v :--> v) :--> k :--> t k v :--> t k v)
padjust :: forall (t :: (S -> Type) -> (S -> Type) -> S -> Type)
       (k :: S -> Type) (v :: S -> Type) (s :: S).
(PInner (t k v) ~ PAssocMap k v, PIsData k, PEq k, PIsData v) =>
Term s ((v :--> v) :--> (k :--> (t k v :--> t k v)))
padjust = (forall (s' :: S).
 Term s' ((v :--> v) :--> (k :--> (t k v :--> t k v))))
-> Term s ((v :--> v) :--> (k :--> (t k v :--> t k v)))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term s' ((v :--> v) :--> (k :--> (t k v :--> t k v))))
 -> Term s ((v :--> v) :--> (k :--> (t k v :--> t k v))))
-> (forall (s' :: S).
    Term s' ((v :--> v) :--> (k :--> (t k v :--> t k v))))
-> Term s ((v :--> v) :--> (k :--> (t k v :--> t k v)))
forall a b. (a -> b) -> a -> b
$
  (Term s' (v :--> v)
 -> Term s' k -> Term s' (t k v) -> Term s' (t k v))
-> Term s' ((v :--> v) :--> (k :--> (t k v :--> t k v)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' k -> Term s' (t k v) -> Term s' (t k v))
-> Term s' (c :--> (k :--> (t k v :--> t k v)))
plam ((Term s' (v :--> v)
  -> Term s' k -> Term s' (t k v) -> Term s' (t k v))
 -> Term s' ((v :--> v) :--> (k :--> (t k v :--> t k v))))
-> (Term s' (v :--> v)
    -> Term s' k -> Term s' (t k v) -> Term s' (t k v))
-> Term s' ((v :--> v) :--> (k :--> (t k v :--> t k v)))
forall a b. (a -> b) -> a -> b
$ \Term s' (v :--> v)
f Term s' k
key Term s' (t k v)
kvs ->
    Term s' ((k :--> (v :--> v)) :--> (t k v :--> t k v))
forall (t :: (S -> Type) -> (S -> Type) -> S -> Type)
       (k :: S -> Type) (a :: S -> Type) (b :: S -> Type) (s :: S).
(PInner (t k a) ~ PAssocMap k a, PInner (t k b) ~ PAssocMap k b,
 PIsData k, PIsData a, PIsData b) =>
Term s ((k :--> (a :--> b)) :--> (t k a :--> t k b))
pmapWithKey Term s' ((k :--> (v :--> v)) :--> (t k v :--> t k v))
-> Term s' (k :--> (v :--> v)) -> Term s' (t k v :--> t k v)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# (Term s' k -> Term s' v -> Term s' v)
-> Term s' (k :--> (v :--> v))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' v -> Term s' v)
-> Term s' (c :--> (v :--> v))
plam (\Term s' k
k' Term s' v
a -> Term s' PBool -> Term s' v -> Term s' v -> Term s' v
forall (a :: S -> Type) (s :: S).
Term s PBool -> Term s a -> Term s a -> Term s a
pif (Term s' k
k' Term s' k -> Term s' k -> Term s' PBool
forall (s :: S). Term s k -> Term s k -> Term s PBool
forall (t :: S -> Type) (s :: S).
PEq t =>
Term s t -> Term s t -> Term s PBool
#== Term s' k
key) (Term s' (v :--> v)
f Term s' (v :--> v) -> Term s' v -> Term s' v
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' v
a) Term s' v
a) Term s' (t k v :--> t k v) -> Term s' (t k v) -> Term s' (t k v)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (t k v)
kvs

----------------------------------------------------------------------
-- Key-value pair manipulation

{- | Get the key of a key-value pair.

@since 2.1.1
-}
pkvPairKey ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  PIsData k =>
  Term s (PBuiltinPair (PAsData k) (PAsData v) :--> k)
pkvPairKey :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PIsData k =>
Term s (PBuiltinPair (PAsData k) (PAsData v) :--> k)
pkvPairKey = (forall (s' :: S).
 Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> k))
-> Term s (PBuiltinPair (PAsData k) (PAsData v) :--> k)
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> k))
 -> Term s (PBuiltinPair (PAsData k) (PAsData v) :--> k))
-> (forall (s' :: S).
    Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> k))
-> Term s (PBuiltinPair (PAsData k) (PAsData v) :--> k)
forall a b. (a -> b) -> a -> b
$ (Term s' (PBuiltinPair (PAsData k) (PAsData v)) -> Term s' k)
-> Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> k)
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' k) -> Term s' (c :--> k)
plam ((Term s' (PBuiltinPair (PAsData k) (PAsData v)) -> Term s' k)
 -> Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> k))
-> (Term s' (PBuiltinPair (PAsData k) (PAsData v)) -> Term s' k)
-> Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> k)
forall a b. (a -> b) -> a -> b
$ \Term s' (PBuiltinPair (PAsData k) (PAsData v))
kv ->
  Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> (PBuiltinPair (PAsData k) (PAsData v) s' -> Term s' k)
-> Term s' k
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' (PBuiltinPair (PAsData k) (PAsData v))
kv ((PBuiltinPair (PAsData k) (PAsData v) s' -> Term s' k)
 -> Term s' k)
-> (PBuiltinPair (PAsData k) (PAsData v) s' -> Term s' k)
-> Term s' k
forall a b. (a -> b) -> a -> b
$ \(PBuiltinPair Term s' (PAsData k)
x Term s' (PAsData v)
_) ->
    Term s' (PAsData k) -> Term s' k
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData Term s' (PAsData k)
x

{- | Get the value of a key-value pair.

@since 2.1.1
-}
pkvPairValue ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  PIsData v =>
  Term s (PBuiltinPair (PAsData k) (PAsData v) :--> v)
pkvPairValue :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PIsData v =>
Term s (PBuiltinPair (PAsData k) (PAsData v) :--> v)
pkvPairValue = (forall (s' :: S).
 Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> v))
-> Term s (PBuiltinPair (PAsData k) (PAsData v) :--> v)
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> v))
 -> Term s (PBuiltinPair (PAsData k) (PAsData v) :--> v))
-> (forall (s' :: S).
    Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> v))
-> Term s (PBuiltinPair (PAsData k) (PAsData v) :--> v)
forall a b. (a -> b) -> a -> b
$ (Term s' (PBuiltinPair (PAsData k) (PAsData v)) -> Term s' v)
-> Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> v)
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' v) -> Term s' (c :--> v)
plam ((Term s' (PBuiltinPair (PAsData k) (PAsData v)) -> Term s' v)
 -> Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> v))
-> (Term s' (PBuiltinPair (PAsData k) (PAsData v)) -> Term s' v)
-> Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> v)
forall a b. (a -> b) -> a -> b
$ \Term s' (PBuiltinPair (PAsData k) (PAsData v))
kv ->
  Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> (PBuiltinPair (PAsData k) (PAsData v) s' -> Term s' v)
-> Term s' v
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' (PBuiltinPair (PAsData k) (PAsData v))
kv ((PBuiltinPair (PAsData k) (PAsData v) s' -> Term s' v)
 -> Term s' v)
-> (PBuiltinPair (PAsData k) (PAsData v) s' -> Term s' v)
-> Term s' v
forall a b. (a -> b) -> a -> b
$ \(PBuiltinPair Term s' (PAsData k)
_ Term s' (PAsData v)
y) ->
    Term s' (PAsData v) -> Term s' v
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData Term s' (PAsData v)
y

{- | Compare two key-value pairs by their keys. Gives 'PTrue' if the key of the
first argument pair is less than the key of the second argument pair.

@since 2.1.1
-}
pkvPairLt ::
  forall (k :: S -> Type) (v :: S -> Type) (s :: S).
  (PIsData k, POrd k) =>
  Term
    s
    ( PBuiltinPair (PAsData k) (PAsData v)
        :--> PBuiltinPair (PAsData k) (PAsData v)
        :--> PBool
    )
pkvPairLt :: forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PIsData k, POrd k) =>
Term
  s
  (PBuiltinPair (PAsData k) (PAsData v)
   :--> (PBuiltinPair (PAsData k) (PAsData v) :--> PBool))
pkvPairLt = (forall (s' :: S).
 Term
   s'
   (PBuiltinPair (PAsData k) (PAsData v)
    :--> (PBuiltinPair (PAsData k) (PAsData v) :--> PBool)))
-> Term
     s
     (PBuiltinPair (PAsData k) (PAsData v)
      :--> (PBuiltinPair (PAsData k) (PAsData v) :--> PBool))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term
    s'
    (PBuiltinPair (PAsData k) (PAsData v)
     :--> (PBuiltinPair (PAsData k) (PAsData v) :--> PBool)))
 -> Term
      s
      (PBuiltinPair (PAsData k) (PAsData v)
       :--> (PBuiltinPair (PAsData k) (PAsData v) :--> PBool)))
-> (forall (s' :: S).
    Term
      s'
      (PBuiltinPair (PAsData k) (PAsData v)
       :--> (PBuiltinPair (PAsData k) (PAsData v) :--> PBool)))
-> Term
     s
     (PBuiltinPair (PAsData k) (PAsData v)
      :--> (PBuiltinPair (PAsData k) (PAsData v) :--> PBool))
forall a b. (a -> b) -> a -> b
$
  (Term s' (PBuiltinPair (PAsData k) (PAsData v))
 -> Term s' (PBuiltinPair (PAsData k) (PAsData v)) -> Term s' PBool)
-> Term
     s'
     (PBuiltinPair (PAsData k) (PAsData v)
      :--> (PBuiltinPair (PAsData k) (PAsData v) :--> PBool))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c
 -> Term s' (PBuiltinPair (PAsData k) (PAsData v)) -> Term s' PBool)
-> Term
     s' (c :--> (PBuiltinPair (PAsData k) (PAsData v) :--> PBool))
plam ((Term s' (PBuiltinPair (PAsData k) (PAsData v))
  -> Term s' (PBuiltinPair (PAsData k) (PAsData v)) -> Term s' PBool)
 -> Term
      s'
      (PBuiltinPair (PAsData k) (PAsData v)
       :--> (PBuiltinPair (PAsData k) (PAsData v) :--> PBool)))
-> (Term s' (PBuiltinPair (PAsData k) (PAsData v))
    -> Term s' (PBuiltinPair (PAsData k) (PAsData v)) -> Term s' PBool)
-> Term
     s'
     (PBuiltinPair (PAsData k) (PAsData v)
      :--> (PBuiltinPair (PAsData k) (PAsData v) :--> PBool))
forall a b. (a -> b) -> a -> b
$ \Term s' (PBuiltinPair (PAsData k) (PAsData v))
kv Term s' (PBuiltinPair (PAsData k) (PAsData v))
kv' ->
    (Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> k)
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PIsData k =>
Term s (PBuiltinPair (PAsData k) (PAsData v) :--> k)
pkvPairKey Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> k)
-> Term s' (PBuiltinPair (PAsData k) (PAsData v)) -> Term s' k
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinPair (PAsData k) (PAsData v))
kv) Term s' k -> Term s' k -> Term s' PBool
forall (s :: S). Term s k -> Term s k -> Term s PBool
forall (t :: S -> Type) (s :: S).
POrd t =>
Term s t -> Term s t -> Term s PBool
#< (Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> k)
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
PIsData k =>
Term s (PBuiltinPair (PAsData k) (PAsData v) :--> k)
pkvPairKey Term s' (PBuiltinPair (PAsData k) (PAsData v) :--> k)
-> Term s' (PBuiltinPair (PAsData k) (PAsData v)) -> Term s' k
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinPair (PAsData k) (PAsData v))
kv')

----------------------------------------------------------------------
-- Conversion

{- | Extract the keys from the given 'PIsAssocMap' instance as a list-like
structure. If the provided Map is 'PSortedMap', the keys will maintain that
order, and will be unique; otherwise, the order is unspecified, and duplicates
may exist.

= Note

You will need to specify what manner of list-like structure you want; we have
arranged the type signature to make specifying this easy with
@TypeApplications@.

@since 2.1.1
-}
pkeys ::
  forall
    (ell :: (S -> Type) -> S -> Type)
    (t :: (S -> Type) -> (S -> Type) -> S -> Type)
    (k :: S -> Type)
    (v :: S -> Type)
    (s :: S).
  ( PInner (t k v) ~ PAssocMap k v
  , PListLike ell
  , PElemConstraint ell (PAsData k)
  ) =>
  Term s (t k v :--> ell (PAsData k))
pkeys :: forall (ell :: (S -> Type) -> S -> Type)
       (t :: (S -> Type) -> (S -> Type) -> S -> Type) (k :: S -> Type)
       (v :: S -> Type) (s :: S).
(PInner (t k v) ~ PAssocMap k v, PListLike ell,
 PElemConstraint ell (PAsData k)) =>
Term s (t k v :--> ell (PAsData k))
pkeys = (forall (s' :: S). Term s' (t k v :--> ell (PAsData k)))
-> Term s (t k v :--> ell (PAsData k))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S). Term s' (t k v :--> ell (PAsData k)))
 -> Term s (t k v :--> ell (PAsData k)))
-> (forall (s' :: S). Term s' (t k v :--> ell (PAsData k)))
-> Term s (t k v :--> ell (PAsData k))
forall a b. (a -> b) -> a -> b
$
  (Term s' (t k v) -> Term s' (ell (PAsData k)))
-> Term s' (t k v :--> ell (PAsData k))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (ell (PAsData k)))
-> Term s' (c :--> ell (PAsData k))
plam ((Term s' (t k v) -> Term s' (ell (PAsData k)))
 -> Term s' (t k v :--> ell (PAsData k)))
-> (Term s' (t k v) -> Term s' (ell (PAsData k)))
-> Term s' (t k v :--> ell (PAsData k))
forall a b. (a -> b) -> a -> b
$ \Term s' (t k v)
kvs ->
    (Term
   s'
   (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
    :--> ell (PAsData k))
 -> Term s' (PBuiltinPair (PAsData k) (PAsData v))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term s' (ell (PAsData k)))
-> (Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> ell (PAsData k))
    -> Term s' (ell (PAsData k)))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> ell (PAsData k))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S)
       (r :: S -> Type).
PIsListLike list a =>
(Term s (list a :--> r) -> Term s a -> Term s (list a) -> Term s r)
-> (Term s (list a :--> r) -> Term s r) -> Term s (list a :--> r)
precList Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> ell (PAsData k))
-> Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (ell (PAsData k))
forall (s' :: S).
Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> ell (PAsData k))
-> Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (ell (PAsData k))
go (Term s' (ell (PAsData k))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> ell (PAsData k))
-> Term s' (ell (PAsData k))
forall a b. a -> b -> a
const Term s' (ell (PAsData k))
forall (a :: S -> Type) (s :: S).
PElemConstraint ell a =>
Term s (ell a)
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
(PListLike list, PElemConstraint list a) =>
Term s (list a)
pnil) Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> ell (PAsData k))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (ell (PAsData k))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAssocMap k v) -> Term s' (PInner (PAssocMap k v))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto (Term s' (t k v) -> Term s' (PInner (t k v))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto Term s' (t k v)
kvs)
  where
    go ::
      forall (s' :: S).
      Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)) :--> ell (PAsData k)) ->
      Term s' (PBuiltinPair (PAsData k) (PAsData v)) ->
      Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))) ->
      Term s' (ell (PAsData k))
    go :: forall (s' :: S).
Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> ell (PAsData k))
-> Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (ell (PAsData k))
go Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> ell (PAsData k))
self Term s' (PBuiltinPair (PAsData k) (PAsData v))
kv Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
acc =
      Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> (PBuiltinPair (PAsData k) (PAsData v) s'
    -> Term s' (ell (PAsData k)))
-> Term s' (ell (PAsData k))
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' (PBuiltinPair (PAsData k) (PAsData v))
kv ((PBuiltinPair (PAsData k) (PAsData v) s'
  -> Term s' (ell (PAsData k)))
 -> Term s' (ell (PAsData k)))
-> (PBuiltinPair (PAsData k) (PAsData v) s'
    -> Term s' (ell (PAsData k)))
-> Term s' (ell (PAsData k))
forall a b. (a -> b) -> a -> b
$ \(PBuiltinPair Term s' (PAsData k)
x Term s' (PAsData v)
_) ->
        Term s' (PAsData k :--> (ell (PAsData k) :--> ell (PAsData k)))
forall (a :: S -> Type) (s :: S).
PElemConstraint ell a =>
Term s (a :--> (ell a :--> ell a))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
(PListLike list, PElemConstraint list a) =>
Term s (a :--> (list a :--> list a))
pcons Term s' (PAsData k :--> (ell (PAsData k) :--> ell (PAsData k)))
-> Term s' (PAsData k)
-> Term s' (ell (PAsData k) :--> ell (PAsData k))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAsData k)
x Term s' (ell (PAsData k) :--> ell (PAsData k))
-> Term s' (ell (PAsData k)) -> Term s' (ell (PAsData k))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# (Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> ell (PAsData k))
self Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> ell (PAsData k))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (ell (PAsData k))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
acc)

----------------------------------------------------------------------
-- Internal

-- | Rebuild the map at the given key.
rebuildAtKey ::
  forall
    (t :: (S -> Type) -> (S -> Type) -> S -> Type)
    (k :: S -> Type)
    (v :: S -> Type)
    (s :: S).
  ( PInner (t k v) ~ PAssocMap k v
  , POrd k
  , PIsData k
  ) =>
  Term
    s
    ( ( PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
          :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      )
        :--> k
        :--> t k v
        :--> t k v
    )
rebuildAtKey :: forall (t :: (S -> Type) -> (S -> Type) -> S -> Type)
       (k :: S -> Type) (v :: S -> Type) (s :: S).
(PInner (t k v) ~ PAssocMap k v, POrd k, PIsData k) =>
Term
  s
  ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
    :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
   :--> (k :--> (t k v :--> t k v)))
rebuildAtKey = (forall (s' :: S).
 Term
   s'
   ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
     :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
    :--> (k :--> (t k v :--> t k v))))
-> Term
     s
     ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
      :--> (k :--> (t k v :--> t k v)))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term
    s'
    ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
     :--> (k :--> (t k v :--> t k v))))
 -> Term
      s
      ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
        :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
       :--> (k :--> (t k v :--> t k v))))
-> (forall (s' :: S).
    Term
      s'
      ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
        :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
       :--> (k :--> (t k v :--> t k v))))
-> Term
     s
     ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
      :--> (k :--> (t k v :--> t k v)))
forall a b. (a -> b) -> a -> b
$
  (Term
   s'
   (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
    :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term s' k -> Term s' (t k v) -> Term s' (t k v))
-> Term
     s'
     ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
      :--> (k :--> (t k v :--> t k v)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' k -> Term s' (t k v) -> Term s' (t k v))
-> Term s' (c :--> (k :--> (t k v :--> t k v)))
plam ((Term
    s'
    (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
     :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
  -> Term s' k -> Term s' (t k v) -> Term s' (t k v))
 -> Term
      s'
      ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
        :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
       :--> (k :--> (t k v :--> t k v))))
-> (Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
    -> Term s' k -> Term s' (t k v) -> Term s' (t k v))
-> Term
     s'
     ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
      :--> (k :--> (t k v :--> t k v)))
forall a b. (a -> b) -> a -> b
$ \Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
handler Term s' k
key Term s' (t k v)
m ->
    Term s' (PInner (t k v)) -> Term s' (t k v)
forall (s :: S) (a :: S -> Type). Term s (PInner a) -> Term s a
punsafeDowncast (Term s' (PInner (t k v)) -> Term s' (t k v))
-> (Term s' (PInner (PInner (t k v))) -> Term s' (PInner (t k v)))
-> Term s' (PInner (PInner (t k v)))
-> Term s' (t k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' (PInner (PInner (t k v))) -> Term s' (PInner (t k v))
forall (s :: S) (a :: S -> Type). Term s (PInner a) -> Term s a
punsafeDowncast (Term s' (PInner (PInner (t k v))) -> Term s' (t k v))
-> Term s' (PInner (PInner (t k v))) -> Term s' (t k v)
forall a b. (a -> b) -> a -> b
$
      (Term
   s'
   (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
    :--> ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
           :--> PInner (PInner (t k v)))
          :--> PInner (PInner (t k v))))
 -> Term s' (PBuiltinPair (PAsData k) (PAsData v))
 -> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term
      s'
      ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
        :--> PInner (PInner (t k v)))
       :--> PInner (PInner (t k v))))
-> (Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
              :--> PInner (PInner (t k v)))
             :--> PInner (PInner (t k v))))
    -> Term
         s'
         ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
           :--> PInner (PInner (t k v)))
          :--> PInner (PInner (t k v))))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
             :--> PInner (PInner (t k v)))
            :--> PInner (PInner (t k v))))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S)
       (r :: S -> Type).
PIsListLike list a =>
(Term s (list a :--> r) -> Term s a -> Term s (list a) -> Term s r)
-> (Term s (list a :--> r) -> Term s r) -> Term s (list a :--> r)
precList
        ( \Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
          :--> PInner (PInner (t k v)))
         :--> PInner (PInner (t k v))))
self Term s' (PBuiltinPair (PAsData k) (PAsData v))
x Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
xs ->
            Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> (PBuiltinPair (PAsData k) (PAsData v) s'
    -> Term
         s'
         ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
           :--> PInner (PInner (t k v)))
          :--> PInner (PInner (t k v))))
-> Term
     s'
     ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> PInner (PInner (t k v)))
      :--> PInner (PInner (t k v)))
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' (PBuiltinPair (PAsData k) (PAsData v))
x ((PBuiltinPair (PAsData k) (PAsData v) s'
  -> Term
       s'
       ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PInner (PInner (t k v)))
        :--> PInner (PInner (t k v))))
 -> Term
      s'
      ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
        :--> PInner (PInner (t k v)))
       :--> PInner (PInner (t k v))))
-> (PBuiltinPair (PAsData k) (PAsData v) s'
    -> Term
         s'
         ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
           :--> PInner (PInner (t k v)))
          :--> PInner (PInner (t k v))))
-> Term
     s'
     ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> PInner (PInner (t k v)))
      :--> PInner (PInner (t k v)))
forall a b. (a -> b) -> a -> b
$ \(PBuiltinPair Term s' (PAsData k)
k' Term s' (PAsData v)
_) ->
              Term s' k
-> (Term s' k
    -> Term
         s'
         ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
           :--> PInner (PInner (t k v)))
          :--> PInner (PInner (t k v))))
-> Term
     s'
     ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> PInner (PInner (t k v)))
      :--> PInner (PInner (t k v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s a -> (Term s a -> Term s b) -> Term s b
plet (Term s' (PAsData k) -> Term s' k
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData Term s' (PAsData k)
k') ((Term s' k
  -> Term
       s'
       ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PInner (PInner (t k v)))
        :--> PInner (PInner (t k v))))
 -> Term
      s'
      ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
        :--> PInner (PInner (t k v)))
       :--> PInner (PInner (t k v))))
-> (Term s' k
    -> Term
         s'
         ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
           :--> PInner (PInner (t k v)))
          :--> PInner (PInner (t k v))))
-> Term
     s'
     ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> PInner (PInner (t k v)))
      :--> PInner (PInner (t k v)))
forall a b. (a -> b) -> a -> b
$ \Term s' k
k ->
                (Term
   s'
   (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
    :--> PInner (PInner (t k v)))
 -> Term s' (PInner (PInner (t k v))))
-> Term
     s'
     ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> PInner (PInner (t k v)))
      :--> PInner (PInner (t k v)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PInner (PInner (t k v))))
-> Term s' (c :--> PInner (PInner (t k v)))
plam ((Term
    s'
    (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
     :--> PInner (PInner (t k v)))
  -> Term s' (PInner (PInner (t k v))))
 -> Term
      s'
      ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
        :--> PInner (PInner (t k v)))
       :--> PInner (PInner (t k v))))
-> (Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> PInner (PInner (t k v)))
    -> Term s' (PInner (PInner (t k v))))
-> Term
     s'
     ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> PInner (PInner (t k v)))
      :--> PInner (PInner (t k v)))
forall a b. (a -> b) -> a -> b
$ \Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PInner (PInner (t k v)))
prefix ->
                  Term s' PBool
-> Term s' (PInner (PInner (t k v)))
-> Term s' (PInner (PInner (t k v)))
-> Term s' (PInner (PInner (t k v)))
forall (a :: S -> Type) (s :: S).
Term s PBool -> Term s a -> Term s a -> Term s a
pif
                    (Term s' k
k Term s' k -> Term s' k -> Term s' PBool
forall (s :: S). Term s k -> Term s k -> Term s PBool
forall (t :: S -> Type) (s :: S).
POrd t =>
Term s t -> Term s t -> Term s PBool
#< Term s' k
key)
                    (Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
          :--> PInner (PInner (t k v)))
         :--> PInner (PInner (t k v))))
self Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
          :--> PInner (PInner (t k v)))
         :--> PInner (PInner (t k v))))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term
     s'
     ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> PInner (PInner (t k v)))
      :--> PInner (PInner (t k v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
xs Term
  s'
  ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
    :--> PInner (PInner (t k v)))
   :--> PInner (PInner (t k v)))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> PInner (PInner (t k v)))
-> Term s' (PInner (PInner (t k v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
#$ (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
 -> Term s' (PInner (PInner (t k v))))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> PInner (PInner (t k v)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PInner (PInner (t k v))))
-> Term s' (c :--> PInner (PInner (t k v)))
plam ((Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
  -> Term s' (PInner (PInner (t k v))))
 -> Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> PInner (PInner (t k v))))
-> (Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
    -> Term s' (PInner (PInner (t k v))))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> PInner (PInner (t k v)))
forall a b. (a -> b) -> a -> b
$ \Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
suffix -> Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PInner (PInner (t k v)))
prefix Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PInner (PInner (t k v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PInner (PInner (t k v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
#$ Term
  s'
  (PBuiltinPair (PAsData k) (PAsData v)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
forall (a :: S -> Type) (s :: S).
PElemConstraint PBuiltinList a =>
Term s (a :--> (PBuiltinList a :--> PBuiltinList a))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
(PListLike list, PElemConstraint list a) =>
Term s (a :--> (list a :--> list a))
pcons Term
  s'
  (PBuiltinPair (PAsData k) (PAsData v)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinPair (PAsData k) (PAsData v))
x Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
suffix)
                    ( Term s' PBool
-> Term s' (PInner (PInner (t k v)))
-> Term s' (PInner (PInner (t k v)))
-> Term s' (PInner (PInner (t k v)))
forall (a :: S -> Type) (s :: S).
Term s PBool -> Term s a -> Term s a -> Term s a
pif
                        (Term s' k
k Term s' k -> Term s' k -> Term s' PBool
forall (s :: S). Term s k -> Term s k -> Term s PBool
forall (t :: S -> Type) (s :: S).
PEq t =>
Term s t -> Term s t -> Term s PBool
#== Term s' k
key)
                        (Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PInner (PInner (t k v)))
prefix Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PInner (PInner (t k v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PInner (PInner (t k v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
#$ Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
handler Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
xs)
                        (Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PInner (PInner (t k v)))
prefix Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PInner (PInner (t k v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PInner (PInner (t k v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
#$ Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
handler Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
#$ Term
  s'
  (PBuiltinPair (PAsData k) (PAsData v)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
forall (a :: S -> Type) (s :: S).
PElemConstraint PBuiltinList a =>
Term s (a :--> (PBuiltinList a :--> PBuiltinList a))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
(PListLike list, PElemConstraint list a) =>
Term s (a :--> (list a :--> list a))
pcons Term
  s'
  (PBuiltinPair (PAsData k) (PAsData v)
   :--> (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
         :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))))
-> Term s' (PBuiltinPair (PAsData k) (PAsData v))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinPair (PAsData k) (PAsData v))
x Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
xs)
                    )
        )
        (Term
  s'
  ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
    :--> PInner (PInner (t k v)))
   :--> PInner (PInner (t k v)))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
             :--> PInner (PInner (t k v)))
            :--> PInner (PInner (t k v))))
-> Term
     s'
     ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> PInner (PInner (t k v)))
      :--> PInner (PInner (t k v)))
forall a b. a -> b -> a
const (Term
   s'
   ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
     :--> PInner (PInner (t k v)))
    :--> PInner (PInner (t k v)))
 -> Term
      s'
      (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
              :--> PInner (PInner (t k v)))
             :--> PInner (PInner (t k v))))
 -> Term
      s'
      ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
        :--> PInner (PInner (t k v)))
       :--> PInner (PInner (t k v))))
-> Term
     s'
     ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> PInner (PInner (t k v)))
      :--> PInner (PInner (t k v)))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
      :--> ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
             :--> PInner (PInner (t k v)))
            :--> PInner (PInner (t k v))))
-> Term
     s'
     ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> PInner (PInner (t k v)))
      :--> PInner (PInner (t k v)))
forall a b. (a -> b) -> a -> b
$ (Term
   s'
   (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
    :--> PInner (PInner (t k v)))
 -> Term s' (PInner (PInner (t k v))))
-> Term
     s'
     ((PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
       :--> PInner (PInner (t k v)))
      :--> PInner (PInner (t k v)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PInner (PInner (t k v))))
-> Term s' (c :--> PInner (PInner (t k v)))
plam (Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PInner (PInner (t k v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PInner (PInner (t k v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
#$ Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
handler Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v))
   :--> PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
-> Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PBuiltinList (PBuiltinPair (PAsData k) (PAsData v)))
forall (a :: S -> Type) (s :: S).
PElemConstraint PBuiltinList a =>
Term s (PBuiltinList a)
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
(PListLike list, PElemConstraint list a) =>
Term s (list a)
pnil))
        # pto (pto m)
        # plam id

-- We have to clone this in here or we get a dependency cycle
passertPJust :: forall (a :: S -> Type) (s :: S). Term s (PString :--> PMaybe a :--> a)
passertPJust :: forall (a :: S -> Type) (s :: S).
Term s (PString :--> (PMaybe a :--> a))
passertPJust = (forall (s' :: S). Term s' (PString :--> (PMaybe a :--> a)))
-> Term s (PString :--> (PMaybe a :--> a))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S). Term s' (PString :--> (PMaybe a :--> a)))
 -> Term s (PString :--> (PMaybe a :--> a)))
-> (forall (s' :: S). Term s' (PString :--> (PMaybe a :--> a)))
-> Term s (PString :--> (PMaybe a :--> a))
forall a b. (a -> b) -> a -> b
$
  (Term s' PString -> Term s' (PMaybe a) -> Term s' a)
-> Term s' (PString :--> (PMaybe a :--> a))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PMaybe a) -> Term s' a)
-> Term s' (c :--> (PMaybe a :--> a))
plam ((Term s' PString -> Term s' (PMaybe a) -> Term s' a)
 -> Term s' (PString :--> (PMaybe a :--> a)))
-> (Term s' PString -> Term s' (PMaybe a) -> Term s' a)
-> Term s' (PString :--> (PMaybe a :--> a))
forall a b. (a -> b) -> a -> b
$ \Term s' PString
emsg Term s' (PMaybe a)
mv' -> Term s' (PMaybe a) -> (PMaybe a s' -> Term s' a) -> Term s' a
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' (PMaybe a)
mv' ((PMaybe a s' -> Term s' a) -> Term s' a)
-> (PMaybe a s' -> Term s' a) -> Term s' a
forall a b. (a -> b) -> a -> b
$ \case
    PJust Term s' a
v -> Term s' a
v
    PMaybe a s'
_ -> Term s' PString -> Term s' a
forall (a :: S -> Type) (s :: S). Term s PString -> Term s a
ptraceInfoError Term s' PString
emsg