4 ms·

I guess this means in large application you should always annotate your types. It should be enforced with a linter.

• mikeash 11y ago
  Not at all. Most code doesn't suffer from this problem. It's a pathological case.
  • catnaroek 11y ago
    The code that triggered this long type inference loop seems pretty normal. It's not like Damas-Milner's pathological case (deeply nested instantiations of type schemas), which is genuinely uncommon.
    • mikeash 11y ago
      Nested collection literals aren't very common. It certainly doesn't justify requiring something like `let x = f()` to have a type annotation.
• geophile 11y ago
  I've been using Swift for a couple of months now. While I appreciate that type inference makes for more concise and cleaner code, it also impedes code comprehension. The absence of explicit types forces me, reading an unfamiliar piece of code, to work harder to figure out the type of each expression. This is especially true for expressions of type Optional<T>. (But at least each expression has a type. While I love Python and have used it for many years, I don't like the uncertainty about types.)
  • mpweiher 11y ago
    In fact, this documentation effect is the only positive effect of static typing that has actual scientific support, unlike the supposed and oft-claimed safety/correctness benefits. So while type-inference is a neat idea in theory, maybe it's not such a good idea in practice.
    • geophile 11y ago
      I'm not sure why you say the safety/correctness benefits are not real. In a large code base, with multiple developers, it is easy to get someone misusing a function, passing one type when a different one is expected. I know that some people in the python world recommend unit testing to guard against this sort of thing, but to me, that is a poor substitute for static type checking.
  • mikeash 11y ago
    If you're using Xcode, you can option-click a variable and (if Xcode's indexing is working, which is not a certainty) it'll show you the inferred type for that variable. This can help when looking at some new code and trying to figure out what all the bits really are.
    • geophile 11y ago
      Yeah, I know, but it's been unreliable.