Is there a way to figure out the country name just by looking at an IP address? I mean, do countries have specific ranges of IP addresses? For example, Australia can have IP addresses only in the range of `123.45.56.89 - 231.54.65.98` (just an example)

Identifying country by IP address

I am trying to compile 2 classes in C++ with the following command:

`g++ Cat.cpp Cat_main.cpp -o Cat`

But I receive the following error:

`Cat.cpp:10:10: error: variable ‘Cat Joey’ has initializer but incomplete type`

Could someone explain to me what this means? What my files basically do is create a class (`Cat.cpp`) and create an instance (`Cat_main.cpp`). Here is my source code:

**Cat.cpp:**

    #include &lt;iostream&gt;
    #include &lt;string&gt;
    
    class Cat;
    
    using namespace std;
    
    int main()
    {
    	Cat Joey(&quot;Joey&quot;);
    	Joey.Meow();
    
    	return 0;
    }

**Cat_main.cpp:**

    #include &lt;iostream&gt;
    #include &lt;string&gt;
    
    using namespace std;
    
    class Cat
    {
    	public:
    		Cat(string str);
    	// Variables
    		string name;
    	// Functions
    		void Meow();
    };
    
    Cat::Cat(string str)
    {
    	this-&gt;name = str;
    }
    
    void Cat::Meow()
    {
    	cout &lt;&lt; &quot;Meow!&quot; &lt;&lt; endl;
    	return;
    }

C++ variable has initializer but incomplete type?

I&#39;ve studied scala for several months, but still at the beginner level. Now I found I have huge trouble with functional programming and scala&#39;s type system. 

I tried finding some documents and blogs, but I can&#39;t understand most of them(especially type-system ones). So I&#39;m looking for some small and good scala projects that I can read the sources to learn.

Could you please recommend me some?

Small and good scala projects to learn scala -- especially functional programming and type system

I've studied scala for several months, but still at the beginner level. Now I found I have huge trouble with functional programming and scala's type system.
I tried finding some documents and blogs, but I can't understand most of them(especially type-system ones). So I'm looking for some small and good scala projects that I can read the sources to learn.
Could you please recommend me some?

I&#39;m still fairly new to Scala, and I&#39;m discovering new and interesting ways for doing things on an almost daily basis, but they&#39;re not always sensible, and sometimes already exist within the language as a construct and I just don&#39;t know about them.  So, with that preamble, I&#39;m checking to see if a given string is comprised entirely of digits, so I&#39;m doing:

    def isAllDigits(x: String) = x.map(Character.isDigit(_)).reduce(_&amp;&amp;_)

is this sensible or just needlessly silly?  It there a better way?  Is it better just to call x.toInt and catch the exception, or is that less idiomatic?  Is there a performance benefit/drawback to either?

How to check to see if a string is a decimal number in Scala

In Java, reading environment variables is done with `System.getenv()`.

Is there a way to do this in Scala?

How to read environment variables in Scala

how to sort a list in Scala by two fields, in this example I will sort by lastName and firstName?

    case class Row(var firstName: String, var lastName: String, var city: String)

    var rows = List(new Row(&quot;Oscar&quot;, &quot;Wilde&quot;, &quot;London&quot;),
                    new Row(&quot;Otto&quot;,  &quot;Swift&quot;, &quot;Berlin&quot;),
                    new Row(&quot;Carl&quot;,  &quot;Swift&quot;, &quot;Paris&quot;),
                    new Row(&quot;Hans&quot;,  &quot;Swift&quot;, &quot;Dublin&quot;),
                    new Row(&quot;Hugo&quot;,  &quot;Swift&quot;, &quot;Sligo&quot;))

    rows.sortBy(_.lastName)


I try things like this 

    rows.sortBy(_.lastName + _.firstName)

but it doesn&#39;t work. So I be curious for a good and easy solution.

How to sort a list in Scala by two fields?

If I have a `List[Option[A]]` in Scala, what is the idiomatic way to filter out the `None` values?

One way is to use the following:

    val someList: List[Option[String]] = List(Some(&quot;Hello&quot;), None, Some(&quot;Goodbye&quot;))
    someList.filter(_ != None)

Is there a more &quot;idiomatic&quot; way? This does seem pretty simple.


How to filter None&#39;s out of List[Option]?

I have two strings in scala and I want to find out, if the bigger string (`needle`) contains a smaller string (`haystack`).

What I found is doing it with regexps and matches like this ([from this question][1]):

`needle.r.pattern.matcher(haystack).matches`

which is (1) grossly overcomplicated for such a simple problem, but more importantly, (2) doesn&#39;t work for me, because

`&quot;needle&quot;.r.pattern.matcher(&quot;Finding needle in haystack&quot;).matches`

returns

`Boolean = false`

  [1]: https://stackoverflow.com/questions/3021813/how-to-check-whether-a-string-fully-matches-a-regex-in-scala

What is the idiomatic scala way of finding, if a given string contains a given substring?

I&#39;m wondering whether/what difference between [First Class Function](http://en.wikipedia.org/wiki/First-class_function) and [High Order Function](http://en.wikipedia.org/wiki/Higher-order_function).

  I read through those two wiki pages and they looks rather similar.
  If they talking about same, why need two terminologies?

  Tried to google but have not found any useful thing.

  



