Scala: Exposing a class in another package and running into problems

I have a class within a trait in one package:

trait NRC {
    final case class Singleton(e: TupleExpr) extends BagExpr {
       val tp: BagType = BagType(e.tp)
    }
}

And I want to expose it using an object in another class which I have done like so:

case object Exposed extends NRC {
  def apply(x: TupleExpr): BagExpr = {
    Singleton(x)
  }
}

Now when it comes to using this implementation I run into issues:

I am using it like so (Note that WrappedDataset is another class which extends NRC):

val e1: WrappedDataset = ds.wrap()
val r1 = e1.customMap(x => Singleton(x))

On the second line above I get a type mismatch errors:

> Type mismatch. Required: Singleton.TupleExpr, found: e1.TupleExpr

&

> Type mismatch. Required: e1.BagExpr, found: Singleton.BagExpr

Which to me doesn't really make sense as they are referring to the same thing essentially.

The errors can be fixed using casting like this:

val r1 = e1.flatMap(x => Singleton(x.asInstanceOf[Exposed.TupleExpr]).asInstanceOf[e1.BagExpr])

However this isn't an adequate solution as I need this logic to be hidden.
Is there some way to handle this in the case object Singleton, or another work around that could be possible?

You call everything Singleton, making it pretty hard to follow and understand what you are trying to do, there also no definition of TupleExpr anywhere, so I can only guess what is going on ...

But I am guessing your problem is you do not realize that inner type definitions are instance specific:

trait Foo { case class X(x: String) } 
object Bar extends Foo
object Baz extends Foo

class Bat extends Foo 

Bar.X("foo") == Baz.X("foo") // false
new Bat().X("foo") == new Bat().X("foo") // false

This returns false because not only Bar.X and Baz.X are two different classes (Bar and Baz are actually different types), but new Bat().X and new Bat().X are also different classes because they belong to different instances (albeit of the same type).

Beside I think the @Dima's answer is pretty clear, I would like to provide more info and details.

Looks like you are trying to use something similar to java inner classes. Scala Inner classes works different. Also you have traits which is what you are using in this case.

> In Scala it is possible to let classes have other classes as members.
> As opposed to Java-like languages where such inner classes are members
> of the enclosing class, in Scala such inner classes are bound to the
> outer object.

You have pretty good scala examples in the docs, but I would like to add also Java code too.

In Java, you can do the following

1. declare a class A with an inner class InnerClass and a static inner class StaticInnerClass

class A {
    class InnerClass {}
    static class StaticInnerClass {}
    public void receiveInnerClass(InnerClass innerClass) {}
    public static void receiveStaticInnerClass(InnerClass staticInnerClass) {}

    public InnerClass newInnerClass() {
        return new InnerClass();
    }

    public static StaticInnerClass newStaticInnerA() {
        return new StaticInnerClass();
    }
}

2. In another class, you can share inner classes from two different instances of A

A anA = new A();
A anotherA = new A();
A.InnerClass aInnerClass = anA.newInnerClass();
A.InnerClass anotherInnerClass = anotherA.newInnerClass();

anA.receiveInnerClass(aInnerClass);
anA.receiveInnerClass(anotherInnerClass);

In Scala there are some things you can and you can't do with inner classes

There is no static classes, you have classes and Singleton Objects.

1. We can define a class A with an inner class InnerClass and a singleton object A with an inner class InnerClassFromCompanion

class A {
  class InnerClass

  def newInnerClass: InnerClass = new InnerClass
  def receiveInnerClass(innerClass: InnerClass): Unit = ()
  def receiveInnerAFromCompanion(innerAFromCompanion: A.InnerClassFromCompanion) = ()
}

object A {
  class InnerClassFromCompanion

  def newInnerClassFromCompanion: InnerClassFromCompanion = new InnerClassFromCompanion
  def receiveInnerClassFromCompanion(innerClassFromCompanion: InnerClassFromCompanion): Unit = ()
  def receiveInnerClass(innerClass: A.InnerClass) = ()
}

2. from another place there will be things that can be done and some others can't

val anA: A = new A
val innerClassFromAnA: A.InnerClass = anA.newInnerClass // this won't compile because it's trying to find `InnerClass` inside singleton object `A`
val innerClassFromAnA: anA.InnerClass = anA.newInnerClass // we can notice that is typed as `anA.InnerClass`, not as an `A.InnerClass`
val anotherA: A = new A
val innerClassFromAnotherA: anotherA.InnerClass = anotherA.newInnerClass // same here about how is typed

// the following lines will fail saying typemismatch
anA.receiveInnerClass(innerClassFromAnotherA) // required `anA.InnerClass`, found `anotherA.InnerClass` 
anotherA.receiveInnerClass(innerClassFromAnA) // required `anotherA.InnerClass`, found `anA.InnerClass`

3. in your case, where you want to share inner classes in different classes, a way of solving that is to extract the inner class from the trait you have and move to a singleton object or directly not declare it as an inner class

val anInnerFromACompanionA = new A.InnerClassFromCompanion
val anotherInnerFromACompanionA = new A.InnerClassFromCompanion

A.receiveInnerClassFromCompanion(anInnerFromACompanionA)
A.receiveInnerClassFromCompanion(anotherInnerFromACompanionA)