ScalaLoci

trait Server extends Peer {
  type Tie <: Multiple[Client]
}

trait Client extends Peer {
  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()) }

placed[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 {
  trait Server extends Peer { type Tie <: Multiple[Client] }













}

  trait Client extends Peer { type Tie <: Single[Server] }

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





  placed[Client].main {

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

  val publicMessage = placed[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 the Macro Paradise Plugin (for macro annotations) in your build.sbt

   addCompilerPlugin("org.scalamacros" % "paradise" % "2.1.0" 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 core (always required):

      libraryDependencies += "de.tuda.stg" %% "scala-loci-core" % "0.1.0"

   2. Transmitter for the types of values to be accessed remotely
      • Built-in Scala types and standard collections

        libraryDependencies += "de.tuda.stg" %% "scala-loci-transmitter-basic" % "0.1.0"

      • REScala reactive events and signals

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

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

        libraryDependencies += "de.tuda.stg" %% "scala-loci-network-tcp" % "0.1.0"

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

        libraryDependencies += "de.tuda.stg" %% "scala-loci-network-ws-akka" % "0.1.0"

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

        libraryDependencies += "de.tuda.stg" %% "scala-loci-network-ws-akka-play" % "0.1.0"

      • WebRTC [JS web browser APIs only]

        libraryDependencies += "de.tuda.stg" %% "scala-loci-network-webrtc" % "0.1.0"

   4. Serializer for network communication

      libraryDependencies += "de.tuda.stg" %% "scala-loci-serializable-upickle" % "0.1.0"

@multitier object Chat {
  trait Node extends Peer { type Tie <: Multiple[Node] }

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

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

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

  val chatLogs = placed[Node] {
    remote[Node].joined.fold(List.empty[Signal[List[String]]]) {
      case (chats, node) => messageLog(node) :: chats } }
}

@multitier object TweetAuthoring {
  trait Input extends Peer { type Tie <: Single[Filter] }
  trait Filter extends Peer { type Tie <: Single[Mapper] with Single[Input] }
  trait Mapper extends Peer { type Tie <: Single[Folder] with Single[Filter] } 
  trait Folder extends Peer { 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 {
  trait Server extends Peer { type Tie <: Single[Client] }
  trait Client extends Peer { type Tie <: Single[Server] }

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

  val allEmails: Signal[List[Email]] localOn 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: Boolean localOn Client = placed {
    Signal { isCurrentFirstPage(word(), filteredEmails.asLocal()) }
}

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

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

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

  val assocs: Signal[Map[Remote[Worker], Task]] localOn 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 = placed[Master].sbj { worker: Remote[Worker] =>           // Event[Task]
    Signal{ assocs().get(worker) }.changed }
  val taskResult = placed[Worker] {                                         // Event[Int]
    deployTask.asLocal collect { case Some(task) => task.exec } }
  val result = placed[Master] {                                             // Signal[Int]
    taskResult.asLocalFromAllSeq.fold(0){ case (acc, (worker, result)) => acc + result } }
}