It indicates a Symbol.  Eg. cfr http://www.scala-lang.org/docu/files/api/scala/Symbol.html :

&gt; the Scala  term &#39;mysym will invoke the constructor of the Symbol class in the following way: Symbol(&quot;mysym&quot;). 

I have a Mercurial repository containing a handful of related projects. I want to branch just one of these projects to work on it elsewhere.

Is cloning just part of a repository possible, and is that the right way to achieve this?

How do I clone a sub-folder of a repository in Mercurial?

Can Maven copy local file to a remote server using SSH? 

I want to specify location in maven configuration file and to copy that file (or files) to server each time deploy phase is executed.

Maven copy local file to remote server using SSH

In this slide show on [ScalaActors.pdf][1] what does the single quote indicate when the message is sent to the pong actor? 

    class Ping(count: int, pong: Pong) extends Actor {
    def act() {
       pong ! &#39;Ping // what does the single quote indicate???
          receive {
             case &#39;Pong =&gt;
          }
       }
    }


  [1]: http://lamp.epfl.ch/~phaller/doc/ScalaActors.pdf

What does a single apostrophe mean in Scala?

In this slide show on <a href="http://lamp.epfl.ch/~phaller/doc/ScalaActors.pdf" target="_blank" rel="noopener noreferrer">ScalaActors.pdf</a> what does the single quote indicate when the message is sent to the pong actor?
<pre><code class="hljs language-scss">class Ping(count: int, pong: Pong) extends Actor {
def act() {
 pong ! 'Ping // what does the single quote indicate???
 receive {
 case 'Pong =>
 }
 }
}
</code></pre>

I am attempting to use JSON to send data between the browser and my app.

