使用 scala-cats IO 类型封装一个可变的 Java 库

Question

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

尽管如此，我还没有完成这一章，我只是从头到尾浏览了一下，然后才与 Cats IO 一起阅读。

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

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

Edit1（应要求我添加了一个片段）

准备进入模型，改变模型而不是创建新模型。例如，我会将 jena 与 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());
}

Answer 1

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

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

这样做有几个原因：

因为命令式/可变式 API 不包含在单个方法中 / class 而是包含在其中几个方法中。而IO中小步骤的封装，就是在帮你推理。
因为你想慢慢将代码迁移到更好的地方。
因为你想让自己感觉更好 :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))
    }
  }

使用 scala-cats IO 类型封装一个可变的 Java 库

Using scala-cats IO type to encapsulate a mutable Java library

scala

scala-cats

cats-effect

Edit1（应要求我添加了一个片段）

1。简单又肮脏

2。走向构图。

3。将其包装在纯界面中