Encapsulation and Scala

[Garrett Rowe]

I seems to me that the Scala encourages a programmer to expose implementation details that would be more tightly encapsulated in Java.

Consider a basic Stack trait:

trait Stack[T] {
   
   def pop: (T, Stack[T])
   def push(e: T): Stack[T]
   def peek: T
   def isEmpty: Boolean
   
}

It is very natural to write an implementation of this trait backed by an immutable Scala list:

class StackImpl[T] extends Stack[T] {
   
   protected val elements: List[T] = Nil
   
   private def mkNewStack(es: List[T]): Stack[T] = new StackImpl[T] {
      override val elements = es
   }
   
   def pop = (elements.head, mkNewStack(elements.tail))
   
   def push(e: T) = mkNewStack(e::elements)
   
   def peek: T = elements.head
   
   def isEmpty = elements.isEmpty
}

However my issue is that now the api exposes the fact that the Stack is packed by a List, it would be nicer if the List could be private, but then it couldn't be overridden when constructing a new Stack. I see a couple of workarounds each with their own problems.

class StackImpl[T](elements: List[T]) extends Stack[T] {
 
   def this() = this(Nil)
   
   private def mkNewStack(es: List[T]): Stack[T] = new StackImpl(es)
   
   def pop = (elements.head, mkNewStack(elements.tail))
   
   def push(e: T) = mkNewStack(e::elements)
   
   def peek: T = elements.head
   
   def isEmpty = elements.isEmpty
}

Here the List is implicitly private, however by moving the List to the constructor, its explicitly exposed by the API. However, there can be no dependencies on the List. I think this is currently my favorite style.

Another way is to hide the implementation altogether and only expose the Stack through a factory method:

object Stack {
 
   def empty[T]: Stack[T] = new StackImpl[T]
  
   private class StackImpl[T] extends Stack[T] {
   
      val elements: List[T] = Nil
  
      private def mkNewStack(es: List[T]): Stack[T] = new StackImpl[T]{
         override val elements = es
      }
      
      def pop = (elements.head, mkNewStack(elements.tail))
   
      def push(e: T) = mkNewStack(e::elements)
      
      def peek: T = elements.head
   
      def isEmpty = elements.isEmpty
   }
}

The problem with this method is that the implementation cannot now be mixed in with other traits to add additional functionality

trait ConsoleLoggingStack[T] extends Stack[T] {
   
   override abstract def pop: (T, Stack[T]) = {
      val (e, ns) = super.pop
      println(e + " popped from stack")
      (e, ns)
   }
   
   override abstract def push(e: T) = {
      println(e + " being pushed onto stack")
      super.push(e)
   }
}
 
object Stack {
 
   def empty[T]: Stack[T] = new StackImpl[T]
   
   def emptyWithLogging[T] = new StackImpl[T] with ConsoleLoggingStack[T] //<- Will NOT compile
   
   private class StackImpl[T] extends Stack[T] {
   
      val elements: List[T] = Nil
  
      private def mkNewStack(es: List[T]): Stack[T] = new StackImpl[T]{
         override val elements = es
      }
      
      def pop = (elements.head, mkNewStack(elements.tail))
   
      def push(e: T) = mkNewStack(e::elements)
      
      def peek: T = elements.head
   
      def isEmpty = elements.isEmpty
   }
}

Is there a way to mimic the encapsulation I'm used to with Java or is this really just much ado about nothing?

[Marc Peabody]

Any thoughts on this?

trait Stack[T] {
  def pop: (T, Stack[T])
  def push(e: T): Stack[T]
  def peek: T
  def isEmpty: Boolean
}
 
class StackCreator[T] {
 
   def empty[T]: Stack[T] = new StackImpl[T]
   
   def emptyWithLogging[T]: Stack[T] = new StackImpl[T] with ConsoleLoggingStack[T]
  
   private class StackImpl[T] extends Stack[T] {
   
      val elements: List[T] = Nil
  
      private def mkNewStack(es: List[T]): Stack[T] = {
        if(this.isInstanceOf[ConsoleLoggingStack[T]]){
          new StackImpl[T] with ConsoleLoggingStack[T]{
            override val elements = es
          }
        }else{
          new StackImpl[T]{
            override val elements = es
          } 
        }       
      }
      
      def pop = (elements.head, mkNewStack(elements.tail))
   
      def push(e: T) = mkNewStack(e::elements)
      
      def peek: T = elements.head
   
      def isEmpty = elements.isEmpty
   }
   
   private trait ConsoleLoggingStack[T] extends StackImpl[T] {
   
   override abstract def pop: (T, Stack[T]) = {
      val (e, ns) = super.pop
      println(e + " popped from stack")
      (e, ns)
   }
   
   override abstract def push(e: T) = {
      println(e + " being pushed onto stack")
      super.push(e)
   }
}
}
 
object StackApp extends Application {
println(new StackCreator[String].emptyWithLogging.push("hi").pop) 
}

