Feature Request: Colour/Bold known Symbols whilst Typing

[stellarpower]

Hi,

Very excited to try the new-and-improved crystal interpreter mode! Very close to being able to replace ruby now, great work!

Something I really like ,coming form the fish shell, if that it highlights commands/functions that don't exist whilst you're typing; they then change colour when you complete a word, and the command is known to it:

https://asciinema.org/a/mrBhMosJptys2L72TaA8f03vx

I think implementing this could be really nice. If a constant, local, method, etc. is known, then when I type or tab-complete, it comes up either in a different colour, or possibly in bold, so that existing colours may be preserved. Or conversely we could add an accent to identifiers that aren't in scope, rather those that are. I think any way is good, I just really like this feature, of interactively checking that your code is correct before you've even had to complete the line.

Thanks

[I3oris]

Thank you @stellarpower bringing this!

I really like the idea too, it's something doable but the main difficulty to know which word is valid or not. It need to execute crystal semantics on fly to know the types and know is a method is defined on a local. (e.g. we need to know if x.foo is valid or not) That something not well supported yet, but in a first time we could enable highlight for trivial definitions like keywords, toplevel vars, toplevel constants, and toplevel defs.

That said, in the REPLy repo, we doesn't consider crystal things, we only have to enable highlight on such definition, then it's the matter of the repo above to decide what highlight, e.g. in crystal directly or IC.

[stellarpower]

Yes, you're quite right. I realised only halfway through it might involve some entanglement.

This might be the route that involves the most effort, but potentially the cleanest idea to me seems to be more of a client-server model. The code using REPLy (i.e. the crystal compiler) could send updates to the repl when it wanted to change something, but also, listen and receive information from the REPL.

Naïvely it could be done for each keystroke; I think more likely would be a sort of dual state machine. The user types a new line, and the REPL pushes an update onto a queue; this gets popped on the compiler side, it does some work, and pushes its message onto the queue in the other direction. So any updates to constants or what have you could come this way. Ideally in some way that frees up the REPL only to need to understand a basic idea of what's important (like you say - constants, locals, globals, typenames, ...), and the compiler then pushes an update to a list. Or alternatively, it might be possible to check with the compiler each time - tab completion, new word, etc.

Idk if it makes much sense with the way the code currently works, it's just an idea that comes to mind. Operating the REPL like a service with its own internal state and lifecycles, also might make sense for other applications. The downside of course is that asynchronous programming like this is quite a bit more annoying to follow, unless you're coming from JavaScript or C# or something similar, where you never seem to find a line without async or await!!!

Thanks for considering this in detail!!

[stellarpower]

In fact I might go back to this again; because one thing I would sorely love would be a Crystal shell. The interactive prompt in the compiler should do for some of this (and I fully accept that something like this would probably have to come once the interpreter has gained some more sophistication); but as a fish user, I still think the CLI has a massive way to go. Manipulating tables and JSON, making web requests, working with other more typed data is a big part of what we need to do from the terminal these days, not just the sorts of whitespace-delimited text processing people did in the 70s.

Something like Xonsh is a pretty good option. However Python is rather horrid, and the syntax for Xonsh isn't really much better than just straightforward plain Python scripts. So I had been keeping an eye out for a usable and maintained ruby-based shell for some time, that kept the language, but made it a bit more frictionless to invoke other programs. Throw in a proper understanding of types to say "Hey, that's stupid - don't do that", yet still really quick and expressive to work with, and Crystal shell would be the ideal tool IMO. If the REPL could (to some extent) support some of the more advanced requirements for something like this, I think that'd be really cool. Hopefully it wouldn't be too long before someome tried to do it. The other possible location I could see it being used is a bit like pry, in some sort of hybrid-debugger, where we can step through code with a native debugger like lldb; yet somehow also jump to an interactive prompt with the ability to inspect things, evaluate expressions and call methods, possibly even change the program state, if linked against our program.

[I3oris]

Yeah, design REPLy more like a client-server could be very beneficial, especially the fact to have a hook for each keystroke. Currently the Repl communicate to the client with overridden methods, and the client send back information through the return value. Without changing the main functioning of this, we could add methods for each event of the Repl. Inside these methods we can then send controls back through already existing methods (e.g. repl.editor.move_cursor_to(x: 0, y: 0), repl.editor.current_line = "Hello", ...)
And we could imagine centralize that on the form of commands with a macro like repl.cmd(:move_cursor_to, x: 0, y: 0), and repl.cmd(:current_line=, "Hello").

Maybe later we could use callbacks instead of overriden methods, but this would be definitively much more work.
In any case, going toward this idea seem to me good!

one thing I would sorely love would be a Crystal shell

Yes, me too!, Could you explain more in detail which features you would like to see over the current crystal repl?

Throw in a proper understanding of types to say "Hey, that's stupid - don't do that",

On the repo IC I put lot of effort to get a smart auto-completion (yet still experimental), which give a pretty good user feedback, but of course, could be improved more.

an interactive prompt with the ability to inspect things, evaluate expressions and call methods, possibly even change the program state

On pry I believe we could already do all these thinks!, but with some limitations (you can change variable content, as long you respect its type, you cannot do hot-reload, ...)

Moreover pry use already REPLy, so it will inherit all shell capacities rather easily.