Agfdhyk

Overview

I have a Kotlin-based project that defines a DSL, but for reasons given below I'm now investigating whether it would be better to write my project in Scala. As Scala doesn't seem to lend itself to creating DSLs with as much ease as in Kotlin, I'm not entirely sure how I'd recreate the same DSL in Scala.

Before this gets flagged as a duplicate of this question, I've looked at that but my DSL requirements are somewhat different and I haven't been able to figure out a solution from that.

Details

I'm trying to create a flow-based programming system for developing automated vehicle part test procedures, and for the past couple of weeks I've been testing out an implementation of this in Kotlin, since it seems to support a lot of features that are really nice for creating FBP systems (native coroutine support, easy creation of DSLs using type-safe builders, etc.).

As awesome as Kotlin is though, I'm starting to realise that it would help a lot if the implementation language for the FBP was more functional, since FBP's seem to share a lot in common with functional languages. In particular, being able to define and consume typeclasses would be really useful for a project like this.

In Kotlin, I've created a DSL representing the "glue" language between nodes in a flow-based system. For example, given the existence of two blackbox processes Add and Square, I can define a "composite" node that squares the sum of two numbers:

@CompositeNode

private fun CompositeOutputtingScalar<Int>.addAndSquare(x: Int, y: Int) {

    val add = create<Add>()

    val square = create<Square>()



    connect {

        input(x) to add.x

        input(y) to add.y

        add.output to square.input

        square.output to output

    }

}

The idea is that connect is a function that takes a lambda of form ConnectionContext.() -> Unit, where ConnectionContext defines various overloads of an infix function to (shadowing the built-in to function in the Kotlin stdlib) allowing me to define the connections between these processes (or nodes).

This is my attempt to do something similar in Scala:

class OutputPort[-A] {

  def connectTo(inputPort: InputPort[A]) {}

}



class InputPort[+A]



object connect {

  val connections = new ListBuffer[Connection[_]]()



  case class Connection[A](outputPort: OutputPort[A], inputPort: InputPort[A])



  class ConnectionTracker() {

    def track[A](connection: Connection[A]) {}

  }



  // Cannot make `OutputPort.connectTo` directly return a `Connection[A]` 

  // without sacrificing covariance, so make an implicit wrapper class

  // that does this instead

  implicit class ExtendedPort[A](outputPort: OutputPort[A]) {

    def |>(inputPort: InputPort[A]): Unit = {

      outputPort connectTo inputPort

      connections += Connection(outputPort, inputPort)

    }

  }

}



def someCompositeFunction() {

  val output = new OutputPort[Int]

  val input = new InputPort[Int]

  output |> input // Should not be valid here



  connect {

    output |> input // Should be valid here

  }

}

Right now this won't compile because ConnectablePort isn't in scope. I can bring it into scope by doing:

import connect._

connect {

  output |> input // Should be valid here

}

However, it's undesirable to have to do this within the node definition.

To summarise, how can I recreate the DSL I've made in Kotlin within Scala? For reference, this is how I've defined my Kotlin DSL:

interface Composite {

    fun <U : ExecutableNode> create(id: String? = null): U

    fun connect(apply: ConnectionContext.() -> Unit)



    class ConnectionContext {

        val constants = mutableListOf<Constant<*>>()



        fun <T> input(parameter: T): OutputPort<T> = error("Should not actually be invoked after annotation processing")

        fun <T> input(parameterPort: OutputPort<T>) = parameterPort

        fun <T> constant(value: T) = Constant(value.toString(), value)



        infix fun <U, V> U.to(input: InputPort<V>): Nothing = error("Cannot connect value to specified input")

        infix fun <U> OutputPort<U>.to(input: InputPort<U>) = this join input

        infix fun <T, U> T.to(other: U): Nothing = error("Invalid connection")

    }

}



interface CompositeOutputtingScalar<T> : Composite {

    val output: InputPort<T>

}



interface CompositeOutputtingCluster<T : Cluster> : Composite {

    fun <TProperty> output(output: T.() -> TProperty): InputPort<TProperty>

}

Just turning on the |> is pretty straightforward in Scala if you use a companion object, and is something always available with the output port

class OutputPort[-A] {

  def connectTo(inputPort: InputPort[A]):Unit = {}

}



class InputPort[+A]



object OutputPort{

    implicit class ConnectablePort[A](outputPort: OutputPort[A]) {

      def |>(inputPort: InputPort[A]): Unit = outputPort connectTo inputPort

    }

}



def someCompositeFunction() {

  val output = new OutputPort[Int]

  val input = new InputPort[Int]

  output |> input // Should be valid here

}

Judiciously deciding where to do imports is a core Scala concept. It is how we turn on implicit in our code, like the following, is very common, since that is the way we turn on our type classes.

class OutputPort[-A] {

  def connectTo(inputPort: InputPort[A]): Unit = {}

}



class InputPort[+A]



object Converter {

  implicit class ConnectablePort[A](outputPort: OutputPort[A]) {

    def |>(inputPort: InputPort[A]): Unit = outputPort connectTo inputPort

  }

}



def someCompositeFunction() {

  val output = new OutputPort[Int]

  val input = new InputPort[Int]

  import Converter._

  output |> input // Should be valid here

}

Now, I think this is what you are looking for, but there are still some import and implicit that needs to be setup, but this would enclose the implicit behavior:

class OutputPort[-A] {

    def connectTo(inputPort: InputPort[A]): Unit = {}

}



class InputPort[+A]



object Converter {



    private class ConnectablePort[A](outputPort: OutputPort[A]) {

        def |>(inputPort: InputPort[A]): Unit = outputPort connectTo

            inputPort

    }



    def convert[A](f: (OutputPort[A] => ConnectablePort[A]) => Unit): Unit = {

        def connectablePortWrapper(x: OutputPort[A]): ConnectablePort[A] = new ConnectablePort[A](x)



        f(connectablePortWrapper _)

    }

}



object MyRunner extends App {



    val output = new OutputPort[Int]

    val input = new InputPort[Int]



    import Converter.convert



    //output |> input  won't work

    convert[Int] { implicit wrapper =>

        output |> input // Should be valid here

    }

}