0

我知道，一般来说，关于决定将什么建模为效果有很多话要说。这个讨论是在 Scala 的函数式编程中关于 IO 的一章中介绍的。

尽管如此，我还没有完成这一章，我只是在与 Cats IO 一起讨论之前端到端浏览它。

同时，我有点需要在工作中尽快交付一些代码。它依赖于一个完全关于突变的 Java 库。该库是很久以前开始的，出于遗留原因，我看不到它们发生变化。

总之，长话短说。实际上将任何变异函数建模为 IO 是封装变异 java 库的可行方法吗？

Edit1（根据要求，我添加了一个片段）

准备好进入一个模型，改变模型而不是创建一个新模型。例如，我会将 jena 与 gremlin 进行对比，gremlin 是一个基于图形数据的函数库。

def loadModel(paths: String*): Model =
    paths.foldLeft(ModelFactory.createOntologyModel(new OntModelSpec(OntModelSpec.OWL_MEM)).asInstanceOf[Model]) {
      case (model, path) ⇒
        val input = getClass.getClassLoader.getResourceAsStream(path)
        val lang  = RDFLanguages.filenameToLang(path).getName
        model.read(input, "", lang)
    }

那是我的 scala 代码，但网站中记录的 java api 看起来像这样。

// create the resource
Resource r = model.createResource();

// add the property
r.addProperty(RDFS.label, model.createLiteral("chat", "en"))
 .addProperty(RDFS.label, model.createLiteral("chat", "fr"))
 .addProperty(RDFS.label, model.createLiteral("<em>chat</em>", true));

// write out the Model
model.write(system.out);

// create a bag
Bag smiths = model.createBag();

// select all the resources with a VCARD.FN property
// whose value ends with "Smith"
StmtIterator iter = model.listStatements(
    new SimpleSelector(null, VCARD.FN, (RDFNode) null) {
        public boolean selects(Statement s) {
                return s.getString().endsWith("Smith");
        }
    });
// add the Smith's to the bag
while (iter.hasNext()) {
    smiths.add(iter.nextStatement().getSubject());
}
4

1 回答 1

4

所以，这个问题有三种解决方案。

1.简单而肮脏

如果不纯 API 的所有使用都包含在单个/一小部分代码库中，您可能只是“作弊”并执行以下操作：

def useBadJavaAPI(args): IO[Foo] = IO {
  // Everything inside this block can be imperative and mutable.
}

我说“作弊”是因为它的概念IO是组合，而一IO大块并不是真正的组合。但是，有时您只想封装该遗留部分而不关心它。

2. 走向组合。

基本上，和上面一样，但是flatMaps在中间丢了一些：

// Instead of:
def useBadJavaAPI(args): IO[Foo] = IO {
  val a = createMutableThing()
  mutableThing.add(args)
  val b = a.bar()
  b.computeFoo()
}

// You do something like this:
def useBadJavaAPI(args): IO[Foo] =
  for {
    a <- IO(createMutableThing())
    _ <- IO(mutableThing.add(args))
    b <- IO(a.bar())
    result <- IO(b.computeFoo())
  } yield result

这样做有几个原因：

  1. 因为命令式/可变 API 不包含在单个方法/类中，而是包含在其中的几个中。而 IO 中小步骤的封装正在帮助你推理它。
  2. 因为你想慢慢地将代码迁移到更好的地方。
  3. 因为你想对自己感觉更好：p

3.将其包装在一个纯界面中

这与许多第三方库（例如Doobie、fs2-blobstore、neotypes）基本相同。在纯接口上包装Java库。

请注意，因此，必须完成的工作量远远超过前两种解决方案。因此，如果可变 API “感染”了代码库的许多地方，或者在多个项目中更糟，这是值得的；如果是这样，那么这样做是有意义的，并且发布是作为一个独立的模块。
（将该模块发布为开源库也可能是值得的，您最终可能会帮助其他人并获得其他人的帮助）

由于这是一项更大的任务，仅提供您必须做的所有事情的完整答案并不容易，因此了解这些库是如何实现的并在此处或在 gitter 频道中提出更多问题可能会有所帮助。

但是，我可以给你一个简短的片段：

// First define a pure interface of the operations you want to provide
trait PureModel[F[_]] { // You may forget about the abstract F and just use IO instead.
  def op1: F[Int]
  def op2(data: List[String]): F[Unit]
}

// Then in the companion object you define factories.
object PureModel {
  // If the underlying java object has a close or release action,
  // use a Resource[F, PureModel[F]] instead.
  def apply[F[_]](args)(implicit F: Sync[F]): F[PureModel[F]] = ???
}

现在，如何创建实现是棘手的部分。也许你可以使用类似的东西Sync来初始化可变状态。

def apply[F[_]](args)(implicit F: Sync[F]): F[PureModel[F]] =
  F.delay(createMutableState()).map { mutableThing =>
    new PureModel[F] {
      override def op1: F[Int] = F.delay(mutableThing.foo())
      override def op2(data: List[String]): F[Unit] = F.delay(mutableThing.bar(data))
    }
  }
于 2021-02-12T16:10:53.577 回答