It&#39;s a pity that it does not even have an index like javadoc. Hoogle is nicer, though. 

I use a personal search engine from Google to search the Scaladocs. 

A search provider (searching with site: &lt;http://www.scala-lang.org/docu/files/api&gt;) in Firefox is another way to search the docs. 

Both do not work well for the Scala 2.8. release – it&#39;s not indexed well enough to be useful – and works not with all operators. For example a search for Cons `::` returns only nonsense.

There are plans to make the Hoogle interface work with multiple languages: http://code.google.com/p/ndmitchell/issues/detail?id=45

Scaladoc for Scala 3 has Hoogle-like searches feature. You can try it out [here][1].

It uses [Inkuire][2] search engine.

  [1]: https://scala-lang.org/api/3.x/
  [2]: https://github.com/VirtusLab/Inkuire

I have a local Git repository setup on my laptop. I would like to push it to my desktop. 

How can I do that?

How to push a local Git repository to another computer?

I understand how to create aliases in PowerShell for cmdlets fine, but I want to create an alias in PowerShell for things like `git status` as just `gs`, and `git pull origin master` as `gpm`. Can anyone point me in the right direction?

Creating aliases in PowerShell for git commands?

[Hoogle][1] allows you to search many standard Haskell libraries by either function name, or by approximate type signature. I find it very useful. Is there anything like Hoogle for Scala? Search in [ScalaDoc 2][2] only finds types and packages by name.


  [1]: http://www.haskell.org/hoogle/
  [2]: http://www.scala-lang.org/archives/rc-api/index.html

Scala Hoogle equivalent?

<p><a href="http://www.haskell.org/hoogle/" target="_blank" rel="noopener noreferrer">Hoogle</a> allows you to search many standard Haskell libraries by either function name, or by approximate type signature. I find it very useful. Is there anything like Hoogle for Scala? Search in <a href="http://www.scala-lang.org/archives/rc-api/index.html" target="_blank" rel="noopener noreferrer">ScalaDoc 2</a> only finds types and packages by name.</p>


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

I like Scala&#39;s propose of operator precedence but in some rare cases, unmodified rules may be inconvenient, because you have restrictions in naming your methods. Are there ways to define another rules for a class/file, etc. in Scala? If not, would it be resolved in the future?


Operator precedence in Scala

I need some code samples (and I also really curious about them) of Scala and Java code which show that Scala code is more simple and concise then code written in Java (of course both samples should solve the same problem).

If there is only Scala sample with comment like &quot;this is abstract factory in Scala, in Java it will look much more cumbersome&quot; then this is also acceptable.

Thanks!

I like most of all accepted and [this][1] answers


  [1]: https://stackoverflow.com/questions/2952732/samples-of-scala-and-java-code-where-scala-code-looks-simpler-has-fewer-lines/2961620#2961620

Samples of Scala and Java code where Scala code looks simpler/has fewer lines?

One of the new features of Scala 2.8 are context bounds. What is a context bound and where is it useful?

Of course I searched first (and found for example [this][1]) but I couldn&#39;t find any really clear and detailed information.


  [1]: https://stackoverflow.com/questions/2961986/how-do-you-write-an-idiomatic-scala-quicksort-function/2962799#2962799

What is a &quot;context bound&quot; in Scala?

Assume I have a Regex pattern I want to match many Strings to.

    val Digit = &quot;&quot;&quot;\d&quot;&quot;&quot;.r

I just want to check whether a given String fully matches the Regex. What is a good and idiomatic way to do this in Scala?

I know that I can pattern match on Regexes, but this is syntactically not very pleasing in this case, because I have no groups to extract:

    scala&gt; &quot;5&quot; match { case Digit() =&gt; true case _ =&gt; false }
    res4: Boolean = true

Or I could fall back to the underlying Java pattern:

    scala&gt; Digit.pattern.matcher(&quot;5&quot;).matches
    res6: Boolean = true

which is not elegant, either.

Is there a better solution?
   

How to check whether a String fully matches a Regex in Scala?

I would like my cabalised program to have a `--version` switch.

I would like it to report the same version as is present in the .cabal file.

If I have to update the version number separately in my Haskell source code as well as in the .cabal file, I will eventually get them out of sync.

So, how can my program, while being compiled under cabal, get its version number from the .cabal file?

How can my Haskell program or library find its version number?

I&#39;ve been thinking of this question very long, but really couldn&#39;t find the answer on Google as well a similar question on Stackoverflow. If there is a duplicate, I&#39;m sorry for that.

A lot of people seem to say that writing compilers and other language tools in functional languages such as OCaml and Haskell is much more efficient and easier then writing them in imperative languages.

Is this true? And if so -- why is it so efficient and easy to write them in functional languages instead of in an imperative language, like C? Also -- isn&#39;t a language tool in a functional language slower then in some low-level language like C?


Why is writing a compiler in a functional language easier?

I have heard that in Haskell, creating a multi-threaded application is as easy as taking a standard Haskell application and compiling it with the `-threaded` flag. Other cases, however, have described the use of a `par` command within the actual source code.

What is the state of Haskell multi-threading? How easy is it to introduce into programs? Is there a good multi-threading tutorial that goes over these different commands and their uses?

How difficult is Haskell multi-threading?

I have been reading _Real World Haskell_, and I am nearing the end, but a matter of style has been niggling at me to do with the `(.)` and `($)` operators.

When you write a function that is a composition of other functions you write it like:

    f = g . h

But when you apply something to the end of those functions I write it like this:

    k = a $ b $ c $ value

But the book would write it like this:

    k = a . b . c $ value

Now, to me they look functionally equivalent, they do the exact same thing in my eyes. However, the more I look, the more I see people writing their functions in the manner that the book does: compose with `(.)` first and then only at the end use `($)` to append a value to evaluate the lot (nobody does it with many dollar compositions). 

Is there a reason for using the books way that is much better than using all `($)` symbols? Or is there some best practice here that I am not getting? Or is it superfluous and I shouldn&#39;t be worrying about it at all?



Haskell function composition (.) and function application ($) idioms: correct use

When I was experimenting with Haskell kinds, and trying to get the kind of `-&gt;`, and this showed up:

    $ ghci
    ...
    Prelude&gt; :k (-&gt;)
    (-&gt;) :: ?? -&gt; ? -&gt; *
    Prelude&gt; 

Instead of the expected `* -&gt; * -&gt; *`.
What are the `??` and `?` things? Do they mean concrete types or &quot;kind variables&quot;? Or something else?


Haskell Weird Kinds: Kind of (-&gt;) is ?? -&gt; ? -&gt; *

I have read that Scala&#39;s type system is weakened by Java interoperability and therefore cannot perform some of the same powers as Haskell&#39;s type system.  Is this true?  Is the weakness because of type erasure, or am I wrong in every way?  Is this difference the reason that Scala has no typeclasses?


Disadvantages of Scala type system versus Haskell?

There are claims that Scala&#39;s type system is Turing complete. My questions are:

1. Is there a formal proof for this?

2. How would a simple computation look like in the Scala type system?

3. Is this of any benefit to Scala - the language? Is this making Scala more &quot;powerful&quot; in some way compared languages without a Turing complete type system?

I guess this applies to languages and type systems in general.

The type system in Scala is Turing complete. Proof? Example? Benefits?

It is well known that Haskell-style typeclasses and ML-style modules offer different mechanisms for specifying *interfaces*. They are (possibly) equivalent in power, but in practice each has their own benefits and drawbacks.

Since I&#39;m a bit of an inclusionist when it comes to language features, my question is this: What are the primary theoretical difficulties with adding ML-style modules to Haskell? I&#39;m interested in answers along the following lines:

* What existing type system features interact poorly with ML-style modules? (An example of poor interaction is GADT and functional dependencies, even though fundeps are technically equivalent to associated types!)

* What things have to be given up on the compiler end in order to compile ML-style modules?

* How do ML style modules interact with type inference?

Related reading:

* &lt;a href=&quot;http://existentialtype.wordpress.com/2011/04/16/modules-matter-most/&quot;&gt;Robert Harper’s post that provoked this question&lt;/a&gt;
* &lt;a href=&quot;http://www.reddit.com/r/haskell/comments/grq99/ml_modules_matter_most/&quot;&gt;Discussion on Haskell Reddit&lt;/a&gt;

What are the primary theoretical difficulties with adding ML-style modules to Haskell?

What is the difference when I write this?

    data Book = Book Int Int

versus

    newtype Book = Book (Int, Int) -- &quot;Book Int Int&quot; is syntactically invalid

Content Type	Original Author	Original Content on Stackoverflow
Question	Alexey Romanov	View Question on Stackoverflow
Solution 1 - Scala	Thomas Jung	View Answer on Stackoverflow
Solution 2 - Scala	Neil Mitchell	View Answer on Stackoverflow
Solution 3 - Scala	KacperFKorban	View Answer on Stackoverflow

Scala Hoogle equivalent?

Scala Problem Overview

Scala Solutions

Solution 1 - Scala

Solution 2 - Scala

Solution 3 - Scala

Creating aliases in PowerShell for git commands?

How to push a local Git repository to another computer?

Attributions