模块，与路径有关的类型和共享

Question

I'm going to briefly provide some context for my question, and then the question itself will follow.

In Martin Odersky's previous publications and lately at some Scala talks, he has emphasized the following relationship between Scala's type system and ML's:

• ML signature => Scala trait
• ML module => Scala object
• ML functor => Scala class

There has been work on experimenting with these ideas more concretely in blog posts such as:

• https://io.pellucid.com/blog/scalas-modular-roots
• https://github.com/yawaramin/scala-modules/blob/master/README.md

In particular, in the second link contributes the idea of a function definition in order to achieve type ascription.

trait Set[A] {
  type T

  def empty: T
}

abstract class SetMod[A](Ord: Ordered[A]) extends Set[A] {
  // Not the real implementaton, obviously.
  type T = List[A]

  override def empty = ???

  def implementationHelper(x: Double): Int = ???
}

object MkSet {
  def apply[A](implicit O: Ordered[A]): Set[A] =
    new SetMod[A](O) {}
}

and we can now say something like

lazy val IntSet = MkSet[Int]

where implementationHelper is not visible to IntSet , but we could still play with the implementation interactively in the REPL if we so desired because nothing is private .

Let's consider a more involved example, which is a very generic graph module:

We start with the interface, keeping the representation abstract:

trait Graph[A] {
  type T <: GraphSig

  type NodeLabel

  type EdgeLabel

  type Weight

  case class Node(labe: NodeLabel, value: A)

  case class Edge(start: Node, end: Node, weight: Weight, label: EdgeLabel)

  def empty: T

  trait GraphSig {
    def nodes: Stream[Node]

    def edges: Stream[Edge]
  }
}

and then add a specialization of the interface for simple cases:

trait SimpleGraph[A] extends Graph[A] {
  type Weight = Unit

  type EdgeLabel = Unit

  def edge(start: Node, end: Node): Edge =
    Edge(start, end, (), ())
}

Next, the actual implementation of the module:

abstract class GraphMod[A] extends Graph[A] {
  override def empty = ???

  class T extends GraphSig {
    override def nodes = ???

    override def edges = ???
  }

  def someHelper(x: Double): Int = ???
}

and finally a nice helper to help us create new graph modules:

object Graph {
  trait StringLabels {
    type NodeLabel = String
  }
}

We can now construct a new specialization of this module as follows (inside the Modules object):

lazy val IntGraph: SimpleGraph[Int] with Graph.StringLabels =
    new GraphMod[Int] with SimpleGraph[Int] with Graph.StringLabels {}

Okay, now the actual question.

I want to construct a new module that depends on a particular graph module. A functor.

In particular, I want a module to help me export graphs to different formats (like the DOT format).

If was writing a single function, then this works as expected:

object GraphFormat {
  def asDot[A](G: Graph[A])(graph: G.T): String =
    "okay"
}

For example,

scala> GraphFormat.asDot(IntGraph)(IntGraph.empty)
scala.NotImplementedError: an implementation is missing
  at scala.Predef$.$qmark$qmark$qmark(Predef.scala:225)
  at GraphMod.empty(Graph.scala:39)
  at GraphMod.empty(Graph.scala:38)
  ... 43 elided

(This is not a compilation error, but expected since the body is ??? ).

But what I really want is something like this:

class GraphFormat[A](val Graph: Graph[A]) {
  def asDot(graph: Graph.T): String =
    "better"

  // Other stuff that depends on `Graph`...
}

and this doesn't work because there's no way (that I can think of) to "expose" the type of Graph.T outside of the definition.

scala> val F = new GraphFormat(IntGraph)
F: GraphFormat[Int] = GraphFormat@27da03d5

scala> F.asDot(IntGraph.empty)
<console>:13: error: type mismatch;
 found   : Modules.IntGraph.T
 required: F.Graph.T
              F.asDot(IntGraph.empty)

See?

Is there a reasonable way to get around this problem?

In this particular case, I could embed a Format object inside of the Graph trait, but I think this example is representative in general of problems that come up when trying to use functors in the fashion. Hence the question. :-)

Answer 1

Thanks to the folks on the #scalaz IRC channel, I have found the solution based on this blog post .

Namely, let's augment the Graph object with a helper, Aux , that "exposes" the value of the type parameter:

object Graph {
  trait StringLabels {
    type NodeLabel = String
  }

  type Aux[T0, A0] = Graph[A0] { type T = T0 }
}

and redefine the GraphFormat class as:

class GraphFormat[GraphInstance, A](val G: Graph.Aux[GraphInstance, A]) {
  def asDot(graph: GraphInstance): String =
    "better"

  // Other stuff that depends on `Graph`...
}

This looks scary, but using it works as expected:

scala> import Modules._

scala> val F = new GraphFormat(IntGraph)
F: GraphFormat[Modules.IntGraph.T,Int] = GraphFormat@305bb85a

scala> F.asDot(IntGraph.empty)
scala.NotImplementedError: an implementation is missing
  at scala.Predef$.$qmark$qmark$qmark(Predef.scala:225)
  at GraphMod.empty(Graph.scala:41)
  at GraphMod.empty(Graph.scala:40)
  ... 43 elided

scala> :t F.asDot _
Modules.IntGraph.T => String

Woohoo! :-)