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 ScalaLoci dependencies that you need for your system to your build.sbt:
   1. ScalaLoci language (always required)

      libraryDependencies ++= Seq(
        "io.github.scala-loci" %% "scala-loci-language" % "0.5.0" % "compile-internal",
        "io.github.scala-loci" %% "scala-loci-language-runtime" % "0.5.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 += "io.github.scala-loci" %% "scala-loci-language-transmitter-rescala" % "0.5.0"

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

        libraryDependencies += "io.github.scala-loci" %% "scala-loci-communicator-tcp" % "0.5.0"

      • WebSocket (using web browser APIs) [JS only, client only]

        libraryDependencies += "io.github.scala-loci" %% "scala-loci-communicator-ws-webnative" % "0.5.0"

      • WebSocket (using Akka HTTP) [JVM only]

        libraryDependencies += "io.github.scala-loci" %% "scala-loci-communicator-ws-akka" % "0.5.0"

      • WebSocket (Play integration using Akka HTTP) [JVM only]

        libraryDependencies += "io.github.scala-loci" %% "scala-loci-communicator-ws-akka-play" % "0.5.0"

      • WebSocket (using Javalin) [JVM only, server only]

        libraryDependencies += "io.github.scala-loci" %% "scala-loci-communicator-ws-javalin" % "0.5.0"

      • WebSocket (using Jetty) [JVM only]

        libraryDependencies += "io.github.scala-loci" %% "scala-loci-communicator-ws-jetty" % "0.5.0"

      • WebRTC (using web browser APIs) [JS only]

        libraryDependencies += "io.github.scala-loci" %% "scala-loci-communicator-webrtc" % "0.5.0"

   4. Serializer for network communication
      • µPickle serialization

        libraryDependencies += "io.github.scala-loci" %% "scala-loci-serializer-upickle" % "0.5.0"

      • Circe serialization

        libraryDependencies += "io.github.scala-loci" %% "scala-loci-serializer-circe" % "0.5.0"

      • Jsoniter Scala serialization

        libraryDependencies += "io.github.scala-loci" %% "scala-loci-serializer-jsoniter-scala" % "0.5.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  lt;: { 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 = Evt[(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
}