3 ms·
Haskell/GHC tells you what the types are. Proper, global, most-general type inference. Not that local inference crap [1] that the sour-grapes types will say i
by mrkeen 2y ago
Haskell/GHC tells you what the types are. Proper, global, most-general type inference. Not that local inference crap [1] that the sour-grapes types will say is better.
You lose this ability if you start letting the compiler decide that `Int` is as good as `Maybe Int`. Or if an `Async (Async String)` may as well be an `Async String`.
That's not to say it's not easy to transform (just a few keystrokes), but explicit beats implicit when it comes to casting (in any language).
[1] Does this work?
var x = 1 == 2 ? Optional.of(2L) : Optional.empty().map(y -> y + y);
// Operator '+' cannot be applied to 'java. lang. Object', 'java. lang. Object'
How about
Optional<Long> x = 1 == 2 ? Optional.of(2L) : Optional.empty().map(y -> y + y);
// Operator '+' cannot be applied to 'java. lang. Object', 'java. lang. Object'
or even
Optional<Long> x = 1 == 2 ? Optional.of(2L) : Optional.empty().map((Long y) -> y + y);
// Cannot infer functional interface type
No, we needed Optional.<Long>empty() instead of Optional.empty() to make it work
- magicalhippo 2y ago> letting the compiler decide that `Int` is as good as `Maybe Int` I was thinking more like explicitly telling the compiler that an implicit cast is OK, in other languages done by implementing the implicit cast operator for example. edit: but if I understood you correctly, Haskell just doesn't support any implicit casting?
- mrkeen 2y agoIt will do some wrangling of literals for you, as long as it can unambiguously decide on an exact type during type-checking. If no other info is given, it will treat `3 + 3` as Integer + Integer (and emit a compiler warning because it guessed the type). With `(3 :: Int64) + 3`, the right 3 will resolve to Int64. Same if you swap their positions. `(3 :: Int64) + (3 :: Int32)` is a compile error. "Text literals" can become a String, a Text, or a ByteString if you're not explicit about it. > implicit cast operator Wouldn't that make it explicit?
- magicalhippo 2y ago> Wouldn't that make it explicit? No, the casting is still done implicitly. That is I can make the following compile fine in Delphi if I add an implicit cast operator to either Foo or Bar: Foo x := Foo.Create(); Bar y := x; If neither of them have a suitable implicit cast operator defined, it will of course fail to compile. Just an example, nothing unique about Delphi. You can see an example of the operator definition here[1]. [1]: https://docwiki.embarcadero.com/RADStudio/Alexandria/en/Operator_Overloading_(Delphi) https://docwiki.embarcadero.com/RADStudio/Alexandria/en/Oper...
- itishappy 2y ago> "Text literals" can become a String, a Text, or a ByteString if you're not explicit about it. Not without explicitly enabling `OverloadedStrings`! https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/overloaded_strings.html https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/over...