Why val is stable identifier and def is not?

Question

Fields (vals) of class instances could be used while pattern matching:

class A {
  val foo = 37
  def bar = 42
}

def patmat1(a: A, x: Int) {
  x match {
    case a.foo => println("a.foo")
    case _     => println("not a.foo")
  }
}

patmat1(new A, 37) // => a.foo
patmat1(new A, 42) // => not a.foo

And I wonder why def cannot be used analogously?

def patmat2(a: A, x: Int) {
  x match {
    case a.bar => println("a.bar")
    //     ^ error: stable identifier required, but a.bar found.
    case _     => println("not a.bar")
  }
}

I thought that val and def are mostly interchangeable.

possible duplicate of [Why can't a variable be a stable identifier?](http://stackoverflow.com/questions/7083502/why-cant-a-variable-be-a-stable-identifier) — Marius Danila, Sep 16 '13 at 07:25
Well, val is a constant and def is a function definition. It could work, but treating nullary function definitions as constants is maybe not a good idea... Or worth the effort. — Boldizsár Németh, Sep 16 '13 at 07:25
@BoldizsárNémeth the answer to this question will be exactly the same. So why is this not a duplicate? — Marius Danila, Sep 16 '13 at 07:31
@MariusDanila You mean that result of `def` may change while pattern matching? — Vladimir Parfinenko, Sep 16 '13 at 07:33
@VladimirParfinenko It might certainly do. Your `def` might use a `var` in its implementation so the argument is the same — Marius Danila, Sep 16 '13 at 07:39
@marius You are right, but for a new student of scala it might not be so trivial. — Boldizsár Németh, Sep 16 '13 at 07:42
And for further investigation: implementation of custom `unapply` may also depend on state of some global `var`. I think that `def` is not worse than `unapply`. — Vladimir Parfinenko, Sep 16 '13 at 07:48

Jatin · Answer 1 · 2013-09-16T08:45:25.563

2

Well as per reference, your second case is not a valid pattern. val foo works because it is a Stable Identifier Pattern § 8.1.5 which basically means that it checks if x == a.foo.

Your second case is simply not any valid pattern (as a.bar is not a identifier but a declaration) hence the error.

One idiomatic way would be:

def patmat1(a: A, x: Int) {
  x match {
    case i if a.bar == x => println("a.foo")
    case _     => println("not a.foo")
  }
}

edited Sep 16 '13 at 08:45

answered Sep 16 '13 at 08:22

Jatin

31,116
15
98
163

1

_A stable identiﬁer is a path which ends in an identiﬁer._ And why `a.bar` is not a stable identifier? I've read `§ 8.1.5` and still do not understand why `a.bar` is prohibited. – Vladimir Parfinenko Sep 16 '13 at 08:34
`a.bar` is not an identifier but a declaration – Jatin Sep 16 '13 at 08:44

score 0 · Answer 2 · answered Sep 16 '13 at 08:41

I believe the first part of the left-half of a case statement is to destructure an object or match it to a constant value. So, for example:

val animal: Animal = Dog("butch",4)

animal match {
  case _: Dog => println("bow-wow")
  case _: Cat => println("meow")
}

If you want to compare to a constant, you can do that in the main part of the case statement:

secretConstant match {
  case Math.PI => println("I'm a PI")
  case Math.E  +> println("I'm an E")
  case _ => println("I don't know what I am")
}

But if you want to compare against a calculated value, then you need to include it within the if portion of a case statement:

tomsWeddingDate match {
  case date: LocalDate if date < LocalDate.now() => println("phew, I still have time to buy a gift.")
  case _ => println("Oops, I guess I need to send a belated card")
}

Why val is stable identifier and def is not?

2 Answers2