| Safe Haskell | Safe-Inferred |
|---|---|
| Language | GHC2021 |
Plutarch.Prelude
Contents
- Boolean
- Bytestring
- Cryptographic primitives
- Data encoding
- Integer
- Opaque
- String
- Unit
- DataRepr
- Either
- Enumerable and Countable
- Eq and Ord
- Fixed point
- IsData
- Lifting and lowering
- Lists
- Arrays
- PlutusType
- Numeric
- Other
- Show
- Term and related functionality
- Conversion
- Maybe
- Pair
- Rational
- TermCont
- Tracing
- Semigroup and Monoid
- Unrolling utilities
- Validation
Synopsis
- 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)
- 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
- data PBuiltinPair (a :: S -> Type) (b :: S -> Type) (s :: S) = PBuiltinPair (Term s a) (Term s 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)
- pheadTailBuiltin :: forall (a :: S -> Type) (b :: S -> Type) (s :: S). Term s (PBuiltinList a) -> (Term s a -> Term s (PBuiltinList a) -> Term s b) -> Term s b
- 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
- class PDataFields (a :: S -> Type)
- data PDataRecord (as :: [PLabeledType]) (s :: S)
- data PDataSum defs s
- data PLabeledType = Symbol := (S -> Type)
- data PlutusTypeData
- pdcons :: forall label a l s. Term s (PAsData a :--> (PDataRecord l :--> PDataRecord ((label ':= a) ': l)))
- pdnil :: Term s (PDataRecord '[])
- pfield :: forall name b p s a as n. (PDataFields p, as ~ PFields p, n ~ PLabelIndex name as, KnownNat n, a ~ PUnLabel (IndexList n as), PFromDataable a b) => Term s (p :--> b)
- pletFields :: forall fs a s b ps bs. (PDataFields a, ps ~ PFields a, bs ~ Bindings ps fs, BindFields ps bs) => Term s a -> (HRecOf a fs s -> Term s b) -> Term s b
- 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
- pfixHoisted :: Term s (((a :--> b) :--> (a :--> b)) :--> (a :--> b))
- pfix :: forall (a :: S -> Type) (b :: S -> Type) (s :: S). (Term s (a :--> b) -> Term s (a :--> b)) -> Term s (a :--> b)
- pfixInline :: forall (a :: S -> Type) (b :: S -> Type) (s :: S). (Term s (a :--> b) -> Term s (a :--> b)) -> Term s (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 DeriveAsDataRec (a :: S -> Type) s = DeriveAsDataRec {
- unDeriveAsDataRec :: a s
- newtype DeriveAsDataStruct (a :: S -> Type) s = DeriveAsDataStruct {
- unDeriveAsDataStruct :: a s
- newtype DeriveAsSOPRec (a :: S -> Type) s = DeriveAsSOPRec {
- unDeriveAsSOPRec :: a s
- newtype DeriveAsSOPStruct (a :: S -> Type) s = DeriveAsSOPStruct {
- unDeriveAsSOPStruct :: a s
- newtype PLifted (s :: S) (a :: S -> Type) = PLifted (Term s POpaque)
- reprToPlutUni :: forall (a :: S -> Type) (s :: S). DefaultUni `Includes` PlutusRepr a => PlutusRepr a -> PLifted s a
- plutToReprUni :: forall (a :: S -> Type). KnownBuiltinType (Term DeBruijn DefaultUni DefaultFun ()) (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))
- data PArray (a :: S -> Type) (s :: S)
- plengthOfArray :: forall (a :: S -> Type) (s :: S). Term s (PArray a :--> PInteger)
- pindexArray :: forall (a :: S -> Type) (s :: S). Term s (PArray a :--> (PInteger :--> a))
- plistToArray :: forall (a :: S -> Type) (s :: S). Term s (PBuiltinList a :--> PArray a)
- class (PInner a ~ DerivedPInner (DPTStrat a) a, PlutusTypeStrat (DPTStrat a), PlutusTypeStratConstraint (DPTStrat a) a, PlutusType a) => DerivePlutusType (a :: S -> Type) where
- class PlutusType (a :: S -> Type) where
- pcon :: PlutusType a => a s -> Term s a
- pmatch :: PlutusType a => Term s a -> (a s -> Term s b) -> Term s b
- data PlutusTypeNewtype
- data PlutusTypeScott
- newtype DeriveNewtypePlutusType (a :: S -> Type) s = DeriveNewtypePlutusType (a s)
- newtype DeriveFakePlutusType (a :: S -> Type) (s :: S) = DeriveFakePlutusType (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)
- 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 -> S -> Type) s = PForall (forall (x :: a). Term s (b x))
- class PShow t where
- pshow :: PShow a => Term s a -> Term s PString
- data Term (s :: S) (a :: S -> Type)
- data S
- data PDelayed (a :: S -> Type) (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 :: forall (a :: S -> Type) (s :: S). HasCallStack => (forall (s' :: S). Term s' 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 :: S -> Type) :--> (b :: S -> Type)) (s :: S)
- type family PSubtype (a :: S -> Type) (b :: S -> Type) :: Constraint where ...
- class PSubtype a b => PTryFrom (a :: S -> Type) (b :: S -> Type) where
- type PTryFromExcess a b :: S -> Type
- 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
- pto :: forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner 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 :: S -> Type). 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)
- pletFieldsC :: forall fs a s b ps bs. (PDataFields a, ps ~ PFields a, bs ~ Bindings ps fs, BindFields ps bs) => Term s a -> TermCont @b s (HRec (BoundTerms ps bs s))
- 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
- 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
- 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
- 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)
- class PValidateData (a :: S -> Type) where
- newtype Don'tValidate (a :: S -> Type) (s :: S) = Don'tValidate {
- unDon'tValidate :: a s
- newtype DeriveNewtypePValidateData (a :: S -> Type) (b :: S -> Type) (s :: S) = DeriveNewtypePValidateData (a s)
- pparseData :: forall (a :: S -> Type) (s :: S). (PIsData a, PValidateData a) => Term s PData -> Term s (PAsData a)
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 #
Deprecated: Use pif instead
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.
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
data PBuiltinPair (a :: S -> Type) (b :: S -> Type) (s :: S) Source #
A builtin Plutus pair.
Since: 1.12.0
Constructors
| PBuiltinPair (Term s a) (Term s b) |
Instances
| (PTryFrom PData a, a ~ PAsData a', PIsData a', PTryFrom PData b, b ~ PAsData b', PIsData b') => PTryFrom PData (PAsData (PBuiltinPair a b)) Source # | Recover a `PAsData (PBuiltinPair a b)` |
Defined in Plutarch.Internal.TryFrom Associated Types type PTryFromExcess PData (PAsData (PBuiltinPair a b)) :: S -> Type Source # | |
| (PValidateData a, PValidateData b) => PValidateData (PBuiltinList (PBuiltinPair (PAsData a) (PAsData b))) Source # | Checks that we have a Since: 1.13.0 |
| (PEq a, PEq b) => PEq (PBuiltinPair a b) Source # | |
Defined in Plutarch.Internal.Eq Methods (#==) :: forall (s :: S). Term s (PBuiltinPair a b) -> Term s (PBuiltinPair a b) -> Term s PBool Source # | |
| PIsData (PBuiltinPair (PAsData a) (PAsData b)) Source # | |
Defined in Plutarch.Internal.IsData | |
| PIsData (PBuiltinPair PData PData) Source # | |
Defined in Plutarch.Internal.IsData | |
| PIsData (PBuiltinPair PInteger (PBuiltinList PData)) Source # | |
Defined in Plutarch.Internal.IsData Methods pfromDataImpl :: forall (s :: S). Term s (PAsData (PBuiltinPair PInteger (PBuiltinList PData))) -> Term s (PBuiltinPair PInteger (PBuiltinList PData)) Source # pdataImpl :: forall (s :: S). Term s (PBuiltinPair PInteger (PBuiltinList PData)) -> Term s PData Source # | |
| (PLiftable a, Includes DefaultUni (PlutusRepr a), KnownBuiltinType (Term DeBruijn DefaultUni DefaultFun ()) (PlutusRepr a), PLiftable b, Includes DefaultUni (PlutusRepr b), KnownBuiltinType (Term DeBruijn DefaultUni DefaultFun ()) (PlutusRepr b)) => PLiftable (PBuiltinPair a b) Source # | Since: 1.13.0 |
Defined in Plutarch.Internal.Lift Associated Types type AsHaskell (PBuiltinPair a b) Source # type PlutusRepr (PBuiltinPair a b) Source # Methods haskToRepr :: AsHaskell (PBuiltinPair a b) -> PlutusRepr (PBuiltinPair a b) Source # reprToHask :: PlutusRepr (PBuiltinPair a b) -> Either LiftError (AsHaskell (PBuiltinPair a b)) Source # reprToPlut :: forall (s :: S). PlutusRepr (PBuiltinPair a b) -> PLifted s (PBuiltinPair a b) Source # plutToRepr :: (forall (s :: S). PLifted s (PBuiltinPair a b)) -> Either LiftError (PlutusRepr (PBuiltinPair a b)) Source # | |
| (PValidateData a, PValidateData b) => PValidateData (PBuiltinPair (PAsData a) (PAsData b)) Source # | Checks that we have a Since: 1.12.0 |
| PValidateData (PBuiltinPair PData PData) Source # | Checks that we have a Since: 1.12.0 |
| PlutusType (PBuiltinPair a b) Source # | Important noteDue to some weirdnesses regarding builtins, Since: 1.12.0 |
Defined in Plutarch.Internal.PlutusType Methods pcon' :: forall (s :: S). PBuiltinPair a b s -> Term s (PInner (PBuiltinPair a b)) Source # pmatch' :: forall (s :: S) (b0 :: S -> Type). Term s (PInner (PBuiltinPair a b)) -> (PBuiltinPair a b s -> Term s b0) -> Term s b0 Source # | |
| (PShow a, PShow b) => PShow (PBuiltinPair a b) Source # | |
Defined in Plutarch.Internal.Show | |
| type PTryFromExcess PData (PAsData (PBuiltinPair a b)) Source # | |
Defined in Plutarch.Internal.TryFrom | |
| type AsHaskell (PBuiltinPair a b) Source # | |
Defined in Plutarch.Internal.Lift | |
| type PlutusRepr (PBuiltinPair a b) Source # | |
Defined in Plutarch.Internal.Lift | |
| type PInner (PBuiltinPair a b) Source # | |
Defined in Plutarch.Internal.PlutusType | |
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 #
Deprecated: Use pmatch instead
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 #
Deprecated: Use pmatch instead
ptailBuiltin :: Term s (PBuiltinList a :--> PBuiltinList a) Source #
pheadTailBuiltin :: forall (a :: S -> Type) (b :: S -> Type) (s :: S). Term s (PBuiltinList a) -> (Term s a -> Term s (PBuiltinList a) -> Term s b) -> Term s b Source #
Use this in preference to pheadBuiltin and ptailBuiltin on the same
PBuiltinList, as this will be faster. This is also faster than a pmatch,
as the PNil case is omitted.
Since: 1.13.0
Integer
A builtin Plutus integer.
Since: 1.10.0
Instances
Opaque
An Arbitrary Term with an unknown type
Instances
| PlutusType POpaque Source # | |
| type PInner 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
DataRepr
class PDataFields (a :: S -> Type) Source #
Class allowing letFields to work for a Plutarch type (`S -> Type`), usually via
PIsDataRepr, but is derived for some other types for convenience.
Instances
| (PIsData a, PDataFields a) => PDataFields (PAsData a) Source # | |
| PDataFields (PDataRecord as) Source # | |
Defined in Plutarch.DataRepr.Internal.Field Associated Types type PFields (PDataRecord as) :: [PLabeledType] Source # Methods ptoFields :: forall (s :: S). Term s (PDataRecord as) -> Term s (PDataRecord (PFields (PDataRecord as))) Source # | |
| PDataFields (PDataSum '[as]) Source # | |
data PDataRecord (as :: [PLabeledType]) (s :: S) Source #
A "record" of `exists a. PAsData a`. The underlying representation is `PBuiltinList PData`.
Instances
A sum of PDataRecords. The underlying representation is the Constr constructor,
where the integer is the index of the variant and the list is the record.
Instances
data PLabeledType Source #
Instances
| PDataFields (PDataSum '[as]) Source # | |
| (SListI xs, POrd x, PIsData x, POrd (PDataRecord (x' ': xs))) => POrd (PDataRecord ((label ':= x) ': (x' ': xs))) Source # | |
Defined in Plutarch.DataRepr.Internal Methods (#<=) :: forall (s :: S). Term s (PDataRecord ((label ':= x) ': (x' ': xs))) -> Term s (PDataRecord ((label ':= x) ': (x' ': xs))) -> Term s PBool Source # (#<) :: forall (s :: S). Term s (PDataRecord ((label ':= x) ': (x' ': xs))) -> Term s (PDataRecord ((label ':= x) ': (x' ': xs))) -> Term s PBool Source # pmax :: forall (s :: S). Term s (PDataRecord ((label ':= x) ': (x' ': xs))) -> Term s (PDataRecord ((label ':= x) ': (x' ': xs))) -> Term s (PDataRecord ((label ':= x) ': (x' ': xs))) Source # pmin :: forall (s :: S). Term s (PDataRecord ((label ':= x) ': (x' ': xs))) -> Term s (PDataRecord ((label ':= x) ': (x' ': xs))) -> Term s (PDataRecord ((label ':= x) ': (x' ': xs))) Source # | |
| (POrd x, PIsData x) => POrd (PDataRecord '[label ':= x]) Source # | |
Defined in Plutarch.DataRepr.Internal Methods (#<=) :: forall (s :: S). Term s (PDataRecord '[label ':= x]) -> Term s (PDataRecord '[label ':= x]) -> Term s PBool Source # (#<) :: forall (s :: S). Term s (PDataRecord '[label ':= x]) -> Term s (PDataRecord '[label ':= x]) -> Term s PBool Source # pmax :: forall (s :: S). Term s (PDataRecord '[label ':= x]) -> Term s (PDataRecord '[label ':= x]) -> Term s (PDataRecord '[label ':= x]) Source # pmin :: forall (s :: S). Term s (PDataRecord '[label ':= x]) -> Term s (PDataRecord '[label ':= x]) -> Term s (PDataRecord '[label ':= x]) Source # | |
| POrd (PDataRecord ('[] :: [PLabeledType])) Source # | |
Defined in Plutarch.DataRepr.Internal Methods (#<=) :: forall (s :: S). Term s (PDataRecord '[]) -> Term s (PDataRecord '[]) -> Term s PBool Source # (#<) :: forall (s :: S). Term s (PDataRecord '[]) -> Term s (PDataRecord '[]) -> Term s PBool Source # pmax :: forall (s :: S). Term s (PDataRecord '[]) -> Term s (PDataRecord '[]) -> Term s (PDataRecord '[]) Source # pmin :: forall (s :: S). Term s (PDataRecord '[]) -> Term s (PDataRecord '[]) -> Term s (PDataRecord '[]) Source # | |
| (All (Top :: PLabeledType -> Constraint) xs, KnownSymbol label, PIsData x, PShow x, PShow (PDataRecordShowHelper xs)) => PShow (PDataRecord ((label ':= x) ': xs)) Source # | |
| PShow (PDataRecord ('[] :: [PLabeledType])) Source # | |
Defined in Plutarch.DataRepr.Internal | |
| (Helper2 (PSubtype' PData pty) pty, PTryFrom (PBuiltinList PData) (PDataRecord as), PTryFromExcess (PBuiltinList PData) (PDataRecord as) ~ HRecP ase) => PTryFrom (PBuiltinList PData) (PDataRecord ((name ':= pty) ': as)) Source # | |
Defined in Plutarch.DataRepr.Internal Associated Types type PTryFromExcess (PBuiltinList PData) (PDataRecord ((name ':= pty) ': as)) :: S -> Type Source # Methods ptryFrom' :: forall (s :: S) (r :: S -> Type). Term s (PBuiltinList PData) -> ((Term s (PDataRecord ((name ':= pty) ': as)), Reduce (PTryFromExcess (PBuiltinList PData) (PDataRecord ((name ':= pty) ': as)) s)) -> Term s r) -> Term s r Source # | |
| PTryFrom (PBuiltinList PData) (PDataRecord ('[] :: [PLabeledType])) Source # | |
Defined in Plutarch.DataRepr.Internal Associated Types type PTryFromExcess (PBuiltinList PData) (PDataRecord '[]) :: S -> Type Source # Methods ptryFrom' :: forall (s :: S) (r :: S -> Type). Term s (PBuiltinList PData) -> ((Term s (PDataRecord '[]), Reduce (PTryFromExcess (PBuiltinList PData) (PDataRecord '[]) s)) -> Term s r) -> Term s r Source # | |
| type PFields (PDataSum '[as]) Source # | |
Defined in Plutarch.DataRepr.Internal.Field | |
| type PTryFromExcess (PBuiltinList PData) (PDataRecord ((name ':= pty) ': as)) Source # | |
Defined in Plutarch.DataRepr.Internal | |
| type PTryFromExcess (PBuiltinList PData) (PDataRecord ('[] :: [PLabeledType])) Source # | |
Defined in Plutarch.DataRepr.Internal | |
data PlutusTypeData Source #
Instances
| PlutusTypeStrat PlutusTypeData Source # | |
Defined in Plutarch.DataRepr.Internal Associated Types type PlutusTypeStratConstraint PlutusTypeData :: (S -> Type) -> Constraint Source # type DerivedPInner PlutusTypeData a :: S -> Type Source # Methods derivedPCon :: forall a (s :: S). (DerivePlutusType a, DPTStrat a ~ PlutusTypeData) => a s -> Term s (DerivedPInner PlutusTypeData a) Source # derivedPMatch :: forall a (s :: S) (b :: S -> Type). (DerivePlutusType a, DPTStrat a ~ PlutusTypeData) => Term s (DerivedPInner PlutusTypeData a) -> (a s -> Term s b) -> Term s b Source # | |
| type PlutusTypeStratConstraint PlutusTypeData Source # | |
Defined in Plutarch.DataRepr.Internal | |
| type DerivedPInner PlutusTypeData a Source # | |
Defined in Plutarch.DataRepr.Internal | |
pdcons :: forall label a l s. Term s (PAsData a :--> (PDataRecord l :--> PDataRecord ((label ':= a) ': l))) Source #
Cons a field to a data record.
You can specify the label to associate with the field using type applications-
foo :: Term s (PDataRecord '[ "fooField" ':= PByteString ]) foo = pdcons @"fooField" # pdata (phexByteStr "ab") # pdnil
pdnil :: Term s (PDataRecord '[]) Source #
An empty PDataRecord.
pfield :: forall name b p s a as n. (PDataFields p, as ~ PFields p, n ~ PLabelIndex name as, KnownNat n, a ~ PUnLabel (IndexList n as), PFromDataable a b) => Term s (p :--> b) Source #
Get a single field from a Term.
- NB*: If you access more than one field from
the same value you should use
pletFieldsinstead, which will generate the bindings more efficiently.
pletFields :: forall fs a s b ps bs. (PDataFields a, ps ~ PFields a, bs ~ Bindings ps fs, BindFields ps bs) => Term s a -> (HRecOf a fs s -> Term s b) -> Term s b Source #
Bind a HRec of named fields containing all the specified fields.
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
pfixHoisted :: Term s (((a :--> b) :--> (a :--> b)) :--> (a :--> b)) Source #
Fixpoint recursion, used to encode recursive functions.
Note
This fixpoint combinator is hoisted, which allows for the smallest code
size. However, in terms of execution units, pfixHoisted is the least
efficient.
pfixHoisted used to be the default fixpoint combinator in Plutarch. If you
used pfix before, and want to maintain identical behaviour, use this
function.
Example
Additional examples can be found in examples/Recursion.hs.
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 = pfixHoisted #$ plam iterateN'Since: 1.12.0
pfix :: forall (a :: S -> Type) (b :: S -> Type) (s :: S). (Term s (a :--> b) -> Term s (a :--> b)) -> Term s (a :--> b) Source #
As pfixHoisted, but not hoisted. This is more efficient in terms of
execution units, but takes up more script space.
Since: 1.12.0
pfixInline :: forall (a :: S -> Type) (b :: S -> Type) (s :: S). (Term s (a :--> b) -> Term s (a :--> b)) -> Term s (a :--> b) Source #
As pfix, but we perform some additional inlining into the function
argument. This allows for even more speed, but at the cost of larger scripts.
Since: 1.12.0
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 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 | |
Fields
| |
Instances
| (Generic (a (Any :: S)), All PInnermostIsDataDataRepr struct, struct ~ UnTermRec struct', Generic (a (Any :: S)), '[struct'] ~ Code (a (Any :: S)), All PValidateData struct, SListI struct) => PValidateData (DeriveAsDataRec a) Source # | Checks that we have a Since: 1.12.0 |
| (Generic (a (Any :: S)), '[struct'] ~ Code (a (Any :: S)), struct ~ UnTermRec struct', All PInnermostIsDataDataRepr struct, SListI struct, forall (s :: S). StructSameRepr s a '[struct], RecTypePrettyError (Code (a (Any :: S)))) => PlutusType (DeriveAsDataRec a) Source # | Since: 1.10.0 |
Defined in Plutarch.Repr.Data Methods pcon' :: forall (s :: S). DeriveAsDataRec a s -> Term s (PInner (DeriveAsDataRec a)) Source # pmatch' :: forall (s :: S) (b :: S -> Type). Term s (PInner (DeriveAsDataRec a)) -> (DeriveAsDataRec a s -> Term s b) -> Term s b Source # | |
| type PInner (DeriveAsDataRec a) Source # | |
Defined in Plutarch.Repr.Data | |
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 | |
Fields
| |
Instances
| (Generic (a (Any :: S)), struct ~ UnTermStruct (a (Any :: S)), All2 PInnermostIsDataDataRepr struct, All2 PValidateData struct, SListI2 struct) => PValidateData (DeriveAsDataStruct a) Source # | Checks that we have a Since: 1.12.0 |
| (Generic (a (Any :: S)), struct ~ UnTermStruct (a (Any :: S)), All2 PInnermostIsDataDataRepr struct, SListI2 struct, forall (s :: S). StructSameRepr s a struct) => PlutusType (DeriveAsDataStruct a) Source # | Since: 1.10.0 |
Defined in Plutarch.Repr.Data Methods pcon' :: forall (s :: S). DeriveAsDataStruct a s -> Term s (PInner (DeriveAsDataStruct a)) Source # pmatch' :: forall (s :: S) (b :: S -> Type). Term s (PInner (DeriveAsDataStruct a)) -> (DeriveAsDataStruct a s -> Term s b) -> Term s b Source # | |
| type PInner (DeriveAsDataStruct a) Source # | |
Defined in Plutarch.Repr.Data | |
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 | |
Fields
| |
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 Methods pcon' :: forall (s :: S). DeriveAsSOPRec a s -> Term s (PInner (DeriveAsSOPRec a)) Source # pmatch' :: forall (s :: S) (b :: S -> Type). Term s (PInner (DeriveAsSOPRec a)) -> (DeriveAsSOPRec a s -> Term s b) -> Term s b Source # | |
| type PInner (DeriveAsSOPRec a) Source # | |
Defined in Plutarch.Repr.SOP | |
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 | |
Fields
| |
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 Methods pcon' :: forall (s :: S). DeriveAsSOPStruct a s -> Term s (PInner (DeriveAsSOPStruct a)) Source # pmatch' :: forall (s :: S) (b :: S -> Type). Term s (PInner (DeriveAsSOPStruct a)) -> (DeriveAsSOPStruct a s -> Term s b) -> Term s b Source # | |
| type PInner (DeriveAsSOPStruct a) Source # | |
Defined in Plutarch.Repr.SOP | |
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). DefaultUni `Includes` PlutusRepr a => PlutusRepr a -> PLifted s a Source #
Valid definition of reprToPlut if PlutusRepr a is in the Plutus universe.
Since: 1.13.0
plutToReprUni :: forall (a :: S -> Type). KnownBuiltinType (Term DeBruijn DefaultUni DefaultFun ()) (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.13.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.
Arrays
data PArray (a :: S -> Type) (s :: S) Source #
A packed collection of values.
Since: 1.11.0
Instances
plengthOfArray :: forall (a :: S -> Type) (s :: S). Term s (PArray a :--> PInteger) Source #
Get the length of an array, as per CIP-138.
Since: 1.11.0
pindexArray :: forall (a :: S -> Type) (s :: S). Term s (PArray a :--> (PInteger :--> a)) Source #
Index an array, as per CIP-138.
Since: 1.11.0
plistToArray :: forall (a :: S -> Type) (s :: S). Term s (PBuiltinList a :--> PArray a) Source #
Convert a (builtin) list to an array with the same contents in the same order, as per CIP-138.
Since: 1.11.0
PlutusType
class (PInner a ~ DerivedPInner (DPTStrat a) a, PlutusTypeStrat (DPTStrat a), PlutusTypeStratConstraint (DPTStrat a) a, PlutusType a) => DerivePlutusType (a :: S -> Type) Source #
Deprecated: Use the new mechanisms instead
class PlutusType (a :: S -> Type) 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
data PlutusTypeNewtype Source #
Instances
| PlutusTypeStrat PlutusTypeNewtype Source # | |
Defined in Plutarch.Internal.Newtype Associated Types type PlutusTypeStratConstraint PlutusTypeNewtype :: (S -> Type) -> Constraint Source # type DerivedPInner PlutusTypeNewtype a :: S -> Type Source # Methods derivedPCon :: forall a (s :: S). (DerivePlutusType a, DPTStrat a ~ PlutusTypeNewtype) => a s -> Term s (DerivedPInner PlutusTypeNewtype a) Source # derivedPMatch :: forall a (s :: S) (b :: S -> Type). (DerivePlutusType a, DPTStrat a ~ PlutusTypeNewtype) => Term s (DerivedPInner PlutusTypeNewtype a) -> (a s -> Term s b) -> Term s b Source # | |
| type PlutusTypeStratConstraint PlutusTypeNewtype Source # | |
Defined in Plutarch.Internal.Newtype | |
| type DerivedPInner PlutusTypeNewtype a Source # | |
Defined in Plutarch.Internal.Newtype | |
data PlutusTypeScott Source #
Instances
| PlutusTypeStrat PlutusTypeScott Source # | |
Defined in Plutarch.Internal.ScottEncoding Associated Types type PlutusTypeStratConstraint PlutusTypeScott :: (S -> Type) -> Constraint Source # type DerivedPInner PlutusTypeScott a :: S -> Type Source # Methods derivedPCon :: forall a (s :: S). (DerivePlutusType a, DPTStrat a ~ PlutusTypeScott) => a s -> Term s (DerivedPInner PlutusTypeScott a) Source # derivedPMatch :: forall a (s :: S) (b :: S -> Type). (DerivePlutusType a, DPTStrat a ~ PlutusTypeScott) => Term s (DerivedPInner PlutusTypeScott a) -> (a s -> Term s b) -> Term s b Source # | |
| type PlutusTypeStratConstraint PlutusTypeScott Source # | |
Defined in Plutarch.Internal.ScottEncoding | |
| type DerivedPInner PlutusTypeScott a Source # | |
Defined in Plutarch.Internal.ScottEncoding | |
newtype DeriveNewtypePlutusType (a :: S -> Type) s Source #
Since: 1.10.0
Constructors
| DeriveNewtypePlutusType (a s) |
Instances
| (pt ~ UnTermSingle (Head (Head (Code (a (Any :: S))))), forall (s :: S). H s a pt) => PlutusType (DeriveNewtypePlutusType a) Source # | |
Defined in Plutarch.Internal.PlutusType Methods pcon' :: forall (s :: S). DeriveNewtypePlutusType a s -> Term s (PInner (DeriveNewtypePlutusType a)) Source # pmatch' :: forall (s :: S) (b :: S -> Type). Term s (PInner (DeriveNewtypePlutusType a)) -> (DeriveNewtypePlutusType a s -> Term s b) -> Term s b Source # | |
| type PInner (DeriveNewtypePlutusType a) Source # | |
Defined in Plutarch.Internal.PlutusType | |
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 Methods pcon' :: forall (s :: S). DeriveFakePlutusType a s -> Term s (PInner (DeriveFakePlutusType a)) Source # pmatch' :: forall (s :: S) (b :: S -> Type). Term s (PInner (DeriveFakePlutusType a)) -> (DeriveFakePlutusType a s -> Term s b) -> Term s b Source # | |
| type PInner (DeriveFakePlutusType a) Source # | |
Defined in Plutarch.Internal.PlutusType | |
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
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
Nothing
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 |
| PMultiplicativeSemigroup a => PMultiplicativeSemigroup (PPullArray a) Source # | Since: 1.12.0 |
Defined in Plutarch.Array Methods (#*) :: forall (s :: S). Term s (PPullArray a) -> Term s (PPullArray a) -> Term s (PPullArray a) Source # ppowPositive :: forall (s :: S). Term s (PPullArray a) -> Term s PPositive -> Term s (PPullArray a) Source # | |
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
Nothing
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
newtype PForall (b :: a -> S -> Type) s Source #
Instances
| PlutusType (PForall f) Source # | |
Defined in Plutarch.Internal.PlutusType | |
| type PInner (PForall f) Source # | |
Defined in Plutarch.Internal.PlutusType | |
Show
Allows a debugging representation of the datatype as a PString.
Important note
Use of PShow in production scripts is not a good idea, as it requires
considerable script budget, especially for larger or more complex values. In
general, this type class is provided to assist with testing or debugging: be
very careful when using it for anything else, lest it impact your
performance.
Writing manual instances of this type class is also discouraged, as it is not
intended to be a pretty printer. In most situations, the Generic-based
derivation of instances for this type class is what you want.
Minimal complete definition
Nothing
Methods
pshow' :: Bool -> Term s t -> Term s PString Source #
Return the PString representation of a Plutarch value.
If the argument is True, wrap the output in `(..)` if it represents multiple parameters.
Since: 1.13.0
Instances
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 :: S -> Type) Source #
Instances
Instances
| UnsafeConstrNP ('[] :: [S -> Type]) Source # | |
| UnsafeConstrNP xs => UnsafeConstrNP (x ': xs) Source # | |
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 :: forall (a :: S -> Type) (s :: S). HasCallStack => (forall (s' :: S). Term s' 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 :: S -> Type) :--> (b :: S -> Type)) (s :: S) infixr 0 Source #
Conversion
type family PSubtype (a :: S -> Type) (b :: S -> Type) :: Constraint where ... Source #
Equations
| PSubtype a b = (PSubtype' a b ~ 'PSubtypeRelation, PSubtypeHelper a b (PSubtype' a b)) |
class PSubtype a b => PTryFrom (a :: S -> Type) (b :: S -> Type) 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 :: S -> Type 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 #
pto :: forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a) Source #
Safely coerce from a Term to it's PInner representation.
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
| (PEq a, PEq b) => PEq (PPair a b) Source # | Since: 1.10.0 |
| PlutusType (PPair a b) Source # | |
| (PMonoid a, PMonoid b) => PMonoid (PPair a b) Source # | Since: 1.10.0 |
| (PSemigroup a, PSemigroup b) => PSemigroup (PPair a b) Source # | Since: 1.10.0 |
| (PShow a, PShow b) => PShow (PPair a b) Source # | Since: 1.10.0 |
| Generic (PPair a b s) Source # | |
| Generic (PPair a b s) Source # | |
| type PInner (PPair a b) Source # | Since: 1.10.0 |
Defined in Plutarch.Pair | |
| type Rep (PPair a b s) Source # | Since: 1.10.0 |
Defined in Plutarch.Pair type Rep (PPair a b s) = D1 ('MetaData "PPair" "Plutarch.Pair" "plutarch-1.14.0-DxKJeQlSo9oLhPFmYEjfmO" 'False) (C1 ('MetaCons "PPair" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Term s a)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Term s b)))) | |
| type Code (PPair a b s) Source # | Since: 1.10.0 |
Defined in Plutarch.Pair | |
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 :: S -> Type). 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
pletFieldsC :: forall fs a s b ps bs. (PDataFields a, ps ~ PFields a, bs ~ Bindings ps fs, BindFields ps bs) => Term s a -> TermCont @b s (HRec (BoundTerms ps bs s)) Source #
Deprecated: Use the new mechanism instead
Like pletFields but works in a TermCont monad.
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
| PEq a => PEq (POr a) Source # | Since: 1.10.0 |
| (PLiftable a, Includes DefaultUni (PlutusRepr a), KnownBuiltinType (Term DeBruijn DefaultUni DefaultFun ()) (PlutusRepr a)) => PLiftable (POr a) Source # | |
Defined in Plutarch.Internal.Semigroup Methods haskToRepr :: AsHaskell (POr a) -> PlutusRepr (POr a) Source # reprToHask :: PlutusRepr (POr a) -> Either LiftError (AsHaskell (POr a)) Source # reprToPlut :: forall (s :: S). PlutusRepr (POr a) -> PLifted s (POr a) Source # plutToRepr :: (forall (s :: S). PLifted s (POr a)) -> Either LiftError (PlutusRepr (POr a)) Source # | |
| POrd a => POrd (POr a) Source # | Since: 1.10.0 |
Defined in Plutarch.Internal.Semigroup Methods (#<=) :: forall (s :: S). Term s (POr a) -> Term s (POr a) -> Term s PBool Source # (#<) :: forall (s :: S). Term s (POr a) -> Term s (POr a) -> Term s PBool Source # pmax :: forall (s :: S). Term s (POr a) -> Term s (POr a) -> Term s (POr a) Source # pmin :: forall (s :: S). Term s (POr a) -> Term s (POr a) -> Term s (POr a) Source # | |
| PlutusType (POr a) Source # | |
| PMonoid (POr PBool) Source # | Since: 1.10.0 |
| PMonoid (POr PByteString) Source # | Since: 1.10.0 |
Defined in Plutarch.Internal.Semigroup | |
| PSemigroup (POr PBool) Source # | Since: 1.10.0 |
| PSemigroup (POr PByteString) Source # | This uses padding semantics as specified in CIP-122, as this allows a
Since: 1.10.0 |
Defined in Plutarch.Internal.Semigroup Methods (#<>) :: forall (s :: S). Term s (POr PByteString) -> Term s (POr PByteString) -> Term s (POr PByteString) Source # pstimes :: forall (s :: S). Term s PPositive -> Term s (POr PByteString) -> Term s (POr PByteString) Source # | |
| Generic (POr a s) Source # | |
| Generic (POr a s) Source # | |
| type AsHaskell (POr a) Source # | Since: 1.13.0 |
Defined in Plutarch.Internal.Semigroup | |
| type PlutusRepr (POr a) Source # | |
Defined in Plutarch.Internal.Semigroup | |
| type PInner (POr a) Source # | Since: 1.10.0 |
Defined in Plutarch.Internal.Semigroup | |
| type Rep (POr a s) Source # | Since: 1.10.0 |
Defined in Plutarch.Internal.Semigroup | |
| type Code (POr a s) Source # | Since: 1.10.0 |
Defined in Plutarch.Internal.Semigroup | |
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
punrollUnboundWhole :: forall a b s. Integer -> (Term s (a :--> b) -> Term s (a :--> b)) -> Term s (a :--> b) Source #
Validation
class PValidateData (a :: S -> Type) where Source #
Describes a Data encoded Plutarch type that requires some additional
validation to ensure its structure is indeed what we expect. This is
especially useful for datums or other user-supplied arguments, since these
can be malformed.
Why the CPS
pwithValidated is written in continuation-passing style (or CPS) for
reasons of efficiency. As pwithValidated is meant to check structure (and
nothing more), our first instinct would be to write something like
pwithValidated :: Term s PData -> Term s PBool
or
pwithValidated :: Term s PData -> Term s PUnit
and rely on perror to sort things out. However, constructing either PUnit
or PBool isn't free, and ultimately, this value ends up unused. At the same
time, we want to ensure that the validation specified in pwithValidated is
actually performed, which neither of the above signatures can promise
anything about.
CPS solves both of these problems. Since the result of pwithValidated is
technically a function that must behave the same no matter what type of r
it operates over, we can't do anything except potentially mess with the
argument PData or error out, which means we don't need to allocate any
'result value'. Furthermore, by working in CPS, we ensure that any
validation defined in pwithValidated must happen, even if the PData (or
whatever it's supposed to be) is never handled or forced.
Important note
It is essential practice to document what exactly any given instance of
PValidateData checks. Each instance should specify this: all the instances
provided by Plutarch and its related libraries follow this rule.
Since: 1.12.0
Methods
pwithValidated :: forall (s :: S). Term s PData -> forall (r :: S -> Type). Term s r -> Term s r Source #
Instances
| PValidateData PBool Source # | Checks that we have a Since: 1.12.0 |
| PValidateData PByteString Source # | Checks that we have a Since: 1.12.0 |
| PValidateData PData Source # | Checks (and does) nothing. Since: 1.12.0 |
| PValidateData PInteger Source # | Checks that we have an Since: 1.12.0 |
| PValidateData PPositive Source # | Checks that we have a positive Since: 1.13.0 |
| PValidateData a => PValidateData (PAsData a) Source # | Since: 1.12.0 |
| (PValidateData a, PValidateData b) => PValidateData (PBuiltinList (PBuiltinPair (PAsData a) (PAsData b))) Source # | Checks that we have a Since: 1.13.0 |
| PValidateData (PBuiltinList PData) Source # | Checks that we have a Since: 1.12.0 |
| PValidateData a => PValidateData (PBuiltinList a) Source # | Checks that we have a Since: 1.12.0 |
| PValidateData (Don'tValidate a) Source # | Since: 1.12.0 |
| (Generic (a (Any :: S)), All PInnermostIsDataDataRepr struct, struct ~ UnTermRec struct', Generic (a (Any :: S)), '[struct'] ~ Code (a (Any :: S)), All PValidateData struct, SListI struct) => PValidateData (DeriveAsDataRec a) Source # | Checks that we have a Since: 1.12.0 |
| (Generic (a (Any :: S)), struct ~ UnTermStruct (a (Any :: S)), All2 PInnermostIsDataDataRepr struct, All2 PValidateData struct, SListI2 struct) => PValidateData (DeriveAsDataStruct a) Source # | Checks that we have a Since: 1.12.0 |
| Generic (a (Any :: S)) => PValidateData (DeriveAsTag a) Source # | Checks that we have an Since: 1.12.0 |
| (PValidateData a, PValidateData b) => PValidateData (PBuiltinPair (PAsData a) (PAsData b)) Source # | Checks that we have a Since: 1.12.0 |
| PValidateData (PBuiltinPair PData PData) Source # | Checks that we have a Since: 1.12.0 |
| PValidateData b => PValidateData (DeriveNewtypePValidateData a b) Source # | Since: 1.12.0 |
newtype Don'tValidate (a :: S -> Type) (s :: S) Source #
Helper to define a do-nothing instance of PValidateData. Useful when
defining an instance for a complex type where we want to validate some parts,
but not others.
Since: 1.12.0
Constructors
| Don'tValidate | |
Fields
| |
Instances
| PValidateData (Don'tValidate a) Source # | Since: 1.12.0 |
| PlutusType a => PlutusType (Don'tValidate a) Source # | Since: 1.12.0 |
Defined in Plutarch.Internal.Parse Methods pcon' :: forall (s :: S). Don'tValidate a s -> Term s (PInner (Don'tValidate a)) Source # pmatch' :: forall (s :: S) (b :: S -> Type). Term s (PInner (Don'tValidate a)) -> (Don'tValidate a s -> Term s b) -> Term s b Source # | |
| type PInner (Don'tValidate a) Source # | |
Defined in Plutarch.Internal.Parse | |
newtype DeriveNewtypePValidateData (a :: S -> Type) (b :: S -> Type) (s :: S) Source #
Helper to define an instance of PValidateData for newtypes over
Terms, which 'borrows' the PValidateData instance for whatever the
newtype is wrapping.
Since: 1.12.0
Constructors
| DeriveNewtypePValidateData (a s) |
Instances
| PValidateData b => PValidateData (DeriveNewtypePValidateData a b) Source # | Since: 1.12.0 |
pparseData :: forall (a :: S -> Type) (s :: S). (PIsData a, PValidateData a) => Term s PData -> Term s (PAsData a) Source #
Given a PData, check that it is, indeed, structured as a expects. If it
is, return that same PData 'rewrapped' into PAsData a.
This helper exists to avoid having to work in CPS when writing regular code.
It is kept out of PValidateData for efficiency and safety reasons.
Since: 1.12.0