[david-given]

I had actually gone and looked for Lua static type checkers. Some exist, but none that'll work with Lua 5.2.

I had a really hilarious bug today where under some circumstances all the text in the display would be replaced by numbers. Small integers, each placed where the word should be.

What had happened is that I'd added a layer of indirection; where previously, after line wrapping, the data structure for a rendered paragraph was an array of pointers to the word objects, now it was an array of indices into the paragraph's word array. And I'd forgotten about one particular exotic code path. Lua was seeing the array of indices, automatically casting the ints to strings, and then using those strings instead of the word data itself...

Static types would have made this bug impossible.

...way back when, there was a really nice and thoroughly obscure language called Strongtalk; it was a Smalltalk 80 clone with optional strict types. You could annotate your classes and methods with type information. If it was there, it would be checked; if it wasn't, you got the traditional behaviour. The JIT knew about the type information and could use it to produce really fast code. It combined the ultimate dynamic language with an expressive static type system (complete with parametric polymorphism).

It was open sourced in 2006 and sank without trace. Sigh.

[Jach]

For your example bug I think you're wrong that static types would have made the bug impossible. What you need is strong type checking and a lack of auto-conversion. For example, in Java, this compiles:

    int[] bodies = {1, 2, 3};
    for (int body : bodies) {
        String formatted_body = "<p>" + body + "</p>";
        callMethodWithStrArg(formatted_body);
    }

And if in this hypothetical case it was previously a `String[] bodies` and a `String body`, I bet a lot of programmers would use an auto-refactoring tool because "static types and auto-refactoring go together for being confident in changes like apples and pie" and I bet the error wouldn't have been noticed even at review time. God help you if you're using a static language without generics that has implicit type conversions. In Python, though, this raises an error:

    bodies = [1, 2, 3]
    for body in bodies:
      formatted_body = '<p>' + body + '</p>'

The error is: "TypeError: cannot concatenate 'str' and 'int' objects".

Dynamically typed languages still have types.

[david-given]

That's very true (and I really wish that Lua didn't do implicit type conversion of numbers to strings --- it's a major wart on an otherwise very nice language).

I had totally forgotten that Java does it too, despite having done `""+i` lots of times as a cheap and easy and evil way to convert numbers to strings.

...I am currently rewriting a big chunk of the primary data storage to use immutable data structures, because it makes implementing Undo easier. I am having to fight the urge to redo it all in Haskell.

[alepper]

You might find (Typed) Racket interesting - it offers the features you mention, and is a delight to work with.