If you've got a #haskell identifier x and you need to figure out how to convert it to some type T, just write
_ x :: T
And hover over the underscore, and you see what type of function you need to get there.
_ x :: T
And hover over the underscore, and you see what type of function you need to get there.
If an appropriate function doesn't exist yet, replace the underscore with some name
f x :: T
and use the "Define ..." code action to automatically stub out a definition for f
f x :: T
and use the "Define ..." code action to automatically stub out a definition for f
If the definition you write for f ends up being really simple, you can then just inline it back at the use site.
Sometimes I'll nest this technique, too. If the only thing that's clear when trying to define f is, e.g. that it will look like
f = fmap _
then I'll change that to
f = fmap g
g = _
and write a definition for g, and then eventually clean it up
f = fmap _
then I'll change that to
f = fmap g
g = _
and write a definition for g, and then eventually clean it up
When stuggling with inscrutable type errors, stop struggling in your head - use the tools to get as much explicit type declaration onto the screen as possible.
Crazy type errors most often come from leaving waaaay too many types inferred. Haskell doesn't have bad error messages, what it has is really great type inference, which makes it super easy to write large expressions with no type annotations
You do this at your own risk, and you need to stop doing this if you're having trouble with it.
• • •
Missing some Tweet in this thread? You can try to
force a refresh
