I'm fairly new to Scala and I would like to learn it properly. My current task is to create a type to represent a heap, as seen in interpreters: a mapping from addresses in memory to values stored there.
A heap of that kind is very much like Map, but I would like to hide implementation details and only expose the interface consisting of a few methods, which in pseudo code would be:
* update :: address value -> Heap
* free :: address -> Heap
* alloc :: value -> (Heap, Address)
* addresses :: () -> Set[Address]
* lookup :: address -> [Value]
Here is what I came up with:
trait Heap[T] {
def update(address: Address, value: T): Heap[T]
def free(address: Address): Heap[T]
def alloc(value: T): (Heap[T], Address)
def addresses(): Set[Address]
def lookup(address: Address): Option[T]
}
private case class HeapImpl[T](map: Map[Address, T]) extends Heap[T] {
override def update(address: Address, value: T): Heap[T] = HeapImpl[T](map.updated(address, value))
override def free(address: Address): Heap[T] = HeapImpl[T](map.removed(address))
override def alloc(value: T): (Heap[T], Address) = {
val nextFreeAddress = addresses().maxOption.getOrElse(0) + 1
(HeapImpl(map.updated(nextFreeAddress, value)), nextFreeAddress)
}
override def addresses(): Set[Address] = Set(map.keys).toSet
override def lookup(address: Address): Option[T] = map.get(address)
}
object Heap {
def apply[T](): Heap[T] = HeapImpl(Map())
}
I would like to know if this is proper idiomatic Scala or should I approach it differently.