Type information for arbitrary portions of code

[jacg]

ghcide gives me information on most alphanumeric symbols (and numeric literals) but there are two features that I'm used to from dante and/or intero:

• type information on operators
• type information on arbitrary selected expressions

Do these features exist, and have I simply not found them?

If not, any hints on how to implement them?

[mitchellwrosen]

I'm able to see type information on operators.

[cocreature]

Operators should definitely work, given that it seems to work in some cases, it would be good if you could provide a specific test case where it fails.

Getting type information of a range is a bit more tricky. It is obviously more complex to implement but there is a second issue here: LSP hover does only give us a position not a range. I’ve taken a quick look at the spec and I also couldn’t find any other method that we could use here either.

[jacg]

Operators should definitely work

Sorry, yes, they do (it's just that in my configuration symbols' types were being shown spontaneously, while it took a bit more effort for symbols).

[jacg]

I guess that the bug label isn't appropriate here, as everything that is expected to work (information about symbols) seems to work.

[jneira]

The type of arbitrary expression can be extracted indirectly in hls, using the eval plugin, that includes :t.
Not sure if it is possible right now to translate in the hover, using the lsp protocol as pointed by @cocreature. So we should wait for some spec update to implement it.

@jacg does the workaround using eval works for you?

[JacoboDominguez]

That question should be addressed by me nearly twin @jacg :)
Cheers,

[alanz]

FYI microsoft/language-server-protocol#377

[normenmueller]

The type of arbitrary expression can be extracted indirectly in hls, using the eval plugin, that includes :t.

@jneira Could you please give some more advice on how to install/ configure?

[jneira]

@normenmueller you have to install haskell-language-server which includes by default the eval plugin (you can see it in action here ).

Then you can write -- >>> in the code to evaluate expressions in the module context:

-- >>> :t fooExe
fooExe :: [Char]
fooExe = "hi"

• pressing a link Evaluate

-- >>> :t fooExe
-- fooExe :: [Char]
fooExe :: [Char]
fooExe = "hi"

You can write arbitrary expressions:

-- >>> :t "hi"
fooExe :: [Char]
fooExe = "hi"

-- >>> :t "hi"
-- "hi" :: [Char]
fooExe :: [Char]
fooExe = "hi"