Fixes codegen bugs (printCaseE, .PlutusTx suffix)

Author: bladyjoker

lambda-buffers-codegen/data/plutustx-plutus.json

@@ -202,13 +202,6 @@
     ]
   },
   "classesConfig": {
-    "Prelude.Eq": [
-      [
-        "plutus-tx",
-        "PlutusTx.Eq",
-        "Eq"
-      ]
-    ],
     "Plutus.V1.PlutusData": [
       [
         "plutus-tx",

lambda-buffers-codegen/lambda-buffers-codegen.cabal

@@ -115,6 +115,7 @@ library
     LambdaBuffers.Codegen.Haskell.Backend
     LambdaBuffers.Codegen.Haskell.Backend.Native
     LambdaBuffers.Codegen.Haskell.Backend.Native.Derive
+    LambdaBuffers.Codegen.Haskell.Backend.Native.LamVal
     LambdaBuffers.Codegen.Haskell.Backend.Plutarch
     LambdaBuffers.Codegen.Haskell.Backend.Plutarch.Derive
     LambdaBuffers.Codegen.Haskell.Backend.Plutarch.LamVal

lambda-buffers-codegen/src/LambdaBuffers/Codegen/Haskell/Backend/Native.hs

@@ -13,7 +13,7 @@ data NativeHaskellBackend
 instance IsHaskellBackend NativeHaskellBackend where
   type HaskellBackendContext NativeHaskellBackend = ()
   type HaskellBackendState NativeHaskellBackend = ()
-  fromLbModuleName mn = Haskell.MkModuleName $ Text.intercalate "." ("LambdaBuffers" : [p ^. #name | p <- mn ^. #parts]) <> ".PlutusTx"
+  fromLbModuleName mn = Haskell.MkModuleName $ Text.intercalate "." ("LambdaBuffers" : [p ^. #name | p <- mn ^. #parts])
   filepathFromLbModuleName mn = Text.unpack (Text.replace "." "/" (let Haskell.MkModuleName txt = fromLbModuleName @NativeHaskellBackend mn in txt)) <> ".hs"
   printImplementation = NativeHaskellBackend.hsClassImplPrinters
   printModule = Haskell.printModule

lambda-buffers-codegen/src/LambdaBuffers/Codegen/Haskell/Backend/Native/Derive.hs

@@ -4,9 +4,13 @@ import Control.Lens ((^.))
 import Data.Foldable (for_)
 import Data.Map (Map)
 import Data.Map qualified as Map
+import Data.Set (Set)
 import LambdaBuffers.Codegen.Haskell.Backend (MonadHaskellBackend)
-import LambdaBuffers.Codegen.Haskell.Print.LamVal (printValueE)
+import LambdaBuffers.Codegen.Haskell.Backend.Native.LamVal qualified as Native
+import LambdaBuffers.Codegen.Haskell.Print.LamVal qualified as Haskell
 import LambdaBuffers.Codegen.Haskell.Print.Syntax qualified as H
+import LambdaBuffers.Codegen.Haskell.Print.Syntax qualified as Haskell
+import LambdaBuffers.Codegen.LamVal qualified as Lv
 import LambdaBuffers.Codegen.LamVal.Eq (deriveEqImpl)
 import LambdaBuffers.Codegen.LamVal.Json (deriveFromJsonImpl, deriveToJsonImpl)
 import LambdaBuffers.Codegen.LamVal.MonadPrint qualified as LV
@@ -46,11 +50,14 @@ hsClassImplPrinters =
       )
     ]
 
+printValue :: (Lv.Ref -> Maybe Haskell.QValName) -> Lv.ValueE -> Either LV.PrintError (Doc ann, Set Haskell.QValName)
+printValue builtins valE = LV.runPrint (LV.Context builtins Native.lamValContext) (Haskell.printValueE valE)
+
 eqClassMethodName :: H.ValueName
 eqClassMethodName = H.MkValueName "=="
 
-lvEqBuiltinsBase :: LV.PrintRead (H.CabalPackageName, H.ModuleName, H.ValueName)
-lvEqBuiltinsBase = LV.MkPrintRead $ \(_ty, refName) ->
+lvEqBuiltinsBase :: Lv.Ref -> Maybe Haskell.QValName
+lvEqBuiltinsBase (_ty, refName) =
   Map.lookup refName $
     Map.fromList
       [ ("eq", (H.MkCabalPackageName "base", H.MkModuleName "Prelude", H.MkValueName "=="))
@@ -64,15 +71,15 @@ printDeriveEqBase mn iTyDefs mkInstanceDoc ty = do
   case deriveEqImpl mn iTyDefs ty of
     Left err -> Print.throwInternalError' (mn ^. #sourceInfo) ("Deriving Prelude.Eq LamVal implementation from a type failed with: " <> err ^. P.msg)
     Right valE -> do
-      case LV.runPrint lvEqBuiltinsBase (printValueE valE) of
+      case printValue lvEqBuiltinsBase valE of
         Left err -> Print.throwInternalError' (mn ^. #sourceInfo) ("Interpreting LamVal into Haskell failed with: " <> err ^. P.msg)
         Right (implDoc, imps) -> do
           instanceDoc <- mkInstanceDoc (printValueDef eqClassMethodName implDoc)
           for_ imps Print.importValue
           return instanceDoc
 
-lvPlutusDataBuiltins :: LV.PrintRead H.QValName
-lvPlutusDataBuiltins = LV.MkPrintRead $ \(_ty, refName) ->
+lvPlutusDataBuiltins :: Lv.Ref -> Maybe Haskell.QValName
+lvPlutusDataBuiltins (_ty, refName) =
   Map.lookup refName $
     Map.fromList
       [ ("toPlutusData", (H.MkCabalPackageName "plutus-tx", H.MkModuleName "PlutusTx", H.MkValueName "toBuiltinData"))
@@ -94,7 +101,7 @@ printDeriveToPlutusData mn iTyDefs mkInstanceDoc ty = do
   case deriveToPlutusDataImpl mn iTyDefs ty of
     Left err -> Print.throwInternalError' (mn ^. #sourceInfo) ("Deriving Plutus.V1.PlutusData LamVal implementation from a type failed with: " <> err ^. P.msg)
     Right valE -> do
-      case LV.runPrint lvPlutusDataBuiltins (printValueE valE) of
+      case printValue lvPlutusDataBuiltins valE of
         Left err -> Print.throwInternalError' (mn ^. #sourceInfo) ("Interpreting LamVal into Haskell failed with: " <> err ^. P.msg)
         Right (implDoc, imps) -> do
           instanceDoc <- mkInstanceDoc (printValueDef toPlutusDataClassMethodName implDoc)
@@ -115,7 +122,7 @@ printDeriveFromPlutusData mn iTyDefs mkInstanceDoc ty = do
   case deriveFromPlutusDataImpl mn iTyDefs ty of
     Left err -> Print.throwInternalError' (mn ^. #sourceInfo) ("Deriving Plutus.V1.PlutusData LamVal implementation from a type failed with: " <> err ^. P.msg)
     Right valE -> do
-      case LV.runPrint lvPlutusDataBuiltins (printValueE valE) of
+      case printValue lvPlutusDataBuiltins valE of
         Left err -> Print.throwInternalError' (mn ^. #sourceInfo) ("Interpreting LamVal into Haskell failed with: " <> err ^. P.msg)
         Right (implDoc, imps) -> do
           instanceDoc <- mkInstanceDoc (printValueDef fromPlutusDataClassMethodName implDoc)
@@ -124,8 +131,8 @@ printDeriveFromPlutusData mn iTyDefs mkInstanceDoc ty = do
           return instanceDoc
 
 -- | LambdaBuffers.Codegen.LamVal.Json specification printing
-lvJsonBuiltins :: LV.PrintRead H.QValName
-lvJsonBuiltins = LV.MkPrintRead $ \(_ty, refName) ->
+lvJsonBuiltins :: Lv.Ref -> Maybe Haskell.QValName
+lvJsonBuiltins (_ty, refName) =
   Map.lookup refName $
     Map.fromList
       [ ("toJson", (H.MkCabalPackageName "lbr-prelude", H.MkModuleName "LambdaBuffers.Runtime.Prelude", H.MkValueName "toJson"))
@@ -152,9 +159,9 @@ printDeriveJson :: MonadHaskellBackend t m => PC.ModuleName -> PC.TyDefs -> (Doc
 printDeriveJson mn iTyDefs mkInstanceDoc ty = do
   let resOrErr = do
         toJsonValE <- deriveToJsonImpl mn iTyDefs ty
-        (toJsonImplDoc, impsA) <- LV.runPrint lvJsonBuiltins (printValueE toJsonValE)
+        (toJsonImplDoc, impsA) <- printValue lvJsonBuiltins toJsonValE
         fromJsonValE <- deriveFromJsonImpl mn iTyDefs ty
-        (fromJsonImplDoc, impsB) <- LV.runPrint lvJsonBuiltins (printValueE fromJsonValE)
+        (fromJsonImplDoc, impsB) <- printValue lvJsonBuiltins fromJsonValE
         return (toJsonImplDoc, fromJsonImplDoc, impsA <> impsB)
 
   (toJsonImplDoc, fromJsonImplDoc, imps) <- case resOrErr of

lambda-buffers-codegen/src/LambdaBuffers/Codegen/Haskell/Backend/Native/LamVal.hs

@@ -0,0 +1,24 @@
+module LambdaBuffers.Codegen.Haskell.Backend.Native.LamVal (printCaseIntE, lamValContext) where
+
+import Data.Traversable (for)
+import LambdaBuffers.Codegen.Haskell.Print.LamVal (HaskellLamValContext (HaskellLamValContext))
+import LambdaBuffers.Codegen.Haskell.Print.LamVal qualified as Haskell
+import LambdaBuffers.Codegen.LamVal qualified as LV
+import Prettyprinter (Doc, align, group, line, vsep, (<+>))
+
+lamValContext :: HaskellLamValContext
+lamValContext = HaskellLamValContext {ctx'printCaseIntE = printCaseIntE}
+
+printCaseIntE :: Haskell.HaskellLamValMonad m => LV.ValueE -> [(LV.ValueE, LV.ValueE)] -> (LV.ValueE -> LV.ValueE) -> m (Doc ann)
+printCaseIntE caseIntVal cases otherCase = do
+  caseValDoc <- Haskell.printValueE caseIntVal
+  caseDocs <-
+    for
+      cases
+      ( \(conditionVal, bodyVal) -> do
+          conditionDoc <- Haskell.printValueE conditionVal
+          bodyDoc <- Haskell.printValueE bodyVal
+          return $ group $ conditionDoc <+> "->" <+> bodyDoc
+      )
+  otherDoc <- Haskell.printOtherCase otherCase
+  return $ "ca" <> align ("se" <+> caseValDoc <+> "of" <> line <> vsep (caseDocs <> [otherDoc]))

lambda-buffers-codegen/src/LambdaBuffers/Codegen/Haskell/Backend/Plutarch/Derive.hs

@@ -4,15 +4,16 @@ import Control.Lens ((^.))
 import Data.Foldable (for_)
 import Data.Map (Map)
 import Data.Map qualified as Map
+import Data.Set (Set)
 import Data.Text (Text)
 import Data.Text qualified as Text
 import LambdaBuffers.Codegen.Haskell.Backend (MonadHaskellBackend)
 import LambdaBuffers.Codegen.Haskell.Backend.Plutarch.LamVal qualified as PlLamVal
 import LambdaBuffers.Codegen.Haskell.Backend.Plutarch.Refs qualified as PlRefs
 import LambdaBuffers.Codegen.Haskell.Print.InstanceDef qualified as Haskell
-import LambdaBuffers.Codegen.Haskell.Print.LamVal qualified as Haskell
 import LambdaBuffers.Codegen.Haskell.Print.Syntax qualified as Haskell
 import LambdaBuffers.Codegen.Haskell.Print.TyDef qualified as Haskell
+import LambdaBuffers.Codegen.LamVal qualified as LV
 import LambdaBuffers.Codegen.LamVal.MonadPrint qualified as LV
 import LambdaBuffers.Codegen.LamVal.PlutusData (deriveFromPlutusDataImplPlutarch, deriveToPlutusDataImplPlutarch)
 import LambdaBuffers.Codegen.Print qualified as Print
@@ -54,6 +55,9 @@ hsClassImplPrinters =
 useVal :: MonadHaskellBackend t m => Haskell.QValName -> m (Doc ann)
 useVal qvn = Print.importValue qvn >> return (Haskell.printHsQValName qvn)
 
+printValue :: (LV.Ref -> Maybe Haskell.QValName) -> LV.ValueE -> Either LV.PrintError (Doc ann, Set Haskell.QValName)
+printValue builtins valE = LV.runPrint (LV.Context builtins ()) (PlLamVal.printValueE valE)
+
 {- | Deriving PEq.
 
 NOTE(bladyjoker): Doesn't derive the implementation but only uses the underlying PData representation for equality.
@@ -111,8 +115,8 @@ printDerivePIsData _mn _iTyDefs mkInstanceDoc _ty = do
       pfromDataImpl = printValueDef (Haskell.MkValueName "pfromDataImpl") punsafeCoerceDoc
   mkInstanceDoc (align $ vsep [pdataImpl, pfromDataImpl])
 
-lvPlutusDataBuiltinsForPlutusType :: LV.PrintRead Haskell.QValName
-lvPlutusDataBuiltinsForPlutusType = LV.MkPrintRead $ \(_ty, refName) ->
+lvPlutusDataBuiltinsForPlutusType :: LV.Ref -> Maybe Haskell.QValName
+lvPlutusDataBuiltinsForPlutusType (_ty, refName) =
   Map.lookup refName $
     Map.fromList
       [ ("toPlutusData", (Haskell.MkCabalPackageName "lbr-plutarch", Haskell.MkModuleName "LambdaBuffers.Runtime.Plutarch.LamVal", Haskell.MkValueName "toPlutusData"))
@@ -138,8 +142,8 @@ printDerivePlutusType mn iTyDefs _mkInstanceDoc ty = do
         do
           toDataE <- deriveToPlutusDataImplPlutarch mn iTyDefs ty
           fromDataE <- deriveFromPlutusDataImplPlutarch mn iTyDefs ty
-          (pconImplDoc, imps) <- LV.runPrint lvPlutusDataBuiltinsForPlutusType (Haskell.printValueE toDataE)
-          (pmatchImplDoc, imps') <- LV.runPrint lvPlutusDataBuiltinsForPlutusType (PlLamVal.printValueE fromDataE)
+          (pconImplDoc, imps) <- printValue lvPlutusDataBuiltinsForPlutusType toDataE
+          (pmatchImplDoc, imps') <- printValue lvPlutusDataBuiltinsForPlutusType fromDataE
           let implDoc =
                 align $
                   vsep
@@ -201,8 +205,8 @@ printPlutusTypeInstanceDef ty implDefDoc = do
 printValueDef :: Haskell.ValueName -> Doc ann -> Doc ann
 printValueDef valName valDoc = Haskell.printHsValName valName <+> equals <+> valDoc
 
-lvPlutusDataBuiltinsForPTryFrom :: LV.PrintRead Haskell.QValName
-lvPlutusDataBuiltinsForPTryFrom = LV.MkPrintRead $ \(_ty, refName) ->
+lvPlutusDataBuiltinsForPTryFrom :: LV.Ref -> Maybe Haskell.QValName
+lvPlutusDataBuiltinsForPTryFrom (_ty, refName) =
   Map.lookup refName $
     Map.fromList
       [ ("toPlutusData", (Haskell.MkCabalPackageName "lbr-plutarch", Haskell.MkModuleName "LambdaBuffers.Runtime.Plutarch.LamVal", Haskell.MkValueName "toPlutusData"))
@@ -233,7 +237,7 @@ printDerivePTryFrom mn iTyDefs _mkInstanceDoc ty = do
   pappDoc <- useVal PlRefs.pappQValName
   let resOrErr = do
         fromDataE <- deriveFromPlutusDataImplPlutarch mn iTyDefs ty
-        (ptryFromImplDoc, imps) <- LV.runPrint lvPlutusDataBuiltinsForPTryFrom (PlLamVal.printValueE fromDataE)
+        (ptryFromImplDoc, imps) <- printValue lvPlutusDataBuiltinsForPTryFrom fromDataE
         return
           ( align $ printValueDef PlRefs.ptryFromMethod (parens $ "\\pd f -> f" <+> parens (parens pappDoc <+> parens ptryFromImplDoc <+> "pd" <+> "," <+> "()"))
           , imps

lambda-buffers-codegen/src/LambdaBuffers/Codegen/Haskell/Backend/Plutarch/LamVal.hs

@@ -15,10 +15,10 @@ import LambdaBuffers.ProtoCompat qualified as PC
 import Prettyprinter (Doc, Pretty (pretty), align, backslash, dquotes, group, hardline, hsep, line, parens, vsep, (<+>))
 import Proto.Codegen_Fields qualified as P
 
-throwInternalError :: MonadPrint m => String -> m a
-throwInternalError msg = throwError $ defMessage & P.msg .~ "[LambdaBuffers.Codegen.Plutarch] " <> Text.pack msg
+type PlutarchLamValMonad m = LV.MonadPrint m HsSyntax.QValName ()
 
-type MonadPrint m = LV.MonadPrint m HsSyntax.QValName
+throwInternalError :: PlutarchLamValMonad m => String -> m a
+throwInternalError msg = throwError $ defMessage & P.msg .~ "[LambdaBuffers.Codegen.Plutarch] " <> Text.pack msg
 
 withInfo :: PC.InfoLessC b => PC.InfoLess b -> b
 withInfo x = PC.withInfoLess x id
@@ -66,7 +66,7 @@ translates to Plutarch
 plam (\x -> <expression over x>)
 ```
 -}
-printLamE :: MonadPrint m => (LV.ValueE -> LV.ValueE) -> m (Doc ann)
+printLamE :: PlutarchLamValMonad m => (LV.ValueE -> LV.ValueE) -> m (Doc ann)
 printLamE lamVal = do
   arg <- LV.freshArg
   bodyDoc <- printValueE (lamVal arg)
@@ -86,7 +86,7 @@ translates to Plutarch
 (#) (funVal) (argVal)
 ```
 -}
-printAppE :: MonadPrint m => LV.ValueE -> LV.ValueE -> m (Doc ann)
+printAppE :: PlutarchLamValMonad m => LV.ValueE -> LV.ValueE -> m (Doc ann)
 printAppE funVal argVal = do
   funDoc <- printValueE funVal
   argDoc <- printValueE argVal
@@ -111,7 +111,7 @@ pcon (Foo'Bar (x) (y))
 
 TODO(bladyjoker): Add import for the `Foo'Bar` constructor value reference.
 -}
-printCtorE :: MonadPrint m => LV.QCtor -> [LV.ValueE] -> m (Doc ann)
+printCtorE :: PlutarchLamValMonad m => LV.QCtor -> [LV.ValueE] -> m (Doc ann)
 printCtorE _qctor@((_, tyN), (ctorN, _)) prodVals = do
   prodDocs <- for prodVals (fmap parens . printValueE)
   let ctorNDoc = HsSyntax.printCtorName (withInfo tyN) (withInfo ctorN)
@@ -147,7 +147,7 @@ pmatch foo (\x -> case x of
            )
 ```
 -}
-printCaseE :: MonadPrint m => LV.QSum -> LV.ValueE -> ((LV.Ctor, [LV.ValueE]) -> LV.ValueE) -> m (Doc ann)
+printCaseE :: PlutarchLamValMonad m => LV.QSum -> LV.ValueE -> ((LV.Ctor, [LV.ValueE]) -> LV.ValueE) -> m (Doc ann)
 printCaseE _qsum@(qtyN, sumTy) caseVal ctorCont = do
   caseValDoc <- printValueE caseVal
   ctorCaseDocs <-
@@ -163,7 +163,7 @@ printCaseE _qsum@(qtyN, sumTy) caseVal ctorCont = do
   let casesDoc = "ca" <> align ("se" <+> pmatchContArgDoc <+> "of" <> line <> ctorCaseDocs)
   return $ pmatchDoc <+> caseValDoc <+> parens (backslash <> pmatchContArgDoc <+> "->" <+> casesDoc)
 
-printCtorCase :: MonadPrint m => PC.QTyName -> ((LV.Ctor, [LV.ValueE]) -> LV.ValueE) -> LV.Ctor -> m (Doc ann)
+printCtorCase :: PlutarchLamValMonad m => PC.QTyName -> ((LV.Ctor, [LV.ValueE]) -> LV.ValueE) -> LV.Ctor -> m (Doc ann)
 printCtorCase (_, tyn) ctorCont ctor@(ctorN, fields) = do
   args <- for fields (const LV.freshArg)
   argDocs <- for args printValueE
@@ -192,7 +192,7 @@ pcon (Foo (x) (y))
 
 TODO(bladyjoker): Add Product constructor import.
 -}
-printProductE :: MonadPrint m => LV.QProduct -> [LV.ValueE] -> m (Doc ann)
+printProductE :: PlutarchLamValMonad m => LV.QProduct -> [LV.ValueE] -> m (Doc ann)
 printProductE ((_, tyN), _) vals = do
   fieldDocs <- for vals (fmap parens . printValueE)
   let ctorDoc = HsSyntax.printMkCtor (withInfo tyN)
@@ -217,7 +217,7 @@ translates to Plutarch
 pmatch foo (\(Foo x y) -> <expression on x and y>)
 ```
 -}
-printLetE :: MonadPrint m => LV.QProduct -> LV.ValueE -> ([LV.ValueE] -> LV.ValueE) -> m (Doc ann)
+printLetE :: PlutarchLamValMonad m => LV.QProduct -> LV.ValueE -> ([LV.ValueE] -> LV.ValueE) -> m (Doc ann)
 printLetE ((_, tyN), fields) prodVal letCont = do
   prodValDoc <- printValueE prodVal
   args <- for fields (const LV.freshArg)
@@ -240,7 +240,7 @@ translates to Plutarch
 pcon (PCons x (PCons y PNil))
 ```
 -}
-printListE :: MonadPrint m => [LV.ValueE] -> m (Doc ann)
+printListE :: PlutarchLamValMonad m => [LV.ValueE] -> m (Doc ann)
 printListE [] = do
   pconDoc <- HsSyntax.printHsQValName <$> LV.importValue pconRef
   pnilDoc <- HsSyntax.printHsQValName <$> LV.importValue pnilRef
@@ -291,13 +291,13 @@ case xs of
         h4:t4 -> d xs -- OTHER
 ```
 -}
-printCaseListE :: MonadPrint m => LV.ValueE -> [(Int, [LV.ValueE] -> LV.ValueE)] -> (LV.ValueE -> LV.ValueE) -> m (Doc ann)
+printCaseListE :: PlutarchLamValMonad m => LV.ValueE -> [(Int, [LV.ValueE] -> LV.ValueE)] -> (LV.ValueE -> LV.ValueE) -> m (Doc ann)
 printCaseListE xs cases otherCase = do
   let maxLength = maximum $ fst <$> cases
   otherCaseDoc <- printValueE (otherCase xs)
   printCaseListE' xs cases otherCaseDoc 0 maxLength []
 
-printCaseListE' :: MonadPrint m => LV.ValueE -> [(Int, [LV.ValueE] -> LV.ValueE)] -> Doc ann -> Int -> Int -> [LV.ValueE] -> m (Doc ann)
+printCaseListE' :: PlutarchLamValMonad m => LV.ValueE -> [(Int, [LV.ValueE] -> LV.ValueE)] -> Doc ann -> Int -> Int -> [LV.ValueE] -> m (Doc ann)
 printCaseListE' _xs _cases otherCaseDoc currentLength maxLength _args | currentLength > maxLength = return otherCaseDoc
 printCaseListE' xs cases otherCaseDoc currentLength maxLength args = do
   pnilRefDoc <- HsSyntax.printHsQValName <$> LV.importValue pnilRef
@@ -345,7 +345,7 @@ pconstant 1
 pconstant (-1)
 ```
 -}
-printIntE :: MonadPrint m => Int -> m (Doc ann)
+printIntE :: PlutarchLamValMonad m => Int -> m (Doc ann)
 printIntE i = do
   pconstantRefDoc <- HsSyntax.printHsQValName <$> LV.importValue pconstantRef
   return $ pconstantRefDoc <+> if i < 0 then parens (pretty i) else pretty i
@@ -362,7 +362,7 @@ translates to Plutarch
 pif ((#==) (x) (pconstant 0)) <A> (pif ((#==) (x) (pconstant 123)) <B> <C>)
 ```
 -}
-printCaseIntE :: MonadPrint m => LV.ValueE -> [(LV.ValueE, LV.ValueE)] -> (LV.ValueE -> LV.ValueE) -> m (Doc ann)
+printCaseIntE :: PlutarchLamValMonad m => LV.ValueE -> [(LV.ValueE, LV.ValueE)] -> (LV.ValueE -> LV.ValueE) -> m (Doc ann)
 printCaseIntE caseIntVal [] otherCase = printValueE (otherCase caseIntVal) -- TODO(bladyjoker): Why is this a function and not just a ValueE?
 printCaseIntE caseIntVal ((iVal, bodyVal) : cases) otherCase = do
   pifRefDoc <- HsSyntax.printHsQValName <$> LV.importValue pifRef
@@ -385,7 +385,7 @@ translates to Plutarch
 pconstant "Dražen Popović"
 ```
 -}
-printTextE :: MonadPrint m => Text.Text -> m (Doc ann)
+printTextE :: PlutarchLamValMonad m => Text.Text -> m (Doc ann)
 printTextE t = do
   pconstantRefDoc <- HsSyntax.printHsQValName <$> LV.importValue pconstantRef
   return $ pconstantRefDoc <+> dquotes (pretty t)
@@ -402,7 +402,7 @@ translates to Plutarch
 pif ((#==) (x) (pconstant "a")) <A> (pif ((#==) (x) (pconstant "b")) <B> <C>)
 ```
 -}
-printCaseTextE :: MonadPrint m => LV.ValueE -> [(LV.ValueE, LV.ValueE)] -> (LV.ValueE -> LV.ValueE) -> m (Doc ann)
+printCaseTextE :: PlutarchLamValMonad m => LV.ValueE -> [(LV.ValueE, LV.ValueE)] -> (LV.ValueE -> LV.ValueE) -> m (Doc ann)
 printCaseTextE caseTxtVal [] otherCase = printValueE (otherCase caseTxtVal) -- TODO(bladyjoker): Why is this a function and not just a ValueE?
 printCaseTextE caseTxtVal ((txtVal, bodyVal) : cases) otherCase = do
   pifRefDoc <- HsSyntax.printHsQValName <$> LV.importValue pifRef
@@ -413,12 +413,12 @@ printCaseTextE caseTxtVal ((txtVal, bodyVal) : cases) otherCase = do
   elseDoc <- printCaseIntE caseTxtVal cases otherCase
   return $ pifRefDoc <+> parens (peqRefDoc <+> parens caseTxtValDoc <+> parens txtValDoc) <+> parens bodyValDoc <+> parens elseDoc
 
-printRefE :: MonadPrint m => LV.Ref -> m (Doc ann)
+printRefE :: PlutarchLamValMonad m => LV.Ref -> m (Doc ann)
 printRefE ref = do
   qvn <- LV.resolveRef ref
   HsSyntax.printHsQValName <$> LV.importValue qvn
 
-printValueE :: MonadPrint m => LV.ValueE -> m (Doc ann)
+printValueE :: PlutarchLamValMonad m => LV.ValueE -> m (Doc ann)
 printValueE (LV.VarE v) = return $ pretty v
 printValueE (LV.RefE ref) = printRefE ref
 printValueE (LV.LamE lamVal) = printLamE lamVal