Any difference between First Class Function and High Order Function

What is the most idiomatic way to achieve something like the following, in Haskell:

    foldl (+) 0 [1,2,3,4,5]
    --&gt; 15

Or its equivalent in Ruby:

    [1,2,3,4,5].inject(0) {|m,x| m + x}
    #&gt; 15

Obviously, Python provides the `reduce` function, which is an implementation of fold, exactly as above, however, I was told that the &#39;pythonic&#39; way of programming was to avoid `lambda` terms and higher-order functions, preferring list-comprehensions where possible. Therefore, is there a preferred way of folding a list, or list-like structure in Python that isn&#39;t the `reduce` function, or is `reduce` the idiomatic way of achieving this?



What is the &#39;pythonic&#39; equivalent to the &#39;fold&#39; function from functional programming?

According to the wikipedia entry for [side effect][1], raising an exception constitutes a side effect. Consider this simple python function:

    def foo(arg):
        if not arg:
            raise ValueError(&#39;arg cannot be None&#39;)
        else:
            return 10

Invoking it with ``foo(None)`` will always be met with an exception. Same input, same output. It is referentially transparent. Why is this not a pure function?

  [1]: http://en.wikipedia.org/wiki/Side_effect_%28computer_science%29

Why is the raising of an exception a side effect?

I&#39;m learning R recently and confused by two function: ``lapply``and ``do.call``. It seems that they&#39;re just similar to ``map`` function in Lisp. But why are there two functions with such a different name? Why doesn&#39;t R just use a function called ``map``?

What&#39;s the difference between lapply and do.call?

The [Haskell Wiki](http://en.wikibooks.org/wiki/Haskell/Existentially_quantified_types#Explaining_the_term_existential) does a good job of explaining how to use existential types, but I don&#39;t quite grok the theory behind them.

Consider this example of an existential type:

    data S = forall a. Show a =&gt; S a      -- (1)

to define a type wrapper for things that we can convert to a `String`. The wiki mentions that what we *really* want to define is a type like

    data S = S (exists a. Show a =&gt; a)    -- (2)

i.e. a true &quot;existential&quot; type - loosely I think of this as saying &quot;the data constructor `S` takes any type for which a `Show` instance **exists** and wraps it&quot;. In fact, you could probably write a GADT as follows:

    data S where                          -- (3)
        S :: Show a =&gt; a -&gt; S

I haven&#39;t tried compiling that, but it seems as though it should work. To me, the GADT is obviously equivalent to the code (2) that we&#39;d like to write.

However, it&#39;s completely not obvious to me why (1) is equivalent to (2). Why does moving the data constructor to the outside turn the `forall` into an `exists`?

The closest thing I can think of are [De Morgan&#39;s Laws](http://en.wikipedia.org/wiki/De_Morgan&#39;s_laws#Extensions) in logic, where interchanging the order of a negation and a quantifier turns existential quantifiers into universal quantifiers, and vice-versa:

    &#172;(∀x. px) ⇔ ∃x. &#172;(px)

but data constructors seem to be a totally different beast to the negation operator.

What is the theory that lies behind the ability to define existential types using `forall` instead of the non-existent `exists`?

What&#39;s the theoretical basis for existential types?

I have seen several sources echo the opinion that &quot;Haskell is gradually becoming a dependently-typed language&quot;. The implication seems to be that with more and more language extensions, Haskell is drifting in that general direction, but isn&#39;t there yet.

There are basically two things I would like to know. The first is, quite simply, what does &quot;being a dependently-typed language&quot; actually _mean_? (Hopefully without being too technical about it.)

The second question is... what&#39;s the drawback? I mean, people know we&#39;re heading that way, so there must be some advantage to it. And yet, we&#39;re not there yet, so there must be some downside stopping people going all the way. I get the impression that the problem is a steep increase in complexity. But, not really understanding what dependent typing is, I don&#39;t know for sure.

What I _do_ know is that every time I start reading about a dependently-typed programming language, the text is utterly incomprehensible... Presumably that&#39;s the problem. (?)


Why not be dependently typed?

What is the difference between **static** and **dynamic** programming languages? I know that it is all about type systems, but I’m looking for more clear clarifications.

Difference between static and dynamic programming languages

I know that Java&#39;s type system is unsound (it fails to type check constructs that are semantically legal) and undecidable (it fails to type check some construct).

For instance, if you copy/paste the following snippet in a class and compile it, the compiler will crash with a `StackOverflowException` (how apt). This is undecidability.

    static class ListX&lt;T&gt; {}
    static class C&lt;P&gt; extends ListX&lt;ListX&lt;? super C&lt;C&lt;P&gt;&gt;&gt;&gt; {}
    ListX&lt;? super C&lt;Byte&gt;&gt; crash = new C&lt;Byte&gt;();

Java uses wildcards with type bounds, which are a form of use-site variance. C# on the other hand, uses declaration site variance annotation (with the `in` and `out` keywords). It is known that declaration-site variance is weaker than use-site variance (use-site variance can express everything declaration-site variance can, and more -- on the down side, it&#39;s much more verbose).

So my question is: Is C# type system sound and decidable? If not, why?

Small and good scala projects to learn scala -- especially functional programming and type system

Scala Problem Overview

Scala Solutions

C++ variable has initializer but incomplete type?

Identifying country by IP address

Attributions