You were very close. Add the abstract modifier to M.foo, and you have the &#39;Stackable Trait&#39; pattern: http://www.artima.com/scalazine/articles/stackable_trait_pattern.html

    trait Foo {
      def foo()
    }
    
    trait M extends Foo {
      abstract override def foo() {println(&quot;M&quot;); super.foo()}
    }
    
    class FooImpl1 extends Foo {
      override def foo() {println(&quot;Impl&quot;)}
    }
    
    class FooImpl2 extends FooImpl1 with M

How can I tell if a given directory is part of a git respository?

(The following is in python, but bash or something would be fine.)

    os.path.isdir(&#39;.svn&#39;)

will tell you if the current directory is controlled by Subversion. Mercurial and Git just have a .hg/.git at the top of the repository, so for `hg` I can use

    os.system(&#39;hg -q stat 2&gt; /dev/null &gt; /dev/null&#39;) == 0)

but `git status` returns a nonzero (error) exit status if nothing&#39;s changed.

Is iterating up the path looking for `.git` myself the best I can do?

Determine if directory is under git control

Look at the following example (partially taken from [MSDN Blog][1]):

    class Animal { }
    class Giraffe : Animal { }

    static void Main(string[] args)
    {
        // Array assignment works, but...
        Animal[] animals = new Giraffe[10]; 
    
        // implicit...
        List&lt;Animal&gt; animalsList = new List&lt;Giraffe&gt;();

        // ...and explicit casting fails
        List&lt;Animal&gt; animalsList2 = (List&lt;Animal&gt;) new List&lt;Giraffe&gt;();
    }

Is this a covariance problem? Will this be supported in the future C# release and are there any clever workarounds (using only .NET 2.0)?


  [1]: http://blogs.msdn.com/ericlippert/archive/2007/10/17/covariance-and-contravariance-in-c-part-two-array-covariance.aspx

C# variance problem: Assigning List&lt;Derived&gt; as List&lt;Base&gt;

I have a base abstract class (trait). It has an abstract method `foo()`. It is extended and implemented by several derived classes. I want to create a trait that can be mixed into the derived classes so that it implements `foo()` and then calls the derived class&#39;s `foo()`.

Something like:

    trait Foo {
      def foo()
    }

    trait M extends Foo {
      override def foo() {
        println(&quot;M&quot;)
        super.foo()
      }
    }

    class FooImpl1 extends Foo {
      override def foo() {
        println(&quot;Impl&quot;)
      }
    }

    class FooImpl2 extends FooImpl1 with M 

I tried self types and structural types, but I can&#39;t get it to work.


Traits and abstract methods override in Scala

I have a base abstract class (trait). It has an abstract method <code>foo()</code>. It is extended and implemented by several derived classes. I want to create a trait that can be mixed into the derived classes so that it implements <code>foo()</code> and then calls the derived class's <code>foo()</code>.
Something like:
<pre><code class="hljs language-ruby">trait Foo {
 def foo()
}

trait M extends Foo {
 override def foo() {
 println("M")
 super.foo()
 }
}

class FooImpl1 extends Foo {
 override def foo() {
 println("Impl")
 }
}

class FooImpl2 extends FooImpl1 with M 
</code></pre>
I tried self types and structural types, but I can't get it to work.

I am not able to understand the point of `Option[T]` class in Scala. I mean, I am not able to see any advanages of `None` over `null`.

For example, consider the code:

    object Main{
      class Person(name: String, var age: int){
        def display = println(name+&quot; &quot;+age)
      }

      def getPerson1: Person = {
        // returns a Person instance or null
      }

      def getPerson2: Option[Person] = {
        // returns either Some[Person] or None
      }

      def main(argv: Array[String]): Unit = {
        val p = getPerson1
        if (p!=null) p.display
        
        getPerson2 match{
          case Some(person) =&gt; person.display
          case None =&gt; /* Do nothing */
        }
      }
    }
    
Now suppose, the method `getPerson1` returns `null`, then the call made to `display` on first line of `main` is bound to fail with `NPE`. Similarly if `getPerson2` returns `None`, the `display` call will again fail with some similar error.

If so, then why does Scala complicate things by introducing a new value wrapper (`Option[T]`) instead of following a simple approach used in Java?

**UPDATE:**

I have edited my code as per [@Mitch][2]&#39;s suggestion. I am still not able to see any particular advantage of `Option[T]`. I have to test for the exceptional `null` or `None` in both cases. :(

If I have understood correctly from [@Michael&#39;s reply][3], is the only advantage of `Option[T]` is that it explicitly tells the programmer that *this method could return None*? Is this the only reason behind this design choice?

  [1]: http://en.wikipedia.org/wiki/Currying
  [2]: https://stackoverflow.com/users/164075
  [3]: https://stackoverflow.com/questions/2079170/why-optiont/2079247#2079247


What is the point of the class Option[T]?

There&#39;s not much info in the spec on what type ascription is, and there certainly isn&#39;t anything in there about the purpose for it.  Other than &quot;making passing varargs work&quot;, what would I use type ascription for?  Below is some scala REPL for the syntax and effects of using it.

    scala&gt; val s = &quot;Dave&quot;
    s: java.lang.String = Dave
    
    scala&gt; val p = s:Object
    p: java.lang.Object = Dave
    
    scala&gt; p.length
    &lt;console&gt;:7: error: value length is not a member of java.lang.Object
           p.length
             ^
    scala&gt; p.getClass
    res10: java.lang.Class[_ &lt;: java.lang.Object] = class java.lang.String
    
    scala&gt; s.getClass
    res11: java.lang.Class[_ &lt;: java.lang.Object] = class java.lang.String
    
    scala&gt; p.asInstanceOf[String].length
    res9: Int = 4

What is the purpose of type ascriptions in Scala?

In Scala there is a Stream class that is very much like an iterator.  The topic [Difference between Iterator and Stream in Scala?](https://stackoverflow.com/questions/1527962/difference-between-iterator-and-stream-in-scala) offers some insights into the similarities and differences between the two.

Seeing how to use a stream is pretty simple but I don&#39;t have very many **common** use-cases where I would use a stream instead of other artifacts.  
 

The ideas I have right now:

 - If you need to make use of an infinite series.  But this does not seem like a common use-case to me so it doesn&#39;t fit my criteria.  (Please correct me if it is common and I just have a blind spot)
 - If you have a series of data where each element needs to be computed but that you may want to reuse several times.  This is weak because I could just load it into a list which is conceptually easier to follow for a large subset of the developer population.  
 - Perhaps there is a large set of data or a computationally expensive series and there is a high probability that the items you need will not require visiting all of the elements.  But in this case an Iterator would be a good match unless you need to do several searches, in that case you could use a list as well even if it would be slightly less efficient.
 - There is a complex series of data that needs to be reused.  Again a list could be used here.  Although in this case both cases would be equally difficult to use and a Stream would be a better fit since not all elements need to be loaded.  But again not that common... or is it?

So have I missed any big uses?  Or is it a developer preference for the most part?

Thanks

Use-cases for Streams in Scala

Is it possible to implement in Scala something equivalent to the Python `yield` statement where it remembers the local state of the function where it is used and &quot;yields&quot; the next value each time it is called?

I wanted to have something like this to convert a recursive function into an iterator. Sort of like this:

    # this is python
    def foo(i):
      yield i
      if i &gt; 0:
        for j in foo(i - 1):
          yield j
    
    for i in foo(5):
      print i

Except, `foo` may be more complex and recurs through some acyclic object graph.


**Additional Edit:**
Let me add a more complex example (but still simple):
I can write a simple recursive function printing things as it goes along:

    // this is Scala
    def printClass(clazz:Class[_], indent:String=&quot;&quot;): Unit = {
      clazz match {
        case null =&gt;
        case _ =&gt;
          println(indent + clazz)
          printClass(clazz.getSuperclass, indent + &quot;  &quot;)
          for (c &lt;- clazz.getInterfaces) {
            printClass(c, indent + &quot;  &quot;)
          }
      }
    }

Ideally I would like to have a library that allows me to easily change a few statements and have it work as an Iterator:

    // this is not Scala
    def yieldClass(clazz:Class[_]): Iterator[Class[_]] = {
      clazz match {
        case null =&gt;
        case _ =&gt;
          sudoYield clazz
          for (c &lt;- yieldClass(clazz.getSuperclass)) sudoYield c
          for (c &lt;- clazz.getInterfaces; d &lt;- yieldClasss(c)) sudoYield d
      }
    }

It does seem continuations allow to do that, but I just don&#39;t understand the `shift/reset` concept. Will continuation eventually make it into the main compiler and would it be possible to extract out the complexity in a library?

**Edit 2:**
check [Rich&#39;s answer][1] in that other thread.


  [1]: https://stackoverflow.com/questions/2201882/implementing-yield-yield-return-using-scala-continuations/2215182#2215182

Scala equivalent to Python generators?

I come from a Python background, where at any point in my code I can add

    import pdb; pdb.set_trace()

and at runtime I&#39;ll be dropped into an interactive interpreter at that spot. Is there an equivalent for scala, or is this not possible at runtime?

Drop into interpreter during arbitrary scala code location

I&#39;m reading Scott Meyers&#39; [*Effective C++*](https://rads.stackoverflow.com/amzn/click/0321334876). He is talking about traits classes, I understood that I need them to determine the type of the object during compilation time, but I can&#39;t understand his explanation about what these classes actually do? (from technical point of view)

How do traits classes work and what do they do?

[Traits][1] have been one of the biggest additions for PHP 5.4. I know the syntax and understand the idea behind traits, like horizontal code re-use for common stuff like logging, security, caching etc.

However, I still don&#39;t know how I would make use of traits in my projects. 

Are there any open source projects that already use traits? Any good articles/reading material on how to structure architectures using traits?

  [1]: http://php.net/manual/en/language.oop5.traits.php

Traits in PHP – any real world examples/best practices?

Given a lambda, is it possible to figure out it&#39;s parameter type and return type? If yes, how?

Basically, I want `lambda_traits` which can be used in following ways:

    auto lambda = [](int i) { return long(i*10); };

    lambda_traits&lt;decltype(lambda)&gt;::param_type  i; //i should be int
    lambda_traits&lt;decltype(lambda)&gt;::return_type l; //l should be long

The motivation behind is that I want to use `lambda_traits` in a function template which accepts a lambda as argument, and I need to know it&#39;s parameter type and return type inside the function:

    template&lt;typename TLambda&gt;
    void f(TLambda lambda)
    {
       typedef typename lambda_traits&lt;TLambda&gt;::param_type  P;
       typedef typename lambda_traits&lt;TLambda&gt;::return_type R;
      
       std::function&lt;R(P)&gt; fun = lambda; //I want to do this!
       //...
    }

For the time being, we can assume that the lambda takes exactly one argument.

Initially, I tried to work with `std::function` as:

    template&lt;typename T&gt;
    A&lt;T&gt; f(std::function&lt;bool(T)&gt; fun)
    {
       return A&lt;T&gt;(fun);
    }

    f([](int){return true;}); //error

But it obviously would give error. So I changed it to `TLambda` version of the function template and want to construct the `std::function` object inside the function (as shown above).


Is it possible to figure out the parameter type and return type of a lambda?

I&#39;ve been trying to study up on PHP lately, and I find myself getting hung up on traits. I understand the concept of horizontal code reuse and not wanting to necessarily inherit from an abstract class. What I don&#39;t understand is: What is the crucial difference between using traits versus interfaces?

I&#39;ve tried searching for a decent blog post or article explaining when to use one or the other, but the examples I&#39;ve found so far seem so similar as to be identical.




Traits vs. interfaces

I know the feature doesn&#39;t exist in C#, but PHP recently added a feature called [Traits](http://php.net/manual/en/language.oop5.traits.php) which I thought was a bit silly at first until I started thinking about it.

Say I have a base class called `Client`. `Client` has a single property called `Name`.

Now I&#39;m developing a re-usable application that will be used by many different customers. All customers agree that a client should have a name, hence it being in the base-class.

Now Customer A comes along and says he also need to track the client&#39;s Weight. Customer B doesn&#39;t need the Weight, but he wants to track Height. Customer C wants to track both Weight and Height.

With traits, we could make the both the Weight and the Height features traits:

    class ClientA extends Client use TClientWeight
    class ClientB extends Client use TClientHeight
    class ClientC extends Client use TClientWeight, TClientHeight

Now I can meet all my customers&#39; needs without adding any extra fluff to the class. If my customer comes back later and says &quot;Oh, I really like that feature, can I have it too?&quot;, I just update the class definition to include the extra trait.

How would you accomplish this in C#?

Interfaces don&#39;t work here because I want concrete definitions for the properties and any associated methods, and I don&#39;t want to re-implement them for each version of the class.

(By &quot;customer&quot;, I mean a literal person who has employed me as a developer, whereas by &quot;client&quot; I&#39;m referring a programming class; each of my customers has clients that they want to record information about)



Content Type	Original Author	Original Content on Stackoverflow
Question	IttayD	View Question on Stackoverflow
Solution 1 - Scala	retronym	View Answer on Stackoverflow

Traits and abstract methods override in Scala

Scala Problem Overview

Scala Solutions

Solution 1 - Scala

C# variance problem: Assigning List<Derived> as List<Base>

Determine if directory is under git control

Attributions