[Feature Request] Quick action: add variable "not in scope" to function arguments and as local definition (using where or let)

[GuillaumeDesforges]

Say I have:

print :: IO ()
print = putStrLn . show $ x

x is not defined/not in scope of print

Quick action could insert variable inside and change type:

print :: String -> IO ()
print x = putStrLn . show $ x

[jneira]

Seems to me this one would be great.

[jneira]

Another quick action could be Define x :: String as local definition to go from

test2 :: String
test2 = id x

to

test2 :: String
test2 = id x
where x :: String
      x = error "not implemented"

[GuillaumeDesforges]

@jneira some people prefer let bindings, would that be a setting or would we have 2 actions? One way to think about it is to have 1 action per possibility

• add to function arguments
• define in where
• define in let

[jneira]

totally agree, thanks for noting it

[GuillaumeDesforges]

Cool :) I'm pushing further the thoughts, stop me now if it's not relevant to talk about it here.

Say I have

a = foo
  where
    foo = bar baz
      where bar = fmap

I get baz not defined, I use quick action "insert in where", where does my definition go?

a = foo
  where
    foo = bar baz
      where
        bar = fmap
        baz = error "not implemented"

or

a = foo
  where
    foo = bar baz
      where
        bar = fmap
    baz = error "not implemented"

?

Same question for let

[jneira]

Well, i think it could be 2 alternatives, not totally exclusive:

• Add it always in the same context where it is being referred. And leverage a hypothetical and orthogonal feature to move up and down definitions in the subexpresions tree (inside let or where)
• Add as many code actions as possible contexts where the definition can be added: Add baz to 'foo' context, Add bazz to 'a' context, Add baz in the top level context

First one needs some indirection but it is more elegant and less invasive cause it uses less code actions and their number is fixed, not depending on the subexpression tree deep.
Second one is direct and maybe more intuitive?