ScalaLoci

@peer type Server <: {
  type Tie <: Multiple[Client]
}

@peer type Client <: {
  type Tie <: Single[Server]
}

val items: Items on Server =
  getCurrentItems()

val ui: UI on Client =
  new UI

val items: Var[Items] on Server =
  Var(getCurrentItems())

on[Client] {
  Signal {
    items.asLocal() map createUIEntry
  }
}

The example demonstrates the design of a chat application in five steps

1. Declaring a Server
2. Declaring a Client
3. Declaring a message event on the Client and firing the event for every user input
4. Declaring a publicMessage event on the Server aggregating all events from the clients
5. Declaring a client-side observer for the server-side publicMessage event

@multitier object Chat {
  @peer type Server <: { type Tie <: Multiple[Client] }













}

  @peer type Client <: { type Tie <: Single[Server] }

  val message = on[Client] { Evt[String]() }





  def main() = on[Client] {

    for (line <- io.Source.stdin.getLines)
      message.fire(line)
  }

  val publicMessage = on[Server] {
    message.asLocalFromAllSeq map { case (_, message) => message }
  }

    publicMessage.asLocal observe println

Try out ScalaLoci Examples from GitHub

• Simple Examples
• Applications in Different Variants

Add ScalaLoci to Your Project

1. Enable support for macro annotations in your build.sbt
   • for Scala 2.13

     scalacOptions += "-Ymacro-annotations"

   • for Scala 2.11 or 2.12 (Macro Paradise Plugin)

     addCompilerPlugin("org.scalamacros" % "paradise" % "2.1.1" cross CrossVersion.patch)

2. Add the resolver for the ScalaLoci dependencies to your build.sbt

   resolvers += ("STG old bintray repo" at "http://www.st.informatik.tu-darmstadt.de/maven/").withAllowInsecureProtocol(true)

3. Add the ScalaLoci dependencies that you need for your system to your build.sbt
   1. ScalaLoci language (always required):

      libraryDependencies += "de.tuda.stg" %% "scala-loci-lang" % "0.4.0"

   2. Transmitter for the types of values to be accessed remotely (built-in Scala types and standard collections are directly supported without additional dependencies)
      • REScala reactive events and signals

        libraryDependencies += "de.tuda.stg" %% "scala-loci-lang-transmitter-rescala" % "0.4.0"

   3. Network communicators to connect the different components of the distributed system
      • TCP [JVM only]

        libraryDependencies += "de.tuda.stg" %% "scala-loci-communicator-tcp" % "0.4.0"

      • WebSocket (using Akka HTTP on the JVM) [server: JVM only, client: JVM and JS web browser APIs]

        libraryDependencies += "de.tuda.stg" %% "scala-loci-communicator-ws-akka" % "0.4.0"

      • WebSocket (Play integration) [server: JVM only, client: JVM and JS web browser APIs]

        libraryDependencies += "de.tuda.stg" %% "scala-loci-communicator-ws-akka-play" % "0.4.0"

      • WebSocket (using Javalin on the JVM) [server: JVM only, client: JS web browser APIs]

        libraryDependencies += "de.tuda.stg" %% "scala-loci-communicator-ws-javalin" % "0.4.0"

      • WebRTC [JS web browser APIs only]

        libraryDependencies += "de.tuda.stg" %% "scala-loci-communicator-webrtc" % "0.4.0"

   4. Serializer for network communication
      • µPickle serialization

        libraryDependencies += "de.tuda.stg" %% "scala-loci-serializer-upickle" % "0.4.0"

      • Circe serialization

        libraryDependencies += "de.tuda.stg" %% "scala-loci-serializer-circe" % "0.4.0"

@multitier object Chat {
  @peer type Node <: { type Tie <: Multiple[Node] }

  type SingleChatLog = Signal[List[String]]
  type MultiChatLogs = Signal[List[SingleChatLog]]

  val ui: UI on Node = UI()

  val messageSent = on[Node] sbj { node: Remote[Node] =>
    ui.messageTyped filter { _ => ui.isSelectedChat(node) }
  }

  def messageLog(node: Remote[Node]): Local[SingleChatLog] on Node =
    ((messageSent from node).asLocal ||
     (messageSent to node)).list 

  val chatLogs: MultiChatLogs on Node =
    remote[Node].joined.fold(List.empty[SingleChatLog]) { (chats, node) =>
      messageLog(node) :: chats
    }
}

@multitier object TweetAuthoring {
  @peer type Input <: { type Tie <: Single[Filter] }
  @peer type Filter <: { type Tie <: Single[Mapper] with Single[Input] }
  @peer type Mapper <: { type Tie <: Single[Folder] with Single[Filter] } 
  @peer type Folder <: { type Tie <: Single[Mapper] }

  val tweetStream: Event[Tweet] on Input =
    retrieveTweetStream()

  val filtered: Event[Tweet] on Filter =
    tweetStream.asLocal filter { tweet => tweet.hasHashtag("multitier") }

  val mapped: Event[Author] on Mapper =
    filtered.asLocal map { tweet => tweet.author }

  val folded: Signal[Map[Author, Int]] on Folder =
    mapped.asLocal.fold(Map.empty[Author, Int].withDefaultValue(0)) {
      (map, author) => map + (author -> (map(author) + 1))
    }
}

@multitier object MasterWorker {
  @peer type Master <: { type Tie <: Multiple[Worker] }
  @peer type Worker <: { type Tie <: Single[Master] }

  class Task(v: Int) { def exec(): Int = 2 * v }

  // to add tasks: `taskStream.fire(Task(42))`
  val taskStream: Local[Event[Task]] on Master = Evt[Task]()

  val assocs: Local[Signal[Map[Remote[Worker], Task]]] on Master =
    (taskStream || taskResult.asLocalFromAllSeq).fold(
        Map.empty[Remote[Worker], Task],
        List.empty[Task]) { (taskAssocs, taskQueue, taskChanged) =>
      assignTasks(taskAssocs, taskQueue, taskChanged, remote[Worker].connected)
    }

  val deployTask: Signal[Task] per Worker on Master =
    worker: Remote[Worker] => Signal{ assocs().get(worker) }

  val taskResult: Event[Int] on Worker =
    deployTask.asLocal.changed collect { case Some(task) => task.exec() }

  val result: Signal[Int] on Master =
    taskResult.asLocalFromAllSeq.fold(0) { case (acc, (worker, result)) =>
      acc + result
    }
}

@multitier object TokenRing {
  @peer type Prev <: { type Tie <: Single[Prev] }
  @peer type Next <: { type Tie <: Single[Next] }
  @peer type Node <: Prev with Next { type Tie <: Single[Prev] with Single[Next] }

  val id: Id on Prev = Id()

  val sendToken: Local[Event[(Id, Token)]] on Prev = Event[(Id, Token)]()

  val recv: Local[Event[Token]] on Prev =
    sent.asLocal collect {
      case (receiver, token) if receiver == id => token
    }

  val sent: Event[(Id, Token)] on Prev =
    (sent.asLocal \ recv) || sendToken
}