5 ms·

I think method signatures are part of application/typesystem design and should not be inferred. Explicitly provided types are a feature. Inferred/auto type sign

I think method signatures are part of application/typesystem design and should not be inferred. Explicitly provided types are a feature. Inferred/auto type signatures are "necessariy evil" to reduce boilerplate type declarations around code. While codeblocks `fn1(fn2(), fn3)` and `var r1 = fn2(); var r2 = fn3; fn1(r1, r2)` are more or less identical, unless you have static type definitions for these methods you start having a very bad time inferring what types are being passed around. Consider typical python wrapper library with liberal use of *kwargs to pass non-wrapped arguments down to wrappee. Those arguments and their types (as much as they are available in python, you get the idea) are entirely missing from wrapper code and make changes at call site pretty difficult

valenterry 4y ago
> unless you have static type definitions for these methods you start having a very bad time inferring what types are being passed around. It doesn't matter if the types are annotated explicitly or inferred. The amount of information is 100% the same. The IDE could just fill in the types _exactly_ in the same way as they would look like when annotated by hand - maybe just with a different color. IntelliJ does this quite well, see for instance: https://i.stack.imgur.com/tiqjc.png https://i.stack.imgur.com/tiqjc.png This is not a guess. This is the real types. There is literally no difference in the behaviour/semantics of the code. > Consider typical python wrapper library with liberal No, because python is not statically typed. You can't compare that.
- dllthomas 4y ago
  > It doesn't matter if the types are annotated explicitly or inferred. The amount of information is 100% the same. Explicit offers the opportunity for narrowing, comments, and sometimes choice of names. Otherwise, yes.
  - valenterry 4y ago
    Good points!
wtetzner 4y ago
I like OCaml's approach, where you write types in module signatures, but don't need to put them in the implementation.

valenterry 4y ago

> unless you have static type definitions for these methods you start having a very bad time inferring what types are being passed around. It doesn't matter if the types are annotated explicitly or inferred. The amount of information is 100% the same. The IDE could just fill in the types _exactly_ in the same way as they would look like when annotated by hand - maybe just with a different color. IntelliJ does this quite well, see for instance: https://i.stack.imgur.com/tiqjc.png https://i.stack.imgur.com/tiqjc.png This is not a guess. This is the real types. There is literally no difference in the behaviour/semantics of the code. > Consider typical python wrapper library with liberal No, because python is not statically typed. You can't compare that.

dllthomas 4y ago
> It doesn't matter if the types are annotated explicitly or inferred. The amount of information is 100% the same. Explicit offers the opportunity for narrowing, comments, and sometimes choice of names. Otherwise, yes.
- valenterry 4y ago
  Good points!

wtetzner 4y ago

I like OCaml's approach, where you write types in module signatures, but don't need to put them in the implementation.