Why can't I match on a Stream?

Question

Specifically:

scala> def f(n: Seq[Any]) = n match { 
     case Nil => "Empty" 
     case h :: t => "Non-empty" 
}
f: (n: Seq[Any])String

scala> f(Stream())
res1: String = Empty

scala> f(List(1))
res17: String = Non-empty

scala> f(Stream(1))
scala.MatchError: Stream(1, ?) (of class scala.collection.immutable.Stream$Cons)
  at .f(<console>:13)
  ... 33 elided

There are a lot of other ways to implement this, but at written the code was statically safe and failed at run time. What's going on?

chengpohi · Accepted Answer · 2017-03-02T02:24:55.893

4

For Stream, the concat symbol should be #::, the pattern match should like:

  def f(n: Seq[Any]) = n match {
    case Nil => "Empty"
    case h :: t => "Non-empty"
    case h #:: t => "Non-empty stream"
  }

for :: is for List / Seq type(List extends from Seq:) ), see:

final case class ::[B](override val head: B, private[scala] var tl: List[B]) extends List[B] {

edited Mar 02 '17 at 02:24

answered Mar 02 '17 at 02:15

chengpohi

14,064
1
24
42

1

`List` extends from `Seq`. – chengpohi Mar 02 '17 at 02:22
@Nyavro `Seq(1, 2)` is a `List`. That is, `List` is the default `Seq`. – Michael Zajac Mar 02 '17 at 02:22

Michael Zajac · Answer 2 · 2017-03-02T02:27:59.110

1

You can only use :: to deconstruct a List and not a Stream. Since the Stream you provide does not match a List, you get a MatchError. If you want f to support streams using that type of matching (extractors), you can use #::.

def f(n: Seq[Any]) = n match {
  case Nil => "Empty"
  case h :: t => "Non-empty"
  case h #:: t => "Non-empty"
}

In general, this approach is very fragile because both extractor types shown above will only work for those two types of Seq. Others maybe break. If all you care about is determining whether or not the Seq is empty or not, then simply use n.nonEmpty or n.isEmpty and deal with the Boolean result. Otherwise, trying to provide an exhaustive match on a trait that is not sealed is bound to fail.

You can also use the Seq extractor:

def f(n: Seq[Any]) = n match { 
  case Nil => "Empty" 
  case Seq(_*) => "Non-empty" 
}

edited Mar 02 '17 at 02:27

answered Mar 02 '17 at 02:21

Michael Zajac

55,144
7
113
138

Really, is `#::` a thing? How am I even suppose to google that. – nmat Mar 02 '17 at 03:05
No more difficult than googling `::`. – Michael Zajac Mar 02 '17 at 03:36
`Stream` has its own cons, it shouldn't be so surprising: http://www.scala-lang.org/api/2.12.1/scala/collection/immutable/Stream.html – Michael Zajac Mar 02 '17 at 03:37
You can even match for head and tail with the Seq syntax: `Seq(h, t @ _*)`. – leifbattermann Jun 26 '17 at 13:49

score 0 · Answer 3 · answered Sep 04 '17 at 09:48

While other answers show correctly an extractor specific for Stream, which is #::, there exists an extractor for Seq (and anything derived from SeqLike) - it is +:, this works for both List (as ::) and Stream (as `#::). With this extractor you can easily write a function which works with both:

def f(n: Seq[Any]) = n match { 
  case h +: t => "Non-empty" 
  case _ => "Empty" 
}

See also Scala pattern matching on sequences other than Lists

Why can't I match on a Stream?

3 Answers3

Linked