问题描述

我明白，一般来说，关于决定想要将什么建模为效果有很多话要说。这个讨论在 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,"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());
}

解决方法

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

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 不包含在单个方法/类中，而是包含在几个方法/类中。 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))
    }
  }

cats-effect scala scala-cats

使用 scala-cats IO 类型封装一个可变的 Java 库 1.简单又脏2.走向组成3.用纯接口包装