5 ms·

I think the interesting point here is that Haskell provides such a high static assurance out of the box that what you write is correct that this can happen. You

I think the interesting point here is that Haskell provides such a high static assurance out of the box that what you write is correct that this can happen. You'd never hear of a ruby programmer releasing a gem without trying it.

calpaterson 14y ago
With the serious caveat that the program you are writing must only be vulnerable to the kind of errors which Hindley-Milner can show aren't present. ie: no IO, no non-deterministic concurrency, no non-total functions, etc, etc.
- danieldk 14y ago
  In addition to that, it's often difficult to predict the runtime properties of a Haskell program. Due to it's laziness, one can often run into space leaks where thunks are not evaluated (yet): http://blog.ezyang.com/2011/05/space-leak-zoo/ http://blog.ezyang.com/2011/05/space-leak-zoo/
- jeffdavis 14y ago
  You forgot the bug: "doesn't do what you want, but does it perfectly".
- dwc 14y ago
  I wish this caveat were attached every time someone mentioned the "once it compiled it worked first time" bit. Not because there's no truth in the works-if-compiles idea, but because getting smug about it is sure to bite you in the ass sooner rather than later. Now that I've said that, I'll state what should be obvious (and probably is to many/most): failure to compile due to type errors is a big clue I am thinking about something incorrectly or incompletely. It's not like I just twiddle stuff until it compiles. I look at it and say, "Duh! That was dumb of me!" It's like using Unit Analysis working out a long physics problem... errors in your thinking about it are very likely to show up in unit analysis. The chance of you coming up with a bogus equation that passes unit analysis is pretty small. When it doesn't pass, you have a good look and find where you went wrong rather than merely tweak.
  - scarmig 14y ago
    That little connection sent me on a Google quest. Interesting paper along those lines: "Types for Units of Measure: Theory and Practice": http://research.microsoft.com/en-us/um/people/akenn/units/CEFP09TypesForUnitsOfMeasure.pdf http://research.microsoft.com/en-us/um/people/akenn/units/CE...
    - dwc 14y ago
      Oh! I am so glad you looked that up. Thank you!
- viscanti 14y ago
  That's still a significant portion of the code-base though. In almost every other language you'd have to write tests to accomplish the same thing. It's certainly possible to compose functions that return something of the correct type but not the correct value (in fact, that's trivial to do). Those should be easier to spot/debug/test than the errors the type system checks for you.
dododo 14y ago
it's a matter of how much you put into the type system: add :: Integer -> Integer -> Integer add x y = x * y in any moderately complicated code, you need to test. types only go so far.
- Peaker 14y ago
  Opaque types like "Integer" don't give a lot of assurance, so either you get a stronger type system (Agda-style) or you have to test. But complicated code may work with non-opaque types, and so it could still be reliable without tests.
- sold 14y ago
  To supplement "it's a matter of how much you put into the type system": This error can be caught if you put units of measure into type system. F# can do this, and addition function will have type int<a> -> int<a> -> int<a> while multiplication int<a> -> int<b> -> int<a * b>; for example, int<m/s> -> int<s> -> int<m> might be a function taking velocity and time, and returing distance. I think Haskell has libraries for this. Similarily, add x y = x - y would be detected if (-) required a group, while (+) worked for monoids only. However, it would be rather hard to create a type system detecting a typo in: quadruple x = 3 * x
- JadeNB 14y ago
  > it's a matter of how much you put into the type system: It's also a matter of how much polymorphism you have. There are lots of functions `Integer -> Integer`; there is only one total function `a -> a`. (This is the parametricity theorem mentioned by sanxiyn in http://news.ycombinator.com/item?id=4215055 http://news.ycombinator.com/item?id=4215055 .)
  - cwzwarich 14y ago
    There are lots of different functions `a -> a`. One could take a few cycles to complete, whereas others could take a day or week to complete. One could use a few bytes of space, whereas others could use megabytes or gigabytes.

calpaterson 14y ago

With the serious caveat that the program you are writing must only be vulnerable to the kind of errors which Hindley-Milner can show aren't present. ie: no IO, no non-deterministic concurrency, no non-total functions, etc, etc.

danieldk 14y ago
In addition to that, it's often difficult to predict the runtime properties of a Haskell program. Due to it's laziness, one can often run into space leaks where thunks are not evaluated (yet): http://blog.ezyang.com/2011/05/space-leak-zoo/ http://blog.ezyang.com/2011/05/space-leak-zoo/
jeffdavis 14y ago
You forgot the bug: "doesn't do what you want, but does it perfectly".
dwc 14y ago
I wish this caveat were attached every time someone mentioned the "once it compiled it worked first time" bit. Not because there's no truth in the works-if-compiles idea, but because getting smug about it is sure to bite you in the ass sooner rather than later. Now that I've said that, I'll state what should be obvious (and probably is to many/most): failure to compile due to type errors is a big clue I am thinking about something incorrectly or incompletely. It's not like I just twiddle stuff until it compiles. I look at it and say, "Duh! That was dumb of me!" It's like using Unit Analysis working out a long physics problem... errors in your thinking about it are very likely to show up in unit analysis. The chance of you coming up with a bogus equation that passes unit analysis is pretty small. When it doesn't pass, you have a good look and find where you went wrong rather than merely tweak.
- scarmig 14y ago
  That little connection sent me on a Google quest. Interesting paper along those lines: "Types for Units of Measure: Theory and Practice": http://research.microsoft.com/en-us/um/people/akenn/units/CEFP09TypesForUnitsOfMeasure.pdf http://research.microsoft.com/en-us/um/people/akenn/units/CE...
  - dwc 14y ago
    Oh! I am so glad you looked that up. Thank you!
viscanti 14y ago
That's still a significant portion of the code-base though. In almost every other language you'd have to write tests to accomplish the same thing. It's certainly possible to compose functions that return something of the correct type but not the correct value (in fact, that's trivial to do). Those should be easier to spot/debug/test than the errors the type system checks for you.

dododo 14y ago

it's a matter of how much you put into the type system: add :: Integer -> Integer -> Integer add x y = x * y in any moderately complicated code, you need to test. types only go so far.

Peaker 14y ago
Opaque types like "Integer" don't give a lot of assurance, so either you get a stronger type system (Agda-style) or you have to test. But complicated code may work with non-opaque types, and so it could still be reliable without tests.
sold 14y ago
To supplement "it's a matter of how much you put into the type system": This error can be caught if you put units of measure into type system. F# can do this, and addition function will have type int<a> -> int<a> -> int<a> while multiplication int<a> -> int<b> -> int<a * b>; for example, int<m/s> -> int<s> -> int<m> might be a function taking velocity and time, and returing distance. I think Haskell has libraries for this. Similarily, add x y = x - y would be detected if (-) required a group, while (+) worked for monoids only. However, it would be rather hard to create a type system detecting a typo in: quadruple x = 3 * x
JadeNB 14y ago
> it's a matter of how much you put into the type system: It's also a matter of how much polymorphism you have. There are lots of functions `Integer -> Integer`; there is only one total function `a -> a`. (This is the parametricity theorem mentioned by sanxiyn in http://news.ycombinator.com/item?id=4215055 http://news.ycombinator.com/item?id=4215055 .)
- cwzwarich 14y ago
  There are lots of different functions `a -> a`. One could take a few cycles to complete, whereas others could take a day or week to complete. One could use a few bytes of space, whereas others could use megabytes or gigabytes.