`foo(args:_*)` does the trick. Instead of applying the sequence as one single argument, each element in the sequence will be used as an argument.

In Python there is a built-in function called `dir`.  This is used to get a list of all the attributes for an object.

I understand what it does, but I am confused about why it is called `dir`.  How is this name related to getting the attributes from an object?

Why is &#39;dir()&#39; named &#39;dir&#39; in python?

In every technical publication, and on this site too, people are always comparing OO languages to [Smalltalk][1]. My experience is in Java: is Smalltalk *so* important that I should study it?


  [1]: http://en.wikipedia.org/wiki/Smalltalk

What is so special about Smalltalk?

Given a function that takes a variable number of arguments, e.g.

    def foo(os: String*) =
      println(os.toList)

How can I pass a sequence of arguments to the function? I would like to write:

    val args = Seq(&quot;hi&quot;, &quot;there&quot;)
    foo(args)

Obviously, this does not work.

Scala: pass Seq to var-args functions

Given a function that takes a variable number of arguments, e.g.
<pre><code class="hljs language-scss">def foo(os: String*) =
 println(os.toList)
</code></pre>
How can I pass a sequence of arguments to the function? I would like to write:
<pre><code class="hljs language-perl">val args = Seq("hi", "there")
foo(args)
</code></pre>
Obviously, this does not work.

I&#39;m doing matching against some case classes and would like to handle two of the cases in the same way. Something like this:

    abstract class Foo
    case class A extends Foo
    case class B(s:String) extends Foo
    case class C(s:String) extends Foo


    def matcher(l: Foo): String = {
      l match {
        case A() =&gt; &quot;A&quot;
        case B(sb) | C(sc) =&gt; &quot;B&quot;
        case _ =&gt; &quot;default&quot;
      }
    }

But when I do this I get the error:

    (fragment of test.scala):10: error: illegal variable in pattern alternative
        case B(sb) | C(sc) =&gt; &quot;B&quot;

I can get it working of I remove the parameters from the definition of B and C but how can I match with the params?

Match multiple cases classes in scala

Are there any best-practice guidelines on when to use [case classes][1] (or case objects) vs extending Enumeration in Scala?

They seem to offer some of the same benefits.

  [1]: http://en.wikipedia.org/wiki/Scala_%28programming_language%29#Case_classes_and_pattern_matching


Case objects vs Enumerations in Scala

This should be an easy one.  How do I apply a function to a tuple in Scala? Viz:

&lt;pre&gt;
scala&gt; def f (i : Int, j : Int) = i + j
f: (Int,Int)Int

scala&gt; val p = (3,4)
p: (Int, Int) = (3,4)

scala&gt; f p
&lt;console&gt;:6: error: missing arguments for method f in object $iw;
follow this method with `_&#39; if you want to treat it as a partially applied function
       f p
       ^

scala&gt; f _ p
&lt;console&gt;:6: error: value p is not a member of (Int, Int) =&gt; Int
       f _ p
           ^

scala&gt; (f _) p
&lt;console&gt;:6: error: value p is not a member of (Int, Int) =&gt; Int
       (f _) p
             ^

scala&gt; f(p)
&lt;console&gt;:7: error: wrong number of arguments for method f: (Int,Int)Int
       f(p)
       ^

scala&gt; grr!
&lt;/pre&gt;

Many thanks in advance.

How to apply a function to a tuple?

A self-type for a trait `A`:

    trait B
    trait A { this: B =&gt; }
 
says that *&quot;`A` cannot be mixed into a concrete class that does not also extend `B`&quot;*.

On the other hand, the following:

    trait B
    trait A extends B

says that *&quot;any (concrete or abstract) class mixing in `A` will also be mixing in B&quot;*.

Don&#39;t these two statements mean the same thing? The self-type seems to serve only to create the possibility of a simple compile-time error.

What am I missing?

What is the difference between self-types and trait subclasses?

What is the advantage of using an abstract class instead of a trait (apart from performance)? It seems like abstract classes can be replaced by traits in most cases.

Content Type	Original Author	Original Content on Stackoverflow
Question	David Crawshaw	View Question on Stackoverflow
Solution 1 - Scala	Joa Ebert	View Answer on Stackoverflow

Scala: pass Seq to var-args functions

Scala Problem Overview

Scala Solutions

Solution 1 - Scala

What is so special about Smalltalk?

Why is 'dir()' named 'dir' in python?

Attributions