[#27] Rename EntryPoints to Entrypoints

Problem: Currently we have some appearances of
"EntryPoints" throughout the project which should
be renamed to "Entrypoints".
Solution: Rename the corresponding types, functions
and modules.
parent cfef7cfd
Pipeline #169920781 passed with stages
in 21 minutes and 36 seconds
......@@ -4,7 +4,7 @@ cabal-version: 2.2
--
-- see: https://github.com/sol/hpack
--
-- hash: 43eff7e06b5b740d23a49f5c0b5ed3aaf4f2c094360b1e02621874a23112a4ce
-- hash: 90c22a6f946f09dad1cd2479e6e88b5c15353daeaae9d0eb5baa6f93665cfba0
name: cleveland
version: 0.1.0
......@@ -137,8 +137,8 @@ test-suite lorentz-test
Test.Lorentz.CustomValue
Test.Lorentz.DeadCode
Test.Lorentz.Doc.Positions
Test.Lorentz.EntryPoints
Test.Lorentz.EntryPoints.Doc
Test.Lorentz.Entrypoints
Test.Lorentz.Entrypoints.Doc
Test.Lorentz.Errors
Test.Lorentz.Errors.Numeric
Test.Lorentz.Extensible
......@@ -204,7 +204,7 @@ test-suite morley-test
other-modules:
Test.Analyzer
Test.Doc.Position
Test.EntryPoints
Test.Entrypoints
Test.Ext
Test.Integrational
Test.Interpreter
......
......@@ -60,7 +60,7 @@ test_General_doc_scan =
-- 'Integer' type to be found while 'Natural' to be not, doc items
-- discovery thought that ":!" has already been traversed and didn't
-- pick its dependencies the second time.
let contract = L.doc $ L.mkDEntryPointArgSimple @("a" :! Integer, "b" :! Natural)
let contract = L.doc $ L.mkDEntrypointArgSimple @("a" :! Integer, "b" :! Natural)
doc = L.buildLorentzDoc contract
defs = cdDefinitionsSet doc
in do
......
......@@ -14,7 +14,7 @@ import Test.Tasty.HUnit (testCase)
import Lorentz (( # ), (/->))
import qualified Lorentz as L
import Lorentz.EntryPoints.Doc
import Lorentz.Entrypoints.Doc
import Lorentz.Test.Doc
import Michelson.Doc
......@@ -33,7 +33,7 @@ contractDoc1 :: ContractDoc
contractDoc1 = L.buildLorentzDoc contract1
contract2 :: L.ContractCode (Either Integer Natural) Integer
contract2 = L.car # L.entryCase (Proxy @PlainEntryPointsKind)
contract2 = L.car # L.entryCase (Proxy @PlainEntrypointsKind)
( #cLeft /-> L.nop
, #cRight /-> L.int
) # L.nil # L.pair
......
......@@ -5,9 +5,9 @@
{-# LANGUAGE DeriveAnyClass #-}
-- | Tests for Lorentz compilation which uses 'LorentzCompilationWay'.
module Test.Lorentz.EntryPoints
( test_FieldEntryPoints
, test_TypeEntryPoints
module Test.Lorentz.Entrypoints
( test_FieldEntrypoints
, test_TypeEntrypoints
, test_Entrypoints_lookup
, test_Contract_call
, test_Self_call
......@@ -26,7 +26,7 @@ import Lorentz ((:!), ( # ), (/->))
import qualified Lorentz as L
import Lorentz.Annotation
import Lorentz.Constraints
import Lorentz.EntryPoints
import Lorentz.Entrypoints
import Lorentz.Run
import Lorentz.Test
import Lorentz.Value
......@@ -38,83 +38,83 @@ import Michelson.Untyped (ann, noAnn)
-- Entrypoints declarations
----------------------------------------------------------------------------
data MyEntryPoints1
data MyEntrypoints1
= Do1 Integer
| Do2 (Integer, Integer)
| Do3 MyEntryPoints2
| Do3 MyEntrypoints2
| Do4 MyParams
deriving stock Generic
deriving anyclass (IsoValue, HasAnnotation)
data MyEntryPoints1a
data MyEntrypoints1a
= Do1a Integer
| Do2a (Integer, Integer)
| Do3a MyEntryPoints2
| Do3a MyEntrypoints2
| Do4a MyParams
deriving stock Generic
deriving anyclass (IsoValue, HasAnnotation)
data MyEntryPoints2
data MyEntrypoints2
= Do10
| Do11 Natural
deriving stock Generic
deriving anyclass (IsoValue, HasAnnotation)
data MyEntryPoints3
data MyEntrypoints3
= Do12 ("tuplearg" :! ("TL" :! Integer, "TR" :! Natural), "boolarg" :! Bool)
| Do13 ("integerarg" :! Integer, "boolarg" :! Bool)
deriving stock Generic
deriving anyclass (IsoValue, HasAnnotation)
data MyEntryPoints4
data MyEntrypoints4
= Do14 ("viewarg1" :! L.View ("owner" :! L.Address) Natural)
| Do15 ()
deriving stock Generic
deriving anyclass (IsoValue, HasAnnotation)
data MyEntryPoints5
data MyEntrypoints5
= Do16 ("maybearg" :! Maybe ("maybeinner" :! Natural))
| Do17 ()
deriving stock Generic
deriving anyclass (IsoValue, HasAnnotation)
data MyEntryPoints6
data MyEntrypoints6
= Do18 ("lambdaarg" :! L.Lambda Natural Natural)
| Do19 ()
deriving stock Generic
deriving anyclass (IsoValue, HasAnnotation)
data MyEntryPoints7
data MyEntrypoints7
= Do20 ("listarg" :! [("balance" :! Natural , "address" :! L.Address)])
| Do21 ()
deriving stock Generic
deriving anyclass (IsoValue, HasAnnotation)
data MyEntryPoints8
data MyEntrypoints8
= Do22 ("maparg" :! (Map Natural ("balance" :! Natural , "address" :! L.Address)))
| Do23 ()
deriving stock Generic
deriving anyclass (IsoValue, HasAnnotation)
data MyEntryPoints9
data MyEntrypoints9
= Do24 ("maybearg" L.:? ("maybeinner" :! Natural))
| Do25 ()
deriving stock Generic
deriving anyclass (IsoValue, HasAnnotation)
data MyEntryPoints10
data MyEntrypoints10
= Do26 ("bigmaparg" :! L.Lambda (BigMap Natural ("balance" :! Natural , "address" :! L.Address)) ())
| Do27 ()
deriving stock Generic
deriving anyclass (IsoValue, HasAnnotation)
data MyEntryPoints11
data MyEntrypoints11
= Do28 ("kek" :! Natural, "pek" :! Integer)
| Do29
deriving stock Generic
deriving anyclass (IsoValue, HasAnnotation)
data MyEntryPointsWithDef
data MyEntrypointsWithDef
= Default Integer
| NonDefault Natural
deriving stock Generic
......@@ -129,78 +129,78 @@ data MyParams = MyParams
-- Normally this cannot declare entrypoints because this is not a sum type.
-- But we will declare them forcibly
data MySingleEntryPoint = Dos1 Integer
data MySingleEntrypoint = Dos1 Integer
deriving stock Generic
deriving anyclass (IsoValue, HasAnnotation)
data MyEntryPointsDelegated
data MyEntrypointsDelegated
= Dod1
| Dod2 MyEntryPointsSubDelegated
| Dod2 MyEntrypointsSubDelegated
deriving stock Generic
deriving anyclass (IsoValue, HasAnnotation)
data MyEntryPointsSubDelegated
data MyEntrypointsSubDelegated
= Dosd1
| Dosd2
deriving stock Generic
deriving anyclass (IsoValue, HasAnnotation)
instance ParameterHasEntryPoints MyEntryPoints1 where
type ParameterEntryPointsDerivation MyEntryPoints1 = EpdRecursive
instance ParameterHasEntrypoints MyEntrypoints1 where
type ParameterEntrypointsDerivation MyEntrypoints1 = EpdRecursive
instance ParameterHasEntryPoints MyEntryPoints1a where
type ParameterEntryPointsDerivation MyEntryPoints1a = EpdPlain
instance ParameterHasEntrypoints MyEntrypoints1a where
type ParameterEntrypointsDerivation MyEntrypoints1a = EpdPlain
instance ParameterHasEntryPoints MyEntryPoints2 where
type ParameterEntryPointsDerivation MyEntryPoints2 = EpdPlain
instance ParameterHasEntrypoints MyEntrypoints2 where
type ParameterEntrypointsDerivation MyEntrypoints2 = EpdPlain
instance ParameterHasEntryPoints MyEntryPoints3 where
type ParameterEntryPointsDerivation MyEntryPoints3 = EpdPlain
instance ParameterHasEntrypoints MyEntrypoints3 where
type ParameterEntrypointsDerivation MyEntrypoints3 = EpdPlain
instance ParameterHasEntryPoints MyEntryPoints4 where
type ParameterEntryPointsDerivation MyEntryPoints4 = EpdPlain
instance ParameterHasEntrypoints MyEntrypoints4 where
type ParameterEntrypointsDerivation MyEntrypoints4 = EpdPlain
instance ParameterHasEntryPoints MyEntryPoints5 where
type ParameterEntryPointsDerivation MyEntryPoints5 = EpdPlain
instance ParameterHasEntrypoints MyEntrypoints5 where
type ParameterEntrypointsDerivation MyEntrypoints5 = EpdPlain
instance ParameterHasEntryPoints MyEntryPoints6 where
type ParameterEntryPointsDerivation MyEntryPoints6 = EpdPlain
instance ParameterHasEntrypoints MyEntrypoints6 where
type ParameterEntrypointsDerivation MyEntrypoints6 = EpdPlain
instance ParameterHasEntryPoints MyEntryPoints7 where
type ParameterEntryPointsDerivation MyEntryPoints7 = EpdPlain
instance ParameterHasEntrypoints MyEntrypoints7 where
type ParameterEntrypointsDerivation MyEntrypoints7 = EpdPlain
instance ParameterHasEntryPoints MyEntryPoints8 where
type ParameterEntryPointsDerivation MyEntryPoints8 = EpdPlain
instance ParameterHasEntrypoints MyEntrypoints8 where
type ParameterEntrypointsDerivation MyEntrypoints8 = EpdPlain
instance ParameterHasEntryPoints MyEntryPoints9 where
type ParameterEntryPointsDerivation MyEntryPoints9 = EpdPlain
instance ParameterHasEntrypoints MyEntrypoints9 where
type ParameterEntrypointsDerivation MyEntrypoints9 = EpdPlain
instance ParameterHasEntryPoints MyEntryPoints10 where
type ParameterEntryPointsDerivation MyEntryPoints10 = EpdPlain
instance ParameterHasEntrypoints MyEntrypoints10 where
type ParameterEntrypointsDerivation MyEntrypoints10 = EpdPlain
instance ParameterHasEntryPoints MyEntryPoints11 where
type ParameterEntryPointsDerivation MyEntryPoints11 = EpdNone
instance ParameterHasEntrypoints MyEntrypoints11 where
type ParameterEntrypointsDerivation MyEntrypoints11 = EpdNone
instance ParameterHasEntryPoints MyEntryPointsWithDef where
type ParameterEntryPointsDerivation MyEntryPointsWithDef = EpdPlain
instance ParameterHasEntrypoints MyEntrypointsWithDef where
type ParameterEntrypointsDerivation MyEntrypointsWithDef = EpdPlain
instance ParameterHasEntryPoints (ShouldHaveEntryPoints MySingleEntryPoint) where
type ParameterEntryPointsDerivation (ShouldHaveEntryPoints MySingleEntryPoint) = EpdPlain
instance ParameterHasEntrypoints (ShouldHaveEntrypoints MySingleEntrypoint) where
type ParameterEntrypointsDerivation (ShouldHaveEntrypoints MySingleEntrypoint) = EpdPlain
instance ParameterHasEntryPoints MyEntryPointsDelegated where
type ParameterEntryPointsDerivation MyEntryPointsDelegated = EpdDelegate
instance ParameterHasEntrypoints MyEntrypointsDelegated where
type ParameterEntrypointsDerivation MyEntrypointsDelegated = EpdDelegate
instance ParameterHasEntryPoints MyEntryPointsSubDelegated where
type ParameterEntryPointsDerivation MyEntryPointsSubDelegated = EpdNone
instance ParameterHasEntrypoints MyEntrypointsSubDelegated where
type ParameterEntrypointsDerivation MyEntrypointsSubDelegated = EpdNone
dummyContract :: Contract param ()
dummyContract = defaultContract $
L.drop L.# L.unit L.# L.nil L.# L.pair
test_FieldEntryPoints :: [TestTree]
test_FieldEntryPoints =
test_FieldEntrypoints :: [TestTree]
test_FieldEntrypoints =
[ testCase "Simple parameter" $
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntryPoints2))
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntrypoints2))
@?=
FANodeOr
(ann "do10") FALeaf
......@@ -208,7 +208,7 @@ test_FieldEntryPoints =
, testGroup "Complex parameter"
[ testCase "Interpreting as direct list of entrypoints" $
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntryPoints1a))
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntrypoints1a))
@?=
FANodeOr
noAnn (FANodeOr (ann "do1a") FALeaf (ann "do2a") FALeaf)
......@@ -220,7 +220,7 @@ test_FieldEntryPoints =
(FANodePair (ann "param1") FALeaf (ann "param2") FALeaf))
, testCase "Recursive entrypoints traversal" $
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntryPoints1))
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntrypoints1))
@?=
FANodeOr
noAnn (FANodeOr (ann "do1") FALeaf (ann "do2") FALeaf)
......@@ -234,7 +234,7 @@ test_FieldEntryPoints =
)
, testCase "Delegating entrypoints traversal" $
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntryPointsDelegated))
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntrypointsDelegated))
@?=
FANodeOr (ann "dod1") FALeaf
(ann "dod2") (FANodeOr noAnn FALeaf noAnn FALeaf)
......@@ -244,41 +244,41 @@ test_FieldEntryPoints =
paramAnnTree :: M.Contract cp st -> FieldAnnTree cp
paramAnnTree = extractFieldAnnTree . pnNotes . cParamNotes
test_TypeEntryPoints :: [TestTree]
test_TypeEntryPoints =
test_TypeEntrypoints :: [TestTree]
test_TypeEntrypoints =
[ testCase "Named field parameter" $
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntryPoints3))
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntrypoints3))
@?=
(TANodeOr noAnn
(TANodePair noAnn (TANodePair (ann "tuplearg") (TALeaf (ann "TL")) (TALeaf (ann "TR"))) (TALeaf (ann "boolarg")))
(TANodePair noAnn (TALeaf (ann "integerarg")) (TALeaf (ann "boolarg")))
)
, testCase "Named field parameter for views" $
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntryPoints4))
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntrypoints4))
@?=
(TANodeOr noAnn
(TANodePair (ann "viewarg1") (TALeaf (ann "owner")) (TALeaf noAnn)) (TALeaf noAnn))
, testCase "Maybe field parameter" $
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntryPoints5))
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntrypoints5))
@?=
(TANodeOr noAnn
(TANodeOption (ann "maybearg") (TALeaf (ann "maybeinner"))) (TALeaf noAnn))
, testCase "Lambda field parameter" $
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntryPoints6))
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntrypoints6))
@?=
(TANodeOr noAnn
(TANodeLambda (ann "lambdaarg") (TALeaf noAnn) (TALeaf noAnn)) (TALeaf noAnn))
, testCase "List field parameter" $
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntryPoints7))
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntrypoints7))
@?=
(TANodeOr noAnn
(TANodeList (ann "listarg") (TANodePair noAnn (TALeaf (ann "balance")) (TALeaf (ann "address")))) (TALeaf noAnn))
, testCase "Map field parameter" $
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntryPoints8))
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntrypoints8))
@?=
(TANodeOr noAnn
(TANodeMap
......@@ -290,13 +290,13 @@ test_TypeEntryPoints =
)
, testCase "Maybe field parameter 2" $
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntryPoints9))
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntrypoints9))
@?=
(TANodeOr noAnn
(TANodeOption (ann "maybearg") (TALeaf (ann "maybeinner"))) (TALeaf noAnn))
, testCase "Big map field parameter" $
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntryPoints10))
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntrypoints10))
@?=
(TANodeOr noAnn
(TANodeLambda (ann "bigmaparg")
......@@ -311,7 +311,7 @@ test_TypeEntryPoints =
)
, testCase "Newtype" $
(paramAnnTree $ compileLorentzContract (dummyContract @(ShouldHaveEntryPoints MySingleEntryPoint)))
(paramAnnTree $ compileLorentzContract (dummyContract @(ShouldHaveEntrypoints MySingleEntrypoint)))
@?=
TALeaf noAnn
......@@ -327,7 +327,7 @@ test_TypeEntryPoints =
TANodePair noAnn (TALeaf noAnn) (TANodeLambda noAnn (TALeaf noAnn) (TALeaf noAnn))
]
, testCase "EpdNone case (type annotations are preserved)" $
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntryPoints11))
(paramAnnTree $ compileLorentzContract (dummyContract @MyEntrypoints11))
@?=
(TANodeOr noAnn
(TANodePair noAnn (TALeaf (ann "kek")) (TALeaf (ann "pek")))
......@@ -346,33 +346,33 @@ test_Entrypoints_lookup :: [TestTree]
test_Entrypoints_lookup =
[ testGroup "Flat parameter type"
[ typeTest "Default entrypoint arg" $ Valid @
(GetDefaultEntryPointArg MyEntryPoints1a `Is` MyEntryPoints1a)
(GetDefaultEntrypointArg MyEntrypoints1a `Is` MyEntrypoints1a)
, typeTest "Can get entrypoint on surface" $ Valid @
(GetEntryPointArg MyEntryPoints1a "Do1a" `Is` Integer)
(GetEntrypointArg MyEntrypoints1a "Do1a" `Is` Integer)
, typeTest "Cannot get entrypoint in deep" $ Valid @
(Eval (LookupParameterEntryPoint MyEntryPoints1a "Do11")
(Eval (LookupParameterEntrypoint MyEntrypoints1a "Do11")
`ExactlyIs` 'Nothing
)
]
, testGroup "Nested parameter type"
[ typeTest "Default entrypoint arg" $ Valid @
(GetDefaultEntryPointArg MyEntryPoints1 `Is` MyEntryPoints1)
(GetDefaultEntrypointArg MyEntrypoints1 `Is` MyEntrypoints1)
, typeTest "Can get entrypoint on surface" $ Valid @
(GetEntryPointArg MyEntryPoints1 "Do1" `Is` Integer)
(GetEntrypointArg MyEntrypoints1 "Do1" `Is` Integer)
, typeTest "Can get entrypoint in deep" $ Valid @
(GetEntryPointArg MyEntryPoints1 "Do11" `Is` Natural)
(GetEntrypointArg MyEntrypoints1 "Do11" `Is` Natural)
, typeTest "Can get entrypoint without arg" $ Valid @
(GetEntryPointArg MyEntryPoints1 "Do10" `Is` ())
(GetEntrypointArg MyEntrypoints1 "Do10" `Is` ())
]
, testGroup "Parameter type with default entrypoint"
[ typeTest "Default entrypoint arg" $ Valid @
(GetDefaultEntryPointArg MyEntryPointsWithDef `Is` Integer)
(GetDefaultEntrypointArg MyEntrypointsWithDef `Is` Integer)
, typeTest "Can get non-default entrypoint" $ Valid @
(GetEntryPointArg MyEntryPointsWithDef "NonDefault" `Is` Natural)
(GetEntrypointArg MyEntrypointsWithDef "NonDefault" `Is` Natural)
]
, testGroup "Delegation"
[ typeTest "Calling immediate entrypoint works" $ Valid @
(GetEntryPointArg MyEntryPointsDelegated "Dod1" `Is` ())
(GetEntrypointArg MyEntrypointsDelegated "Dod1" `Is` ())
]
]
......@@ -380,10 +380,10 @@ test_Entrypoints_lookup =
-- entrypoint of another contract.
callerContract
:: forall cp mname arg.
( arg ~ GetEntryPointArgCustom cp mname
( arg ~ GetEntrypointArgCustom cp mname
, NiceConstant arg, NiceParameter arg, NiceParameterFull cp
)
=> EntryPointRef mname
=> EntrypointRef mname
-> arg
-> Contract (TAddress cp) ()
callerContract epRef arg = defaultContract $
......@@ -397,7 +397,7 @@ test_Contract_call =
[ testCase "Calling entrypoint" $
integrationalTestExpectation $ do
let myCallerContract = callerContract (Call @"Do11") 5
let myTargetContract = defaultContract $ L.car # L.caseT @MyEntryPoints2
let myTargetContract = defaultContract $ L.car # L.caseT @MyEntrypoints2
( #cDo10 /-> L.push 0
, #cDo11 /-> L.nop
) # L.nil # L.pair
......@@ -410,7 +410,7 @@ test_Contract_call =
, testCase "Calling default entrypoint" $
integrationalTestExpectation $ do
let myCallerContract = callerContract CallDefault 3
let myTargetContract = defaultContract $ L.car # L.caseT @MyEntryPointsWithDef
let myTargetContract = defaultContract $ L.car # L.caseT @MyEntrypointsWithDef
( #cDefault /-> L.nop
, #cNonDefault /-> L.neg
) # L.nil # L.pair
......@@ -425,9 +425,9 @@ test_Self_call :: [TestTree]
test_Self_call =
[ testCase "Calling entrypoint" $
integrationalTestExpectation $ do
let myContract = defaultContract $ L.car # L.caseT @MyEntryPoints2
let myContract = defaultContract $ L.car # L.caseT @MyEntrypoints2
( #cDo10 /->
L.selfCalling @MyEntryPoints2 (Call @"Do11") #
L.selfCalling @MyEntrypoints2 (Call @"Do11") #
L.push (toMutez 1) # L.push 5 # L.transferTokens #
L.dip (L.push @Integer 1 # L.nil) # L.cons # L.pair
, #cDo11 /-> L.push @Integer 10 # L.add # L.nil # L.pair
......
......@@ -3,7 +3,7 @@
-- SPDX-License-Identifier: LicenseRef-MIT-TQ
-- | Tests on autodoc for entrypoints.
module Test.Lorentz.EntryPoints.Doc
module Test.Lorentz.Entrypoints.Doc
( test_ParamBuildingSteps_are_correct
, test_Finalization_check
, unit_Uncallables_detection
......@@ -18,8 +18,8 @@ import Lorentz ((:->), (/->))
import qualified Lorentz as L
import Lorentz.Annotation
import Lorentz.Doc
import Lorentz.EntryPoints
import Lorentz.EntryPoints.Doc
import Lorentz.Entrypoints
import Lorentz.Entrypoints.Doc
import Lorentz.Test.Doc
import Lorentz.Value
import Michelson.Untyped (EpName(..))
......@@ -37,7 +37,7 @@ instance TypeHasDoc MySub where
typeDocMdDescription = "MySub"
mySubImpl :: '[MySub] :-> '[]
mySubImpl = L.entryCase (Proxy @PlainEntryPointsKind)
mySubImpl = L.entryCase (Proxy @PlainEntrypointsKind)
( #cDos1 /-> L.nop
, #cDos2 /-> L.nop
)
......@@ -51,11 +51,11 @@ data MyPlainEps
instance TypeHasDoc MyPlainEps where
typeDocMdDescription = "MyPlainEps"
instance ParameterHasEntryPoints MyPlainEps where
type ParameterEntryPointsDerivation MyPlainEps = EpdPlain
instance ParameterHasEntrypoints MyPlainEps where
type ParameterEntrypointsDerivation MyPlainEps = EpdPlain
myPlainImplDumb :: '[MyPlainEps] :-> '[]
myPlainImplDumb = L.entryCase (Proxy @PlainEntryPointsKind)
myPlainImplDumb = L.entryCase (Proxy @PlainEntrypointsKind)
( #cDo1 /-> L.drop
, #cDo2 /-> mySubImpl
)
......@@ -69,12 +69,12 @@ data MyRecursiveEps
deriving stock (Generic)
deriving anyclass (IsoValue, HasAnnotation)
instance ParameterHasEntryPoints MyRecursiveEps where
type ParameterEntryPointsDerivation MyRecursiveEps = EpdRecursive
instance ParameterHasEntrypoints MyRecursiveEps where