[ August 11, 2008: Message edited by: Marc Peabody ]

[Garrett Rowe]

Is that an instanceOf check? <gollum-voice>It burns us.. NOOOO</gollum-voice>. I did come up with a hack that works though.

trait StackDelegator[T] extends Stack[T] {
  protected def stack: Stack[T] //This method must be overridden
  
  def pop: (T, Stack[T]) = stack.pop
  def push(e: T): Stack[T] = stack.push(e)
  def peek: T = stack.peek
  def isEmpty: Boolean = stack.isEmpty
}

That doesn't look to useful on its surface, but using it allows us to mixin traits into a Stack after the point of instantiation. So now we can modify the ConsoleLoggingStack trait to return a ConsoleLoggingStack backed by the original Stack that it is mixed in with.

trait ConsoleLoggingStack[T] extends Stack[T] {
   
   override abstract def pop: (T, Stack[T]) = {
      val (e, ns) = super.pop
      println(e + " popped from stack")
      val newStack = new StackDelegator[T] with ConsoleLoggingStack[T] { 
         val stack = ns
      }
      (e, newStack)
   }
   
   override abstract def push(e: T) = {
      println(e + " being pushed onto stack")
      val newStack = super.push(e)
      new StackDelegator[T] with ConsoleLoggingStack[T] {
         val stack = newStack
      }
   }
}

And we can mixin the Stack created from the factory method with the ConsoleLoggingStack just as easily

object Main extends Application {
   
   val s = new StackDelegator[String] with ConsoleLoggingStack[String] {
              val stack = Stack.empty[String] 
           }
   
   s.push("Hello").push("World").pop
}

There may be a better way to do this but I haven't figureed it out yet. The only downside I see is the boilerplate code that is needed to create the *Delegate trait.
[ August 13, 2008: Message edited by: Garrett Rowe ]

[Marc Peabody]

After looking through the Stairway book, I think declaring your elements List in the primary constructor (which is the class declaration) is the most accepted method.

(I added an alternate constructor for more flexibility.)

class StackImpl[T](private val elements: List[T]) extends Stack[T]{
  def this(es: T*) = this(es.toList)
 
  def pop = (elements.head, new StackImpl(elements.tail))
  def push(e: T) = new StackImpl(e::elements)
  def peek: T = elements.head 
  def isEmpty = elements.isEmpty
}
object StackApp extends Application {
  println(new StackImpl().push("hello").pop)
  println(new StackImpl("hi").push("bob").pop)
}    

I've played around with how in the world to conveniently mixin the ConsoleLoggingStack but without success.
[ August 13, 2008: Message edited by: Marc Peabody ]

[Garrett Rowe]

Originally posted by Marc Peabody:
After looking through the Stairway book, I think declaring your elements List in the primary constructor (which is the class declaration) is the most accepted method.

I figured that was true. It seems to be the most natural way to go.

I've played around with how in the world to conveniently mixin the ConsoleLoggingStack but without success.

You have to use my StackDelegator (and the amended ConsoleLoggingStack trait), its not as useless as it looks.

[ August 13, 2008: Message edited by: Garrett Rowe ]

[Marc Peabody]

Originally posted by Garrett Rowe:
You have to use my StackDelegator (and the amended ConsoleLoggingStack trait), its not as useless as it looks.

I had my post window open a long time and your Delegate post slipped in before I finished so it looks like I was ignoring yours. Oops.

I can't tell you how much I cringed using isInstanceOf[] but something had to be done to allow the returned object to be of the same type.

The Delegator seems to do the trick just fine. I'll play around with it some tonight and challenge myself to one-up you on the neato factor.

[Gabriel Claramunt]

Originally posted by Marc Peabody:

I can't tell you how much I cringed using isInstanceOf[] but something had to be done to allow the returned object to be of the same type.

IIRC, Scala has something called "self types", where you can write

self: Stack[T] =>

and roughly translates to " use my current type as Stack[T] type".
I've used it successfully to implement a generic graph type (Playing with Scala 4: Abstract types and Self-types) but I must confess that some details are still fuzzy for me

[Actually, is more like: cast "this" to the type defined.
http://www.scala-lang.org/intro/selfrefs.html ]
[ August 13, 2008: Message edited by: Gabriel Claramunt ]

[Garrett Rowe]

Looking through Scala libraries last night I learned that what I really did was rediscover the Proxy (pattern?). A more idiomatic version would be:

trait StackProxy[T] extends Stack[T] with Proxy {
  def self: Stack[T] //This is actually inherited from the proxy trait but I include it for clarity
  
  def pop: (T, Stack[T]) = self.pop
  def push(e: T): Stack[T] = self.push(e)
  def peek: T = self.peek
  def isEmpty: Boolean = self.isEmpty
}

[T. Morris]

Garrett, Look up "Abstract Algebraic Data Types". The use of an abstract ADT will resolve your issue.