scala nested case classes generate strange type error

Question

I'm am trying to use a case class that has one attribute reference another case class. But there are certain conditions where I construct the object that I get strange type errors.

So something like this works fine.

case class Foo(a:Int)
case class Bar(b:Foo, c:Foo)
val t = Bar(Foo(1),Foo(2))
//t: Bar = Bar(Foo(1),Foo(2))

When I nest it into an object, there doesn't seem to be any problem

object w {
    case class Foo(a:Int)
    case class Bar(b:Foo, c:Foo)
}

I can even create an object

val t = w.Bar(w.Foo(1),w.Foo(2))

However, when I try to construct the object from the previously defined Foo, it gives me a crazy type error.

val f = w.Foo(1)
w.Bar(f,f)

// error: type mismatch;
//  found   : w.Foo
//  required: w.Foo
//               w.Bar(f,f)

Any ideas? Scala 2.10.5

in scala 2.11.7 works fine

ka4eli
– ka4eli

2015-10-03 06:20:58 +00:00
Commented Oct 3, 2015 at 6:20 — ka4eli
– ka4eli, Commented Oct 3, 2015 at 6:20
I cannot reproduce this (on scala 2.10.5)

roterl
– roterl

2015-10-03 06:59:04 +00:00
Commented Oct 3, 2015 at 6:59 — roterl
– roterl, Commented Oct 3, 2015 at 6:59

roterl · Accepted Answer · 2015-10-03 07:12:39Z

This can happen if you try it on the console, while redefine some of the classes.
If you type this in the console:

scala> :paste
// Entering paste mode (ctrl-D to finish)

case class Foo(a:Int)
case class Bar(b:Foo, c:Foo)
val t = Bar(Foo(1),Foo(2))

object w {
    case class Foo(a:Int)
    case class Bar(b:Foo, c:Foo)
}

// Exiting paste mode, now interpreting.

defined class Foo
defined class Bar
t: Bar = Bar(Foo(1),Foo(2))
defined module w

scala> val t = w.Bar(w.Foo(1),w.Foo(2))
t: w.Bar = Bar(Foo(1),Foo(2))

scala> val f = w.Foo(1)
f: w.Foo = Foo(1)

scala> w.Bar(f,f)
res1: w.Bar = Bar(Foo(1),Foo(1))

It will work. However, if you then redefine the w object it will fail:

scala> object w {
     |     case class Foo(a:Int)
     |     case class Bar(b:Foo, c:Foo)
     | }
defined module w

scala> w.Bar(f,f)
<console>:14: error: type mismatch;
 found   : w.Foo(in object w)(in object w)(in object w)(in object w)
 required: w.Foo(in object w)(in object w)(in object w)(in object w)
              w.Bar(f,f)

This happen since at w.Bar(f,f) in the second w, it use the w that define on the second type, but the f is define in the first time. Since they are actually different object (same name and properties, but the type itself is different), then it does not fit.
If you will redefine the depend class (f) then it will works:

scala> object w {
     |     case class Foo(a:Int)
     |     case class Bar(b:Foo, c:Foo)
     | }
defined module w

scala> val f = w.Foo(1)
f: w.Foo = Foo(1)

scala> w.Bar(f,f)
res3: w.Bar = Bar(Foo(1),Foo(1))

Collectives™ on Stack Overflow

scala nested case classes generate strange type error

1 Answer 1

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Related