3

假设我们想要定义一个简单的 DSL 来定义 UI 交互，我们可以在其中创建对象然后选择它们：

object TestCommand {

  sealed trait EntityType
  case object Project extends EntityType
  case object Site extends EntityType

  sealed trait TestCommand[A, E]
  case class Create[A, E](entityType: EntityType, withEntity: E => A) extends  TestCommand[A, E]
  case class Select[A, E](entity: E, next: A) extends TestCommand[A, E]

}

我遇到的问题是我不想指定创建命令的返回类型应该是什么（E上面）。我想把这个决定交给口译员。例如，E可以是一个字符串，或者Future如果我们正在使用异步 REST 调用创建对象。

如果我尝试以通常的方式定义 DSL，liftF如下所示：

object TestDSL {

  def create[E](entityType: EntityType): Free[TestCommand[?, E], E] =
    Free.liftF(Create(entityType, identity: E => E): TestCommand[E, E])

  def select[E](entity: E): Free[TestCommand[?, E], Unit] =
    Free.liftF(Select[Unit, E](entity, ()))

}

我收到以下错误：

Error:(10, 10) no type parameters for method liftF: (value: S[A])scalaz.Free[S,A] exist so that it can be applied to arguments (dsl.TestCommand.TestCommand[E,E])
 --- because ---
argument expression's type is not compatible with formal parameter type;
 found   : dsl.TestCommand.TestCommand[E,E]
 required: ?S[?A]
    Free.liftF(Create(entityType, identity: E => E): TestCommand[E, E])

我无法理解上面的代码出了什么问题，但更重要的问题是这是否是对出现在自由单子中的类型进行抽象的正确方法。如果不是，那么正确的（功能性）方法是什么？

编辑：

在 Haskell 中，上述方法没有问题：

{-# LANGUAGE DeriveFunctor #-}
-- |

module TestDSL where

import           Control.Monad.Free

data EntityType = Project | Site

data TestCommand e a = Create EntityType (e -> a) | Select e a
  deriving Functor

-- | The DSL
create :: EntityType -> Free (TestCommand e) e
create et = liftF $ Create et id

select :: e -> Free (TestCommand e) ()
select e = liftF $ Select e ()


-- | A sample program:
test :: Free (TestCommand e) ()
test = do
  p <- create Project
  select p
  _ <- create Site
  return ()

-- | A trivial interpreter.
interpTestCommand :: TestCommand String a -> IO a
interpTestCommand (Create Project withEntity) = do
  putStrLn $ "Creating a project"
  return (withEntity "Project X")
interpTestCommand (Create Site withEntity) = do
  putStrLn $ "Creating a site"
  return (withEntity "Site 51")
interpTestCommand (Select e next) = do
  putStrLn $ "Selecting " ++ e
  return next

-- | Running the interpreter
runTest :: IO ()
runTest = foldFree interpTestCommand test

运行测试将产生以下输出：

λ> runTest
Creating a project
Selecting Project X
Creating a site
4

1 回答 1

3

现在你有test :: Free (TestCommand e) (). 这意味着实体的类型e可以是调用者想要的任何类型，但它在整个计算过程中是固定的。

但这是不对的！在现实世界中，为响应Create命令而创建的实体的类型取决于命令本身：如果您创建了一个Projectthene应该是Project; 如果你创建了一个Sitethene应该是Site. 所以e不应该在整个计算中固定（因为我可能想要创建Projects和 Sites），也不应该由调用者来选择一个e.

这是一个解决方案，其中实体的类型取决于命令的值。

data Site = Site { {- ... -} }
data Project = Project { {- ... -} }

data EntityType e where
    SiteTy :: EntityType Site
    ProjectTy :: EntityType Project

这里的想法是 an 上的模式匹配EntityType e告诉你它e是什么。在Create命令中，我们将存在性地打包一个实体e以及一些 GADT 形式的证据EntityType e，您可以对其进行模式匹配以了解它是什么e。

data CommandF r where
    Create :: EntityType e -> (e -> r) -> CommandF r
    Select :: EntityType e -> e -> r -> CommandF r

instance Functor CommandF where
    fmap f (Create t next) = Create t (f . next)
    fmap f (Select t e next) = Select t e (f next)

type Command = Free CommandF

create :: EntityType e -> Command e
create t = Free (Create t Pure)

select :: EntityType e -> e -> Command ()
select t e = Free (Select t e (Pure ()))

myComputation :: Command ()
myComputation = do
    p <- create ProjectTy  -- p :: Project
    select ProjectTy p
    s <- create SiteTy  -- s :: Site
    return ()

当解释器到达一条Create指令时，它的工作是返回一个与被包装的类型匹配的实体EntityType。它必须检查EntityType以了解是什么e并适当地表现。

-- assuming createSite :: IO Site and createProject :: IO Project

interp :: CommandF a -> IO a
interp (Create SiteTy next) = do
    site <- createSite
    putStrLn "created a site"
    return (next site)
interp (Create ProjectTy next) = do
    project <- createProject
    putStrLn "created a project"
    return (next project)
-- plus clauses for Select

我不知道这将如何准确地转化为 Scala，但这就是 Haskell 中的要点。

于 2016-11-08T21:02:49.940 回答