triffid has quit [Remote host closed the connection]
mesuutt has quit [Ping timeout: 264 seconds]
Odin-LAP has quit [Ping timeout: 260 seconds]
<cracauer>
I'll be at ELS.
nij- has joined #commonlisp
<nij->
bike - Yes. But in that table, there are columes "Mode" and "New Mode". I'm not sure what "New Mode" is supposed to mean..
<Colleen>
nij-: bike said 3 hours, 1 minute ago: as the eval-when table says, "process" means "process the body as top level forms _in the specified mode_", emphasis mine
<Colleen>
nij-: SAL9000 said 3 hours, 1 minute ago: lightning talks generally get arranged on the day by emailing Didier
shka has quit [Ping timeout: 256 seconds]
<nij->
Another question - Is there a function ALL-TYPES-OF that returns all atomic type specifiers for its argument?
semz has quit [Quit: ZNC 1.8.2+deb2build5 - https://znc.in]
semz has joined #commonlisp
<nij->
And this -- Is there a function that takes an object and a generic function and returns a list of methods (in calling order) that will be invoked if generic fun is applied onto the object? (Basically, to dry-run generic function calls.)
mesuutt has joined #commonlisp
triffid has joined #commonlisp
mesuutt has quit [Ping timeout: 264 seconds]
istewart has quit [Quit: Konversation terminated!]
istewart has joined #commonlisp
triffid has quit [Remote host closed the connection]
triffid has joined #commonlisp
ebrasca has quit [Remote host closed the connection]
Krystof has quit [Ping timeout: 255 seconds]
jmercouris1 has joined #commonlisp
X-Scale has quit [Quit: Client closed]
<bike>
nij-: new mode is the mode the body is processed in.
<bike>
nij-: there is no all-types-of. the dry run generic function call is compute-applicable-methods.
<nij->
bike.. hmm compute-applicable-methods does return a list, but in the order of calling.. https://bpa.st/YJEQ
<ixelp>
View paste YJEQ
mesuutt has joined #commonlisp
jmercouris1 has quit [Quit: jmercouris1]
mesuutt has quit [Ping timeout: 256 seconds]
<bike>
right, c-a-m returns them in specialization order. the "order of calling" is a lot more difficult
<bike>
with custom method combinations there might not even be a sensible "order of calling". you could have methods called more than once, or skipped based on the results of other methods
<bike>
you can get the effective method form, which has all those details, with compute-effective-method
<bike>
why are you asking about this?
<nij->
I think there should be a way to clearly see what the chains of method calls are.
<nij->
Without having a clear way of inspection, I may always be daunted to use it freely.
<bike>
it's compute-effective-method
<nij->
So.. at least, is there any way to dry-run and see what the next method is (argument: object, current-method)?
<nij->
Oh, compute-effective-method. Lmme try that now.
<bike>
there is no "chain". if you use call-next-method from a before method you'll get an error
<nij->
compute-effective-method ..? Is that in the standard?
<bike>
because that's how it's used internally. but it's not exactly human readable
edgar-rfx is now known as edgar-rft
<beach>
Not that I know why it is supposed to be a form, but that's what the MOP says.
<beach>
nij-: Yes, that's better.
<nij->
Why shouldn't there be all-types-of ..?
<bike>
i think i made it return a form for the semi practical reason that it makes it possible to compile effective methods into files. since a method function isn't exactly serializable
<bike>
well, the first reason there's no all-types-of is that why would there be such a function
<beach>
Makes sense.
<bike>
why does it matter if the type is atomic? you can define any number of stupid deftypes
<nij->
bike Hmm.. I guess there will be infinite many types?
<bike>
in general, yes
<nij->
If a function can return all types of an object; sure. That's better. I'm worrying that it may not end.
<nij->
Yeah.
<bike>
okay, but why would you want to know all types of an object to begin with
rogersm has joined #commonlisp
<nij->
More interactivity
<bike>
that doesn't really answer the question.
<aeth>
there are infinitely many types... "hello world" is string and (and string (not list)) and (and string (not list) (not number)) and...
<bike>
asking for "all types of an object" is like saying you want to know all sets that contain 4.
<bike>
not only are there are infinite number of such sets, most of them are uninteresting
<nij->
aeth Oh, good, yes that's an example why I shouldn't expect a function that returns all types.
<bike>
are there an*
<aeth>
but you don't get infinite from there (without deftype or repetition or whatever) until you start adding length
<nij->
bike Hmm.. but there are only finitely many atomic types. I hope I can understand an object more by inspecting that.
<nij->
Or at least.. is there a function that returns the DAG of all (super)classes of an object?
<aeth>
and as bike says most of the ones you can construct are, of course, uninteresting because of course a (string 11) can't be a (string 12) and a string cannot be a list etc.
<bike>
there are also finitely many integer types with bounds with absolutely value below 986
<bike>
sure, that's class-precedence-list. mop again
<bike>
it's the linearized list rather than the dag
<aeth>
you could probably find a way to get a list of all non-compound, non-user-defined, non-negated, non-SATISFIES, non-range (e.g. 2 is both an (integer 1 2) and (integer 1 10)), ...
<beach>
nij-: There was no glossary in the AMOP book, and I didn't make one up.
<beach>
nij-: The general idea is that there are so many markup languages, and everyone has a favorite, so it is impossible to reach consensus, or even a majority for a particular markup language.
mesuutt has quit [Ping timeout: 264 seconds]
<beach>
... so the best format would be an internal format in the form of a graph of objects.
<nij->
So.. instead of a type setting language.. just use common lisp?
<beach>
Pretty much, yes.
<nij->
I'm actually typing my CV in CL. But it works by compiling into a tex file anyway to start with :(
<beach>
But not S-expression input as some suggest, CCL I believe. Just a specification of the internal format.
<ixelp>
GitHub - robert-strandh/Doclang: A documentation and typesetting system.
<beach>
scymtym has done some work as well, but I am not sure it is available.
<beach>
nij-: It is *very* preliminary.
<nij->
Would it just be an internalized version of some html like thing?
<nij->
I mean.. if it's general enough, then it seems to have be html like.
<nij->
A section may hold a list of paragraphs. But each paragraph is just a list of strings.
<nij->
Some strings have to be marked up, and so you quickly need analogues for spans and divs.
<beach>
A paragraph could be more structured than just a list of strings.
<beach>
A phrase could be wrapped in an object that indicates some semantics of that phrase.
<nij->
Interested to see how this develops.
X-Scale86 has quit [Quit: Client closed]
admich1 has quit [Ping timeout: 264 seconds]
<nij->
I was thinking about a similar problem for math documents. But I decide it's too hard..
admich1 has joined #commonlisp
<beach>
Math notation would definitely have to be incorporated.
<nij->
Not just math notation.. but when it comes to math semantics..
<beach>
Ah, yes.
<nij->
Math semantics are often so rich that their textual presentations must be abbreviated and contextual.
<beach>
I see, but that does not have to be the case with its representation as an object graph.
<nij->
How to control all this well? And how to set up an object/class system that allows capturing all those semantics? I have no idea.
<nij->
How would object graph be helpful here?
<beach>
It wouldn't have to be directly readable by humans, so it can contain all the information you want to provide.
<nij->
Right. That sounds really cool, as we no longer have to write in syntax, but write in semantics.
<beach>
Yes, that's one of the main ideas.
<nij->
How would you write the semantics of (d/dx)?
<beach>
And object representing "derivative" containing a "variable" object and an "expression" object.
<nij->
It is the ordinary differentiation. However, it's trickier. x is the symbol that denotes the variable used. And the variable lives on some differentiable manifold (not just R^1).
<nij->
hmm
<nij->
So one needs to define the semantic object 'derivative somewhere else in the doc?
<beach>
The "variable" object would contain its name, but the "expression" object would not contain the name, and instead it would contain a reference to the "variable" object.
<nij->
in the document*?
<beach>
At the very least, you would have to define a way to display it if you want someone to read it. Most likely, this would be as a CLIM graph of "presentations".
<nij->
Also, sometimes it's better to denote (d/dx)(f) as f'.. sometimes D_x(f).. sometimes \partial_x(f) .. depending on the context.
<beach>
Yes, there would be different ways of displaying some semantic object.
<nij->
Cool. Lemme think about this. (Gotta go asleep.)
<beach>
Sleep well.
nij- has quit [Ping timeout: 268 seconds]
notzmv has quit [Read error: Connection reset by peer]
wacki has joined #commonlisp
amb007 has joined #commonlisp
amb007 has quit [Ping timeout: 246 seconds]
ronald has quit [Ping timeout: 260 seconds]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
admich1 has quit [Read error: Connection reset by peer]
admich1 has joined #commonlisp
admich1 has quit [Remote host closed the connection]
amb007 has joined #commonlisp
admich1 has joined #commonlisp
admich1 has quit [Ping timeout: 252 seconds]
notzmv has joined #commonlisp
ronald has joined #commonlisp
waleee has quit [Ping timeout: 268 seconds]
zetef has joined #commonlisp
Pixel_Outlaw has quit [Quit: Leaving]
synchromesh has quit [Read error: Connection reset by peer]
synchromesh has joined #commonlisp
szkl has joined #commonlisp
pve has joined #commonlisp
domovod has quit [Ping timeout: 268 seconds]
admich1 has joined #commonlisp
amb007 has quit [Remote host closed the connection]
amb007 has joined #commonlisp
gnu-user has joined #commonlisp
gnu-user is now known as axioms
axioms has quit [Client Quit]
axioms has joined #commonlisp
poplin has quit [Ping timeout: 255 seconds]
admich1 has quit [Ping timeout: 252 seconds]
admich1 has joined #commonlisp
mesuutt has joined #commonlisp
rogersm has joined #commonlisp
mesuutt has quit [Ping timeout: 255 seconds]
amb007 has quit [Ping timeout: 255 seconds]
amb007 has joined #commonlisp
rogersm has quit [Remote host closed the connection]
rogersm has joined #commonlisp
rogersm has quit [Remote host closed the connection]
rogersm has joined #commonlisp
axioms has quit [Remote host closed the connection]
danza has joined #commonlisp
gnu-user has joined #commonlisp
rgherdt has joined #commonlisp
rogersm has quit [Remote host closed the connection]
gnu-user is now known as axioms
igemnace has joined #commonlisp
mesuutt has joined #commonlisp
rogersm has joined #commonlisp
axioms has quit [Quit: axioms]
mesuutt has quit [Remote host closed the connection]
mesuutt has joined #commonlisp
rogersm has quit [Ping timeout: 264 seconds]
shka has joined #commonlisp
mesuutt has quit [Ping timeout: 268 seconds]
zetef has quit [Ping timeout: 264 seconds]
beach` has joined #commonlisp
gnu-user has joined #commonlisp
gnu-user_ has joined #commonlisp
gnu-user is now known as axioms
domovod has joined #commonlisp
gnu-user_ is now known as gnu-user
beach has quit [Ping timeout: 255 seconds]
rogersm has joined #commonlisp
rogersm has quit [Remote host closed the connection]
gnu-user has quit [Quit: gnu-user]
beach` is now known as beach
mesuutt has joined #commonlisp
danza has quit [Remote host closed the connection]
danza has joined #commonlisp
mesuutt has quit [Ping timeout: 256 seconds]
danza has quit [Ping timeout: 268 seconds]
dino_tutter has joined #commonlisp
mesuutt has joined #commonlisp
mesuutt has quit [Ping timeout: 268 seconds]
akoana has joined #commonlisp
makomo has joined #commonlisp
lagash has quit [Ping timeout: 246 seconds]
traidare has joined #commonlisp
amb007 has quit [Ping timeout: 255 seconds]
mesuutt has joined #commonlisp
zetef has joined #commonlisp
mesuutt has quit [Ping timeout: 252 seconds]
mesuutt has joined #commonlisp
mathrick has quit [Ping timeout: 264 seconds]
tok has joined #commonlisp
danse-nr3 has joined #commonlisp
nij- has joined #commonlisp
igemnace has quit [Quit: WeeChat 4.2.2]
mesuutt has quit [Ping timeout: 260 seconds]
pfdietz has quit [Quit: Client closed]
attila_lendvai has joined #commonlisp
danse-nr3 has quit [Ping timeout: 260 seconds]
notzmv has quit [Quit: salaam and see you on the other side]
<ixelp>
Cleavir/CST-to-AST/convert-special.lisp at main · s-expressionists/Cleavir · GitHub
poplin has joined #commonlisp
<nij->
I wonder, do you find the spec clear in its prose-style writing, on this aspect?
<nij->
(And awesome, I will study this code.)
igemnace has quit [Quit: WeeChat 4.2.2]
<bike>
not really. eval-when is pretty confusing and obscure. it's very rare to see anything other than (eval-when (:compile-toplevel :load-toplevel :execute) ...) anyway
mgl_ has quit [Ping timeout: 252 seconds]
rogersm has joined #commonlisp
<nij->
( I'm stuck here for 2 days. That makes me feel better :D )
<nij->
Even the ansi test doesn't test it "fully", right? I may take cautions on this in the future. Who knows what different implementations do.
<bike>
they probably all implement it fine, since it's not actuaaly that complicated
<nij->
But.. what is "fine"?
<bike>
correctly
pfdietz has joined #commonlisp
<edgar-rft>
A fine is an amount of money you have to pay for doing something wrong.
<bjorkintosh>
related to 'final' :-)
<bjorkintosh>
you did something wrong? them: Fine!. you: Fine!
Noisytoot has quit [Excess Flood]
Noisytoot has joined #commonlisp
<Inline>
ceza, Bussgeld, fine
poplin has quit [Ping timeout: 260 seconds]
mesuutt has joined #commonlisp
X-Scale has quit [Ping timeout: 250 seconds]
poplin has joined #commonlisp
cage has quit [Remote host closed the connection]
cage has joined #commonlisp
triffid has quit [Ping timeout: 260 seconds]
poplin has quit [Ping timeout: 252 seconds]
poplin has joined #commonlisp
Eoco has quit [Ping timeout: 252 seconds]
mesuutt has quit [Ping timeout: 268 seconds]
Eoco has joined #commonlisp
Noisytoot has quit [Excess Flood]
Noisytoot has joined #commonlisp
triffid has joined #commonlisp
Eoco has quit [Remote host closed the connection]
Eoco has joined #commonlisp
<dbotton>
is there a way to tell the pprint to try not to put forms on the same line? anyone know of a way to preserve comments and pretty print?
mesuutt has joined #commonlisp
<yitzi>
dbotton: For comments, you'd have to preserve them in some kind of AST versus the usual s-expr. The pretty printer interface does't have a way to skip over items when doing pprint-pop (without an extension).
<dbotton>
I figured that hoping maybe that may already exist :)
<yitzi>
If the forms are on the same line then they are probably using a fill newline. You probably want linear newline.
<beach>
Eclector can be programmed to preserve comments, but not in the S-expression result of course.
emaczen has joined #commonlisp
<yitzi>
There is also miser mode which will print fill newlines as linear in some cases
edgar-rfx has joined #commonlisp
<yitzi>
Aside from writing your own pprint-dispatch entries.
waleee has joined #commonlisp
<dbotton>
thanks, wish someone wrote a simple source code formatter outside emacs
<yitzi>
Beyond indention?
pranav has quit [Remote host closed the connection]
<dbotton>
that and also to preserve comments etc
<dbotton>
but I would take even just indention to start
edgar-rft has quit [Ping timeout: 255 seconds]
<beach>
dbotton: We are doing that as part of Second Climacs, but the task there is more complicated, because it needs to deal with incorrect code.
<yitzi>
cl-indentify, will do just indention
<yitzi>
And I have done the "preserve comments" with Inravina, but I haven't merged to main since it requires some changes to the pprint-pop protocol.
<dbotton>
thanks!
X-Scale has joined #commonlisp
traidare has quit [Ping timeout: 260 seconds]
mesuutt has quit [Ping timeout: 256 seconds]
<dbotton>
yitzi emacs and most style guides I have see place the then/else clauses of if in column with the test, is your style more common today of a simple indent?
<beach>
It is not more common, but I prefer it. It saves horizontal space, and it is more consistent with indentation of other special forms.
mesuutt has joined #commonlisp
yottabyte has quit [Quit: Connection closed for inactivity]
admich1 has quit [Read error: Connection reset by peer]
admich1 has joined #commonlisp
mesuutt has quit [Ping timeout: 256 seconds]
<dbotton>
it seems the defaults anyways different from the readme, but has other interesting things that are different like the let lining up with the bindings and with with the test
mgl_ has joined #commonlisp
<dbotton>
it works for what I want but guess have to tweak to something closer to the style guides
<beach>
Maybe you could put operators in all capital letters, so that one can parse your message more easily?
<dbotton>
thank you, good idea
<dbotton>
sorry
zxcvz has joined #commonlisp
OlCe has joined #commonlisp
X-Scale has quit [Quit: Client closed]
X-Scale has joined #commonlisp
veqq has joined #commonlisp
synchromesh has quit [Read error: Connection reset by peer]
synchromesh has joined #commonlisp
<dbotton>
yitzi sorry saw I had to load the default template first.
rogersm has quit [Remote host closed the connection]
<veqq>
I'm trying to make a GUI in CL. Most libraries don't work (e.g. gtk 3 guide examples cause division by 0 and crash slime). https://github.com/bohonghuang/cl-gtk4 is recent and has people actively using it, but during macro expansion: "Typelib file for namespace 'Gtk', version '4.0' not found"
<ixelp>
GitHub - bohonghuang/cl-gtk4: GTK4/Libadwaita/WebKit2 bindings for Common Lisp.
<beach>
veqq: Do you have any particular reason not to use McCLIM?
rogersm has joined #commonlisp
<yitzi>
dbotton: You can custom the styles of cl-identify. I don't use it much right now, but it is used in common-lisp-jupyter to code indentation. If there are changes you want, I am open to those.
rogersm has quit [Ping timeout: 264 seconds]
<dbotton>
it seems to work well so far :) I just may adjust template a bit to match emacs closer (like double tab for PROG1 and 2 and for IF)
<yitzi>
beach: which indentation do you prefer for IF? Just curious.
<dbotton>
(PROG1 and 2 indent the first 1 or 2 forms then back to normal)
<yitzi>
dbotton: Yeah, I agree. I my preferrences have changed a bit since I wrote it.
<beach>
yitzi: The one where the `then' and `else' clauses are both indented 2 spaces, like the body of most special operators.
<beach>
I was about to say something like "I would use it if my editor supported it", but I guess I could program Emacs to do it that way. Though I have noticed that when I mess with the indentation code of Emacs, strange things happen.
<yitzi>
Yeah, I like that too, but I have fallen into the habit of doing what everyone else does with the alignment with the test form.
<beach>
I understand.
<beach>
I have programmed Emacs to indent MAKE-INSTANCE like that, with everything except the class indented 2 spaces.
<beach>
... because that saves a lot of horizontal space.
<dbotton>
I honestly agree I like it better but emacs has spoken
<beach>
But, like I said, it then messes up some other indentation.
<yitzi>
Hmmmm, I guess in that case miser mode would be four spaces for the primary form.
mgl_ has quit [Ping timeout: 260 seconds]
<beach>
yitzi: Which case are you referring to?
<dbotton>
I think he meant the IF
<yitzi>
Like prog1 when the primary form doesn't fit on the same line, it is put on a new line indented by four spaces. Like this for make-instance... https://plaster.tymoon.eu/view/4230#4230
<beach>
yitzi: Right.
<yitzi>
I like it.
<beach>
Thanks.
domovod has joined #commonlisp
msavoritias has joined #commonlisp
X-Scale23 has joined #commonlisp
veqq has quit [Quit: Client closed]
X-Scale has quit [Ping timeout: 250 seconds]
nij- has left #commonlisp [Using Circe, the loveliest of all IRC clients]
mgl_ has joined #commonlisp
yitzi has quit [Remote host closed the connection]
tok has quit [Remote host closed the connection]
X-Scale23 has quit [Ping timeout: 250 seconds]
X-Scale has joined #commonlisp
triffid has quit [Remote host closed the connection]
triffid has joined #commonlisp
admich1 has quit [Ping timeout: 272 seconds]
josrr has quit [Remote host closed the connection]
<veqq>
beach what is the advantage of McCLIM vs. others? (I was able to get gtk-4 running!)
<beach>
It's a pure Common Lisp solution, so you don't have to deal with FFI. Plus, it has many advanced features that most GUI libraries don't have (because it is not practical in other languages), in particular presentations and presentation types.
admich1 has quit [Ping timeout: 252 seconds]
admich1 has joined #commonlisp
Pixel_Outlaw has joined #commonlisp
veqq has quit [Quit: Client closed]
veqq has joined #commonlisp
X-Scale has joined #commonlisp
<younder>
Ok got McCLIM to display graphs for cl-dagre
<veqq>
Actually, I have a really global problem. I struggle to find a basic workflow. I've used dbotton 's learn lisp guide on packages, the cookbook etc. but most days I can't actually get a package to load, just using the tutorials copypasted
<beach>
younder: Great!
<beach>
veqq: Maybe you are confusing Common Lisp packages with what is called packages in other languages?
<veqq>
Slime's quickload just says any package doesn't exist 75% of the time. And when it does work, the next time it will say that again
<beach>
veqq: You don't "load" Common Lisp packages. You "load" Common Lisp systems defined by ASDF:DEFSYSTEM.
<beach>
veqq: You should just have to do (ASDF:LOAD-SYSTEM "name-of-system").
<beach>
veqq: Your own ASDF system definition should depend on the GTK system.
<beach>
You should have the DEFSYSTEM in a different file with extension .asd.
awlygj has quit [Ping timeout: 268 seconds]
<veqq>
The top comment is showing that part is a file "ide.asd" . I separated it from another file with the ----- so I could copypaste it in the same textbin
<veqq>
The image shows the different files
<beach>
Oh, I see.
<scymtym>
the :cl in :depends-on (:cl :gtk4) looks a bit suspicious. are you really attempting to use a system called "cl"?
<beach>
What is the system :CL?
<dbotton>
common-llisp
<beach>
???
<scymtym>
is there an asdf system of that name? i'm not sure who this is supposed to work
<scymtym>
*how
<dbotton>
oh ya there would be issue in asdf fi;e
<beach>
veqq: Are you sure it didn't say that the "system" "cl" does't exist?
<veqq>
It's been a problem for about 6 weeks, but I only used this in the last few hours (with :cl)
<beach>
That would be normal in a DEFPACKAGE form but not in a DEFSYSTEM form.
<veqq>
Without it I have:
<veqq>
Circular dependency:
<veqq>
((#<ASDF/FIND-SYSTEM:DEFINE-OP >
<veqq>
. #<ASDF/SYSTEM:UNDEFINED-SYSTEM "ide">))
<veqq>
[Condition of type ASDF/ACTION:CIRCULAR-DEPENDENCY]
<beach>
veqq: You can't just add random system names to depend on in order to attempt to fix such a problem.
<beach>
veqq: You figure out what the problem is, and then fix it the right way.
admich1 has quit [Ping timeout: 252 seconds]
<veqq>
I didn't. I just removed it now and told you what happened. But the overall issue of asdf and quickload telling me my package doesn't exist has occured far longer than me trying to run examples with :cl
<veqq>
The key is that this example ran 2 hours ago, but returning to my computer, it now says the package doesn't exist
<beach>
Which package is it that doesn't exist?
<veqq>
"ide" the one from the picture and the bin
<veqq>
I rewrite the same file with new stuff, because dbutton's example is the only package I've ever been able to run, eve
danse-nr3 has quit [Ping timeout: 240 seconds]
<beach>
You shouldn't have a quickload in your test2.lisp.
<beach>
You should have no quickloads anywhere.
<beach>
You should have a :DEPENDS-ON clause in your DEFSYSTEM where you depend on other systems.
<veqq>
So the quickload conflicts with the asd? If I don't use asdf to manage this, I would use a quickload in the .lisp file?
<beach>
Quicklisp uses ASDF.
<beach>
And you should too.
<beach>
Sorry, got to go. My (admittedly small) family just announced that dinner is served.
<veqq>
But I am using asdf
<veqq>
I gave you the errors from asdf "(asdf:load-system :ide)"
<veqq>
Thank you. Bon appetit
awlygj has joined #commonlisp
msavoritias has quit [Remote host closed the connection]
mgl_ has quit [Ping timeout: 255 seconds]
<veqq>
Basically, I'm desperate. I've spent 6 weeks fighting emacs/slime/idk unable to just open a file, put stuff in it, load it, then close everything and load it again. Loading it again fails. Now both asdf and quicklisp say the package doesn't exist. But I'm willing to robotically use anyone's workflow.
<veqq>
Otherwise I comfortably work in vscode and just use scbl as a compiler. But everyone says that's not the way...
<dbotton>
veqq use the builder to create your initial project - choose on projects - new and then console project and then add the gtk or whatever you like
<dbotton>
after you have done that you can go back to emacs or whatever ide you want
<dbotton>
the new project you created can be loaded (ql:quickload :yourproj)
mesuutt has quit [Ping timeout: 260 seconds]
<dbotton>
sorry for throwing my project at this, but hoping you can look at the generated files and compare and learn
jmercouris1 has joined #commonlisp
<dbotton>
(if you are using the ultralisp version you can actually run, debug and edit even the gtk project in the builder)
jmercouris1 has quit [Client Quit]
poplin has quit [Read error: Connection reset by peer]
poplin has joined #commonlisp
mgl_ has joined #commonlisp
danse-nr3 has joined #commonlisp
admich1 has joined #commonlisp
amb007 has joined #commonlisp
danse-nr3 has quit [Ping timeout: 252 seconds]
domovod has quit [Ping timeout: 264 seconds]
mgl_ has quit [Ping timeout: 268 seconds]
veqq has quit [Quit: Client closed]
veqq has joined #commonlisp
yitzi has joined #commonlisp
markb1 has joined #commonlisp
<younder>
dbottom when trying to create a new project in CLOG I choose common-lisp then clog complains that the directory already exists. Shouldn't it create a directory system-name under common-lisp?
decweb has quit [Ping timeout: 240 seconds]
awlygj has quit [Quit: leaving]
alcor has left #commonlisp [ERC 5.6-git (IRC client for GNU Emacs 29.3)]
alcor has joined #commonlisp
<dbotton>
it does, you most already have one there
<dbotton>
try different project name younder or PM my what you are seeing
veqq has quit [Quit: Client closed]
decweb has joined #commonlisp
OlCe has quit [Remote host closed the connection]
veqq has joined #commonlisp
OlCe has joined #commonlisp
decweb has quit [Ping timeout: 255 seconds]
mesuutt has joined #commonlisp
random-jellyfish has joined #commonlisp
mesuutt has quit [Ping timeout: 252 seconds]
pfdietz has quit [Quit: Client closed]
veqq has quit [Quit: Client closed]
emaczen has quit [Ping timeout: 268 seconds]
admich1 has quit [Quit: Quit]
decweb has joined #commonlisp
veqq has joined #commonlisp
X-Scale has quit [Ping timeout: 250 seconds]
X-Scale has joined #commonlisp
random-jellyfish has quit [Ping timeout: 256 seconds]
<dbotton>
yitzi any chance your cl-indent could handle &key arguments over multiple lines and how to do in your config file?
kevingal has quit [Ping timeout: 260 seconds]
<yitzi>
No, don't think it is that clever.
<yitzi>
Out of curiosity, what are you trying to format?
<dbotton>
I got the rest how I like :)
kevingal_ has quit [Ping timeout: 260 seconds]
<dbotton>
the builder IDE, source files, tabbify etc
<dbotton>
works amazing
<dbotton>
btw
<dbotton>
I am adding keyboard hooks now for that tabbing
<yitzi>
ok
<dbotton>
can try it anytime in ultralisp version if have setup
mgl_ has joined #commonlisp
<yitzi>
If you have changes, please feel free to submit a PR. I'm open.
<dbotton>
at this point need to have the editor select to start of row next form up and then run your code
X-Scale has quit [Quit: Client closed]
<veqq>
Another package related question. If I just load my file, it doesn't work because gtk4 doesn't exist (whether in depends, :use etc. I also tried cl-gtk4, but the examples just use :use :gtk4 with no .asd at all.) But if I first (ql:quickload :cl-gtk4), then load my file, it works. What is going on? ;(
<dbotton>
cl-gtk4 is loaded into your image by the quickload
<dbotton>
if you add it in your asd file to the depends-on then quickload will load it for you when you load your system
<veqq>
I just wrote that it is in the depends...
<dbotton>
do you reload your system after adding it?
<dbotton>
if you change the ASD file nothing happens till the next time you load the system
<veqq>
Of course. And each permutation with different names (since quickload uses a different name than the use)
mesuutt has joined #commonlisp
mesuutt has quit [Ping timeout: 268 seconds]
<veqq>
I literally made a chart of all permutations and tried them, but unless I first manually quickload it doesn't work. Even if I put that quickload as the first thing in the file it doesn't work
<josrr>
veqq: the system is called CL-GTK4; the package is called GTK4; so in :DEPENDS-ON you put the system and in :USE you put the package.
poplin has quit [Ping timeout: 240 seconds]
poplin has joined #commonlisp
<veqq>
1, is there a difference between which you use / should you use both?
<veqq>
2, I have done permutations like that. I just made it like that now, it still isn't working.
<veqq>
"The name "GTK4" does not designate any package.
<veqq>
[Condition of type PACKAGE-DOES-NOT-EXIST]"
poplin has quit [Read error: Connection reset by peer]
poplin has joined #commonlisp
X-Scale has joined #commonlisp
mesuutt has joined #commonlisp
<josrr>
veqq: (1) Yes, they are completely different things. (2) I think you need to show us exactly what you're doing.
<yitzi>
use `(export #:start-app)` in your package definition
<yitzi>
`(:export #:start-app)` that is.
<yitzi>
And you don't LOAD the system. You use either ASDF:LOAD-SYSTEM or QL:QUICKLOAD
<yitzi>
So line 30 should be `(ql:quickload :5ide)`
<yitzi>
With that you should be able to skip like 29
<yitzi>
s/like/line/
<veqq>
I want to cry. (Actually I have been for some hours...) Others told me to never use quickload, nor asdf. and just use (load ...).
<veqq>
The :export is only there because of the clog builder, which is the only way I was able to get something which would work with quickload.
<veqq>
I swear, I've read the guides multiple times. I've gone through PCL, even PAIP and so on in the past. But none of this build system makes sense.
<yitzi>
ASDF isn't really covered in those.
<veqq>
The cookbook and Clog's learn CL cover it
<yitzi>
Did you try those changes?
<veqq>
It worked.
<yitzi>
Good
cage has quit [Quit: rcirc on GNU Emacs 29.2]
pve has quit [Quit: leaving]
<veqq>
What was going on there? I removed the export etc. and it works with both load and quickload now, woo.
random-jellyfish has joined #commonlisp
<yitzi>
The export is fine. It just needs an uninterned symbol. `#:start-app`
<veqq>
The clog builder makes it without :#, but I dont see how interning that symbol would lead to it not identifying another namespace. I'm beyond baffled
<yitzi>
The main issue is that you need to use ql:quickload or asdf:load-system because that calls ASDF to locate the ASD file and its contents.
<veqq>
I have been. I started the day having a problem with ql:quickload and people told me not to use it, then not to use asdf. :D
<veqq>
I've been having such problems for about ~6 weeks, giving up constantly, but the allure of image based development keeps me coming back
<yitzi>
I don't think you are getting what I am saying.
<holycow>
no one told you not to use quickload
<yitzi>
The issue isn't avoiding using QL:QUICKLOAD
<holycow>
they told you to not use quickload in your files
<yitzi>
Yep
<bike>
beach said not to use quickload, but he meant within your system files
<bike>
analogously that's like, i don't know, putting make commands in your c sources
veqq has quit [Quit: Client closed]
<bike>
alright
veqq has joined #commonlisp
<bike>
your connection die?
<holycow>
it is okay to be frustrated though, it's a normal prt of learning somthing complicated
<veqq>
Why did an interned symbol in export make quickload/asdf not find the gtk4 namespace, though?
<veqq>
I'm using the client on libera.chat, maybe it can't keep a connection for long. :(
<bike>
it's fine, just make sure you check the log in case you miss something
<Noisytoot>
web browsers like to kill tabs
<veqq>
holycow Frustration because it doesn't feel like learning. Robotic repetitions seem to result in wildly different outcomes. None of the guides really cover stuff/explain this (or where do I find that?) All but 1 friend gave up and just use clojure or racket (as did I in the past.)
<veqq>
It doesn't seem like there are concepts to learn, or tricky interactions.
<veqq>
I actually can't figure out what's different from this and the first stuff I had this morning where quickload wouldn't identify the local package
<holycow>
in other languages this is handled for users by the ide
traidare has joined #commonlisp
<holycow>
for example, python is a mind bender to get the vm running and remember the obscure vm environment setup
<holycow>
never mind backing it up, workign with revisions, etc.
<holycow>
from a noobs perspective
<holycow>
but in a python ide, all of that is hidden from you and it the ide handles it
<veqq>
Oh, but python has the brutalist deployment story of all.
<holycow>
anyway i mean that only as advice. i want to minimize chat here, it is meant to be more technical
<veqq>
I've done rust, forth, factor, ada, squeak etc.
<bjorkintosh>
squeak??
<bjorkintosh>
wild.
<veqq>
Ah, understood. Well, my question: why does uninterning the export impact whether it finds a name space later?
<yitzi>
It doesn't
<yitzi>
Again, the issue is LOAD vs QL:QUICKLOAD
amb007 has quit [Ping timeout: 268 seconds]
<yitzi>
But in general, :export should only have uninterned symbols because you are not in the package namespace. The package is still being defined there.
yitzi has quit [Remote host closed the connection]
<veqq>
bike I was using quickload the whole time, along with load and asdf's load. The pastebin said "Beach said not to have a quickload in the code". I can reproduce the failing again by interning exports, that's why I'm baffled
<veqq>
Also, uninterning it made load work, too.
<josrr>
no, LOAD probably works because the CL-GTK4 system is already present in you image.
<veqq>
Is it fine/idiomatic to not use :use and handle all imports through asdf? (At least in toys where you don't need the separation)
<veqq>
Thank you everyone. Sorry for the spam/volume.
<bike>
i think you are misunderstanding the relationship between packages (namespaces) and systems (collections of files representing together a program or library)
<bike>
asdf does not have :use or imports. :use and imports are package stuff
mgl_ has quit [Ping timeout: 268 seconds]
<veqq>
I mean, asdf uses quickload to verb (if not import?) but it's still usable without a :use in the file, because the image reveals it. When compiling straight with sbcl, that doesn't work, but it seems to be now
<bike>
asdf does not use quickload for anything.
<bike>
quicklisp is built on top of asdf.
<veqq>
Oh, quickload uses asdf. What would the depends-ons be then?
<bike>
depends-on are part of the asdf system specification.
<bike>
these are, again, unrelated to :use.
<veqq>
If I put the system :cl-gtk into :depends on, I don't have to put its namespace in :use, while working in an image. 1) If taking a system isn't an import, what is it? 2) is it ok to not use :use in this case?
<reb>
veqq: Have you read the ASDF documentation?
<veqq>
I read straight through until where it tells you where to define systems, just using /common-lisp/ instead. But it's been some weeks.
mesuutt has quit [Ping timeout: 268 seconds]
<bike>
I'm pretty sure "If I put the system :cl-gtk into :depends-on, I don't have to put its namespace in :use" is incorrect.
<bike>
asdf knows about systems. when you tell it to load a system, it loads all the files in that system as well as the systems that system depends-on. so if your system depends-on cl-gtk, loading your system will load cl-gtk first.
<ixelp>
asdf/doc/best_practices.md at master · fare/asdf · GitHub
<bike>
but asdf does **not** do anything with packages. it may load the cl-gtk system, which may define some packages, but asdf doesn't know about that.
<bike>
if you define your package (namespace), and it does not :use whatever cl-gtk package(s), you will be unable to use *unqualified* names from cl-gtk in code that is in your *package*. this is all core lisp stuff, not asdf.
<veqq>
It could be an artefact of cl-gtk (exposing?) them in it's example packages
<bike>
So, in https://plaster.tymoon.eu/view/4233, here's what's happening: you load 5ide.lisp. because you are just loading a file, asdf is not involved, and in particular the cl-gtk4 system is not loaded. so, the gtk package that the cl-gtk4 system defines is not defined, so you get a package-does-not-exist on gtk4
<bike>
If you then quickload cl-gtk4 yourself, the gtk package is defined. so if you load 5ide.lisp after quickloading, the gtk package exists and there's no problem.
<bike>
now, once it's quickloaded, it's quickloaded. the gtk package continues to exist in the image. so loading 5ide.lisp thereafter will work fine. but you're still not using your asdf system.
mesuutt has joined #commonlisp
<bike>
if you restart your lisp image and load 5ide.lisp again without first quickloading cl-gtk4, you'll get the package-does-not-exist again. so what you want to do is use asdf. if you just quickload (or asdf:load-system) your 5ide system, asdf will see the cl-gtk4 dependency and load that, and then load your 5ide.lisp file, so everything goes fine.
<bike>
is this making any sense?
<veqq>
This makes sense yes. (load ...) obviously doesn't use what's in .asd when it's only loading a specific .lisp file.
<bike>
Yes.
<bike>
and, this is important, the defpackage form doesn't have anything to do with loading dependencies like cl-gtk4 - it just defines a namespace, and you wrote it to assume the gtk4 namespace already exists.
<bike>
so if it doesn't exist, kablooie
<veqq>
I'm asking if there's a reason to use :use (for small projects) instead of just putting dependencies in an .asd's depends-on and using ql:quickload for everything
dom2 has quit [Ping timeout: 268 seconds]
mesuutt has quit [Ping timeout: 252 seconds]
<veqq>
I think I'm asking about the opposite direction of what you explained
<younder>
Perhaps you would like cl-project which sets up the project for you. That has helped me with these setup problems.
<veqq>
Going back to the original ide (not 2-5) from 8 hours ago, the issue was "defpackage :ide" instead of "defpackage #:ide"
seanw has quit [Remote host closed the connection]
<younder>
If it is more than one file I find it is better to make it a system.
traidare has quit [Ping timeout: 272 seconds]
attila_lendvai has quit [Ping timeout: 256 seconds]
amb007 has joined #commonlisp
dom2 has joined #commonlisp
seanw has joined #commonlisp
<bike>
veqq: :use and dependencies are unrelated.
<bike>
if what you're asking is "should i bother with asdf for small projects", that is of course up to you, but yeah, for like a really simple single file script you can probably get by without asdf.
<bike>
defining an actual system will be easier to understand and more future proof.
<veqq>
I'm asking the exact opposite. Why use :use in a system?
<veqq>
Please, I understand that defsystem and defpackage are different. But what is the purpose of putting :use in the defpackage if defsystem does so much more, and the :use won't do anything, requiring you to manually load them before loading the actual package?
<bike>
defsystem does not do what use does
<bike>
your :use says: in the 5ide package, when you see a symbol with no package qualifier, it can be a symbol exported from either the CL or gtk4 packages.
<bike>
defsystem does not affect your 5ide package at all so it does not have this effect.
<bike>
(and in the other direction, the defpackage does not tell anything to load the cl-gtk4 system)
zetef has joined #commonlisp
<veqq>
I understand that :use lets you e.g. not type gtk4:thing and use do :thing if there aren't namespace collisions. But does it play any required role, or could you safely not use it (and type things out more?)
<veqq>
I dont know why that was bold,s orry.
<bike>
no problem. you can safely not use it. it strictly affects the package and not anything about dependencies. i would actually recommend not using it, usually.
<bike>
i mean, don't :use except for cl
<veqq>
I'm sorry for being so distraught that that wasn't clear. That's what I've been trying to ask the whole time. Thank you for your time, I really appreciate it.
<bike>
don't worry about it, it's confusing and dealing with computers not doing what you expect is very frustrating
wacki has quit [Quit: My iMac has gone to sleep. ZZZzzz…]
gooba has quit [Ping timeout: 256 seconds]
gooba has joined #commonlisp
shka has quit [Ping timeout: 252 seconds]
HerlockSholmes has joined #commonlisp
amb007 has quit [Ping timeout: 256 seconds]
dino_tutter has quit [Ping timeout: 268 seconds]
veqq has quit [Quit: Client closed]
zetef has quit [Remote host closed the connection]
poplin has quit [Read error: Connection reset by peer]
poplin has joined #commonlisp
HerlockSholmes has quit [Remote host closed the connection]
mesuutt has joined #commonlisp
mesuutt has quit [Ping timeout: 260 seconds]
rgherdt has quit [Remote host closed the connection]
pfdietz has joined #commonlisp
yitzi has joined #commonlisp
<yitzi>
younder: What packages are "used" by default is implementation dependent. Some implementations "use" CL for you always.
lagash has quit [Remote host closed the connection]
Inline has quit [Ping timeout: 260 seconds]
luna-is-here has quit [Ping timeout: 260 seconds]
pfdietz has quit [Quit: Client closed]
luna-is-here has joined #commonlisp
Inline has joined #commonlisp
pfdietz has joined #commonlisp
amb007 has joined #commonlisp
<aeth>
yes, so always have the empty (:use) if you're doing something fancy (i.e. writing a package just for namespacing, perhaps for a DSL, and you don't want CL symbols in there).