Cardano Updates

        Language.PlutusCore.Generators.Interesting

        Language.PlutusCore.Generators.Test

        Language.PlutusCore.Lexer

        PlutusPrelude

        Control.Monad.Trans.Inner

        Common

module Language.PlutusCore

    (

      -- * Parser

    , parseTerm

    , parseType

    -- * AST

-- | Convert a PLC constant (unwrapped from 'Value') into the corresponding Haskell value.

-- Checks that the constant is of a given built-in type.

extractBuiltin

    => Value TyName Name uni () -> EvaluateConstApp uni m a

extractBuiltin value                             =

    thoist (InnerT . fmap nat . runReflectT) $ readKnownM value where

-- | A dynamic built-in name that allows to call arbitrary 'IO' actions over

-- PLC values of a built-in types (including dynamic built-in types).

module Language.PlutusCore.Constant.Dynamic.Call

    ( dynamicCallTypeScheme

    , dynamicCallAssign

import           Data.Proxy

import           System.IO.Unsafe

dynamicCallTypeScheme = Proxy `TypeSchemeArrow` TypeSchemeResult Proxy

dynamicCallAssign

    :: (KnownType a uni, Evaluable uni)

    => DynamicBuiltinName

    -> (a -> IO ())

dynamicCallAssign name f =

dynamicCall :: DynamicBuiltinName -> Term tyname name uni ()

dynamicCall = dynamicBuiltinNameAsTerm

    prettyKnown = undefined

instance KnownType a uni => KnownType (EvaluationResult a) uni where

    toTypeAst _ = toTypeAst @a Proxy

    makeKnown EvaluationFailure     = Error () $ toTypeAst @a Proxy

    pretty = pretty . unShallow

instance (Evaluable uni, uni `Includes` a, PrettyKnown a) => KnownType (Shallow a) uni where

    toTypeAst _ = constantType @a Proxy ()

    makeKnown (Shallow x) = constantTerm () x

instance PrettyKnown a => PrettyKnown (Shallow a) where

    prettyKnown = prettyKnown . unShallow

instance Evaluable uni => KnownType Bool uni where

    toTypeAst _ = bool

instance (Evaluable uni, euni ~ Extend a uni, Typeable a, Pretty a) =>

            KnownType (AsExtension uni a) euni where

    toTypeAst _ = extensionType ()

    makeKnown = extensionTerm () . unAsExtension

-- make is just one @[email protected] by induction on the list type argument.

oneArg

    => TypeScheme uni '[a] b

oneArg =

    Proxy `TypeSchemeArrow` TypeSchemeResult Proxy

twoArgs

    => TypeScheme uni '[a, b] c

twoArgs =

    Proxy `TypeSchemeArrow` Proxy `TypeSchemeArrow` TypeSchemeResult Proxy

threeArgs

    => TypeScheme uni '[a, b, c] d

threeArgs =

    Proxy `TypeSchemeArrow` Proxy `TypeSchemeArrow` Proxy `TypeSchemeArrow` TypeSchemeResult Proxy

-- | Typed 'LessThanInteger'.

typedLessThanInteger

typedLessThanInteger = TypedBuiltinName LessThanInteger twoArgs

-- | Typed 'LessThanEqInteger'.

typedLessThanEqInteger

typedLessThanEqInteger = TypedBuiltinName LessThanEqInteger twoArgs

-- | Typed 'GreaterThanInteger'.

typedGreaterThanInteger

typedGreaterThanInteger = TypedBuiltinName GreaterThanInteger twoArgs

-- | Typed 'GreaterThanEqInteger'.

typedGreaterThanEqInteger

typedGreaterThanEqInteger = TypedBuiltinName GreaterThanEqInteger twoArgs

-- | Typed 'EqInteger'.

typedEqInteger

typedEqInteger = TypedBuiltinName EqInteger twoArgs

-- | Typed 'Concatenate'.

-- | Typed 'VerifySignature'.

typedVerifySignature

typedVerifySignature = TypedBuiltinName VerifySignature threeArgs

-- | Typed 'EqByteString'.

typedEqByteString

typedEqByteString = TypedBuiltinName EqByteString twoArgs

-- | Typed 'LtByteString'.

typedLtByteString

typedLtByteString = TypedBuiltinName LtByteString twoArgs

-- | Typed 'GtByteString'.

typedGtByteString

typedGtByteString = TypedBuiltinName GtByteString twoArgs

    , Evaluator (..)

    , EvaluateT (..)

    , ReflectT (..)

    , KnownType (..)

    , PrettyKnown (..)

    , KnownTypeValue (..)

    , OpaqueTerm (..)

infixr 9 `TypeSchemeArrow`

-- | Type schemes of primitive operations.

-- @[email protected] is the Haskell denotation of a PLC type represented as a 'TypeScheme'.

-- @[email protected] is the resulting type in @[email protected], e.g. the resulting type in

-- @ByteString -> Size -> [email protected] is @[email protected]

data TypeScheme uni as r where

    TypeSchemeResult

    TypeSchemeArrow

    TypeSchemeAllType

        :: (KnownSymbol text, KnownNat uniq)

           -- Here we require the user to manually provide the unique of a type variable.

makeRightReflectT :: Monad m => m (EvaluationResult a) -> ReflectT m a

makeRightReflectT = ReflectT . lift . InnerT

-- See Note [Semantics of dynamic built-in types].

-- See Note [Converting PLC values to Haskell values].

-- | Haskell types known to exist on the PLC side.

class PrettyKnown a => KnownType a uni where

    -- | The type representing @[email protected] used on the PLC side.

    toTypeAst :: proxy a -> Type TyName uni ()

-- A type known in a universe is known in an extended version of that universe.

instance (Evaluable uni, KnownType a uni, euni ~ Extend b uni, Typeable b) =>

            KnownType (InExtended b uni a) euni where

    toTypeAst _ = shiftConstantsType $ toTypeAst @a Proxy

    makeKnown (InExtended x) = shiftConstantsTerm $ makeKnown @a x

instance (Evaluable uni, KnownType a euni, euni ~ Extend b uni, Typeable b) =>

            KnownType (InUnextended euni a) uni where

    toTypeAst _ = unshiftConstantsType $ toTypeAst @a @euni Proxy

    makeKnown (InUnextended x) = unshiftConstantsTerm $ makeKnown @a @euni x

-- | The CK machine.

module Language.PlutusCore.Evaluation.CkMachine

    ( CkMachineException

test2 :: EvaluationResult (Either Text ())

test2 = readKnownCk @() @DefaultUni unitval

infix 4 |>, <|

-- | The CK machine-specific 'MachineException'.