Why is F#’s type inference so fickle?

by

Regarding “Haskell’s equally powerful inference”, I don’t think Haskell has to deal with

  • OO-style dynamic subtyping (type classes can do some similar stuff, but type classes are easier to type/infer)
  • method overloading (type classes can do some similar stuff, but type classes are easier to type/infer)

That is, I think F# has to deal with some hard stuff that Haskell does not. (Almost certainly, Haskell has to deal with some hard stuff that F# does not.)

As is mentioned by other answers, most of the major .NET languages have the Visual Studio tooling as a major language design influence (see e.g. how LINQ has “from … select” rather than the SQL-y “select… from”, motivated by getting intellisense from a program prefix). Intellisense, error squiggles, and error-message comprehensibility are all tooling factors that inform the F# design.

It may well be possible to do better and infer more (without sacrificing on other experiences), but I don’t think it’s among our high priorities for future versions of the language. (The Haskellers may see F# type inference as somewhat weak, but they are probably outnumbered by the C#ers who see F# type inference as very strong. 🙂 )

It might also be hard to extend the type inference in a non-breaking fashion; it is ok to change illegal programs into legal ones in a future version, but you have to be very careful to ensure previously-legal programs do not change semantics under new inference rules, and name resolution (an awful nightmare in every language) is likely to interact with type-inference-changes in surprising ways.

More Related Contents:

  1. Understanding F# Value Restriction Errors
  2. How to write a function for generic numbers?
  3. F# : not sure how to start [closed]
  4. How to have two methods calling each other?
  5. Handy F# snippets [closed]
  6. Functions with generic parameter types
  7. How to constrain one type parameter by another
  8. F# Functions vs. Values
  9. F# Tail Recursive Function Example
  10. Shadowing and Nested function
  11. Use of `inline` in F#
  12. How to Async.AwaitTask on plain Task (not Task)?
  13. How can i convert between F# List and F# Tuple?
  14. Why are functions in OCaml/F# not recursive by default?
  15. Why isn’t there a protected access modifier in F#?
  16. Using keywords as identifiers in F#
  17. Global operator overloading in F#
  18. F#: let mutable vs. ref
  19. Correct version of Fsharp.Core
  20. F# getting a list of random numbers
  21. While or Tail Recursion in F#, what to use when?
  22. Help me to explain the F# Matrix transpose function
  23. F# Split list into sublists based on comparison of adjacent elements
  24. F# changes to OCaml [closed]
  25. F# interface inheritance failure due to unit
  26. Why doesn’t C# infer my generic types?
  27. Why are await and async valid variable names?
  28. Why do Consumers accept lambdas with statement bodies but not expression bodies?
  29. C++: rationale behind hiding rule
  30. How to infer the type of an expression manually

Leave a Comment