ScalaLoci

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

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

val items: Items on Server = placed {
  getCurrentItems()
}

val ui: UI on Client = placed {
  new UI
}

val items: Var[Items] on Server =
  placed { 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 += Resolver.bintrayRepo("stg-tud", "maven")

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] }

  val ui = on[Node] { UI() }

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

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

  val chatLogs = on[Node] {
    remote[Node].joined.fold(List.empty[Signal[List[String]]]) {
      case (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 = placed { retrieveTweetStream() }

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

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

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

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

  val word: Signal[String] on Client = placed { /* GUI input */ }
  val days: Signal[Int] on Client = placed { /* GUI input */ }

  val allEmails: Local[Signal[List[Email]]] on Server = placed {
    /* e-mail collection */ }

  val filteredEmails: Signal[List[Email]] on Server = placed {
    Signal {
      allEmails() filter { email =>
        (email.date < Date.today() - days.asLocal()) &&
        (email.text contains word.asLocal()) } } }

  val inCurrentPage: Local[Boolean] on Client = placed {
    Signal { isCurrentFirstPage(word(), filteredEmails.asLocal()) }
}

@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 }

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

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

  val deployTask = on[Master] sbj { worker: Remote[Worker] =>           // Event[Task]
    Signal{ assocs().get(worker) }.changed }
  val taskResult = on[Worker] {                                         // Event[Int]
    deployTask.asLocal collect { case Some(task) => task.exec } }
  val result = on[Master] {                                             // Signal[Int]
    taskResult.asLocalFromAllSeq.fold(0){ case (acc, (worker, result)) => acc + result } }
}