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

Question

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

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

与此同时，我有点需要在工作中尽快交付一些代码。 它依赖于一个完全关于突变的 Java 库。该库很久以前就开始了，出于遗留原因，我认为它们没有改变。

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

Edit1（应要求我添加了一个 sn-p）

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

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

这样做有几个原因：

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))
    }
  }