模式与无形副产品匹配

我可以使用与无形副产品匹配的模式吗？

import shapeless.{CNil, :+:}

type ListOrString = List[Int] :+: String :+: CNil

def f(a: ListOrString): Int = a match {
  case 0 :: second :: Nil => second
  case first :: Nil => first
  case Nil => -1
  case string: String => string.toInt
}

这当然不起作用,因为a盒装为Coproduct.

有没有其他方法可以使用副产品并保持模式匹配的能力？

您可以在模式匹配中使用Inl和Inr构造函数:

import shapeless.{ CNil, Inl, Inr, :+: }

type ListOrString = List[Int] :+: String :+: CNil

def f(a: ListOrString): Int = a match {
  case Inl(0 :: second :: Nil) => second
  case Inl(first :: Nil) => first
  case Inl(Nil) => -1
  case Inr(Inl(string)) => string.toInt
}

这种方法并不理想,因为CNil如果你希望编译器能够告诉匹配是穷举的你必须处理这种情况 - 我们知道这种情况不可能匹配,但是编译器没有,所以我们必须做这样的事情:

def f(a: ListOrString): Int = a match {
  case Inl(0 :: second :: Nil) => second
  case Inl(first :: Nil) => first
  case Inl(Nil) => -1
  case Inl(other) => other.sum
  case Inr(Inl(string)) => string.toInt
  case Inr(Inr(_)) => sys.error("Impossible")
}

我个人也只是发现导航到副产品中的适当位置,Inr并且Inl有点违反直觉.

通常,最好使用多态函数值折叠副产品:

object losToInt extends shapeless.Poly1 {
  implicit val atList: Case.Aux[List[Int], Int] = at {
    case 0 :: second :: Nil => second
    case first :: Nil => first
    case Nil => -1
    case other => other.sum
  }

  implicit val atString: Case.Aux[String, Int] = at(_.toInt)
}

def f(a: ListOrString): Int = a.fold(losToInt)

现在,编译器将验证穷举,而无需处理不可能的情况.

我刚刚在这里提交了一个可以满足您需求的Shapeless拉取请求.(请注意,它只是一个拉取请求,可能会进行修改或被拒绝......但如果您觉得它很有用,请随意使用机器并在您自己的代码中使用它.)

从提交消息:

[...] Int类型的Coproduct c:+:String:+:Boolean:+:CNil可以折叠成Double,如下所示:

val result = c.foldCases[Double]
               .atCase(i => math.sqrt(i))
               .atCase(s => s.length.toDouble)
               .atCase(b => if (b) 100.0 else -1.0)

与现有折叠Coproducts的方法相比,这提供了一些好处.与Folder类型类不同,这个类不需要具有稳定标识符的多态函数,因此语法有点轻量级,更适合于不重用折叠函数的情况(例如,解析器组合库).

此外,与通过Inl和Inr注入器上的模式匹配直接折叠Coproduct不同,此类型类可确保生成的折叠是详尽的.也可以部分折叠Coproduct(只要按照Coproduct类型签名指定的顺序处理案例),这样就可以逐步折叠Coproduct.

对于您的示例,您可以这样做:

  def f(a: ListOrString): Int = a.foldCases[Int]
    .atCase(list => list match {
      case 0 :: second :: Nil => second
      case first :: Nil => first
      case Nil => -1
      case other => other.sum
    })
    .atCase(s => s.toInt)