Delegate Rational invariant to PNonZero + optimizations

Plutarch.hs

@@ -11,6 +11,7 @@ module Plutarch (
   PI.pforce,
   PI.phoistAcyclic,
   PI.plet,
+  PI.pthrow,
   PI.Term,
   PI.S,
   PI.PType,

Plutarch/Builtin.hs

@@ -28,6 +28,7 @@ module Plutarch.Builtin (
   pchooseListBuiltin,
 ) where
 
+import Data.Functor.Const (Const)
 import Data.Proxy (Proxy (Proxy))
 import GHC.Generics (Generic)
 import Plutarch (
@@ -91,25 +92,14 @@ import Plutarch.List (
   ptail,
  )
 import Plutarch.Show (PShow (pshow'), pshow)
+import Plutarch.TermCont (TermCont (runTermCont), tcont, unTermCont)
+import Plutarch.TryFrom (PSubtype, PTryFrom, PTryFromExcess, ptryFrom, ptryFrom', pupcast)
 import Plutarch.Unit (PUnit)
 import Plutarch.Unsafe (punsafeBuiltin, punsafeCoerce, punsafeDowncast)
 import qualified PlutusCore as PLC
 import PlutusTx (Data (Constr), ToData)
 import qualified PlutusTx
 
-import Plutarch.TermCont (TermCont (runTermCont), tcont, unTermCont)
-
-import Data.Functor.Const (Const)
-
-import Plutarch.TryFrom (
-  PSubtype,
-  PTryFrom,
-  PTryFromExcess,
-  ptryFrom,
-  ptryFrom',
-  pupcast,
- )
-
 -- | Plutus 'BuiltinPair'
 data PBuiltinPair (a :: PType) (b :: PType) (s :: S) = PBuiltinPair (Term s (PBuiltinPair a b))
 

Plutarch/Positive.hs

@@ -0,0 +1,79 @@
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE UndecidableInstances #-}
+
+module Plutarch.Positive (PPositive, ppositive, ptryPositive) where
+
+import Data.Functor.Const (Const)
+import GHC.Generics (Generic)
+
+import Plutarch.Bool (PEq, POrd, pif, (#<=))
+import Plutarch.Builtin (PAsData, PData, PIsData, pdata)
+import Plutarch.Integer (PInteger, PIntegral)
+
+import Plutarch.Maybe (PMaybe (PJust, PNothing))
+
+import Plutarch (
+  DerivePlutusType (DPTStrat),
+  PlutusType,
+  PlutusTypeNewtype,
+  Term,
+  TermCont (runTermCont),
+  pcon,
+  phoistAcyclic,
+  plam,
+  plet,
+  pthrow,
+  pto,
+  (#),
+  (#$),
+  type (:-->),
+ )
+import Plutarch.Num (PNum (pfromInteger, (#-)))
+import Plutarch.Show (PShow)
+import Plutarch.TermCont (tcont)
+import Plutarch.Trace (ptraceError)
+import Plutarch.TryFrom (PTryFrom (PTryFromExcess, ptryFrom'), ptryFrom)
+
+newtype PPositive s = PPositive (Term s PInteger)
+  deriving stock (Generic)
+  deriving anyclass (PlutusType, PIsData, PEq, POrd, PIntegral, PShow)
+instance DerivePlutusType PPositive where type DPTStrat _ = PlutusTypeNewtype
+
+instance PNum PPositive where
+  x #- y = ptryPositive #$ pto x #- pto y
+
+  pfromInteger x
+    | x <= 0 = pthrow "PPositive.pfromInteger: encountered non positive"
+    | otherwise = pcon $ PPositive $ pfromInteger x
+
+instance PTryFrom PInteger PPositive where
+  type PTryFromExcess PInteger PPositive = Const ()
+  ptryFrom' opq = runTermCont $ pure (ptryPositive # opq, ())
+
+newtype Flip f a b = Flip (f b a) deriving stock (Generic)
+
+instance PTryFrom PData (PAsData PPositive) where
+  type PTryFromExcess PData (PAsData PPositive) = Flip Term PPositive
+  ptryFrom' opq = runTermCont $ do
+    (_, i) <- tcont $ ptryFrom @(PAsData PInteger) opq
+    res <- tcont . plet $ ptryPositive # i
+    resData <- tcont . plet $ pdata res
+    pure (resData, res)
+
+-- | Build a 'PPositive' from a 'PInteger'. Yields 'PNothing' if argument is zero.
+ppositive :: Term s (PInteger :--> PMaybe PPositive)
+ppositive = phoistAcyclic $
+  plam $ \i ->
+    pif
+      (i #<= 0)
+      (pcon PNothing)
+      $ pcon . PJust . pcon $ PPositive i
+
+-- | Partial version of 'PPositive'. Errors if argument is zero.
+ptryPositive :: Term s (PInteger :--> PPositive)
+ptryPositive = phoistAcyclic $
+  plam $ \i ->
+    pif
+      (i #<= 0)
+      (ptraceError "ptryPositive: building with non positive")
+      $ pcon $ PPositive i

Plutarch/Prelude.hs

@@ -16,6 +16,7 @@ module Plutarch.Prelude (
   pinl,
   pto,
   pfix,
+  pthrow,
   Type,
   S,
   PType,
@@ -36,10 +37,9 @@ module Plutarch.Prelude (
   PIntegral (pdiv, pmod, pquot, prem),
 
   -- * Rational numbers and utilities
-  PRational,
+  PRational (PRational),
   pnumerator,
   pdenominator,
-  pfromInteger,
   pround,
 
   -- * Booleans and boolean functions