mwnaylor has quit [Remote host closed the connection]
mwnaylor has joined #commonlisp
bpanthi977 has quit [Ping timeout: 260 seconds]
yaneko has quit [Quit: parting]
yaneko has joined #commonlisp
troojg has quit [Remote host closed the connection]
amb007 has quit [Ping timeout: 260 seconds]
olnw has joined #commonlisp
parjanya has quit [Remote host closed the connection]
alfiee has joined #commonlisp
rkazak has quit [Ping timeout: 260 seconds]
alfiee has quit [Ping timeout: 260 seconds]
hernan604 is now known as HER
istewart has joined #commonlisp
screwlisp has quit [Ping timeout: 260 seconds]
alfiee has joined #commonlisp
rkazak has joined #commonlisp
alfiee has quit [Ping timeout: 246 seconds]
brokkoli_origin has quit [Remote host closed the connection]
rkazak has quit [Ping timeout: 260 seconds]
jonatack has quit [Read error: Connection reset by peer]
spdegabrielle has joined #commonlisp
<kanuba>
Not easily, as it appears there is no functional analog to the query macro at a quick glance. The query list is converted to a S-SQL string at macro-expansion time, so your runtime list may not be realized. In short, you'd need to write a macro and and have access to the data that early I believe.
zwr has joined #commonlisp
bpanthi977 has joined #commonlisp
Alfr has quit [Ping timeout: 272 seconds]
Inline has quit [Ping timeout: 248 seconds]
luna-is-here has quit [Ping timeout: 248 seconds]
Alfr has joined #commonlisp
bpanthi977 has quit [Ping timeout: 260 seconds]
jonatack has joined #commonlisp
<tux0r>
that's unfortunate. thank you for glancing, at least!
GalaxyNova has joined #commonlisp
rkazak has joined #commonlisp
rkazak has quit [Ping timeout: 260 seconds]
alfiee has joined #commonlisp
Pixel_Outlaw has quit [Quit: Leaving]
brokkoli_origin has joined #commonlisp
alfiee has quit [Ping timeout: 260 seconds]
Inline has joined #commonlisp
Inline has quit [Remote host closed the connection]
<decweb>
sabraonthehill is an excellent postmodern resource
<tux0r>
:) well... yes, it is (thanks), and the :insert-rows-into thing *would* work *if* 1) the conses were lists and 2) the input was sanitized.. (which it is not, so *some* manual cleaning *will* be required anyway)
<tux0r>
ugly but probably sort-of-working. not tried yet.
shmorg83 has joined #commonlisp
rkazak has joined #commonlisp
<decweb>
Yeah, I tend to stay away from dotted pairs, I always regret it when I use them, also, there are no `format` directives that can deal usefully with them.
<tux0r>
dotted pairs are the easiest way to retrieve html post forms though
<tux0r>
at least as far as my limited understanding of lisp goes
<tux0r>
which is what i'm dealing with here *sigh*
<tux0r>
anyway... thanks, you two. i'll take a nap! :)
rkazak has quit [Ping timeout: 260 seconds]
random-nick has quit [Ping timeout: 244 seconds]
<aeth>
dotted pairs are basically close to 100% of the time seen in alists, but Common Lisp heavily prefers plists to alists (while Scheme prefers alists)
shmorg83 has quit [Ping timeout: 260 seconds]
bpanthi977 has joined #commonlisp
semz has quit [Quit: ZNC 1.8.2+deb2ubuntu0.1 - https://znc.in]
bpanthi977 has quit [Ping timeout: 244 seconds]
alfiee has joined #commonlisp
alfiee has quit [Ping timeout: 248 seconds]
semz has joined #commonlisp
bjorkintosh has joined #commonlisp
rkazak has joined #commonlisp
halloy2529 has joined #commonlisp
halloy2529 is now known as trabbo
surabax has quit [Quit: Leaving]
trabbo has quit [Read error: Connection reset by peer]
rkazak has quit [Ping timeout: 248 seconds]
bpanthi977 has joined #commonlisp
alfiee has joined #commonlisp
alfiee has quit [Ping timeout: 244 seconds]
molson has joined #commonlisp
zwr has quit [Read error: Connection reset by peer]
rkazak has joined #commonlisp
wobbol has quit [Ping timeout: 252 seconds]
zwr has joined #commonlisp
shmorg83 has joined #commonlisp
rkazak has quit [Ping timeout: 260 seconds]
bpanthi977 has quit [Ping timeout: 260 seconds]
spdegabrielle has quit [Quit: Connection closed for inactivity]
cow_2001 has quit [Quit: ✡]
rkazak has joined #commonlisp
cow_2001 has joined #commonlisp
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
alfiee has joined #commonlisp
ebrasca has quit [Ping timeout: 248 seconds]
alfiee has quit [Ping timeout: 260 seconds]
rkazak has quit [Ping timeout: 260 seconds]
istewart has quit [Quit: Konversation terminated!]
rkazak has joined #commonlisp
rkazak has quit [Ping timeout: 260 seconds]
m5zs7k has quit [Ping timeout: 272 seconds]
amb007 has quit [Ping timeout: 260 seconds]
m5zs7k has joined #commonlisp
rkazak has joined #commonlisp
edgar-rft_ has joined #commonlisp
<kanuba>
Syntactically, dotted pairs are both property lists and asociation lists if there are an even number of pairs.
thonkpod has quit [Ping timeout: 252 seconds]
edgar-rft` has quit [Ping timeout: 246 seconds]
thonkpod has joined #commonlisp
edgar-rft` has joined #commonlisp
alfiee has joined #commonlisp
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
edgar-rft_ has quit [Ping timeout: 248 seconds]
amb007 has joined #commonlisp
rkazak has quit [Ping timeout: 248 seconds]
bpanthi977 has joined #commonlisp
alfiee has quit [Ping timeout: 244 seconds]
amb007 has quit [Ping timeout: 244 seconds]
bpanthi977 has quit [Ping timeout: 260 seconds]
rkazak has joined #commonlisp
rkazak has quit [Ping timeout: 260 seconds]
Inline has quit [Quit: Leaving]
rkazak has joined #commonlisp
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
mishoo has joined #commonlisp
alfiee has joined #commonlisp
rkazak has quit [Ping timeout: 260 seconds]
alfiee has quit [Ping timeout: 252 seconds]
amb007 has quit [Ping timeout: 260 seconds]
decweb has quit [Quit: Konversation terminated!]
rkazak has joined #commonlisp
pve has joined #commonlisp
alfiee has joined #commonlisp
rkazak has quit [Ping timeout: 260 seconds]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
notzmv has quit [Ping timeout: 260 seconds]
alfiee has quit [Ping timeout: 244 seconds]
amb007 has quit [Ping timeout: 260 seconds]
amb007 has joined #commonlisp
notzmv has joined #commonlisp
rkazak has joined #commonlisp
amb007 has quit [Ping timeout: 260 seconds]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
rkazak has quit [Ping timeout: 244 seconds]
varjag has joined #commonlisp
alternateved has joined #commonlisp
alfiee has joined #commonlisp
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
alfiee has quit [Ping timeout: 245 seconds]
rkazak has joined #commonlisp
GalaxyNova has quit [Ping timeout: 260 seconds]
bendersteed has joined #commonlisp
rkazak has quit [Ping timeout: 245 seconds]
Guest47 has joined #commonlisp
alfiee has joined #commonlisp
AetherWind has joined #commonlisp
alfiee has quit [Ping timeout: 252 seconds]
rkazak has joined #commonlisp
zwr has quit [Read error: Connection reset by peer]
Devon has quit [Ping timeout: 248 seconds]
rkazak has quit [Ping timeout: 248 seconds]
bpanthi977 has joined #commonlisp
AetherWind has quit [Remote host closed the connection]
<dnhester26>
time type declarations like he shows? Isn't that akin to what coalton is trying to do?
<ixelp>
Static type checking in the programmable programming language (Lisp) | by Martin Cracauer | Medium
<phoe>
it's different than what coalton does
<phoe>
basically, you are able to do local type declarations, and the compiler is supposed to trust you there
<scymtym>
implementations can (and do) use type declarations in different ways, sometimes depending on the requested optimization policy. for example, SBCL, when compiling and evaluating safe code, treats type declarations as assertions that are checked at compile-time and/or runtime
random-nick has joined #commonlisp
_whitelogger has joined #commonlisp
notzmv has quit [Read error: Connection reset by peer]
alfiee has joined #commonlisp
cqst has quit [Ping timeout: 252 seconds]
alfiee has quit [Ping timeout: 260 seconds]
rkazak has joined #commonlisp
<dnhester26>
interesting, thank you for your answers. Is this a widespread practice? How come it's not very common? It would be nice when calling a function to have a compile time error instead of finding out at runtime. Furthermore, I imagine that even the IDE could say what's the type like emacs tells me the parameters of the function, it could probably also tell the declared types. Why isn't this more common?
<dnhester26>
The author worked at ITA/Orbitz/Google it seems like for a long time, so I was wondering if they used that heavily over there
<phoe>
it's widespread enough because often enough achieving performance requires typing information
<phoe>
you are going to have different code paths for accessing simple and non-simple arrays, for example
<phoe>
ELT is going to be compiled differently depeding on whether the argument is promised to be a list, a vector, a sequence, or any kind of object (there's chance for a type error!)
<dnhester26>
I had this thought that there have been a ton of CL companies throughout the years, but maybe it was before open source was popular, because I don't really see in our ecosystem so many libraries/systems shared by big companies that are widespread in use. I don't recall seeing a ITA/Google system, or any from the game maker andy gavin, or just in general. Even that portuguese company, I don't recall seeing many libraries they've shar
<dnhester26>
ed for the benefit of the community. Maybe it's because it's a prvious generation?
rkazak has quit [Ping timeout: 252 seconds]
<dnhester26>
yeah, I was thinking for me it doesn't make that much of a difference because performance has not been an issue, but people making games or anything that needs to optimize on performance would do. But my point was not that people don't use the declare, it was more that alexandria doesn't have a macro for doing type declarations (that I know of at least) like the one presented in the post, so it makes me think it's not such a common
<dnhester26>
practice
<phoe>
serapeum has its -> macro that wraps DECLAIM FTYPE
<dnhester26>
ah I didn't know, thanks for pointing that out
cqst has joined #commonlisp
geminium has joined #commonlisp
rkazak has joined #commonlisp
rkazak has quit [Ping timeout: 260 seconds]
dnhester26 has quit [Remote host closed the connection]
dnhester26 has joined #commonlisp
dnhester26 has quit [Remote host closed the connection]
mwnaylor has quit [Ping timeout: 260 seconds]
dnhester26 has joined #commonlisp
dnhester26 has quit [Remote host closed the connection]
dnhester_ has joined #commonlisp
dnhester_ has quit [Remote host closed the connection]
dnhester26 has joined #commonlisp
dnhester26 has quit [Remote host closed the connection]
rkazak has joined #commonlisp
dnhester26 has joined #commonlisp
dnhester26 has quit [Remote host closed the connection]
dnhester26 has joined #commonlisp
dnhester26 has quit [Remote host closed the connection]
<phoe>
but note that you can do more than just that - you have DECLARE TYPE, DECLARE FTYPE, and THE if you need to declare types of local variables, local functions, and values
alfiee has joined #commonlisp
alfiee has quit [Ping timeout: 260 seconds]
rkazak has quit [Ping timeout: 265 seconds]
rkazak has joined #commonlisp
bendersteed has quit [Quit: bendersteed]
bpanthi977 has joined #commonlisp
dnhester26 has joined #commonlisp
rkazak has quit [Ping timeout: 260 seconds]
bpanthi977 has quit [Ping timeout: 260 seconds]
<beach>
dnhester26: You can't use type declarations in Common Lisp the way they are used in a statically typed programming language.
AetherWind has joined #commonlisp
<beach>
dnhester26: And you probably wouldn't want to. There is evidence that supplying type information is a major consumer of time, and that this information often needs to be altered later during development.
dnhester26 has quit [Ping timeout: 272 seconds]
geminium has quit [Quit: Client closed]
<beach>
dnhester26: In a statically typed programming language, the program is rejected if the (mandatory) type information is inconsistent, and this requirement imposes a lot of restrictions on the type system; restrictions that don't exist in Common Lisp.
rkazak has joined #commonlisp
<beach>
dnhester26: Take GETHASH for instance. In general, it is undecidable to check that the object returned is of a particular type.
pranav has quit [Read error: Connection reset by peer]
alfiee has joined #commonlisp
geminium has joined #commonlisp
alfiee has quit [Ping timeout: 260 seconds]
rkazak has quit [Ping timeout: 244 seconds]
spdegabrielle has joined #commonlisp
dnhester26 has joined #commonlisp
dnhester26 has quit [Ping timeout: 244 seconds]
pfd has joined #commonlisp
dnhester26 has joined #commonlisp
bjorkintosh has quit [Remote host closed the connection]
pabs3 has quit [Ping timeout: 246 seconds]
<dnhester26>
beach: thanks for the comments. What do you mean by "undecidable"
adeht is now known as _death
<beach>
dnhester26: It is a term in theoretical computer science. It can't be determined statically.
<dnhester26>
Ah interesting. I guess other languages deal with that by making the setter only accept a certain input?
<beach>
They deal with it by forcing the user to make the entire program available before it can be executed, and by requiring type information of every function and every variable.
<beach>
dnhester26: Static typing essentially makes interactive development impossible.
surabax has joined #commonlisp
surabax has quit [Changing host]
surabax has joined #commonlisp
geminium has quit [Quit: Client closed]
<dnhester26>
Interesting. But that's only when the return values are involved or also on the parameter definition?
<beach>
"that"?
<dnhester26>
I guess the parameter definition will need to adapt to having values returned from functions, be unkonwn anyway
<beach>
What are you referring to now? In statically typed languages? In Common Lisp? For interactive development?
<dnhester26>
Ah that you said the gethash return value is undecidable, so "that" is the return value, in contrast to the parameter types of a function
<dnhester26>
In CL
<beach>
It is undecidable because you can't specify the types of the values of a hash table.
<dnhester26>
Ok
<beach>
So if you say (defun f (x y z) (+ x (gethash y z))) there is no way you can be sure of the type returned by GETHASH.
<dnhester26>
yeah, I understood that the first time
<beach>
You can declare Z to be a hash table, but you can't be sure what was put in it.
<dnhester26>
It's just that in the example from the blog post it was declaring the types of the parameters of the function; something like `(defunt foo ((string a) (string b) ... )`
<dnhester26>
I remember reading comments on how statically typed languages are easier to refactor because if a given function is changed, or type, the compiler picks up all the issues everywhere. So I thought using this existing facility could provide that functionality, that's where I was coming from
<beach>
DEFUNT? Is that the person's own macro?
<dnhester26>
yeah, from the blog post, let me find the link again.
<ixelp>
Static type checking in the programmable programming language (Lisp) | by Martin Cracauer | Medium
<dnhester26>
Ah, ok
<beach>
So another "no-no" when you work in statically typed languages is to use implementation types in declarations. Those very often need to change later.
bjorkintosh has joined #commonlisp
bjorkintosh has joined #commonlisp
bjorkintosh has quit [Changing host]
<dnhester26>
He posts the macro, which is also not a very long one. To do something like `(declaim (ftype (function (string) t) meh4a))` where `meh4a` is the name of a function
<beach>
You should use application-defined types instead,
<dnhester26>
I don't know what that means. Use the classes defined in my application?
<beach>
Classes or other types (using DEFTYPE).
rkazak has joined #commonlisp
<beach>
I absolutely think focusing on type declarations in Common Lisp is a waste of time. They are occasionally useful, but not very often, and they take a lot of time to supply correctly.
bjorkintosh has quit [Remote host closed the connection]
<dnhester26>
Ok. To be honest I haven't done any type declarations, I just haven't needed to do it. My questions stem from understanding if it's possible to develop useful tools for refactoring code, or if maybe by using certain features already available in CL we could at least make it easier to refactor code written using that functionality
bjorkintosh has joined #commonlisp
bjorkintosh has joined #commonlisp
bjorkintosh has quit [Changing host]
<beach>
CHECK-TYPE is often much better as an alternative. You can use it to prevent incorrect values from propagating deep into your code.
<dnhester26>
Ok I am actually using check-type already, didn't think about it as typing as much as validating inputs for controller routes in my web application
rkazak has quit [Ping timeout: 248 seconds]
<beach>
Exactly.
<dnhester26>
So in conclusion: there are no particularly useful refactoring tools we can build that don't already exist and are not CL implementation dependent. Correct?
alfiee has joined #commonlisp
<beach>
Oh, there are tons of things that can be built. Some of them may exist in commercial Common Lisp implementations (I don't know), but we don't have many in free Common Lisp implementations.
<beach>
Like I often say, we don't even have an editor that can determine the role of each symbol in an editor buffer.
<beach>
If we did, we could provide a tool for things like renaming a lexical variable.
<dnhester26>
that are not implementation dependent? Are those listed in your page of suggested projects? can you provide a list of useful things to build that are not implementation dependent (and maybe some that are)?
<dnhester26>
"we don't even have an editor that can determine the role of each symbol in an editor buffer.": The climacs project is attempting to address this IIRC?
<beach>
Sure, determining the role of each symbol in a file is a simple matter of applying the first phase of a compiler to it.
alfiee has quit [Ping timeout: 246 seconds]
<beach>
dnhester26: Yes, we want Second Climacs to be able to do that.
<beach>
... and the first phase of a compiler can be largely independent of the implementation, since the semantics of Common Lisp are documented.
<beach>
dnhester26: I really haven't thought of a complete list of implementation-independent refactoring tools.
<beach>
dnhester26: But I can say that, whenever you need to apply some transformation that depends on the meaning of symbols in your code, you need a code walker (which can be thought of as the same as the first pass of a compiler).
pranav has joined #commonlisp
<beach>
dnhester26: Take this example from McCLIM: (DEFMETHOD GRAFT ((GRAFT GRAFT)) GRAFT)
<beach>
There are three different meanings for GRAFT in that code.
<dnhester26>
you mean look up the source code?
<beach>
No, no need.
<beach>
I am just saying that you need a compiler to figure out what the meaning of each GRAFT is.
<dnhester26>
ah, realize that thee's a class, a function, and a parameter
<beach>
Yes.
<dnhester26>
Yeah
geminium has joined #commonlisp
bjorkintosh has quit [Remote host closed the connection]
bjorkintosh has joined #commonlisp
bjorkintosh has joined #commonlisp
rkazak has joined #commonlisp
<dnhester26>
Right. I feel like there's such a big gap between me a relatively new CL user and you who is writing compilers/SICL. To understand writing useful CL development applications, it feels like a requirement is to understand the compilation process and a lot of other things I don't usually run into when making say a web application in CL
<beach>
Just a simple thing (one of my favorite examples) like when you put the cursor on a lexical variable, or when you hover your pointer over it and you get all the usages of it highlighted, requires a compiler.
<dnhester26>
ah right, I use `M-. C-s` all the time in my files which somewhat dumbly mimics that functionality without the meaning
<beach>
Right, the application programmer often does not need to understand all that. I am explaining it so that you see the reason why we have few free tools like this.
<beach>
Exactly. We don't have many alternatives now.
<thuna`>
I think I remember seeing something like that in Lem's demo in ELS (or was it SBCL25?)
<beach>
thuna`: That would be fantastic. But as I recall, they use SLIME so they wouldn't be able to do that correctly then.
<dnhester26>
yeah, lem IIRC doesn't have any CL development improvements over slime, it's just an emacs in CL
<phoe>
lem has an option to use swank, afaik
<phoe>
or it can evaluate in-image
<beach>
Like suppose you have (LET ((X ...)) (MY-MACRO X ...)). There is no way to know whether the last X refers to the lexical variable without expanding MY-MACRO.
<beach>
And only a compiler can do that.
<dnhester26>
Ok, I summarized what you said for myself and in case you make an entry in your suggested projects it may be helpful: https://plaster.tymoon.eu/view/4728#4728
Guest47 has quit [Quit: My MacBook Air has gone to sleep. ZZZzzz…]
bpanthi977 has joined #commonlisp
prokhor has joined #commonlisp
bpanthi977 has quit [Ping timeout: 245 seconds]
Guest47 has joined #commonlisp
rkazak has quit [Ping timeout: 245 seconds]
jonatack has quit [Read error: Connection reset by peer]
pabs3 has joined #commonlisp
lacko has joined #commonlisp
shmorg83 has quit [Ping timeout: 260 seconds]
alfiee has joined #commonlisp
alfiee has quit [Ping timeout: 265 seconds]
rkazak has joined #commonlisp
ebrasca has joined #commonlisp
<phoe>
beach: "first phase of a compiler", you mean minimal compilation + some basic semantic analysis?
<phoe>
and a way to associate the X in (MY-MACRO X) with some meaning that it has in the resulting code after minimal compilation (e.g. does it refer to a variable, a function, a class, is it quoted somewhere in the expansion, etc.)?
rkazak has quit [Ping timeout: 248 seconds]
<jackdaniel>
in short -- expanding all macros
<jackdaniel>
it is somewhere in the spec, 3.x
kurfen has quit [Ping timeout: 244 seconds]
kurfen has joined #commonlisp
Inline has joined #commonlisp
dnhester26 has quit [Remote host closed the connection]
dnhester26 has joined #commonlisp
spdegabrielle has quit [Quit: Connection closed for inactivity]
<beach>
phoe: Yes, something like that.
rkazak has joined #commonlisp
<scymtym>
the step from character syntax to s-expression syntax is needed as well since editor buffers and source files are (or can be presented as) character sequences
alfiee has joined #commonlisp
alfiee has quit [Ping timeout: 244 seconds]
<beach>
phoe: And things are nontrivial because of MACROLET. The thing needs to be able to generate code for the macro function.
ingeniot has joined #commonlisp
josrr has joined #commonlisp
skin has joined #commonlisp
varjag has quit [Quit: ERC 5.5.0.29.1 (IRC client for GNU Emacs 29.3)]
<younder>
s-expessionist:Eclector is SICL's read package.
<beach>
Elector is now completely independent of SICL.
alfiee has joined #commonlisp
alfiee has quit [Ping timeout: 260 seconds]
rkazak has joined #commonlisp
attila_lendvai has joined #commonlisp
msv has quit [Read error: Connection reset by peer]
svm has joined #commonlisp
svm is now known as msv
rkazak has quit [Ping timeout: 246 seconds]
pfd has quit [Quit: Client closed]
pfd has joined #commonlisp
geminium has quit [Quit: Client closed]
AetherWind has quit [Quit: leaving]
geminium has joined #commonlisp
ingeniot has quit [Ping timeout: 240 seconds]
dnhester26 has quit []
alfiee has joined #commonlisp
rkazak has joined #commonlisp
alfiee has quit [Ping timeout: 265 seconds]
cage has joined #commonlisp
cage has quit [Excess Flood]
cage has joined #commonlisp
yitzi has quit [Ping timeout: 252 seconds]
geminium has quit [Quit: geminium]
pfd has quit [Quit: Client closed]
pfd has joined #commonlisp
jonatack has joined #commonlisp
rkazak has quit [Ping timeout: 260 seconds]
yitzi has joined #commonlisp
skin_ has joined #commonlisp
Guest47 has quit [Quit: My MacBook Air has gone to sleep. ZZZzzz…]
Thermoriax has joined #commonlisp
cage has quit [Remote host closed the connection]
cage has joined #commonlisp
cage has quit [Excess Flood]
Guest47 has joined #commonlisp
cage has joined #commonlisp
Guest47 has quit [Client Quit]
rkazak has joined #commonlisp
alfiee has joined #commonlisp
Guest47 has joined #commonlisp
alfiee has quit [Ping timeout: 244 seconds]
bjorkintosh has quit [Quit: "Every day, computers are making people easier to use." David Temkin]
ldb has joined #commonlisp
bjorkintosh has joined #commonlisp
bjorkintosh has joined #commonlisp
bjorkintosh has quit [Changing host]
pfd has quit [Quit: Client closed]
<ldb>
I've seen people been working on a Scheme Language Server Protocol server
NotThatRPG_ has joined #commonlisp
<ldb>
They are stuck on the problem of tracking variables after macro expansion
NotThatRPG has quit [Ping timeout: 252 seconds]
<beach>
Is the Language Server Protocol complete enough for Lisp, and in particular for Common Lisp?
NotThatRPG_ has quit [Ping timeout: 252 seconds]
<ldb>
I'm afraid not, it is only because many people who newly started to learning programming are more getting used to VSCode or Neovim, which only provides LSP as the interface to be extended with programming language specific supports
<beach>
I see.
<beach>
Given the amount of work that scymtym had to put in just to make sure the editor buffer is parsed correctly by the reader, doing something similar when you need to communicate using a wire protocol must be orders of magnitude harder. At least if you want reasonable performance.
rkazak has quit [Ping timeout: 252 seconds]
<ldb>
well the language sever typically maintains their own file buffer, and call the front end of their compiler after each update
<beach>
I see, so the editor just communicates buffer updates to the server?
shawnw has joined #commonlisp
alfiee has joined #commonlisp
<ldb>
and request for cross reference/completion at point information when user interacts
<beach>
Ah, yes.
<ldb>
lsp does transmitter what user typed, since it is not always the case file is saved to disk
<beach>
Makes sense.
spdegabrielle has joined #commonlisp
alfiee has quit [Ping timeout: 252 seconds]
ldb has quit [Ping timeout: 265 seconds]
cage has quit [Quit: rcirc on GNU Emacs 29.4]
GalaxyNova has joined #commonlisp
rkazak has joined #commonlisp
ColinRobinson has joined #commonlisp
pfd has joined #commonlisp
rkazak has quit [Ping timeout: 260 seconds]
Lord_of_Life has quit [Read error: Connection reset by peer]
Lord_of_Life has joined #commonlisp
rkazak has joined #commonlisp
alfiee has joined #commonlisp
shmorg83 has joined #commonlisp
alfiee has quit [Ping timeout: 260 seconds]
NotThatRPG has joined #commonlisp
rkazak has quit [Ping timeout: 248 seconds]
shmorg83 has quit [Ping timeout: 244 seconds]
zxcvz has joined #commonlisp
ColinRobinson has quit [Quit: praxis.meansofproduction.biz (juan@acm.org)]