6

I happened to find that it's not allowed to have abstract private fields in a trait, that is,

trait A1 {
    //private val a: Int         // Not allowed
    protected val b: Int         // OK
}

And it seems all right to do such thing to an abstract class, if private fields are constructor parameters, that is,

abstract class A2 (private val i: Int) // OK

So I guess that a trait doesn't have constructor parameters, so there's no way to initialize them, therefore no abstract private fields are allowed.

If they are "protected", then a subclass can initialize them using pre-initialized fields. This approach allows subclass to see these fields.

What if I just want to initialize them and hide them afterwards, as in the following example?

object holding {
    trait trick {
        protected val seed: Int                     // Can't be private
        final def magic: Int = seed + 123
    }

    trait new_trick extends trick {
        def new_magic: Int = magic + 456
        def the_seed: Int = seed                    // [1]
    }

    def play: new_trick = new { val seed = 1 } with new_trick 

    def show_seed(t: new_trick): Int = t.the_seed   // [2]
}

I don't want anyone to be able to see seed, that is, [2] (and so [1]) shouldn't be allowed. Is there a way for a trait to do that?

As @Randall and @pagoda_5b have pointed out, my question doesn't make much sense. But luckily @Régis and @axel22 have turned it into another interesting question and provided a pattern for solving it.

Improve this question
4
  • 1
    How can it be meaningful to have something private and unimplemented? It's a contradiction, since it's not inherited and can never be implemented and hence would prevent instantiation of any subtype of the trait bearing such a member. Commented Apr 5, 2013 at 15:08
  • 1
    I'm not sure I follow you. If you need subclasses to define seed (overriding its definition) it doesn't makes sense to make it private. That said, the subclass that defines the implementation of the seed member will always be able to show it with a public accessor. I can't understand the need behind this design choice. Commented Apr 5, 2013 at 15:09
  • I think it boils down to being able to let the direct sub-trait define the value of seed while making further sub-traits (and external code) be unable to access the value. Kind of like a protected value (treat like a protected value for the sub-traits, and treat as private for everything lese). As for the meaningfulness, I think the idea is just to fully emulate what can be done through parameters (in classes) as shown in his example. Commented Apr 5, 2013 at 15:43
  • Sorry, I meant "Kind of like a one-level protected value" Commented Apr 5, 2013 at 17:05

2 Answers 2

Reset to default
11

A simple way to keep a val private while allowing the sub-traits to initalize it would be to define it as private but initialize it with the value returned by another protected method. Then the sub-traits can define this protected method so as to change the initial value, but cannot access the value itself. So you would change this:

trait A {
  protected val foo: Bar
}

into: 

trait A {
  private val foo: Bar = initFoo 
  protected def initFoo: Bar
}

Now, only trait A can access the val foo. Sub-traits can set the initial value of foo by definint initFoo, but cannot access foo itself:

trait B extends A {
  protected def initFoo: Bar = ???
}

Obviously, initFoo itself is still accessible by sub-traits. This is often not a problem if initFoo creates a new instance everytime (in other words, it is a factory), as we might only be interested in making the instance private to A without being concerned with having sub-traits being able to create new instances of Bar (irrespective of whether the new instances are equals to foo as per their equals method).

But if it is a concern (and it certainly is in your case as seed is fo type Int and thus what you want to hide is a value and not just a reference), we can use an additional trick to allow sub-traits to define initFoo but prevent them (and their sub-traits) from being able to call it. This trick is, let's face it, pretty awful for such a simple need, but it illustrates a nice pattern for advanced access control. Credits goes to the standard library authors for the idea (see http://www.scala-lang.org/api/current/index.html#scala.concurrent.CanAwait).

trait A {
  // A "permit" to call fooInit. Only this instance can instantiate InitA
  abstract class InitA private[this]()
  // Unique "permit"
  private implicit def initA: InitA = null

  private def foo: Int = fooInit
  protected def fooInit( implicit init: InitA ): Int
}

trait B extends A {
  protected def fooInit( implicit init: InitA ): Int = 123
}

Now, if B tries to call initFoo, the compiler will complain that it could not find an implicit of type InitA (the unique such instance is A.initA and is only accesible to in A) .

As I said, it's a bit awful and the package private solution given by axel22 is certainly a much easier alternative (although it won't prevent anyone from defining their sub-traits inside the same package as yours, thus defeating the access restriction).

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

"Now, if B tries to call foo, the compiler will...", did you mean "if B tries to call fooInit"?
6

The best you could do is to declare these package private - private[package_name]. This would allow you to extend and define the trait within the same package in which you are doing your implementation, but disallow clients to use it from other packages.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.