4 ms·
I think you are underestimating the power of statically typed generics when using a language with a decent type system. In your example: let r = f([...])
by the_af 12y ago
I think you are underestimating the power of statically typed generics when using a language with a decent type system.
In your example:
let r = f([...])
assert(r, correct_value)
assert(r.type, correct_type)
This doesn't test everything we need to know. For example, the following function passes your asserts (in pseudocode):
f(a_list):
if (a_list instanceof List[Int]):
return 0
else
... other stuff ...
whereas the original, statically typed version of the function with signature
f :: [a] -> a
cannot ever do that. This is a profound insight. It cannot return zero "in the case of a list of ints". It doesn't know anything about its input if you don't tell it. And you shouldn't tell it, either, unless you have a very specific reason to do so.
Also, in programming language with decent static typing (that is, not Java or C++; I wouldn't know about Swift to comment), there is a huge additional difference between the two functions:
I can promise you my function doesn't write to disk, doesn't output to the screen, etc. You cannot promise the same with your function. Your function might work when it has access to the disk, as in your test environment, but fail on production where it does not. Ok, so you inspect the code to make sure your function (or any function it calls) don't do I/O. But I don't have to do this, because the type system tells me my function is side-effect free.
So now you have some pretty powerful assurances in favor of my statically typed function:
- It doesn't perform side effects. I don't know about the dynamic function.
- It doesn't produce any value out of thin air; it must work with the list I passed it, because it doesn't know anything else. It doesn't know how to create new values.
- As a consequence of the above, there are fewer possible implementations of my function than of yours, excluding no-ops.
This is a kind of testing "for free" that you don't have with dynamically typed languages. And it is pretty powerful.
Yes, you can cover a lot of cases with unit tests in a dynamic language, but why not let the computer do the boring work for you? It's what computers are there for. Focus on the interesting test cases instead.
- owensd 12y ago> I can promise you my function doesn't write to disk, doesn't output to the screen, etc. You cannot promise the same with your function. WHAT?! Your type signatures have absolutely no assurances with regards to side effects. They cannot even make a claim that the function is thread safe, let alone that it doesn't write to disk our output to the screen. I'm baffled at why you think that is true: int foo(int bar): // network call here // write a log to disk here // change a global value here return happy_int And you are woefully mistaken about about this claim as well: "it must work with the list I passed it, because it doesn't know anything else." Many languages that actually have good generic type systems allow for type specialization. That means that I can provide different implementations for different types. So in the contrived example of you doing something completely different with my list of ints in the dynamic version is completely possible in many statically typed languages too.
- the_af 12y ago> Your type signatures have absolutely no assurances with regards to side effects. [example] This might be true for Swift (which I suspect it is), but it's not true in the wider ecosystem of statically typed languages. A language with a type system with allows controlling side effects, such as Haskell, does indeed make such assurances. In Haskell, for a function to make network calls or output to disk, it must live within the IO monad (which can be seen by its type!). I'm discussing Haskell here because I'm more familiar with it, but there are alternative mechanisms in other languages. Compare: f :: [a] -> a -- I promise you this function doesn't do any I/O with f :: [a] -> IO a -- this function may do I/O This is a powerful assurance right there! Of course, Haskell programs as a whole must live in the IO monad (a program without any kind of I/O is useless). But you're encouraged to write as much as the program as you can as pure functions, which can then be tested (unit tested or whatever you prefer) with the very useful knowledge that they cannot do I/O. Next, generics systems. Languages with OOP and generics, such as Scala and, I suspect, Swift, let you do all sorts of naughty things within generic functions. But doing generic programming like in Haskell is way safer in this regard. No, you are not allowed specialize the type in f :: [a] -> a. Doing so would be unsafe. So let's go back to my claim: the above function cannot do anything else but produce a value out of the list I passed it. It doesn't know how to produce something else out of thin air. It cannot "inspect" the value of its type; it has no unsafe "instanceOf" operator. It cannot even apply any operation to the values of the list (except of course list operations), since I didn't declare the generic type had any. This is a very powerful assurance that a dynamic language cannot make, and one that simplifies the tests I have to write. Because of this property, you are encouraged to write, whenever possible, functions that are as generic as possible. Sometimes you can't, but then you'll specify as little as possible, such as: sumAll :: Num a => [a] -> a -- "a" is a number with operations +, -, etc. And then you'll have additional operations available for your type a, but not as many as if you were writing this with a dynamically typed language with no assurances at all! Once you realize this, you'll start thinking of generic programming as a tool that constrains the kind of errors you can make (because you have less choices to make, so to speak). And this has a huge impact on testing! > So in the contrived example of you doing something completely different with my list of ints in the dynamic version is completely possible in many statically typed languages too. Of course, many statically typed languages are no better than dynamic languages in this regard. I was talking about decent type systems. Not sure where you'll place Swift, though. Even with languages which allow instanceOf checks, such as Java and I'm willing to bet most OO languages, the practice is frowned upon and wouldn't pass a code review. Unless, of course, there was no other way to solve the problem, but this really would limit the usefulness of generic programming.