Question

让我们看一个例子（这是一个天真的例子，但足以说明问题）。

def produce(l: List[Int]) : Any =
  l match {
    case List(x) => x
    case List(x, y) => (x, y)
  }

val client1 : Int = produce(List(1)).asInstanceOf[Int]

缺点：客户需要施放！

def produce2[A](l: List[Int])(f: List[Int] => A) = {
  f(l)
}

val toOne = (l: List[Int]) => l.head
val toTwo = (l: List[Int]) => (l.head, l.tail.head)


val client2 : Int = produce2(List(1))(toOne)

缺点：输入安全性，即我们可以用单例列表调用两个。

有更好的解决方案吗？

Answer 1

如果您只有两个可能的返回值，则可以使用以下任一：

def produce(l : List[Any]) : Either[Any, (Any, Any)] = l match {
    case List(x) => Left(x)
    case List(x, y) => Right((x, y))
}

如果您不想创建Either，可以传递一个函数来转换每个案例：

def produce[A](l : List[Int])(sf: Int => A)(pf: (Int, Int) => A): A = l match {
    case List(x) => sf(x)
    case List(x, y) => pf(x, y)
}

Answer 2

这会有用吗？

  def produce(l: List[Int]) = {
     l match {
      case List(x) => (x, None)
      case List(x,y) => (x,y)
      case Nil => (None, None)
     }
   }

甚至更好，以避免长度超过2个元素的列表出现匹配错误：

  def produce(l: List[Int]) =
     l match {
      case x :: Nil => (x, None)
      case x :: xs  => (x,xs.head)
      case Nil => (None, None)
     }

根据输入参数返回不同的类型

2 个答案: