`val a: A = _` is a compile error. For example:

    scala&gt; val a: String = _
    &lt;console&gt;:1: error: unbound placeholder parameter
           val a: String = _
                           ^


What does work is `var a: A = _` (note `var` instead of `val`). As Chuck says in his answer, this initialises the variable to a default value. From the Scala Language Specification:

&gt; 0 if T is Int or one of its subrange types,&lt;br&gt;
&gt; 0L if T is Long,&lt;br&gt;
&gt; 0.0f if T is Float,&lt;br&gt;
&gt; 0.0d if T is Double,&lt;br&gt;
&gt; false if T is Boolean,&lt;br&gt;
&gt; () if T is Unit,&lt;br&gt;
&gt; null for all other types T.

It initializes `a` to the default value of the type `A`. For example, the default value of an Int is 0 and the default value of a reference type is null.

Is there a way to write a delete/deleteAll query like findAll?

For example I want to do something like this (assuming MyModel is a Sequelize model...):

    MyModel.deleteAll({ where: [&#39;some_field != ?&#39;, something] })
        .on(&#39;success&#39;, function() { /* ... */ });


Sequelize.js delete query?

Does anybody encounter this warning when executing `python setup.py install` of a PyPI package?

`install_requires` defines what the package requires. A lot of PyPI packages have this option. How can it be an &quot;unknown distribution option&quot;?

pypi UserWarning: Unknown distribution option: &#39;install_requires&#39;

What exactly does `val a: A = _` initialize a value to? Is this a typed null? Thanks.

In Scala, what exactly does &#39;val a: A = _&#39; (underscore) mean?

<p>What exactly does <code>val a: A = _</code> initialize a value to? Is this a typed null? Thanks.</p>


Can please someone explain the differences between Functor and Monad in the Scala context?

Scala Functor and Monad differences

In Scala, we can use at least two methods to retrofit existing or new types. Suppose we want to express that something can be quantified using an `Int`. We can define the following trait.

###Implicit conversion

    trait Quantifiable{ def quantify: Int }

And then we can use implicit conversions to quantify e.g. Strings and Lists.

    implicit def string2quant(s: String) = new Quantifiable{ 
      def quantify = s.size 
    }
    implicit def list2quantifiable[A](l: List[A]) = new Quantifiable{ 
      val quantify = l.size 
    }

After importing these, we can call the method `quantify` on strings and lists. Note that the quantifiable list stores its length, so it avoids the expensive traversal of the list on subsequent calls to `quantify`.

###Type classes

An alternative is to define a &quot;witness&quot; `Quantified[A]` that states, that some type `A` can be quantified.

    trait Quantified[A] { def quantify(a: A): Int }

We then provide instances of this type class for `String` and `List` somewhere.

    implicit val stringQuantifiable = new Quantified[String] {
      def quantify(s: String) = s.size 
    }

And if we then write a method that needs to quantify its arguments, we write:

    def sumQuantities[A](as: List[A])(implicit ev: Quantified[A]) = 
      as.map(ev.quantify).sum

Or using the context bound syntax:

    def sumQuantities[A: Quantified](as: List[A]) = 
      as.map(implicitly[Quantified[A]].quantify).sum

###But when to use which method?
Now comes the question. How can I decide between those two concepts?

What I have noticed so far.

**type classes**

 - type classes allow the nice context bound syntax
 - with type classes I don&#39;t create a new wrapper object on each use
 - the context bound syntax does not work anymore if the type class has multiple type parameters; imagine I want to quantify things not only with integers but with values of some general type `T`. I would want to create a type class `Quantified[A,T]`

**implicit conversion**

 - since I create a new object, I can cache values there or compute a better representation; but should I avoid this, since it might happen several times and an explicit conversion would probably be invoked only once?

###What I expect from an answer
Present one (or more) use case(s) where the difference between both concepts matters and explain why I would prefer one over the other. Also explaining the essence of the two concepts and their relation to each other would be nice, even without example.



Implicit conversion vs. type class

What is so powerful about flatmap that it deserves such a place in the Scala folklore?


Where does the &quot;flatmap that s***&quot; idiomatic expression in Scala come from?

I&#39;m trying to incorporate ScalaTest into my Java project; replacing all JUnit tests with ScalaTests. At one point, I want to check if Guice&#39;s Injector injects the correct type. In Java, I have a test like this:

    public class InjectorBehaviour {
    	@Test
    	public void shouldInjectCorrectTypes() {
    		Injector injector = Guice.createInjector(new ModuleImpl());
    		House house = injector.getInstance(House.class);
    
    		assertTrue(house.door() instanceof WoodenDoor);
    		assertTrue(house.window() instanceof BambooWindow);
    		assertTrue(house.roof() instanceof SlateRoof);
    	}
    }

But I have a problem doing the same with ScalaTest:

    class InjectorSpec extends Spec {
    	describe(&quot;An injector&quot;) {
    		it(&quot;should inject the correct types&quot;) {
    			val injector = Guice.createInjector(new ModuleImpl)
    			val house = injector.getInstance(classOf[House])
    
    			assert(house.door instanceof WoodenDoor)
    			assert(house.window instanceof BambooWindow)
    			assert(house.roof instanceof SlateRoof)
    		}
    	}
    }

It complains that the value `instanceof` is not a member of `Door`/`Window`/`Roof`. Can&#39;t I use `instanceof` that way in Scala? 


How to do an instanceof check with Scala(Test)

given:

    val m = Map[String, Int](&quot;a&quot; -&gt; 1, &quot;b&quot; -&gt; 2, &quot;c&quot; -&gt; 3)
    m.foreach((key: String, value: Int) =&gt; println(&quot;&gt;&gt;&gt; key=&quot; + key + &quot;, value=&quot; + value))

why does the compiler complain 

    error: type mismatch
    found   : (String, Int) =&gt; Unit
    required: (String, Int) =&gt; ?




Scala Map foreach

I am wondering when static variables are initialized to their default values.
Is it correct that when a class is loaded, static vars are created (allocated),
then static initializers and initializations in declarations are executed?
At what point are the default values are given?  This leads to the problem of forward reference.

Also please if you can explain this in reference to the question asked on https://stackoverflow.com/questions/2547713/why-static-fields-are-not-initialized-in-time and especially the answer given by Kevin Brock on the same site. I can&#39;t understand the 3rd point.

When are static variables initialized?

Is it possible to create an empty array without specifying the size?

For example, I created:

    String[] a = new String[5];

Can we create the above string array without the size?


How do I initialize an empty array in C#?

Today I was surprised to find that in C# I can do:

    List&lt;int&gt; a = new List&lt;int&gt; { 1, 2, 3 };

Why can I do this? What constructor is called? How can I do this with my own classes? I know that this is the way to initialize arrays but arrays are language items and Lists are simple objects ...

Why can I initialize a List like an array in C#?

I have 2 jars, let&#39;s call them a.jar and b.jar.

b.jar depends on a.jar.

In a.jar, I defined a class, let&#39;s call it StaticClass. In the StaticClass, I defined a static block, calling a method named &quot;init&quot; : 

    public class StaticClass {
      static {
        init();
      } 
    
      public void static init () {
        // do some initialization here
      }
    }

in b.jar, I have a main, so in the main, I expect that the init() method has been called, but actually not. I suspect that is because the StaticClass has not been loaded by the jvm, could anyone tell me

 1. Is my conclusion correct? 
 2. What triggers the jvm to load a class?
 3. How can I get the static block executed automatically?

Thanks

When is the static block of a class executed?

I am trying to initialise an `std::vector&lt;std::unique_ptr&lt;std::string&gt;&gt;` in a way that is equivalent to an example from [Bjarne Stroustrup&#39;s C++11 FAQ](http://www.stroustrup.com/C++11FAQ.html#std-unique_ptr):

    using namespace std;
    vector&lt;unique_ptr&lt;string&gt;&gt; vs { new string{&quot;Doug&quot;}, new string{&quot;Adams&quot;} }; // fails
    unique_ptr&lt;string&gt; ps { new string{&quot;42&quot;} }; // OK

I can see no reason why this syntax should fail. Is there something wrong with this way of initializing the container?   
The compiler error message is huge; the relevant segment I find is below:

&gt; /usr/lib/gcc-snapshot/lib/gcc/i686-linux-gnu/4.7.0/../../../../include/c++/4.7.0
&gt; /bits/stl_construct.h:77:7: error: no matching function for call to
&gt; `&#39;std::unique_ptr&lt;std::basic_string&lt;char&gt; &gt;::unique_ptr(std::basic_string&lt;char&gt;&amp;)&#39;`

What is the way to fix this error ?

Content Type	Original Author	Original Content on Stackoverflow
Question	Gregor Scheidt	View Question on Stackoverflow
Solution 1 - Scala	Paul Butcher	View Answer on Stackoverflow
Solution 2 - Scala	Chuck	View Answer on Stackoverflow

In Scala, what exactly does 'val a: A = _' (underscore) mean?

Scala Problem Overview

Scala Solutions

Solution 1 - Scala

Solution 2 - Scala

pypi UserWarning: Unknown distribution option: 'install_requires'

Sequelize.js delete query?

Attributions