The difference is that all subclasses of a sealed class (whether it&#39;s abstract or not) must be in the same file as the sealed class.

As [answered][1], all *directly inheriting* subclasses of a sealed class (abstract or not) must be in the same file. A practical consequence of this is that the compiler can warn if the pattern match is incomplete. For instance:

    sealed abstract class Tree
    case class Node(left: Tree, right: Tree) extends Tree
    case class Leaf[T](value: T) extends Tree
    case object Empty extends Tree
    
    def dps(t: Tree): Unit = t match {
      case Node(left, right) =&gt; dps(left); dps(right)
      case Leaf(x) =&gt; println(&quot;Leaf &quot;+x)
      // case Empty =&gt; println(&quot;Empty&quot;) // Compiler warns here
    }

If the `Tree` is `sealed`, then the compiler warns unless that last line is uncommented.

  [1]: https://stackoverflow.com/questions/3032771/scalas-sealed-abstract/3032787#3032787


I&#39;m looking for a *diff* equivalent written in JavaScript that only returns/prints relevant lines. I don&#39;t want both full text displayed next to each other with the differences highlighted, but just want the actual differences (plus some buffer lines to know where the difference is), similar to the output from the linux diff utility.

Does anybody know a javascript function that does this? All differences should be recognized (even changed whitespace). Thanks.

JavaScript based diff utility

I&#39;m working on an implementation of the memcache protocol which, at some points, uses 64 bits integer values. These values must be stored in &quot;network byte order&quot;.

I wish there was some `uint64_t htonll(uint64_t value)` function to do the change, but unfortunately, if it exist, I couldn&#39;t find it.

So I have 1 or 2 questions:

 * Is there any **portable** (Windows, Linux, AIX) standard function to do this ?
 * If there is no such function, how would you implement it ?

I have in mind a basic implementation but I don&#39;t know how to check the endianness at compile-time to make the code portable. So your help is more than welcome here ;)

Thank you.

&lt;hr/&gt;

Here is the final solution I wrote, thanks to Brian&#39;s solution.

	uint64_t htonll(uint64_t value)
	{
		// The answer is 42
		static const int num = 42;

		// Check the endianness
		if (*reinterpret_cast&lt;const char*&gt;(&amp;num) == num)
		{
			const uint32_t high_part = htonl(static_cast&lt;uint32_t&gt;(value &gt;&gt; 32));
			const uint32_t low_part = htonl(static_cast&lt;uint32_t&gt;(value &amp; 0xFFFFFFFFLL));

			return (static_cast&lt;uint64_t&gt;(low_part) &lt;&lt; 32) | high_part;
		} else
		{
			return value;
		}
	}

Is there any &quot;standard&quot; htonl-like function for 64 bits integers in C++?

What is the difference between `sealed abstract` and `abstract` Scala class?

Scala&#39;s sealed abstract vs abstract class

<p>What is the difference between <code>sealed abstract</code> and <code>abstract</code> Scala class?</p>


One handy feature of Scala is `lazy val`, where the evaluation of a `val` is delayed until it&#39;s necessary (at first access).

Of course, a `lazy val` must have some overhead - somewhere Scala must keep track of whether the value has already been evaluated and the evaluation must be synchronized, because multiple threads might try to access the value for the first time at the same time.

What exactly is the cost of a `lazy val` - is there a hidden boolean flag associated with a `lazy val` to keep track if it has been evaluated or not, what exactly is synchronized and are there any more costs?

In addition, suppose I do this:

    class Something {
        lazy val (x, y) = { ... }
    }

Is this the same as having two separate `lazy val`s `x` and `y` or do I get the overhead only once, for the pair `(x, y)`?


What&#39;s the (hidden) cost of Scala&#39;s lazy val?

Let&#39;s say I have this code:

    val string = &quot;one493two483three&quot;
    val pattern = &quot;&quot;&quot;two(\d+)three&quot;&quot;&quot;.r
    pattern.findAllIn(string).foreach(println)

I expected `findAllIn` to only return `483`, but instead, it returned `two483three`. I know I could use `unapply` to extract only that part, but I&#39;d have to have a pattern for the entire string, something like:

     val pattern = &quot;&quot;&quot;one.*two(\d+)three&quot;&quot;&quot;.r
     val pattern(aMatch) = string
     println(aMatch) // prints 483

Is there another way of achieving this, without using the classes from `java.util` directly, and without using unapply? 

Scala capture group using regex

What is the canonical way to get an empty array in Scala? `new Array[String](0)` is too verbose.

Canonical way for empty Array in Scala?

I am exploring the Scala language. One claim I often hear is that Scala has a _stronger_ type system than Java. By this I think what people mean is that:

  * `scalac` rejects certain buggy programs which `javac` will compile happily, only to cause a runtime error.
  * Certain invariants can be encoded in a Scala program such that the compiler won&#39;t let the programmer write code that violates the condition.

Am I right in thinking so?

Advantages of Scala&#39;s type system

I think there is `@tailrec` annotation to ensure the compiler will optimize a tail recursive function. Do you just put it in front of the declaration? Does it also work if Scala is used in scripting mode (for instance using `:load &lt;file&gt;` under REPL)?

What is the Scala annotation to ensure a tail recursive function is optimized?

I am working with classes and object class structure, but not at a complex level – just classes and functions, then, in one place, instantiation.

As to `__construct` and `__destruct`, please tell me very simply: **what is the purpose of constructors and destructors**?

I know the school level theoretical explanation, but i am expecting something like in real world, as in which situations we have to use them.

Provide also an example, please.

Regards


Purpose of PHP constructors

I&#39;m writing a lightweight class whose attributes are intended to be publicly accessible, and only sometimes overridden in specific instantiations.  There&#39;s no provision in the Python language for creating docstrings for class attributes, or any sort of attributes, for that matter.  What is the expected and supported way, should there be one, to document these attributes?  Currently I&#39;m doing this sort of thing:

    class Albatross(object):
        &quot;&quot;&quot;A bird with a flight speed exceeding that of an unladen swallow.

        Attributes:
        &quot;&quot;&quot;
    
        flight_speed = 691
        __doc__ += &quot;&quot;&quot;
            flight_speed (691)
              The maximum speed that such a bird can attain.
        &quot;&quot;&quot;
    
        nesting_grounds = &quot;Raymond Luxury-Yacht&quot;
        __doc__ += &quot;&quot;&quot;
            nesting_grounds (&quot;Raymond Luxury-Yacht&quot;)
              The locale where these birds congregate to reproduce.
        &quot;&quot;&quot;
    
        def __init__(self, **keyargs):
            &quot;&quot;&quot;Initialize the Albatross from the keyword arguments.&quot;&quot;&quot;
            self.__dict__.update(keyargs)

This will result in the class&#39;s docstring containing the initial standard docstring section, as well as the lines added for each attribute via augmented assignment to `__doc__`.

Although this style doesn&#39;t seem to be expressly forbidden in the [docstring style guidelines][1], it&#39;s also not mentioned as an option.  The advantage here is that it provides a way to document attributes alongside their definitions, while still creating a presentable class docstring, and avoiding having to write comments that reiterate the information from the docstring.  I&#39;m still kind of annoyed that I have to actually write the attributes twice; I&#39;m considering using the string representations of the values in the docstring to at least avoid duplication of the default values.

Is this a heinous breach of the ad hoc community conventions?  Is it okay?  Is there a better way?  For example, it&#39;s possible to create a dictionary containing values and docstrings for the attributes and then add the contents to the class `__dict__` and docstring towards the end of the class declaration; this would alleviate the need to type the attribute names and values twice.  **edit**: this last idea is, I think, not actually possible, at least not without dynamically building the entire class from data, which seems like a really bad idea unless there&#39;s some other reason to do that.

I&#39;m pretty new to python and still working out the details of coding style, so unrelated critiques are also welcome.


  [1]: http://www.python.org/dev/peps/pep-0257/

How to document class attributes in Python?

Essentially I want to do something like this:

    class foo:
        x = 4
        @property
        @classmethod
        def number(cls):
            return x

Then I would like the following to work:    

    &gt;&gt;&gt; foo.number
    4

Unfortunately, the above doesn&#39;t work. Instead of given me `4` it gives me `&lt;property object at 0x101786c58&gt;`. Is there any way to achieve the above?


How to create a read-only class property in Python?

The element looks like this:

    &lt;li class=&quot;blah active&quot;&gt; ... &lt;/li&gt;


`jQuery.attr(&#39;class&#39;)` will return both classes.
How can I get only the 1st class (&#39;blah&#39; in this case) with jQuery?


jQuery - get the first class only from a element

How can I get list of all available classes in [`CLASSPATH`][1] at runtime?  
In Eclipse IDE, you can do this by pressing &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;T&lt;/kbd&gt;.  
Is there any method in Java to get it done?

  [1]: http://docs.oracle.com/javase/tutorial/essential/environment/paths.html &quot;ClassPath&quot;

Get all of the Classes in the Classpath

I have an abstract class A that define abstract methods. This means that, for a class to be instanciable, all the abstract method have to be implemented.

I&#39;d like all my subclasses to implement a constructor with 2 ints as parameters. 

Declaring a constructor defeats my purpose, as I want the constructor defined in subclasses and I don&#39;t know anything about the implementation. Moreover I cannot declare a constructor as being abstract;

Is there a way to do this ?

__Example of what I want:__

Lets say that I am defining the API of a Matrix class. In my problem, Matrix cannot change their dimensions.

For a Matrix to be created, I need to provide its size.

Hence, I want all my implementors to provide the constructor with the size as a parameter. This constructor is motivated by the problem, not by an implementation concern. The implementation can do whatever it wants with these, provided that all the semantic of the methods are kept.

Let&#39;s say I want to provide a basic implementation of the `invert()` method in my abstract class. This method will create a new matrix with `this` inverted dimensions. More specifically, as it is defined in the abstract class, it will create a new instance of the same class as `this`, using a constructor that takes two ints. As it does not know the instance it will use reflection (getDefinedConstructor) and I want a way to waranty that I&#39;ll get it and that it will be meaningfull for the implementation.


How can I force a Constructor to be defined in all subclass of my abstract class

C# methods in interfaces are declared without using the `virtual` keyword, and overridden in the derived class without using the `override` keyword.

Is there a reason for this?  I assume that it is just a language convenience, and obviously the CLR knows how to handle this under the covers (methods are not virtual by default), but are there other technical reasons?

Here is the IL that a derived class generates:

    class Example : IDisposable {
        public void Dispose() { }
    }

    .method public hidebysig newslot virtual final 
            instance void  Dispose() cil managed
    {
      // Code size       2 (0x2)
      .maxstack  8
      IL_0000:  nop
      IL_0001:  ret
    } // end of method Example::Dispose

Notice that the method is declared `virtual` `final` in the IL. 

Why are C# interface methods not declared abstract or virtual?

I am having trouble in using inheritance with Python. While the concept seems too easy for me in Java yet up till now I have been unable to understand in Python which is surprising to me at least.

I have a prototype which follow:

    class Shape():
       def __init__(self, shape_name):
           self.shape = shape_name

    class Rectangle(Shape):
       def __init__(self, name):
           self.shape = name

In the above code how can I make an abstract method that would need to be implemented for all the subclasses?

Abstract methods in Python

What are the advantages and disadvantages of each of these?

 - interface methods
 - virtual methods
 - abstract methods

When one should choose what? What are the points one should keep in mind when making this decision?

Comparison : interface methods vs virtual methods vs abstract methods

Can I define an abstract class without adding an abstract method?

Defining an abstract class without any abstract methods

I was looking through some C# code for extending language support in VS2010 (Ook example). I saw some classes called `internal sealed class`

What do these do? Would one use them?

What is an internal sealed class in C#?

How to stop the class to be inherited by other class.

How to define sealed class in C++?

Sealed classes are described in &#39;Programming in Scala&#39;, but sealed traits are not.
Where can I find more information about a sealed trait?

I would like to know, if a sealed trait is the same as a sealed class?
Or, if not, what are the differences? 
When is it a good idea to use a sealed trait (and when not)?

What is a sealed trait?

1. Is there any class that be implemented in static class? means: 

        static class ABC : Anyclass
2. Is there any class which can be inherited in both sealed class and static class?  
means:  
 
        static class ABC : AClass {}
And

        sealed class ABC : AClass {}

May I be wrong in some extent?

Content Type	Original Author	Original Content on Stackoverflow
Question	Łukasz Lew	View Question on Stackoverflow
Solution 1 - Scala	sepp2k	View Answer on Stackoverflow
Solution 2 - Scala	Daniel C. Sobral	View Answer on Stackoverflow

Scala's sealed abstract vs abstract class

Scala Problem Overview

Scala Solutions

Solution 1 - Scala

Solution 2 - Scala

Is there any "standard" htonl-like function for 64 bits integers in C++?

JavaScript based diff utility

Attributions