case y :: ys 是什么意思？

Question

I'm trying to make sense of the code below, but got stuck on case y :: ys . How is this defined? I don't see any declaration for y , and ys ... Where do they come from?

I understand that case matches try to do equals on the object, but case y :: ys seems to be an operation. What is happening here?

def f(xs: List[Int], g: (Int, Int) => Boolean) = {
  def h(x: Int, xs: List[Int]): List[Int] =
    xs match {
      case List() => List(x)
      case y :: ys => if (!g(x, y)) x :: xs else y :: h(x, ys)
    }
  (xs :\ List[Int]())(h)
}

Answer 1

I don't see any declaration for y, and ys, so where do they come from?

What you see is the declaration.

A case is able to deconstruct a value (here xs ) into its parts according to a pattern, if that "matches" (see it?). Here a list is deconstructed into a head (giving it the name y ) and a tail/rest (giving it the name ys ). Those two parts can now be accessed separately in the expression after the arrow.

Answer 2

case y :: ys =>

This is an equivalent of pattern matching for lists wherein your x matches with head of the list while ys matches with the tail . In pattern maching allows you to de-structure the input to match a given pattern, in this case a list with y as head and ys as tail

Answer 3

Like other answers, case y :: ys matches head (y) and tail (ys) of a list.

It's actually a syntactic sugar, :: is a case class , you can check the docs and case y :: ys equals to case ::(y, ys) .