What about dynamic language + runtime type checking + (nearly) 100% test coverage? You get the flexibility of a dynamic language and the safety of a static type language (in fact you get more, since runtime type checking is more powerful).
What about dynamic language + runtime type checking + (nearly) 100% test coverage? You get the flexibility of a dynamic language and the safety of a static type language (in fact you get more, since runtime type checking is more powerful).
Yet it does not mean that the code is correct for any definition of "correct" other than "passes the associated test suite." One unit test makes a line of code covered. It does not make the domain of inputs covered - 100% coverage does not mean that corner cases have been handled correctly - or that they have been considered at all. Again, all it means is that every line of code was executed at least once.
There are useless tests:
def test167 [
if [ val == foo(8); return true]
then return passed
else return failed
endif ]
enddefOf course, this doesn't really substitute for a type system either.
Static types also help in situations other than testing. For example, you can use "guardrail programming" to be much more liberal when refactoring things: want to change a function signature? Just change it and the compiler will point out what other parts of the code need to be updated. This is even if you haven't written a test suite yet or are doing big changes that invalidate the old test suite.
That said, I think the perfect world would be one that lets you mix dynamic and static typing in a single program (some things are hard to verify statically, but would be nice if we could at least express them as types) but I think we are still a way off that being a practical alternative.
Don't misunderstand me: tests are good. But language syntax that makes some bugs impossible is also good.
Of course, that is probably just saying that there should be documentation.
function foo(f){
return [f(["1", "2", "3"]), f([1,2,3])];
}
function length(xs){
return xs.length;
}
foo(length);
Anyone can see what this Javascript program doing but to write the Haskell equivalent you would need to understand higher-rank-types and enable the corresponding language extension, which gets in the way of beginners.> I think this is because there is yet to be a language that makes expressing complex types easy.
Since I'm obliged to use a dynamic language (JavaScript) I'm looking for a solution in it. And in JavaScript is really easy to express a complex type, say "the set of all the even integers between 2 and 14 but 10", using runtime checking to enforce the constraints. Is it simple in Haskell to define such a set in its type system?
sealed trait Even[N <: Nat]
object Even {
implicit object zero extends Even[_0]
implicit def evenSS[N <: Nat](implicit e: Even[N]) = new Even[S[S[N]]]{}
}
sealed trait EvenAndBetweenTwoAndFourteenAndNotTen
object EvenAndBetweenTwoAndFourteenAndNotTen {
implicit def forN[N <: Nat](implicit e: Even[N], le2: Le[_2, N], le14: Le[N, _14]) =
new EvenAndBetweenTwoAndFourteenAndNotTen[N]{}
implicit object interfere10 extends EvenAndBetweenTwoAndFourteenAndTen[_10]
}
Like I said, it's cumbersome, but there's nothing actually complicated about writing this, it's just boilerplate to represent it in the type system.On the other hand, in Idris or the other languages mentioned in the article, you should be able to write that kind of constraint at the type level just as easily as you can at the value level. That's where it gets really exciting.
Here's an example in rust[0]. If the `print_bare` method relies on only receiving even numbers between 2 and 14 excluding 10, then it is buggy, because it isn't checking its input, but the `print_tagged` method is correct without needing to check!
[0]: http://is.gd/9uHrc7
Its true that to make that a proper, statically-enforced type in Haskell takes some complexity, but if you aren't willing to do that, you could make it a runtime-enforced constraint on a statically-enforced type of integers as easily in Haskell as, in JavaScript, you could make it a runtime-enforced constraint on a value that is not statically enforced to be anything more specifically than a valid JS value.
http://hackage.haskell.org/package/base-4.7.0.1/docs/Data-Dy...