
A statically typed language I'd actually want to use - andybak
http://alexgaynor.net/2010/nov/04/staticly-typed-language-id-actually-want-use/
======
apl
At this point in computing history, your language needs a stronger raison
d'être than "Python isn't statically typed, and C++ has awkward syntax!";
especially considering that 99% of all new languages never get off the ground.
I'm virtually certain that there's something out there that fits the bill.

If not, contribute to something that gets close. Go, Scala, Haskell; whatever
works. [Obviously, I do realize that building
compilers/interpreters/parsers/etc. can be fun: if that's the point, disregard
this.]

~~~
jbermudes
I'm not sure if that's true. While newer languages like python and ruby have
taken the desktop app and web app arena by storm, most system/embedded level
stuff is still done in C/C++. The usual arguments for this are that

A) The language gives you more control over memory management so you can
squeeze as much performance out of every cycle.

B) There's a ton of existing libraries and legacy code in these languages.
(Arguably one of the only reasons C++ gained any sort of traction was because
of its advertised compatibility with C)

We've put up with the "shortcomings" of C (most programmers learned or think
in OOP) and C++ (abundance of so-called gotchas and quirky areas of the
language, Alan Kay's famous quote about C++'s OOP) and it still leaves much to
be desired in my opinion. Java was an interesting development, but its GC
disqualifies it for many systems or high-performance programming until
recently. I don't have much experience with obj-c but it looks like another
contender in this space as well.

There does seem to be a desire for a true "heir" to C as evidenced by D,
Google's Go, and Mozilla's Rust. In fact, I'd be happy if someone just took
the Java language and stripped out the GC instead of trying to restrict myself
to a "safe" subset of C++.

I'm rooting for all of these projects because I'd love to see some of of the
benefits of modern programming language theory brought to this sector of
programming. This is an area where when there's competition everybody wins.

~~~
MichaelGG
<http://www.bitc-lang.org/> <http://www.ats-lang.org/>

Those might show promise as nice languages with speed comparable to C.

------
jbellis
C# is a statically typed language that gets a lot right (and not
coincidentally also borrows a ton from Python). As mainstream languages go
it's probably the best out there; too bad the Mono compiler is usually a
version behind and the VM does not have competitive performance with either
Windows CLR or Linux JVM.

~~~
MichaelGG
Except C#'s still quite verbose. Doubly so if you heavily use generics and
functional programming. You just aren't as free in the style of code that
works.

For one sample point, I rewrote one of FreeSWITCH's C modules in C# and F#.
The F# version had 1/20th the number of type annotations.

~~~
fertel
The c# version is pretty concise. And since 3.0 with implicitly typed local
variables, its gotten less verbose.

var result = seq.Where(a=>a %3==0).Select(a=>a*a);

~~~
MichaelGG
Yea, but try moving the predicate to a local function, and you get:

Func<int, bool> pred = a => a %3 == 0.

Mix in more complex types (say a dictionary with a tuple in it), and it starts
getting pretty verbose.

------
swannodette
Talking about static typing without investigating something like Haskell (as
mentioned by others) seems limiting, particularly since Guido picked up a
couple of things from Haskell like the list comprehensions presented in this
post.

And then you'll discover that Haskell's type system is limited as well. Learn
some Qi - <http://www.lambdassociates.org/qilisp.htm>.

------
rwmj
Those who don't know type inference are destined to reinvent it ... badly.

~~~
raganwald
True, but Matz didn't know a lot of things about programming languages and
luckily for me, he didn't care and reinvented them anyways.

------
tomjen3
Haskell could, trivially, do the first example shorter than python.

~~~
fogus
I'm no Haskell expert, but it's a couple chars shorter AND solves the premise
of the entire post.

    
    
        [x*x | x <- s, x `mod` 3 == 0]
    

And the function definition doesn't need all of the type clutter:

    
    
        let playWithSeq s = [x*x | x <- s, x `mod` 3 == 0]
        
        playWithSeq [0..10]
        -- [0,9,36,81]

~~~
kleiba
Just curious: would anyone care to show me how something like that would look
in Clojure?

~~~
fogus

        (for [x s :when (== 0 (mod x 3))] (* x x))

~~~
nickik
why do you use ==? You should use =.

~~~
fogus
I use `==` when I know that I'm comparing numbers.

------
jrockway
C++ is statically typed? I guess if you omit the five cast operators and don't
throw exceptions and don't allocate any heap, you can sort of reason about
type safety. Sort of.

~~~
gjm11
It's _statically_ typed (variables have types), _manifestly_ typed (you have
to declare them), but not type- _safe_ (won't treat values of one type as if
they're of another).

~~~
eru
That seems to be the worst of all words.

------
scott_s
I use C++, and I have a variety of utility functions defined. To do his task,
first I already would have the following defined:

    
    
      template <class Pred, class Sequence>
      Sequence filter(Pred p, const Sequence& in)
      {
        Sequence out; 
        for (typename Sequence::const_iterator i = in.begin(); i != in.end(); ++i) {
          if (p(*i)) {
            out.insert(out.end(), *i);
          }
        }
        return out;
      }
    

And then I would do:

    
    
      bool is_div3(const int n)
      {
        return n % 3;
      }
    
      // in another scope
    
      result = filter(is_div3, seq);
    

It's not how most people use C++, but my recent work has involved manipulating
parse trees. I find the most natural way to do this is recursively using
functional techniques, so I've built up a small set of functionaly inspired
utility functions
(<https://github.com/scotts/cellgen/blob/master/src/utility.h>). C++0x will
let me use an anonymous function instead of having to define a function (or
function object) for my predicate.

------
jimwise
Looks like scala to me:

    
    
      def playwith_seq[A] (seq : Iterable[A]) : List[A]
        for (x <- seq if x % 3 == 0) yield x * x

------
auxbuss
I really wish that Fantom <http://fantom.org/> received more love.

~~~
paulsmith
Can you elaborate on why? What is it you like about Fantom? Why should I check
it out?

~~~
KingOfB
Just found: <http://fantom.org/doc/docIntro/WhyFantom.html>

Nice language syntax wise, seems pretty nice. Prime unique feature is the
ability to run on a JVM or the .NET runtime. It also provides a base layer of
objects to replace java.io/util etc.

I'm not to clear if it maintains JVM or .NET interoperability. That would be
interesting if it could call both JVM and .NET code.

------
viraptor
OOC, assuming `x` implements `List<Int>` (sorry for syntax mistakes, don't
have a compiler here). So yes - generics and type safety included:

    
    
        x = x filter(func (i:Int)->Bool {i%3==0}) map(func (i:Int)->Int {i*i})
    

Edit: missed the multiplication

------
efsavage
"A good example is "give me the square of all the items in this sequence who
are divisible by 3""

A good example? Really? You get paid to write stuff like that? Because I
don't. If you're going to promote a language as a better solution, try solving
real problems.

What happens when there's a string in the sequence? The C++ example solved
that, why didn't your code?

~~~
eru
Haskell also would solve it, by outlawing the occurence of strings at compile
time.