I am attempting to use Lift 1.0 to create and parse JSON strings, but for some reason I am unable to parse the JSON I just constructed:

    scala&gt;import scala.util.parsing.json.JSON._
    import scala.util.parsing.json.JSON._
    
    scala&gt; import net.liftweb.http.js._
    import net.liftweb.http.js._
    
    scala&gt; import net.liftweb.http.js.JE._
    import net.liftweb.http.js.JE._
    
    scala&gt; val json = JsObj((&quot;foo&quot;, 4), (&quot;bar&quot;, &quot;baz&quot;)).toJsCmd
    json: String = {&#39;foo&#39;: 4, &#39;bar&#39;: &#39;baz&#39;}
    
    scala&gt;  parseFull(json)  
    res3: Option[Any] = None

How do I programmatically construct a valid JSON message in Scala/Lift that can also be parsed again?




How can I construct and parse a JSON string in Scala / Lift

Given a variable with type `Graphics`, 
how do I cast it to `Graphics2D` in Scala?


How do I cast a variable in Scala?

With equals sign:

    object HelloWorld {
      def main(args: Array[String]) = {
        println(&quot;Hello!&quot;)
      }
    }

Without equals sign:

    object HelloWorld {
      def main(args: Array[String]) {
        println(&quot;Hello!&quot;)
      }
    }

Both of the above programs execute the same way. In the blog post *[Things I do not like in Scala][1]* I read that when the equals sign are missing, the method will return `Unit` (same as Java&#39;s `void`), so methods that return a value must use the equals sign. But methods that don&#39;t return a value can be written either way.

What is the best practice for using the equals sign in Scala methods that don&#39;t return a value?

  [1]: http://www.francolombardo.net/things-i-do-not-like-in-scala_post-69.html


When to use the equals sign in a Scala method declaration?

What are the available code coverage tools for Scala? 

I have Scala spec tests and a Hudson continuous integration set-up. Is there something I can hook-in to this setup to measure and track code coverage?


Code Coverage Tools for Scala

Just wondering if anyone has experience with the three.  I have used read through some RoR and used Django.  They seem fairly easy to use.  Is lift &quot;easy&quot; like these two are?  I know easy is subjective and has no context here.  I mean in a very high level and general sense.

Is the Lift framework as &quot;easy&quot; as Ruby on Rails or Django?

Let me first say that I have quite a lot of Java experience, but have only recently become interested in functional languages. Recently I&#39;ve started looking at Scala, which seems like a very nice language.

However, I&#39;ve been reading about Scala&#39;s Actor framework in [_Programming in Scala_](http://www.artima.com/shop/programming_in_scala), and there&#39;s one thing I don&#39;t understand. In chapter 30.4 it says that using `react` instead of `receive` makes it possible to re-use threads, which is good for performance, since threads are expensive in the JVM.

Does this mean that, as long as I remember to call `react` instead of `receive`, I can start as many Actors as I like? Before discovering Scala, I&#39;ve been playing with Erlang, and the author of [_Programming Erlang_](http://www.pragprog.com/titles/jaerlang/programming-erlang) boasts about spawning over 200,000 processes without breaking a sweat. I&#39;d hate to do that with Java threads. What kind of limits am I looking at in Scala as compared to Erlang (and Java)?

Also, how does this thread re-use work in Scala? Let&#39;s assume, for simplicity, that I have only one thread. Will all the actors that I start run sequentially in this thread, or will some sort of task-switching take place? For example, if I start two actors that ping-pong messages to each other, will I risk deadlock if they&#39;re started in the same thread?

According to _Programming in Scala_, writing actors to use `react` is more difficult than with `receive`. This sounds plausible, since `react` doesn&#39;t return. However, the book goes on to show how you can put a `react` inside a loop using `Actor.loop`. As a result, you get

    loop {
        react {
            ...
        }
    }

which, to me, seems pretty similar to

    while (true) {
        receive {
            ...
        }
    }

which is used earlier in the book. Still, the book says that &quot;in practice, programs will need at least a few `receive`&#39;s&quot;. So what am I missing here? What can `receive` do that `react` cannot, besides return? And why do I care?

Finally, coming to the core of what I don&#39;t understand: the book keeps mentioning how using `react` makes it possible to discard the call stack to re-use the thread. How does that work? Why is it necessary to discard the call stack? And why can the call stack be discarded when a function terminates by throwing an exception (`react`), but not when it terminates by returning (`receive`)?

I have the impression that _Programming in Scala_ has been glossing over some of the key issues here, which is a shame, because otherwise it&#39;s a truly excellent book.



Scala actors: receive vs react

Is there any good implementation of [actors concurrency model][1] for .net/c#? 

I have to optimize a c# routine and i think that actors model fits perfectly as a solution for my problem. Unfortunately i have experience only with scala implementation.


  [1]: http://en.wikipedia.org/wiki/Actor_model

Any good implementation of Actors for C#?

*Updated:  This question contains an error which makes the benchmark meaningless.  I will attempt a better benchmark comparing F# and Erlang&#39;s basic concurrency functionality and inquire about the results in another question.*

I am trying do understand the performance characteristics of Erlang and F#.  I find Erlang&#39;s concurrency model very appealing but am inclined to use F# for interoperability reasons. While out of the box F# doesn&#39;t offer anything like Erlang&#39;s concurrency primitives -- from what I can tell async and MailboxProcessor only cover a small portion of what Erlang does well -- I&#39;ve been trying to understand what is possible in F# performance wise.

In Joe Armstrong&#39;s Programming Erlang book, he makes the point that processes are very cheap in Erlang.  He uses the (roughly) the following code to demonstrate this fact:

    -module(processes).
    -export([max/1]).
    
    %% max(N) 
    %%   Create N processes then destroy them
    %%   See how much time this takes
    
    max(N) -&gt;
        statistics(runtime),
        statistics(wall_clock),
        L = for(1, N, fun() -&gt; spawn(fun() -&gt; wait() end) end),
        {_, Time1} = statistics(runtime),
        {_, Time2} = statistics(wall_clock),
        lists:foreach(fun(Pid) -&gt; Pid ! die end, L),
        U1 = Time1 * 1000 / N,
        U2 = Time2 * 1000 / N,
        io:format(&quot;Process spawn time=~p (~p) microseconds~n&quot;,
    	      [U1, U2]).
    
    wait() -&gt;
        receive
    		die -&gt; void
        end.
    
    for(N, N, F) -&gt; [F()];
    for(I, N, F) -&gt; [F()|for(I+1, N, F)].

On my Macbook Pro, spawning and killing 100 thousand processes (`processes:max(100000)`) takes about 8 microseconds per processes.  I can raise the number of processes a bit further, but a million seems to break things pretty consistently.

Knowing very little F#, I tried to implement this example using async and MailBoxProcessor.  My attempt, which may be wrong, is as follows:

    #r &quot;System.dll&quot;
    open System.Diagnostics
    
    type waitMsg =
        | Die
    
    let wait =
        MailboxProcessor.Start(fun inbox -&gt;
            let rec loop =
                async { let! msg = inbox.Receive()
                        match msg with 
                        | Die -&gt; return() }
            loop)
    
    let max N =
        printfn &quot;Started!&quot;
        let stopwatch = new Stopwatch()
        stopwatch.Start()
        let actors = [for i in 1 .. N do yield wait]
        for actor in actors do
            actor.Post(Die)
        stopwatch.Stop()
        printfn &quot;Process spawn time=%f microseconds.&quot; (stopwatch.Elapsed.TotalMilliseconds * 1000.0 / float(N))
        printfn &quot;Done.&quot;

Using F# on Mono, starting and killing 100,000 actors/processors takes under 2 microseconds per process, roughly 4 times faster than Erlang.  More importantly, perhaps, is that I can scale up to millions of processes without any apparent problems.  Starting 1 or 2 million processes still takes about 2 microseconds per process. Starting 20 million processors is still feasible, but slows to about 6 microseconds per process.

I have not yet taken the time to fully understand how F# implements async and MailBoxProcessor, but these results are encouraging.  Is there something I&#39;m doing horribly wrong?

If not, is there some place Erlang will likely outperform F#? Is there any reason Erlang&#39;s concurrency primitives can&#39;t be brought to F# through a library?

EDIT: The above numbers are wrong, due to the error Brian pointed out.  I will update the entire question when I fix it.


Is F# really faster than Erlang at spawning and killing processes?

I&#39;m trying to find the &#39;right&#39; actor implementation. I realized there is a bunch of them and it&#39;s a bit confusing to pick one. Personally I&#39;m especially interested in remote actors, but I guess a complete overview would be helpful to many others. This is a pretty general question, so feel free to answer just for the implementation you know about.

I know about the following Scala Actor implementations (SAI). Please add the missing ones.

- Scala 2.7 (difference to)
- Scala 2.8
- Akka (http://www.akkasource.org/)
- Lift (http://liftweb.net/)
- Scalaz (http://code.google.com/p/scalaz/)
--- --- --- --- --- --- --- --- --- --- --- --- 
- What are the target use-cases for these SAIs (lightweight vs. &quot;heavy&quot; enterprise framework)?
- do they support remote actors? What shortcomings do remote actors have in the SAIs?
- How is their performace?
- How active is there community?
- How easy are they to get started? How good is the documentation?
- How easy are they to extend? 
- How stable are they? Which projects are using them?
- What are their shortcomings?
- What are their design principles?
  - Are they thread based or event based (receive/ react) or both?
  - Nested receiveS
  - hotswapping the Actor’s message loop

Different Scala Actor Implementations Overview

Is there any good and short explanation of how *Actors* works compared to threads?

Can&#39;t a thread be seen as an actor and send messages to other threads? I see some difference, but it&#39;s not that clear for me. Can I use *Actors* in any language by using threads differently?

Content Type	Original Author	Original Content on Stackoverflow
Question	JeffV	View Question on Stackoverflow
Solution 1 - Scala	Alex Martelli	View Answer on Stackoverflow

What does a single apostrophe mean in Scala?

Scala Problem Overview

Scala Solutions

Solution 1 - Scala

Maven copy local file to remote server using SSH

How do I clone a sub-folder of a repository in Mercurial?

Attributions