Question

我正在使用Scala创建一个处理固定长度的库。

为了编码和解码strings我使用基于类型的系统。我提供了自己的Read[A]和Write[A]来处理此操作。

我的Write类型类正在使用来自Show的{{1}}。它有效，但它要求用户明确导入 cats'含义，例如：

Cats

可以在Github项目中看到这个例子：
https://github.com/atais/Fixed-Length/blob/702d7d242e5b1f6e1c6b581ad7356f36ca6ed8d9/src/test/scala/com/github/atais/fixedlength/simple/CodecTest.scala

有没有走动？我想隐藏import com.github.atais.util.Read._ import cats.implicits._ import com.github.atais.util.Write._导入或（如果可能）将所有三个合并到一个隐式对象中。

Answer 1

cats将特殊字符集中的类型类实例存储起来，您可以扩展这些特性以将对象转换为提供程序。但是，实例按类型分组，因此您可以获取Int，AnyVal或List的所有实例，但不能使用Show＆＃34;的任何实例。

例如，您可以扩展AnyValInstances，这将编译（在工作表中）

import cats.Show
import cats.instances.AnyValInstances


trait Write[A]

object Write extends AnyValInstances {
    implicit def writeForCatsShow[A](implicit s: Show[A]): Write[A] = new Write[A] { }
}

import Write._

implicitly[Write[Int]] // Show[Int] is in scope

但是，有一点需要注意。从cats导入实例将导致编译错误，因为Show[Int]不明确：

import Write._
import cats.implicits._

// implicitly[Write[Int]] // this will fail to compile b/c we have Show[Int] twice

我的偏好是编写一些样板代码，以避免给用户带来任何进口负担。

object file1 {
  // pretend it's a different file
  import cats.Show
  import cats.implicits._ 

  trait Write[A]

  object Write {

    // implement generic Show <-> Write here
    private def fromShow[A](implicit s: Show[A]): Write[A] = new Write[A] { }

    // manually create instances for types you need
    implicit val intWrite  = fromShow[Int]
    implicit val longWrite = fromShow[Long]
    implicit val doubleWrite = fromShow[Double]
    implicit val stringWrite = fromShow[String]

    // BONUS: define instances for other types that have Show
    // without causing any ambiguities
    implicit def listWrite[A](implicit wa: Write[A]): Write[List[A]] = ???
  }
}

object file2 {
  import file1.Write

  object Methods {
        def testWrite[A](a: A)(implicit write: Write[A]) = 42
    }
}

object file3 {
  import file2.Methods

  // We don't need to import cats.Show OR Write at all
  // because Show instances are resolved in object Write code
  // and Scala automatically looks up Write[A] instances in
  // companion object, so Write[Double] will be picked
  def main(args: Array[String]) = {
        println(Methods.testWrite(2.11))
    }
}

以上代码的可运行版本可用here

导入所需的外部含义或合并含义以获得一个常见的导入

1 个答案: