| Safe Haskell | Safe-Inferred |
|---|---|
| Language | GHC2021 |
Plutarch.Prelude
Contents
Synopsis
- newtype PDataNewtype (a :: S -> Type) (s :: S) = PDataNewtype (Term s (PAsData a))
- data PBool (s :: S)
- pand' :: forall (s :: S). Term s (PBool :--> (PBool :--> PBool))
- pcond :: forall (a :: S -> Type) (s :: S). [(Term s PBool, Term s a)] -> Term s a -> Term s a
- pif :: forall (a :: S -> Type) (s :: S). Term s PBool -> Term s a -> Term s a -> Term s a
- pif' :: forall (a :: S -> Type) (s :: S). Term s (PBool :--> (a :--> (a :--> a)))
- pnot :: forall (s :: S). Term s (PBool :--> PBool)
- por' :: Term s (PBool :--> (PBool :--> PBool))
- (#&&) :: forall (s :: S). Term s PBool -> Term s PBool -> Term s PBool
- (#||) :: forall (s :: S). Term s PBool -> Term s PBool -> Term s PBool
- data PByte (s :: S)
- data PByteString s
- data PLogicOpSemantics (s :: S)
- pandBS :: forall (s :: S). Term s (PLogicOpSemantics :--> (PByteString :--> (PByteString :--> PByteString)))
- pbyteToInteger :: Term s (PByte :--> PInteger)
- pcomplementBS :: forall (s :: S). Term s (PByteString :--> PByteString)
- pconsBS :: Term s (PByte :--> (PByteString :--> PByteString))
- phexByteStr :: HasCallStack => String -> Term s PByteString
- pindexBS :: Term s (PByteString :--> (PInteger :--> PByte))
- pintegerToByte :: Term s (PInteger :--> PByte)
- plengthBS :: Term s (PByteString :--> PInteger)
- porBS :: forall (s :: S). Term s (PLogicOpSemantics :--> (PByteString :--> (PByteString :--> PByteString)))
- ppadding :: forall (s :: S). Term s PLogicOpSemantics
- preplicateBS :: forall (s :: S). Term s (PInteger :--> (PByte :--> PByteString))
- psliceBS :: Term s (PInteger :--> (PInteger :--> (PByteString :--> PByteString)))
- ptruncation :: forall (s :: S). Term s PLogicOpSemantics
- pxorBS :: forall (s :: S). Term s (PLogicOpSemantics :--> (PByteString :--> (PByteString :--> PByteString)))
- psha2_256 :: Term s (PByteString :--> PByteString)
- psha3_256 :: Term s (PByteString :--> PByteString)
- pverifySignature :: Term s (PByteString :--> (PByteString :--> (PByteString :--> PBool)))
- newtype PAsData (a :: S -> Type) (s :: S) = PAsData (Term s a)
- data PBuiltinList (a :: S -> Type) (s :: S)
- = PCons (Term s a) (Term s (PBuiltinList a))
- | PNil
- newtype PBuiltinPair (a :: S -> Type) (b :: S -> Type) (s :: S) = PBuiltinPair (Term s (PBuiltinPair a b))
- newtype PData (s :: S) = PData (Term s PData)
- pasByteStr :: Term s (PData :--> PByteString)
- pasConstr :: Term s (PData :--> PBuiltinPair PInteger (PBuiltinList PData))
- pasInt :: Term s (PData :--> PInteger)
- pasList :: Term s (PData :--> PBuiltinList PData)
- pasMap :: Term s (PData :--> PBuiltinList (PBuiltinPair PData PData))
- pchooseData :: Term s (PData :--> (a :--> (a :--> (a :--> (a :--> (a :--> a))))))
- pchooseListBuiltin :: Term s (PBuiltinList a :--> (b :--> (b :--> b)))
- pconsBuiltin :: Term s (a :--> (PBuiltinList a :--> PBuiltinList a))
- pconstrBuiltin :: Term s (PInteger :--> (PBuiltinList PData :--> PAsData (PBuiltinPair PInteger (PBuiltinList PData))))
- pfstBuiltin :: Term s (PBuiltinPair a b :--> a)
- pheadBuiltin :: Term s (PBuiltinList a :--> a)
- plistData :: Term s (PBuiltinList PData :--> PData)
- pnullBuiltin :: Term s (PBuiltinList a :--> PBool)
- ppairDataBuiltin :: Term s (PAsData a :--> (PAsData b :--> PBuiltinPair (PAsData a) (PAsData b)))
- pserialiseData :: Term s (PData :--> PByteString)
- psndBuiltin :: Term s (PBuiltinPair a b :--> b)
- ptailBuiltin :: Term s (PBuiltinList a :--> PBuiltinList a)
- data PInteger s
- newtype POpaque s = POpaque (Term s POpaque)
- popaque :: Term s a -> Term s POpaque
- data PString s
- pdecodeUtf8 :: Term s (PByteString :--> PString)
- pencodeUtf8 :: Term s (PString :--> PByteString)
- data PUnit (s :: S) = PUnit
- data PEither (a :: S -> Type) (b :: S -> Type) (s :: S)
- class POrd a => PCountable (a :: S -> Type) where
- psuccessor :: forall (s :: S). Term s (a :--> a)
- psuccessorN :: forall (s :: S). Term s (PPositive :--> (a :--> a))
- class PCountable a => PEnumerable (a :: S -> Type) where
- ppredecessor :: forall (s :: S). Term s (a :--> a)
- ppredecessorN :: forall (s :: S). Term s (PPositive :--> (a :--> a))
- class PEq t where
- class PEq t => POrd t where
- (#>) :: forall (a :: S -> Type) (s :: S). POrd a => Term s a -> Term s a -> Term s PBool
- (#>=) :: forall (a :: S -> Type) (s :: S). POrd a => Term s a -> Term s a -> Term s PBool
- pfix :: Term s (((a :--> b) :--> (a :--> b)) :--> (a :--> b))
- class PIsData a where
- pdata :: PIsData a => Term s a -> Term s (PAsData a)
- pforgetData :: forall s a. Term s (PAsData a) -> Term s PData
- pfromData :: PIsData a => Term s (PAsData a) -> Term s a
- class PlutusType a => PLiftable (a :: S -> Type) where
- type AsHaskell a :: Type
- type PlutusRepr a :: Type
- haskToRepr :: AsHaskell a -> PlutusRepr a
- reprToHask :: PlutusRepr a -> Either LiftError (AsHaskell a)
- reprToPlut :: forall (s :: S). PlutusRepr a -> PLifted s a
- plutToRepr :: (forall (s :: S). PLifted s a) -> Either LiftError (PlutusRepr a)
- data DeriveDataPLiftable (a :: S -> Type) (h :: Type) (s :: S)
- data DeriveNewtypePLiftable (wrapper :: S -> Type) (h :: Type) (s :: S)
- newtype PLifted (s :: S) (a :: S -> Type) = PLifted (Term s POpaque)
- reprToPlutUni :: forall (a :: S -> Type) (s :: S). (PLiftable a, DefaultUni `Includes` PlutusRepr a) => PlutusRepr a -> PLifted s a
- plutToReprUni :: forall (a :: S -> Type). (PLiftable a, DefaultUni `Includes` PlutusRepr a) => (forall (s :: S). PLifted s a) -> Either LiftError (PlutusRepr a)
- pconstant :: forall (a :: S -> Type) (s :: S). PLiftable a => AsHaskell a -> Term s a
- plift :: forall (a :: S -> Type). PLiftable a => (forall (s :: S). Term s a) -> AsHaskell a
- type family PElemConstraint list (a :: S -> Type) :: Constraint
- type PIsListLike list a = (PListLike list, PElemConstraint list a)
- class PListLike (list :: (S -> Type) -> S -> Type)
- data PList (a :: S -> Type) (s :: S)
- pelem :: (PIsListLike list a, PEq a) => Term s (a :--> (list a :--> PBool))
- pelemAt :: PIsListLike l a => Term s (PInteger :--> (l a :--> a))
- pfind :: PIsListLike l a => Term s ((a :--> PBool) :--> (l a :--> PMaybe a))
- plistEquals :: (PIsListLike list a, PEq a) => Term s (list a :--> (list a :--> PBool))
- puncons :: PIsListLike list a => Term s (list a :--> PMaybe (PPair a (list a)))
- pzip :: (PListLike list, PElemConstraint list a, PElemConstraint list b, PElemConstraint list (PPair a b)) => Term s (list a :--> (list b :--> list (PPair a b)))
- (#!!) :: PIsListLike l a => Term s (l a) -> Term s PInteger -> Term s a
- pall :: PIsListLike list a => Term s ((a :--> PBool) :--> (list a :--> PBool))
- pany :: PIsListLike list a => Term s ((a :--> PBool) :--> (list a :--> PBool))
- pconcat :: PIsListLike list a => Term s (list a :--> (list a :--> list a))
- pcons :: (PListLike list, PElemConstraint list a) => Term s (a :--> (list a :--> list a))
- pdrop :: PIsListLike list a => Natural -> Term s (list a) -> Term s (list a)
- pelimList :: (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
- pfilter :: PIsListLike list a => Term s ((a :--> PBool) :--> (list a :--> list a))
- pfoldl :: PIsListLike list a => Term s ((b :--> (a :--> b)) :--> (b :--> (list a :--> b)))
- pfoldr :: PIsListLike list a => Term s ((a :--> (b :--> b)) :--> (b :--> (list a :--> b)))
- pfoldrLazy :: PIsListLike list a => Term s ((a :--> (PDelayed b :--> b)) :--> (b :--> (list a :--> b)))
- phead :: (PListLike list, PElemConstraint list a) => Term s (list a :--> a)
- plength :: PIsListLike list a => Term s (list a :--> PInteger)
- pmap :: (PListLike list, PElemConstraint list a, PElemConstraint list b) => Term s ((a :--> b) :--> (list a :--> list b))
- pnil :: (PListLike list, PElemConstraint list a) => Term s (list a)
- pnull :: (PListLike list, PElemConstraint list a) => Term s (list a :--> PBool)
- precList :: 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)
- psingleton :: PIsListLike list a => Term s (a :--> list a)
- ptail :: (PListLike list, PElemConstraint list a) => Term s (list a :--> list a)
- ptryIndex :: PIsListLike list a => Natural -> Term s (list a) -> Term s a
- pzipWith :: (PListLike list, PElemConstraint list a, PElemConstraint list b, PElemConstraint list c) => Term s ((a :--> (b :--> c)) :--> (list a :--> (list b :--> list c)))
- pzipWith' :: (PListLike list, PElemConstraint list a, PElemConstraint list b, PElemConstraint list c) => (Term s a -> Term s b -> Term s c) -> Term s (list a :--> (list b :--> list c))
- type PCon = PlutusType
- type PMatch = PlutusType
- class PlutusType (a :: PType) where
- pcon :: PlutusType a => a s -> Term s a
- pmatch :: PlutusType a => Term s a -> (a s -> Term s b) -> Term s b
- newtype DeriveNewtypePlutusType (a :: S -> Type) s = DeriveNewtypePlutusType (a s)
- newtype DeriveFakePlutusType (a :: S -> Type) (s :: S) = DeriveFakePlutusType (a s)
- newtype DeriveAsDataStruct (a :: S -> Type) s = DeriveAsDataStruct (a s)
- newtype DeriveAsDataRec (a :: S -> Type) s = DeriveAsDataRec (a s)
- newtype DeriveAsSOPStruct (a :: S -> Type) s = DeriveAsSOPStruct (a s)
- newtype DeriveAsSOPRec (a :: S -> Type) s = DeriveAsSOPRec (a s)
- data Positive
- data PPositive (s :: S)
- data PNatural (s :: S)
- class PAdditiveSemigroup (a :: S -> Type) where
- class PAdditiveSemigroup a => PAdditiveMonoid (a :: S -> Type) where
- class PAdditiveMonoid a => PAdditiveGroup (a :: S -> Type) where
- class PMultiplicativeSemigroup (a :: S -> Type) where
- class PMultiplicativeSemigroup a => PMultiplicativeMonoid (a :: S -> Type) where
- class (PAdditiveGroup a, PMultiplicativeMonoid a) => PRing (a :: S -> Type) where
- pfromInteger :: forall (s :: S). Integer -> Term s a
- class (PRing a, POrd a) => PIntegralDomain (a :: S -> Type) where
- pquot :: forall (s :: S). Term s (PInteger :--> (PInteger :--> PInteger))
- prem :: forall (s :: S). Term s (PInteger :--> (PInteger :--> PInteger))
- pdiv :: forall (s :: S). Term s (PInteger :--> (PInteger :--> PInteger))
- pmod :: forall (s :: S). Term s (PInteger :--> (PInteger :--> PInteger))
- ppositive :: Term s (PInteger :--> PMaybe PPositive)
- ptryPositive :: forall (s :: S). Term s (PInteger :--> PPositive)
- pnatural :: forall (s :: S). Term s (PInteger :--> PMaybe PNatural)
- ptryNatural :: forall (s :: S). Term s (PInteger :--> PNatural)
- ppositiveToNatural :: forall (s :: S). Term s (PPositive :--> PNatural)
- pto :: Term s a -> Term s (PInner a)
- pinl :: Term s a -> (Term s a -> Term s b) -> Term s b
- plam :: forall c. (PLamN a b s, HasCallStack) => (Term s c -> a) -> Term s (c :--> b)
- newtype PForall (b :: a -> PType) s = PForall (forall (x :: a). Term s (b x))
- class PShow t
- pshow :: PShow a => Term s a -> Term s PString
- data Term (s :: S) (a :: PType)
- data S
- type ClosedTerm (a :: PType) = forall (s :: S). Term s a
- data PDelayed (a :: PType) (s :: S)
- papp :: Term s (a :--> b) -> Term s a -> Term s b
- pdelay :: Term s a -> Term s (PDelayed a)
- pforce :: Term s (PDelayed a) -> Term s a
- perror :: Term s a
- phoistAcyclic :: HasCallStack => ClosedTerm a -> Term s a
- plet :: Term s a -> (Term s a -> Term s b) -> Term s b
- pthrow :: HasCallStack => Text -> Term s a
- (#) :: Term s (a :--> b) -> Term s a -> Term s b
- (#$) :: Term s (a :--> b) -> Term s a -> Term s b
- data ((a :: PType) :--> (b :: PType)) (s :: S)
- type family PSubtype (a :: PType) (b :: PType) :: Constraint where ...
- class PSubtype a b => PTryFrom (a :: PType) (b :: PType) where
- type PTryFromExcess a b :: PType
- ptryFrom' :: forall s r. Term s a -> ((Term s b, Reduce (PTryFromExcess a b s)) -> Term s r) -> Term s r
- ptryFrom :: forall b a s r. PTryFrom a b => Term s a -> ((Term s b, Reduce (PTryFromExcess a b s)) -> Term s r) -> Term s r
- pupcast :: forall a b s. PSubtype a b => Term s b -> Term s a
- data PMaybe (a :: S -> Type) (s :: S)
- data PPair (a :: S -> Type) (b :: S -> Type) (s :: S) = PPair (Term s a) (Term s b)
- data PRational s = PRational (Term s PInteger) (Term s PPositive)
- pdenominator :: Term s (PRational :--> PPositive)
- pnumerator :: Term s (PRational :--> PInteger)
- pround :: Term s (PRational :--> PInteger)
- newtype TermCont :: forall (r :: PType). S -> Type -> Type where
- pguardC :: Term s PString -> Term s PBool -> TermCont s ()
- pguardC' :: Term s a -> Term s PBool -> TermCont @a s ()
- pletC :: Term s a -> TermCont s (Term s a)
- pmatchC :: PlutusType a => Term s a -> TermCont s (a s)
- ptraceC :: Term s PString -> TermCont s ()
- ptryFromC :: forall b r a s. PTryFrom a b => Term s a -> TermCont @r s (Term s b, Reduce (PTryFromExcess a b s))
- unTermCont :: TermCont @a s (Term s a) -> Term s a
- tcont :: ((a -> Term s r) -> Term s r) -> TermCont @r s a
- ptrace :: forall (a :: S -> Type) (s :: S). Term s PString -> Term s a -> Term s a
- ptraceDebug :: forall (a :: S -> Type) (s :: S). Term s PString -> Term s a -> Term s a
- ptraceDebugError :: forall (a :: S -> Type) (s :: S). Term s PString -> Term s a
- ptraceDebugIfFalse :: forall (s :: S). Term s PString -> Term s PBool -> Term s PBool
- ptraceDebugIfTrue :: forall (s :: S). Term s PString -> Term s PBool -> Term s PBool
- ptraceDebugShowId :: forall (a :: S -> Type) (s :: S). PShow a => Term s a -> Term s a
- ptraceError :: forall (a :: S -> Type) (s :: S). Term s PString -> Term s a
- ptraceIfFalse :: forall (s :: S). Term s PString -> Term s PBool -> Term s PBool
- ptraceInfo :: forall (a :: S -> Type) (s :: S). Term s PString -> Term s a -> Term s a
- ptraceInfoError :: forall (a :: S -> Type) (s :: S). Term s PString -> Term s a
- ptraceInfoIfFalse :: forall (s :: S). Term s PString -> Term s PBool -> Term s PBool
- ptraceInfoIfTrue :: forall (s :: S). Term s PString -> Term s PBool -> Term s PBool
- ptraceInfoShowId :: forall (a :: S -> Type) (s :: S). PShow a => Term s a -> Term s a
- ptraceShowId :: forall (a :: S -> Type) (s :: S). PShow a => Term s a -> Term s a
- class PSemigroup (a :: S -> Type) where
- class PSemigroup a => PMonoid (a :: S -> Type) where
- newtype PAnd (a :: S -> Type) (s :: S) = PAnd (Term s a)
- newtype POr (a :: S -> Type) (s :: S) = POr (Term s a)
- newtype PXor (a :: S -> Type) (s :: S) = PXor (Term s a)
- punrollBound :: forall a b s. Integer -> Term s (a :--> b) -> (Term s (a :--> b) -> Term s (a :--> b)) -> Term s (a :--> b)
- punrollBound' :: forall a b c s. Integer -> (c -> Term s (a :--> b)) -> ((c -> Term s (a :--> b)) -> c -> Term s (a :--> b)) -> c -> Term s (a :--> b)
- punrollUnbound :: forall a b s. Integer -> (Term s (a :--> b) -> Term s (a :--> b)) -> Term s (a :--> b)
- punrollUnboundWhole :: forall a b s. Integer -> (Term s (a :--> b) -> Term s (a :--> b)) -> Term s (a :--> b)
Documentation
newtype PDataNewtype (a :: S -> Type) (s :: S) Source #
Since: 1.7.0
Constructors
| PDataNewtype (Term s (PAsData a)) |
Instances
Boolean
Builtin Plutus boolean.
Since: 1.10.0
Instances
pand' :: forall (s :: S). Term s (PBool :--> (PBool :--> PBool)) Source #
As pand, but strict.
Since: 1.10.0
pcond :: forall (a :: S -> Type) (s :: S). [(Term s PBool, Term s a)] -> Term s a -> Term s a Source #
Essentially multi-way pif. More precisely, given a list of
condition-action pairs, and an 'action of last resort', construct a
left-to-right 'chain' of pifs, using the conditions to determine which
action gets taken. The 'action of last resort' finishes the 'chain'. For
example:
pcond [(cond1, act1), (cond2, act2)] act3
does the same thing as
pif cond1 act1 (pif cond2 act2 act3)
Since: 1.10.0
pif :: forall (a :: S -> Type) (s :: S). Term s PBool -> Term s a -> Term s a -> Term s a Source #
Lazy if-then-else.
Since: 1.10.0
pif' :: forall (a :: S -> Type) (s :: S). Term s (PBool :--> (a :--> (a :--> a))) Source #
Strict if-then-else. Emits slightly less code than the lazy version.
Since: 1.10.0
(#&&) :: forall (s :: S). Term s PBool -> Term s PBool -> Term s PBool infixr 3 Source #
Lazy AND for terms.
Since: 1.10.0
(#||) :: forall (s :: S). Term s PBool -> Term s PBool -> Term s PBool infixr 2 Source #
Lazy OR for terms.
Since: 1.10.0
Bytestring
A Plutarch-level representation of bytes.
Note =
This type is intentionally quite restrictive, as it's not really meant to be
computed with. Instead, it ensures certain operations' type safety while also
allowing more sensible signatures. If you want to do anything with PBytes,
we recommend converting them to PIntegers first.
Since: 1.10.0
Instances
data PByteString s Source #
Plutus BuiltinByteString
Instances
data PLogicOpSemantics (s :: S) Source #
Type designating whether logical operations should use padding or truncation semantics. See CIP-122 for more details on this.
Since: 1.10.0
Instances
pandBS :: forall (s :: S). Term s (PLogicOpSemantics :--> (PByteString :--> (PByteString :--> PByteString))) Source #
Perform the logical AND of two PByteStrings, as per
CIP-122.
The PLogicOpSemantics argument specifies what should be done if the lengths
of the two PByteString arguments do not match.
Since: 1.10.0
pcomplementBS :: forall (s :: S). Term s (PByteString :--> PByteString) Source #
Perform the logical complement of a PByteString, as per
CIP-122.
Since: 1.10.0
pconsBS :: Term s (PByte :--> (PByteString :--> PByteString)) Source #
Prepend a PByte to a 'PByteString.
Since: 1.10.0
phexByteStr :: HasCallStack => String -> Term s PByteString Source #
Interpret a hex string as a PByteString.
pindexBS :: Term s (PByteString :--> (PInteger :--> PByte)) Source #
Given a valid index into a PByteString, returns the PByte at that
index. Will crash if given an out-of-bounds index.
Since: 1.10.0
plengthBS :: Term s (PByteString :--> PInteger) Source #
Find the length of a PByteString.
porBS :: forall (s :: S). Term s (PLogicOpSemantics :--> (PByteString :--> (PByteString :--> PByteString))) Source #
Perform the logical OR of two PByteStrings, as per
CIP-122.
The PLogicOpSemantics argument specifies what should be done if the lengths
of the two PByteString arguments do not match.
Since: 1.10.0
ppadding :: forall (s :: S). Term s PLogicOpSemantics Source #
Indicates that padding semantics should be used.
Since: 1.10.0
preplicateBS :: forall (s :: S). Term s (PInteger :--> (PByte :--> PByteString)) Source #
Given a desired length and a PByte, construct a PByteString of the
specified length (0 if negative) consisting entirely of that PByte.
Since: 1.10.0
psliceBS :: Term s (PInteger :--> (PInteger :--> (PByteString :--> PByteString))) Source #
Slice a PByteString with given start index and slice length.
>>>(pslice # 2 # 3 phexByteStr "4102afde5b2a") #== phexByteStr "afde5b"
ptruncation :: forall (s :: S). Term s PLogicOpSemantics Source #
Indicates that truncation semantics should be used.
Since: 1.10.0
pxorBS :: forall (s :: S). Term s (PLogicOpSemantics :--> (PByteString :--> (PByteString :--> PByteString))) Source #
Perform the logical XOR of two PByteStrings, as per
CIP-122.
The PLogicOpSemantics argument specifies what should be done if the lengths
of the two PByteString arguments do not match.
Since: 1.10.0
Cryptographic primitives
psha2_256 :: Term s (PByteString :--> PByteString) Source #
Hash a PByteString using SHA-256.
psha3_256 :: Term s (PByteString :--> PByteString) Source #
Hash a PByteString using SHA3-256.
pverifySignature :: Term s (PByteString :--> (PByteString :--> (PByteString :--> PBool))) Source #
Deprecated: use one of the Ed25519, Schnorr- or ECDSA Secp256k1 signature verification functions
Verify the signature against the public key and message.
Data encoding
newtype PAsData (a :: S -> Type) (s :: S) Source #
Instances
data PBuiltinList (a :: S -> Type) (s :: S) Source #
Plutus BuiltinList
Constructors
| PCons (Term s a) (Term s (PBuiltinList a)) | |
| PNil |
Instances
newtype PBuiltinPair (a :: S -> Type) (b :: S -> Type) (s :: S) Source #
Constructors
| PBuiltinPair (Term s (PBuiltinPair a b)) |
Instances
newtype PData (s :: S) Source #
Instances
pasByteStr :: Term s (PData :--> PByteString) Source #
pasConstr :: Term s (PData :--> PBuiltinPair PInteger (PBuiltinList PData)) Source #
pasMap :: Term s (PData :--> PBuiltinList (PBuiltinPair PData PData)) Source #
pchooseListBuiltin :: Term s (PBuiltinList a :--> (b :--> (b :--> b))) Source #
pconsBuiltin :: Term s (a :--> (PBuiltinList a :--> PBuiltinList a)) Source #
pconstrBuiltin :: Term s (PInteger :--> (PBuiltinList PData :--> PAsData (PBuiltinPair PInteger (PBuiltinList PData)))) Source #
pfstBuiltin :: Term s (PBuiltinPair a b :--> a) Source #
pheadBuiltin :: Term s (PBuiltinList a :--> a) Source #
pnullBuiltin :: Term s (PBuiltinList a :--> PBool) Source #
ppairDataBuiltin :: Term s (PAsData a :--> (PAsData b :--> PBuiltinPair (PAsData a) (PAsData b))) Source #
pserialiseData :: Term s (PData :--> PByteString) Source #
Serialise any builtin data to its cbor represented by a builtin bytestring
psndBuiltin :: Term s (PBuiltinPair a b :--> b) Source #
ptailBuiltin :: Term s (PBuiltinList a :--> PBuiltinList a) Source #
Integer
A builtin Plutus integer.
Since: 1.10.0
Instances
Opaque
An Arbitrary Term with an unknown type
Instances
| PlutusType POpaque Source # | |
Defined in Plutarch.Internal.PlutusType | |
| type PContravariant' POpaque Source # | |
Defined in Plutarch.Internal.PlutusType | |
| type PCovariant' POpaque Source # | |
Defined in Plutarch.Internal.PlutusType | |
| type PInner POpaque Source # | |
Defined in Plutarch.Internal.PlutusType | |
| type PVariant' POpaque Source # | |
Defined in Plutarch.Internal.PlutusType | |
String
Plutus BuiltinString values
Instances
pdecodeUtf8 :: Term s (PByteString :--> PString) Source #
Decode a PByteString using UTF-8.
pencodeUtf8 :: Term s (PString :--> PByteString) Source #
Encode a PString using UTF-8.
Unit
Constructors
| PUnit |
Instances
Either
data PEither (a :: S -> Type) (b :: S -> Type) (s :: S) Source #
SOP-encoded Either.
Since: 1.10.0
Instances
Enumerable and Countable
class POrd a => PCountable (a :: S -> Type) where Source #
A notion of 'next' value. More formally, instances of this type class are discrete linear orders with no maximal element.
Laws
x /= psuccessor x
y < x=psuccessor y <= xx < psuccessor y=x <= y
If you define psuccessorN, you must also ensure the following hold; the
default implementation ensures this.
psuccessorN 1=psuccessorpsuccessorN n . psuccessorN m=psuccessorN (n + m)
Law 1 ensures no value is its own successor. Laws 2 and 3 ensure that there
are no 'gaps': every value is 'reachable' from any lower value by a
finite number of applications of successor.
Since: 1.10.0
Minimal complete definition
Methods
psuccessor :: forall (s :: S). Term s (a :--> a) Source #
Since: 1.10.0
psuccessorN :: forall (s :: S). Term s (PPositive :--> (a :--> a)) Source #
The default implementation of this function is inefficient: if at all possible, give instances an optimized version that doesn't require recursion.
Since: 1.10.0
Instances
| PCountable PInteger Source # | Since: 1.10.0 |
| PCountable PPositive Source # | Since: 1.10.0 |
class PCountable a => PEnumerable (a :: S -> Type) where Source #
Similar to PCountable, but has the ability to get a 'previous' value as
well. More formally, instances of this type class are discrete linear orders
with no maximal or minimal element.
Laws
ppredecessor . psuccessor=psuccessor . ppredecessor=id
If you define ppredecessorN, you must also ensure the following hold; the
default implementation ensures this.
ppredecessorN 1=ppredecessorppredecessorN n . ppredecessorN m=ppredecessorN (n + m)
From Law 1, we obtain the following theorem:
x /= predecessor x
Since: 1.10.0
Minimal complete definition
Methods
ppredecessor :: forall (s :: S). Term s (a :--> a) Source #
Since: 1.10.0
ppredecessorN :: forall (s :: S). Term s (PPositive :--> (a :--> a)) Source #
The default implementation of this function is inefficient: if at all possible, give instances an optimized version that doesn't require recursion.
Since: 1.10.0
Eq and Ord
Minimal complete definition
Nothing
Instances
class PEq t => POrd t where Source #
Total ordering relation.
Laws
#<= must form a total order. More precisely:
x #<= x=pcon PTrue(reflexivity)(y #< x) #|| (z #< y) #|| (x #<= z)=pcon PTrue(transitivity)(x #<= y) #|| (y #<= x)=pcon PTrue(totality)
Furthermore, #< must be an equivalent strict total order to #<=:
x #< x=pcon PFalse(irreflexivity)(y #<= x) #|| (z #<= y) #|| (x #< z)=pcon PTrue(transitivity)(x #< y) #|| (y #< x) #|| (x #== z)=pcon PTrue(trichotomy)x #<= y=(x #< y) #|| (x #== y)(strict equivalence)
If you define pmax or pmin, ensure the following also hold:
pmax # x # y=pmax # y # x(commutativity, also for @pmin)pmax # x #$ pmax y z=pmax # (pmax # x # y) # z(associativity, also for @pmin)pmax # x #$ pmin # y # z=pmin # (pmax # x # y) # (pmax # x # z)(pmaxdistributes overpmin, also equivalent forpmin)pmin x y=pif' (x #<= y) x ypmax x y=pif' (x #<= y) y x
Laws 8-12 hold if you use the defaults provided by this type class.
Since: 1.10.0
Minimal complete definition
Nothing
Methods
(#<=) :: Term s t -> Term s t -> Term s PBool infix 4 Source #
Since: 1.10.0
(#<) :: Term s t -> Term s t -> Term s PBool infix 4 Source #
Since: 1.10.0
pmax :: forall (s :: S). Term s t -> Term s t -> Term s t Source #
Since: 1.10.0
pmin :: forall (s :: S). Term s t -> Term s t -> Term s t Source #
Since: 1.10.0
Instances
(#>) :: forall (a :: S -> Type) (s :: S). POrd a => Term s a -> Term s a -> Term s PBool infix 4 Source #
Since: 1.10.0
(#>=) :: forall (a :: S -> Type) (s :: S). POrd a => Term s a -> Term s a -> Term s PBool infix 4 Source #
Since: 1.10.0
Fixed point
pfix :: Term s (((a :--> b) :--> (a :--> b)) :--> (a :--> b)) Source #
Fixpoint recursion. Used to encode recursive functions.
Example:
iterateN' :: Term s (PInteger :--> (a :--> a) :--> a :--> a) -> Term s PInteger -> Term s (a :--> a) -> Term s a iterateN' self n f x = pif (n #== 0) x (self # n - 1 #$ f x) iterateN :: Term s (PInteger :--> (a :--> a) :--> a :--> a) iterateN = pfix #$ plam iterateN'
Further examples can be found in examples/Recursion.hs
IsData
class PIsData a where Source #
Laws:
- If PSubtype PData a, then pdataImpl a must be pupcast.
- pdataImpl . pupcast . pfromDataImpl ≡ id
- pfromDataImpl . punsafeDowncast . pdataImpl ≡ id
Minimal complete definition
Nothing
Instances
Lifting and lowering
class PlutusType a => PLiftable (a :: S -> Type) where Source #
Indicates that the given Plutarch type has an equivalent in Haskell (and Plutus by extension), and we have the ability to move between them.
Important note
Calling methods of PLiftable directly should rarely, if ever, be a
thing you do, unless defining your own instances without via-deriving
helpers (below). Prefer using pconstant and plift, as these handle
some of the oddities required without you having to think about them.
You should rarely, if ever, need to define PLiftable instances by hand.
Whenever possible, prefer using DeriveBuiltinPLiftable,
DeriveDataPLiftable, and DeriveNewtypePLiftable as they have fewer
complexities and caveats. See their documentation for when to use them.
If you do want to define the methods yourself, there's a few key factors to keep in mind:
- You still shouldn't write every method by hand, there are helpers
plutToReprUniandreprToPlutUnito cover common cases. - If defining
plutToReprandreprToPlutfor Scott encoded types you need to setPlutusReprPMyType =PLiftedClosedPMyType - When choosing a type for
AsHaskell, any value of that type must be representable in Plutarch. If you have internal invariants to maintain on the Haskell side, make sure you do so with great care.
Laws
Any derivations via DeriveBuiltinPLiftable, DeriveDataPLiftable, and
DeriveNewtypePLiftable automatically follow these laws.
Together, these imply plift . pconstant = id.
Since: 1.10.0
Methods
haskToRepr :: AsHaskell a -> PlutusRepr a Source #
Transform a's Haskell equivalent to its Plutus universe
representation.
reprToHask :: PlutusRepr a -> Either LiftError (AsHaskell a) Source #
Given a's Plutus universe representation, turn it back into its (true)
Haskell equivalent if possible.
reprToPlut :: forall (s :: S). PlutusRepr a -> PLifted s a Source #
Given a's Plutus universe representation, lift it into Plutarch.
plutToRepr :: (forall (s :: S). PLifted s a) -> Either LiftError (PlutusRepr a) Source #
Given a closed Plutarch term, evaluate it back into its Plutus universe representation, or fail.
Instances
data DeriveDataPLiftable (a :: S -> Type) (h :: Type) (s :: S) Source #
via-deriving helper, indicating that a has a Haskell-level equivalent
h by way of its Data encoding, rather than by h being directly part of
the Plutus default universe.
Since: 1.10.0
Instances
data DeriveNewtypePLiftable (wrapper :: S -> Type) (h :: Type) (s :: S) Source #
via-deriving helper, indicating that wrapper has a Haskell-level equivalent
h by way PInner wrapper, up to coercibility.
Since: 1.10.0
Instances
newtype PLifted (s :: S) (a :: S -> Type) Source #
Similar to Identity, but at the level of Plutarch. Only needed when
writing manual instances of PLiftable, or if you want to use reprToPlut
and plutToRepr directly.
This is used for coercing Plutarch terms at Haskell level with
`coerce :: PLifted s a -> PLifted s b` for via-deriving helpers.
Since: 1.10.0
reprToPlutUni :: forall (a :: S -> Type) (s :: S). (PLiftable a, DefaultUni `Includes` PlutusRepr a) => PlutusRepr a -> PLifted s a Source #
Valid definition of reprToPlut if PlutusRepr a is in the Plutus universe.
Since: 1.10.0
plutToReprUni :: forall (a :: S -> Type). (PLiftable a, DefaultUni `Includes` PlutusRepr a) => (forall (s :: S). PLifted s a) -> Either LiftError (PlutusRepr a) Source #
Valid definition of plutToRepr if PlutusRepr a is in the Plutus
universe.
Since: 1.10.0
pconstant :: forall (a :: S -> Type) (s :: S). PLiftable a => AsHaskell a -> Term s a Source #
Given a Haskell-level representation of a Plutarch term, transform it into its equivalent term.
Since: 1.10.0
plift :: forall (a :: S -> Type). PLiftable a => (forall (s :: S). Term s a) -> AsHaskell a Source #
Given a closed Plutarch term, compile and evaluate it, then produce the
corresponding Haskell value. If compilation or evaluation fails somehow, this
will call error: if you need to 'trap' these outcomes and handle them
differently somehow, use reprToPlut and reprToHask manually.
Since: 1.10.0
Lists
type family PElemConstraint list (a :: S -> Type) :: Constraint Source #
Instances
| type PElemConstraint PBuiltinList a Source # | |
Defined in Plutarch.Internal.ListLike | |
| type PElemConstraint PList _1 Source # | |
Defined in Plutarch.List | |
type PIsListLike list a = (PListLike list, PElemConstraint list a) Source #
'PIsListLike list a' constraints list be a PListLike with valid element type, a.
class PListLike (list :: (S -> Type) -> S -> Type) Source #
Plutarch types that behave like lists.
Instances
data PList (a :: S -> Type) (s :: S) Source #
SOP-encoded list.
Since: 1.10.0
Instances
pelem :: (PIsListLike list a, PEq a) => Term s (a :--> (list a :--> PBool)) Source #
O(n) . Check if element is in the list
pelemAt :: PIsListLike l a => Term s (PInteger :--> (l a :--> a)) Source #
O(n) . Like Haskell level (!!) but on the Plutarch level, not infix and
with arguments reversed, errors if the specified index is greater than or equal
to the lists length
pfind :: PIsListLike l a => Term s ((a :--> PBool) :--> (l a :--> PMaybe a)) Source #
O(n) . like haskell level find but on plutarch level
plistEquals :: (PIsListLike list a, PEq a) => Term s (list a :--> (list a :--> PBool)) Source #
O(min(n, m)) . Check if two lists are equal.
puncons :: PIsListLike list a => Term s (list a :--> PMaybe (PPair a (list a))) Source #
Extract head and tail of the list, if list is not empty.
pzip :: (PListLike list, PElemConstraint list a, PElemConstraint list b, PElemConstraint list (PPair a b)) => Term s (list a :--> (list b :--> list (PPair a b))) Source #
O(min(n, m)) . Zip two lists together, creating pairs of the elements.
If the lists are of differing lengths, cut to the shortest.
(#!!) :: PIsListLike l a => Term s (l a) -> Term s PInteger -> Term s a Source #
O(n) . Like Haskell level (!!) but on the plutarch level
pall :: PIsListLike list a => Term s ((a :--> PBool) :--> (list a :--> PBool)) Source #
O(n) . Check that predicate holds for all elements in a list.
pany :: PIsListLike list a => Term s ((a :--> PBool) :--> (list a :--> PBool)) Source #
O(n) . Check that predicate holds for any element in a list.
pconcat :: PIsListLike list a => Term s (list a :--> (list a :--> list a)) Source #
O(n) . Concatenate two lists
Example: > pconcat # psingleton x # psingleton y == plistLiteral [x, y]
pconcat exhibits identities with empty lists such that > forall x. pconcat # pnil # x == x > forall x. pconcat # x # pnil == x
pcons :: (PListLike list, PElemConstraint list a) => Term s (a :--> (list a :--> list a)) Source #
Cons an element onto an existing list.
pdrop :: PIsListLike list a => Natural -> Term s (list a) -> Term s (list a) Source #
Drop the first n fields of a List.
The term will be statically generated as
repeated applications of ptail, which will be more
efficient in many circumstances.
pelimList :: (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 Source #
Canonical eliminator for list-likes.
pfilter :: PIsListLike list a => Term s ((a :--> PBool) :--> (list a :--> list a)) Source #
O(n) . Filter elements from a list that don't match the predicate.
pfoldl :: PIsListLike list a => Term s ((b :--> (a :--> b)) :--> (b :--> (list a :--> b))) Source #
O(n) . Fold on a list left-associatively.
pfoldr :: PIsListLike list a => Term s ((a :--> (b :--> b)) :--> (b :--> (list a :--> b))) Source #
O(n) . Fold on a list right-associatively.
pfoldrLazy :: PIsListLike list a => Term s ((a :--> (PDelayed b :--> b)) :--> (b :--> (list a :--> b))) Source #
O(n) . Fold on a list right-associatively, with opportunity for short circuting.
May short circuit when given reducer function is lazy in its second argument.
phead :: (PListLike list, PElemConstraint list a) => Term s (list a :--> a) Source #
Return the first element of a list. Partial, throws an error upon encountering an empty list.
plength :: PIsListLike list a => Term s (list a :--> PInteger) Source #
O(n) . Count the number of elements in the list
pmap :: (PListLike list, PElemConstraint list a, PElemConstraint list b) => Term s ((a :--> b) :--> (list a :--> list b)) Source #
O(n) . Map a function over a list of elements
pnull :: (PListLike list, PElemConstraint list a) => Term s (list a :--> PBool) Source #
O(1) . Check if a list is empty
precList :: 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) Source #
Like pelimList, but with a fixpoint recursion hatch.
psingleton :: PIsListLike list a => Term s (a :--> list a) Source #
O(1) . Create a singleton list from an element
ptail :: (PListLike list, PElemConstraint list a) => Term s (list a :--> list a) Source #
Take the tail of a list, meaning drop its head. Partial, throws an error upon encountering an empty list.
ptryIndex :: PIsListLike list a => Natural -> Term s (list a) -> Term s a Source #
Index a BuiltinList, throwing an error if the index is out of bounds.
pzipWith :: (PListLike list, PElemConstraint list a, PElemConstraint list b, PElemConstraint list c) => Term s ((a :--> (b :--> c)) :--> (list a :--> (list b :--> list c))) Source #
O(min(n, m)) . Zip two lists together with a passed function.
If the lists are of differing lengths, cut to the shortest.
pzipWith' :: (PListLike list, PElemConstraint list a, PElemConstraint list b, PElemConstraint list c) => (Term s a -> Term s b -> Term s c) -> Term s (list a :--> (list b :--> list c)) Source #
Like pzipWith but with Haskell-level merge function.
PlutusType
type PCon = PlutusType Source #
Deprecated: Use PlutusType
type PMatch = PlutusType Source #
Deprecated: Use PlutusType
class PlutusType (a :: PType) Source #
Instances
pcon :: PlutusType a => a s -> Term s a Source #
Construct a Plutarch Term via a Haskell datatype
pmatch :: PlutusType a => Term s a -> (a s -> Term s b) -> Term s b Source #
Pattern match over Plutarch Terms via a Haskell datatype
newtype DeriveNewtypePlutusType (a :: S -> Type) s Source #
Since: 1.10.0
Constructors
| DeriveNewtypePlutusType (a s) |
Instances
newtype DeriveFakePlutusType (a :: S -> Type) (s :: S) Source #
This is a cursed derivation strategy that will give you PlutusType with no questions asked. This is occasionally helpful
for deriving PlutusType for another derivation strategy wrapper whose target instance requires PlutusType as superclass.
See PLiftable
Constructors
| DeriveFakePlutusType (a s) |
Instances
| PlutusType (DeriveFakePlutusType a) Source # | |
Defined in Plutarch.Internal.PlutusType Associated Types type PInner (DeriveFakePlutusType a) :: PType Source # type PCovariant' (DeriveFakePlutusType a) Source # type PContravariant' (DeriveFakePlutusType a) Source # type PVariant' (DeriveFakePlutusType a) Source # Methods pcon' :: forall (s :: S). DeriveFakePlutusType a s -> Term s (PInner (DeriveFakePlutusType a)) Source # pmatch' :: forall (s :: S) (b :: PType). Term s (PInner (DeriveFakePlutusType a)) -> (DeriveFakePlutusType a s -> Term s b) -> Term s b Source # | |
| type PContravariant' (DeriveFakePlutusType a) Source # | |
Defined in Plutarch.Internal.PlutusType | |
| type PCovariant' (DeriveFakePlutusType a) Source # | |
Defined in Plutarch.Internal.PlutusType | |
| type PInner (DeriveFakePlutusType a) Source # | |
Defined in Plutarch.Internal.PlutusType | |
| type PVariant' (DeriveFakePlutusType a) Source # | |
Defined in Plutarch.Internal.PlutusType | |
newtype DeriveAsDataStruct (a :: S -> Type) s Source #
DeriveAsDataStruct derives PlutusType instances for the given type as Data structure, namely, using Constr constructor
of the Data type. Each constructor of the given type will have matching constructor index in the order of its definition.
Also, it is important to note that each fields can only contain term that has innermost representation of Data. Hence,
PInteger is not allowed but PAsData PInteger is allowed. Failure to follow this requirement will result in type error
with detailed explanation of the issue.
PInner of defined type will be PDataStruct (struct :: [[S -> Type]]) where struct is SOP type of its structure. Since PInner of
PDataStruct is PData, multiple data encoded structure can be nested without being wrapped in PAsData.
Consult example below for defining custom data-encoded datatype: @@ data PBobData (a :: S -> Type) (s :: S) = PBobData (Term s (PAsData a)) (Term s (PAsData PBool)) | PRobData (Term s (PAsData PByteString)) deriving stock (Generic) deriving anyclass (SOP.Generic) deriving PlutusType via (DeriveAsDataStruct (PBobData a))
pcon $ PBobData (pdata 10) (pdata pfalse) -- Constr 0 [#10, #false] pcon $ PRobData "hello" -- Constr 1 [#"hello"] @@
Since: 1.10.0
Constructors
| DeriveAsDataStruct (a s) |
Instances
newtype DeriveAsDataRec (a :: S -> Type) s Source #
DeriveAsDataRec derives PlutusType instances for given type as builtin list of Data. Unlike PDataAsDataStruct above, this will
encode data as List. Similarly, only types with its innermost representation PData is allowed for its fields.
One major difference is that DeriveAsDataRec only allows single constructor as it does not encode the constructor index. When
attempted to use this strategy to a type with more than one constructor will result in type error with detailed explanation of the issue.
PInner of defined type will be PDataRec (struct :: [S -> Type]) where struct is product type of its structure. PInner of PDataRec struct
is PBuiltinList PData.
It is almost always better to use DeriveAsDataRec over DeriveAsDataStruct when data type only have one constructor as it is more efficient
to work with on-chain. However, Plith(previously PlutusTx), by default, derives every datatype to use Constr. So, if a Plutarch type needs to remain
compatible with type defined in Plith, one needs to use DeriveAsDataStruct. This is why many single-constructor types are derived using
DeriveAsDataStruct on plutarch-ledger-api.
Consult example below for defining custom data-encoded datatype: @@ data PBobData (a :: S -> Type) (s :: S) = PBobData (Term s (PAsData a)) (Term s (PAsData PBool)) deriving stock (Generic) deriving anyclass (SOP.Generic) deriving PlutusType via (DeriveAsDataRec (PBobData a))
pcon $ PBobData (pdata 10) (pdata pfalse) -- [#10, #false] @@
Since: 1.10.0
Constructors
| DeriveAsDataRec (a s) |
Instances
newtype DeriveAsSOPStruct (a :: S -> Type) s Source #
via-derivation helper to derive PlutusType instance using SoP encoding. If your type has
only one constructor prefer using DeriveAsSOPRec instead.
Since: 1.10.0
Constructors
| DeriveAsSOPStruct (a s) |
Instances
| (Generic (a (Any :: S)), struct ~ UnTermStruct (a (Any :: S)), SListI2 struct, forall (s :: S). StructSameRepr s a struct, PSOPStructConstraint struct) => PlutusType (DeriveAsSOPStruct a) Source # | Since: 1.10.0 |
Defined in Plutarch.Repr.SOP Associated Types type PInner (DeriveAsSOPStruct a) :: PType Source # type PCovariant' (DeriveAsSOPStruct a) Source # type PContravariant' (DeriveAsSOPStruct a) Source # type PVariant' (DeriveAsSOPStruct a) Source # Methods pcon' :: forall (s :: S). DeriveAsSOPStruct a s -> Term s (PInner (DeriveAsSOPStruct a)) Source # pmatch' :: forall (s :: S) (b :: PType). Term s (PInner (DeriveAsSOPStruct a)) -> (DeriveAsSOPStruct a s -> Term s b) -> Term s b Source # | |
| type PContravariant' (DeriveAsSOPStruct a) Source # | |
Defined in Plutarch.Repr.SOP | |
| type PCovariant' (DeriveAsSOPStruct a) Source # | |
Defined in Plutarch.Repr.SOP | |
| type PInner (DeriveAsSOPStruct a) Source # | |
Defined in Plutarch.Repr.SOP | |
| type PVariant' (DeriveAsSOPStruct a) Source # | |
Defined in Plutarch.Repr.SOP | |
newtype DeriveAsSOPRec (a :: S -> Type) s Source #
via-derivation helper for SOP encoding, currently behaves exactly like DeriveAsSOPStruct
but can be used only on types with a single constructor. It is separate to leave a room for
future optimizations.
Since: 1.10.0
Constructors
| DeriveAsSOPRec (a s) |
Instances
| (Generic (a (Any :: S)), '[struct'] ~ Code (a (Any :: S)), struct ~ UnTermRec struct', SListI struct, forall (s :: S). StructSameRepr s a '[struct], RecTypePrettyError (Code (a (Any :: S)))) => PlutusType (DeriveAsSOPRec a) Source # | Since: 1.10.0 |
Defined in Plutarch.Repr.SOP Associated Types type PInner (DeriveAsSOPRec a) :: PType Source # type PCovariant' (DeriveAsSOPRec a) Source # type PContravariant' (DeriveAsSOPRec a) Source # type PVariant' (DeriveAsSOPRec a) Source # Methods pcon' :: forall (s :: S). DeriveAsSOPRec a s -> Term s (PInner (DeriveAsSOPRec a)) Source # pmatch' :: forall (s :: S) (b :: PType). Term s (PInner (DeriveAsSOPRec a)) -> (DeriveAsSOPRec a s -> Term s b) -> Term s b Source # | |
| type PContravariant' (DeriveAsSOPRec a) Source # | |
Defined in Plutarch.Repr.SOP | |
| type PCovariant' (DeriveAsSOPRec a) Source # | |
Defined in Plutarch.Repr.SOP | |
| type PInner (DeriveAsSOPRec a) Source # | |
Defined in Plutarch.Repr.SOP | |
| type PVariant' (DeriveAsSOPRec a) Source # | |
Defined in Plutarch.Repr.SOP | |
Numeric
Since: 1.10.0
Instances
| Arbitrary Positive Source # | Since: 1.10.0 |
| CoArbitrary Positive Source # | Since: 1.10.0 |
Defined in Plutarch.Internal.Numeric Methods coarbitrary :: Positive -> Gen b -> Gen b | |
| Function Positive Source # | Since: 1.10.0 |
Defined in Plutarch.Internal.Numeric | |
| Show Positive Source # | Since: 1.10.0 |
| Eq Positive Source # | Since: 1.10.0 |
| Ord Positive Source # | Since: 1.10.0 |
Defined in Plutarch.Internal.Numeric | |
| Pretty Positive Source # | Since: 1.10.0 |
Defined in Plutarch.Internal.Numeric | |
data PPositive (s :: S) Source #
Since: 1.10.0
Instances
data PNatural (s :: S) Source #
Since: 1.10.0
Instances
class PAdditiveSemigroup (a :: S -> Type) where Source #
The addition operation, and the notion of scaling by a positive.
Laws
x #+ y=y #+ x(commutativity of#+)x #+ (y #+ z)=(x #+ y) #+ z(associativity of#+)
If you define a custom pscalePositive, ensure the following also hold:
pscalePositive x pone=x(pscalePositive x n) #+ (pscalePositive x m)=pscalePositive x (n #+ m)pscalePositive (pscalePositive x n) m=pscalePositive x (n #* m)
The default implementation ensures these laws are satisfied.
Since: 1.10.0
Minimal complete definition
Nothing
Methods
(#+) :: forall (s :: S). Term s a -> Term s a -> Term s a infix 6 Source #
default (#+) :: forall (s :: S). PAdditiveSemigroup (PInner a) => Term s a -> Term s a -> Term s a Source #
pscalePositive :: forall (s :: S). Term s a -> Term s PPositive -> Term s a Source #
This defaults to exponentiation-by-squaring, which in general is the best we can do.
Instances
| PAdditiveSemigroup PBuiltinBLS12_381_G1_Element Source # | Since: 1.10.0 |
Defined in Plutarch.Internal.Numeric Methods (#+) :: forall (s :: S). Term s PBuiltinBLS12_381_G1_Element -> Term s PBuiltinBLS12_381_G1_Element -> Term s PBuiltinBLS12_381_G1_Element Source # pscalePositive :: forall (s :: S). Term s PBuiltinBLS12_381_G1_Element -> Term s PPositive -> Term s PBuiltinBLS12_381_G1_Element Source # | |
| PAdditiveSemigroup PBuiltinBLS12_381_G2_Element Source # | Since: 1.10.0 |
Defined in Plutarch.Internal.Numeric Methods (#+) :: forall (s :: S). Term s PBuiltinBLS12_381_G2_Element -> Term s PBuiltinBLS12_381_G2_Element -> Term s PBuiltinBLS12_381_G2_Element Source # pscalePositive :: forall (s :: S). Term s PBuiltinBLS12_381_G2_Element -> Term s PPositive -> Term s PBuiltinBLS12_381_G2_Element Source # | |
| PAdditiveSemigroup PInteger Source # | Since: 1.10.0 |
| PAdditiveSemigroup PNatural Source # | Since: 1.10.0 |
| PAdditiveSemigroup PPositive Source # | Since: 1.10.0 |
| PAdditiveSemigroup PRational Source # | Since: 1.10.0 |
class PAdditiveSemigroup a => PAdditiveMonoid (a :: S -> Type) where Source #
The notion of zero, as well as a way to scale by naturals.
Laws
pzero #+ x=x(pzerois the identity of#+)pscalePositive pzero n=pzero(pzerodoes not scale up)
If you define pscaleNatural, ensure the following as well:
pscaleNatural x (ppositiveToNatural # p)=pscalePositive x ppscaleNatural x pzero=pzero
The default implementation of pscaleNatural ensures these laws hold.
Since: 1.10.0
Minimal complete definition
Methods
pzero :: forall (s :: S). Term s a Source #
pscaleNatural :: forall (s :: S). Term s a -> Term s PNatural -> Term s a Source #
Instances
| PAdditiveMonoid PBuiltinBLS12_381_G1_Element Source # | Since: 1.10.0 |
Defined in Plutarch.Internal.Numeric Methods pzero :: forall (s :: S). Term s PBuiltinBLS12_381_G1_Element Source # pscaleNatural :: forall (s :: S). Term s PBuiltinBLS12_381_G1_Element -> Term s PNatural -> Term s PBuiltinBLS12_381_G1_Element Source # | |
| PAdditiveMonoid PBuiltinBLS12_381_G2_Element Source # | Since: 1.10.0 |
Defined in Plutarch.Internal.Numeric Methods pzero :: forall (s :: S). Term s PBuiltinBLS12_381_G2_Element Source # pscaleNatural :: forall (s :: S). Term s PBuiltinBLS12_381_G2_Element -> Term s PNatural -> Term s PBuiltinBLS12_381_G2_Element Source # | |
| PAdditiveMonoid PInteger Source # | Since: 1.10.0 |
| PAdditiveMonoid PNatural Source # | Since: 1.10.0 |
| PAdditiveMonoid PRational Source # | Since: 1.10.0 |
class PAdditiveMonoid a => PAdditiveGroup (a :: S -> Type) where Source #
The notion of additive inverses, and the subtraction operation.
Laws
If you define pnegate, the following laws must hold:
(pnegate # x) #+ x=pzero(pnegateis an additive inverse)pnegate #$ pnegate # x=x(pnegateis self-inverting)
If you define #-, the following law must hold:
x #- x=pzero
Additionally, the following 'consistency laws' must hold. Default
implementations of both pnegate and #- uphold these.
pnegate # x=pzero #- xx #- y=x #+ (pnegate # y)
Lastly, if you define a custom pscaleInteger, the following laws
must hold:
pscaleInteger x pzero=pzeropscaleInteger x (pnegate # y)=pnegate # (pscaleInteger x y)
Since: 1.10.0
Methods
pnegate :: forall (s :: S). Term s (a :--> a) Source #
(#-) :: forall (s :: S). Term s a -> Term s a -> Term s a infix 6 Source #
pscaleInteger :: forall (s :: S). Term s a -> Term s PInteger -> Term s a Source #
Instances
class PMultiplicativeSemigroup (a :: S -> Type) where Source #
The multiplication operation.
Laws
x #* (y #* z)=(x #* y) #* z(associativity of#*)
If you define a custom ppowPositive, ensure the following also hold:
ppowPositive x pone=x(ppowPositive x n) #* (ppowPositive x m)=ppowPositive x (n #+ m)ppowPositive (ppowPositive x n) m=ppowPositive x (n #* m)
The default implementation ensures these laws are satisfied.
Note
Unlike PAdditiveSemigroup, the multiplication operation doesn't need to be
commutative. Currently, all Plutarch-provided instances are, but this need
not be true for other instances.
Since: 1.10.0
Minimal complete definition
Nothing
Methods
(#*) :: forall (s :: S). Term s a -> Term s a -> Term s a infix 6 Source #
default (#*) :: forall (s :: S). PMultiplicativeSemigroup (PInner a) => Term s a -> Term s a -> Term s a Source #
ppowPositive :: forall (s :: S). Term s a -> Term s PPositive -> Term s a Source #
Instances
| PMultiplicativeSemigroup PBuiltinBLS12_381_MlResult Source # | Since: 1.10.0 |
Defined in Plutarch.Internal.Numeric Methods (#*) :: forall (s :: S). Term s PBuiltinBLS12_381_MlResult -> Term s PBuiltinBLS12_381_MlResult -> Term s PBuiltinBLS12_381_MlResult Source # ppowPositive :: forall (s :: S). Term s PBuiltinBLS12_381_MlResult -> Term s PPositive -> Term s PBuiltinBLS12_381_MlResult Source # | |
| PMultiplicativeSemigroup PInteger Source # | Since: 1.10.0 |
| PMultiplicativeSemigroup PNatural Source # | Since: 1.10.0 |
| PMultiplicativeSemigroup PPositive Source # | Since: 1.10.0 |
| PMultiplicativeSemigroup PRational Source # | Since: 1.10.0 |
class PMultiplicativeSemigroup a => PMultiplicativeMonoid (a :: S -> Type) where Source #
The notion of one (multiplicative identity), and exponentiation by - naturals.
Laws
pone #* x=x(poneis the left identity of#*)x #* pone=x(poneis the right identity of#*)ppowPositive pone p=pone(ponedoes not scale up)
If you define ppowNatural, ensure the following as well:
ppowNatural x (ppositiveToNatural # p)=ppowPositive x pppowNatural x pzero=pone
Since: 1.10.0
Minimal complete definition
Methods
pone :: forall (s :: S). Term s a Source #
ppowNatural :: forall (s :: S). Term s a -> Term s PNatural -> Term s a Source #
Instances
| PMultiplicativeMonoid PInteger Source # | Since: 1.10.0 |
| PMultiplicativeMonoid PNatural Source # | Since: 1.10.0 |
| PMultiplicativeMonoid PPositive Source # | Since: 1.10.0 |
| PMultiplicativeMonoid PRational Source # | Since: 1.10.0 |
class (PAdditiveGroup a, PMultiplicativeMonoid a) => PRing (a :: S -> Type) where Source #
Laws
pfromInteger 0=pzeropfromInteger 1=ponepfromInteger (x + y)=pfromInteger x #+ pfromInteger ypfromInteger (x * y)=pfromInteger x #* pfromInteger y
Additionally, the following 'interaction laws' must hold between the
instances of PAdditiveGroup and PMultiplicativeMonoid for a:
x #* (y #+ z)=(x #* y) #+ (x #* z)(#*left-distributes over#+)(y #+ z) #* x=(y #* x) #+ (z #* x)(#*right-distributes over#+)
Since: 1.10.0
Minimal complete definition
Nothing
Instances
class (PRing a, POrd a) => PIntegralDomain (a :: S -> Type) where Source #
Laws
Pedantry note
Technically, the requirements here are too strong: we demand an ordered ring, which integral domains don't necessarily have to be. However, in our case, our hand is forced by expected semantics: in abstract algebra, both the absolute value and the signum are real numbers (which are always totally ordered) but in our case, both must be elements of the integral domain itself. Thus, in order for the laws to make any sense, we have to ensure a total order on the integral domain. Since all of our integral domains are 'at least as big' as the integers, this doesn't pose a huge problem.
Since: 1.10.0
Minimal complete definition
Nothing
Instances
| PIntegralDomain PInteger Source # | Since: 1.10.0 |
| PIntegralDomain PRational Source # | Since: 1.10.0 |
ptryPositive :: forall (s :: S). Term s (PInteger :--> PPositive) Source #
Partial version of ppositive. Errors if argument is not positive.
Since: 1.10.0
ptryNatural :: forall (s :: S). Term s (PInteger :--> PNatural) Source #
Partial version of pnatural. Errors if argument is negative.
Since: 1.10.0
ppositiveToNatural :: forall (s :: S). Term s (PPositive :--> PNatural) Source #
'Relax' a PPositive to PNatural. This uses punsafeCoerce
underneath, but because any positive is also a natural, is safe.
Since: 1.10.0
Other
pto :: Term s a -> Term s (PInner a) Source #
Safely coerce from a Term to it's PInner representation.
newtype PForall (b :: a -> PType) s Source #
Instances
| PlutusType (PForall f) Source # | |
Defined in Plutarch.Internal.PlutusType | |
| type PContravariant' (PForall f) Source # | |
Defined in Plutarch.Internal.PlutusType | |
| type PCovariant' (PForall f) Source # | |
Defined in Plutarch.Internal.PlutusType | |
| type PInner (PForall f) Source # | |
Defined in Plutarch.Internal.PlutusType | |
| type PVariant' (PForall f) Source # | |
Defined in Plutarch.Internal.PlutusType | |
Show
Instances
| PShow PBool Source # | |
| PShow PByteString Source # | |
Defined in Plutarch.Internal.Show | |
| PShow PData Source # | |
| PShow PInteger Source # | |
| PShow PString Source # | |
| PShow PUnit Source # | |
| PShow PPositive Source # | Since: 1.10.0 |
| PShow PRational Source # | |
| (PIsData a, PShow a) => PShow (PDataNewtype a) Source # | Since: 1.7.0 |
Defined in Plutarch.Builtin | |
| (PIsData a, PShow a) => PShow (PAsData a) Source # | |
| (PShow a, Contains DefaultUni (PlutusRepr a)) => PShow (PBuiltinList a) Source # | |
Defined in Plutarch.Internal.Show | |
| PShow a => PShow (PList a) Source # | |
| PShow a => PShow (PMaybe a) Source # | Since: 1.10.0 |
| (PShow a, PShow b) => PShow (PBuiltinPair a b) Source # | |
Defined in Plutarch.Internal.Show | |
| (PShow a, PShow b) => PShow (PEither a b) Source # | Since: 1.10.0 |
| (PIsData a, PIsData b, PShow a, PShow b) => PShow (PEitherData a b) Source # | Since: 1.10.0 |
Defined in Plutarch.Either | |
| (PShow a, PShow b) => PShow (PPair a b) Source # | Since: 1.10.0 |
pshow :: PShow a => Term s a -> Term s PString Source #
Return the string representation of a Plutarch value
Term and related functionality
data Term (s :: S) (a :: PType) Source #
Instances
type ClosedTerm (a :: PType) = forall (s :: S). Term s a Source #
- Closed* terms with no free variables.
pforce :: Term s (PDelayed a) -> Term s a Source #
Plutus 'force',
used to force evaluation of PDelayed terms.
Plutus 'error'.
When using this explicitly, it should be ensured that the containing term is delayed, avoiding premature evaluation.
phoistAcyclic :: HasCallStack => ClosedTerm a -> Term s a Source #
plet :: Term s a -> (Term s a -> Term s b) -> Term s b Source #
Let bindings.
This is approximately a shorthand for a lambda and application:
plet v f == papp (plam f) v
But sufficiently small terms in WHNF may be inlined for efficiency.
(#) :: Term s (a :--> b) -> Term s a -> Term s b infixl 8 Source #
High precedence infixl synonym of papp, to be used like
function juxtaposition. e.g.:
>>>f # x # yf x y
data ((a :: PType) :--> (b :: PType)) (s :: S) infixr 0 Source #
Instances
| PlutusType (a :--> b) Source # | |
Defined in Plutarch.Internal.PlutusType | |
| (a' ~ Term s a, PLamN b' b s) => PLamN (a' -> b') (a :--> b) s Source # | |
Defined in Plutarch.Internal.PLam | |
| type PContravariant' (a :--> b) Source # | |
Defined in Plutarch.Internal.PlutusType | |
| type PCovariant' (a :--> b) Source # | |
Defined in Plutarch.Internal.PlutusType | |
| type PInner (a :--> b) Source # | |
Defined in Plutarch.Internal.PlutusType | |
| type PVariant' (a :--> b) Source # | |
Defined in Plutarch.Internal.PlutusType | |
Conversion
type family PSubtype (a :: PType) (b :: PType) :: Constraint where ... Source #
Equations
| PSubtype a b = (PSubtype' a b ~ 'PSubtypeRelation, PSubtypeHelper a b (PSubtype' a b)) |
class PSubtype a b => PTryFrom (a :: PType) (b :: PType) where Source #
PTryFrom a b represents a subtyping relationship between a and b,
and a way to go from a to b.
Laws:
- (punsafeCoerce . fst) $ tcont (ptryFrom x) ≡ pure x
Minimal complete definition
Nothing
Associated Types
type PTryFromExcess a b :: PType Source #
type PTryFromExcess a b = PTryFromExcess a (PInner b)
Methods
ptryFrom' :: forall s r. Term s a -> ((Term s b, Reduce (PTryFromExcess a b s)) -> Term s r) -> Term s r Source #
default ptryFrom' :: forall s r. (PTryFrom a (PInner b), PTryFromExcess a b ~ PTryFromExcess a (PInner b)) => Term s a -> ((Term s b, Reduce (PTryFromExcess a b s)) -> Term s r) -> Term s r Source #
Instances
ptryFrom :: forall b a s r. PTryFrom a b => Term s a -> ((Term s b, Reduce (PTryFromExcess a b s)) -> Term s r) -> Term s r Source #
Maybe
data PMaybe (a :: S -> Type) (s :: S) Source #
Since: 1.10.0
Instances
Pair
data PPair (a :: S -> Type) (b :: S -> Type) (s :: S) Source #
Plutus encoding of Pairs.
Note: This is represented differently than BuiltinPair. It is SoP encoded.
Instances
Rational
A Scott-encoded rational number, with a guaranteed positive denominator (and thus, a canonical form).
Note
This is not the Plutarch equivalent of a Plutus Rational; for this, you
want PRationalData from plutarch-ledger-api. PRational is designed to
optimize for computation: if you want to do any serious work with rational
numbers that isn't just passing them around, you want to use (or convert to)
PRational.
Instances
TermCont
newtype TermCont :: forall (r :: PType). S -> Type -> Type where Source #
Constructors
| TermCont | |
Fields
| |
Instances
| MonadFail (TermCont s) Source # | |
| Applicative (TermCont s) Source # | |
Defined in Plutarch.Internal.TermCont Methods pure :: a -> TermCont s a Source # (<*>) :: TermCont s (a -> b) -> TermCont s a -> TermCont s b Source # liftA2 :: (a -> b -> c) -> TermCont s a -> TermCont s b -> TermCont s c Source # (*>) :: TermCont s a -> TermCont s b -> TermCont s b Source # (<*) :: TermCont s a -> TermCont s b -> TermCont s a Source # | |
| Functor (TermCont s) Source # | |
| Monad (TermCont s) Source # | |
pguardC :: Term s PString -> Term s PBool -> TermCont s () Source #
Trace a message and raise error if cond is false. Otherwise, continue.
Example ===
onlyAllow42 :: Term s (PInteger :--> PUnit) onlyAllow42 = plam $ i -> unTermCont $ do pguardC "expected 42" $ i #== 42 pure $ pconstant ()
pguardC' :: Term s a -> Term s PBool -> TermCont @a s () Source #
Stop computation and return given term if cond is false. Otherwise, continue.
Example ===
is42 :: Term s (PInteger :--> PBool) is42 = plam $ i -> unTermCont $ do pguardC' (pconstant False) $ i #== 42 pure $ pconstant True
ptraceC :: Term s PString -> TermCont s () Source #
Like ptrace but works in a TermCont monad.
Example ===
foo :: Term s PUnit foo = unTermCont $ do ptraceC "returning unit!" pure $ pconstant ()
ptryFromC :: forall b r a s. PTryFrom a b => Term s a -> TermCont @r s (Term s b, Reduce (PTryFromExcess a b s)) Source #
Tracing
ptraceDebug :: forall (a :: S -> Type) (s :: S). Term s PString -> Term s a -> Term s a Source #
Trace the given message at the debug level before evaluating the given argument.
Since: 1.6.0
ptraceDebugError :: forall (a :: S -> Type) (s :: S). Term s PString -> Term s a Source #
Trace the given message at the debug level, then terminate with perror.
Since: 1.6.0
ptraceDebugIfFalse :: forall (s :: S). Term s PString -> Term s PBool -> Term s PBool Source #
Trace the given message at the debug level if the argument is false.
Since: 1.6.0
ptraceDebugIfTrue :: forall (s :: S). Term s PString -> Term s PBool -> Term s PBool Source #
Trace the given message at the debug level if the argument is true.
Since: 1.6.0
ptraceDebugShowId :: forall (a :: S -> Type) (s :: S). PShow a => Term s a -> Term s a Source #
Like Haskell's traceShowId but for Plutarch, at the debug level.
Since: 1.6.0
ptraceInfo :: forall (a :: S -> Type) (s :: S). Term s PString -> Term s a -> Term s a Source #
Trace the given message at the info level before evaluating the given argument.
Since: 1.6.0
ptraceInfoError :: forall (a :: S -> Type) (s :: S). Term s PString -> Term s a Source #
Trace the given message at the info level, then terminate with perror.
Since: 1.6.0
ptraceInfoIfFalse :: forall (s :: S). Term s PString -> Term s PBool -> Term s PBool Source #
Trace the given message at the info level if the argument is false.
Since: 1.6.0
ptraceInfoIfTrue :: forall (s :: S). Term s PString -> Term s PBool -> Term s PBool Source #
Trace the given message at the info level if the argument is true.
Since: 1.6.0
ptraceInfoShowId :: forall (a :: S -> Type) (s :: S). PShow a => Term s a -> Term s a Source #
Like Haskell's traceShowId but for Plutarch, at the info level.
Since: 1.6.0
Semigroup and Monoid
class PSemigroup (a :: S -> Type) where Source #
Laws
The only mandatory law is that #<> must be associative:
x #<> (y #<> z) = (x #<> y) #<> z
If you define pstimes, ensure the following also hold:
pstimes pone x=x(pstimes p1 x) #<> (pstimes p2 x)=pstimes (p1 #+ p2) xpstimes p1 (pstimes p2 x)=pstimes (p1 #* p2) x
The default implementation automatically ensures these laws hold.
Since: 1.10.0
Minimal complete definition
Nothing
Methods
(#<>) :: forall (s :: S). Term s a -> Term s a -> Term s a infixr 6 Source #
default (#<>) :: forall (s :: S). PSemigroup (PInner a) => Term s a -> Term s a -> Term s a Source #
pstimes :: forall (s :: S). Term s PPositive -> Term s a -> Term s a Source #
Instances
class PSemigroup a => PMonoid (a :: S -> Type) where Source #
Laws
pmempty #<> x=x #<> pmempty=xpstimes n pmempty=pmempty
If you define pmtimes, ensure the following as well:
pmtimes (ppositiveToNatural # p) x=pstimes p xpmtimes pzero x=pmempty
The default implementation of pmtimes ensures these laws hold.
Since: 1.10.0
Minimal complete definition
Nothing
Methods
pmempty :: forall (s :: S). Term s a Source #
pmtimes :: forall (s :: S). Term s PNatural -> Term s a -> Term s a Source #
Instances
| PMonoid PBitString Source # | Since: 1.10.0 |
Defined in Plutarch.BitString | |
| PMonoid PBuiltinBLS12_381_G1_Element Source # | Since: 1.10.0 |
Defined in Plutarch.Internal.Semigroup | |
| PMonoid PBuiltinBLS12_381_G2_Element Source # | Since: 1.10.0 |
Defined in Plutarch.Internal.Semigroup | |
| PMonoid PByteString Source # | Since: 1.10.0 |
Defined in Plutarch.Internal.Semigroup | |
| PMonoid PString Source # | Since: 1.10.0 |
| PMonoid PUnit Source # | Since: 1.10.0 |
| PMonoid (PAnd PBool) Source # | Since: 1.10.0 |
| PMonoid (PAnd PByteString) Source # | Since: 1.10.0 |
Defined in Plutarch.Internal.Semigroup | |
| PMonoid (POr PBool) Source # | Since: 1.10.0 |
| PMonoid (POr PByteString) Source # | Since: 1.10.0 |
Defined in Plutarch.Internal.Semigroup | |
| PMonoid (PXor PBool) Source # | Since: 1.10.0 |
| PMonoid (PXor PByteString) Source # | Since: 1.10.0 |
Defined in Plutarch.Internal.Semigroup | |
| (PMonoid a, PMonoid b) => PMonoid (PPair a b) Source # | Since: 1.10.0 |
newtype PAnd (a :: S -> Type) (s :: S) Source #
Wrapper for types which have logical AND semantics somehow.
Since: 1.10.0
Instances
newtype POr (a :: S -> Type) (s :: S) Source #
Wrapper for types which have logical OR semantics somehow.
Since: 1.10.0
Instances
newtype PXor (a :: S -> Type) (s :: S) Source #
Wrapper for types which have logical XOR semantics somehow.
Since: 1.10.0
Instances
Unrolling utilities
punrollBound :: forall a b s. Integer -> Term s (a :--> b) -> (Term s (a :--> b) -> Term s (a :--> b)) -> Term s (a :--> b) Source #
This is simplified version of punrollBound' without doing additional recursion on Haskell level value.
Since: 1.10.0
punrollBound' :: forall a b c s. Integer -> (c -> Term s (a :--> b)) -> ((c -> Term s (a :--> b)) -> c -> Term s (a :--> b)) -> c -> Term s (a :--> b) Source #
The first argument specifies the unrolling depth. The second argument defines the fallback behavior when the recursion depth exceeds the provided unrolling depth.
The fixed-point implementation provided requires a Haskell-level value c and a Plutarch function of type `Term s (a :--> b)`. The functional for the recursion is passed as a Haskell function.
The inclusion of the additional, arbitrary Haskell value (typed c) enables further optimization by allowing pre-computation of constant values that depend only on the recursion depth.
This function will be used in a very niche situations. Using Haskell-level value for constant replacement is only practical on a single branch recursion with constant value that needs to be added
on each step. plength is one of the niche use case.
Since: 1.10.0
punrollUnbound :: forall a b s. Integer -> (Term s (a :--> b) -> Term s (a :--> b)) -> Term s (a :--> b) Source #
Unroll given amount of steps, and for rest, uses pfix to support unbound recursion.
Since: 1.10.0