<moon-child>
i mean, you're probably doing alias analysis anyway
<moon-child>
and you don't know how often some bit of code is gonna be called
<phoe>
if it happens at compile time with (optimize speed) then who cares if it's expensive or not, as long as it gives you a little bit of runtime speed
<masinter>
it's not for macroexpansion
<phoe>
:D
<phoe>
but this, again, assumes a sufficiently smart compiler
<moon-child>
I'm gonna get a bumper sticker that says 'my other car is a sufficiently smart compiler'
<phoe>
(incf moon-child)
<masinter>
there are lots of situations where freshness isn't determinable
<phoe>
yes
<masinter>
do python and js have the problem?
<moon-child>
I don't think python and js have ,. or ,@
<masinter>
i meant of determining freshness
<masinter>
turning calls to APPEND into calls to NCONC
<moon-child>
oh. There's been some work done on this in the past, but usually language features, not an implementation strategy
<moon-child>
cf linear lisp, koka I think
<masinter>
readonly strings
Bike has quit [Quit: Connection closed]
pve has quit [Quit: leaving]
dlowe has joined #commonlisp
dlowe has quit [Remote host closed the connection]
<sveit>
is there a standard way to "undefine" a package for interactive use? delete-package doesn't seem to unintern symbols, etc. and I'd like the whole thing to be available for garbage collection
<sveit>
the reason is I want to remove/reset some things I have been working on without restarting the lisp session
<phoe>
delete-package *should* unintern symbols
<mfiano>
If there is no longer a package, there is nothing to intern them into.
<sveit>
I was just referring to the standard "After this operation completes, the home package of any symbol whose home package had previously been package is implementation-dependent."
jpl01 has left #commonlisp [ERC (IRC client for Emacs 27.2)]
<mfiano>
That hurts my brain to think about the damage a conforming but insane implementation could cause.
Bike has joined #commonlisp
<sveit>
so in practice if i define a bunch of garbage in some throw-away package in what I want to be a long-running lisp session, and then delete the package, I can expect that the data/variables associated to that package can be garbage collected?
unyu has joined #commonlisp
masinter has quit [Ping timeout: 240 seconds]
s-liao has joined #commonlisp
s-liao has quit [Ping timeout: 256 seconds]
s-liao has joined #commonlisp
raeda has quit [Quit: Leaving]
xsperry has quit [Remote host closed the connection]
<Bike>
this example doesn't really explain what you mean
<mfiano>
Nor slots
mon_aaraj has quit [Ping timeout: 240 seconds]
<Bike>
also, all slots are "optional" in the sense that you can just leave them unbound if you want
<Bike>
is that what you mean by "optional"?
<asarch>
From Seibel's PCL: "To define a function with optional parameters, after the names of any required parameters, place the symbol &optional followed by the names of the optional parameters. A simple example looks like this: (defun foo (a b &optional c d) (list a b c d))"
<asarch>
So, by this way: "(foo 1 2) ==> (1 2 NIL NIL)"
<beach>
asarch: That has nothing to do with slots.
semz has quit [Ping timeout: 250 seconds]
<moon-child>
asarch: do you perhaps want :initform nil?
<mfiano>
Maybe you want to (apply #'make-instance :allow-other-keys t ...)
<mfiano>
Your question and follow up citation makes me very confused.
<Bike>
could you please just write out an explanation of what you have in mind in english
mon_aaraj has joined #commonlisp
Oladon has quit [Quit: Leaving.]
<asarch>
Ok. In HTML, every element can have a class, right?
<Bike>
a class attribute? sure.
<White_Flame>
javascript doesn't have fixed slots, though, so already it's not that comparable to defclass
<asarch>
By default, every element has the "foo" class. But let say I want an element with no class at all
<mfiano>
Maybe next time start off by saying you don't mean Common Lisp classes.
<Bike>
well, like i said, slots can be unbound
<White_Flame>
or they could hold NIL or any other special "not a class" value
<Bike>
so if you had a slot for the html class, having it unbound could mean no class, and having it be "foo" would mean that the class would be "foo"
<moon-child>
in javascript, from a lisp perspective, every object has its own class. Kinda
* White_Flame
hides in a shadow class
<asarch>
So, I was wonder if there was a way to "turn off" the class attribute of the element with an option function paramenter a la (let ((my-button (make-instance 'the-html-element ... :noclass) ...)
<Bike>
just don't provide it
<Bike>
presto, it's unbound
<Bike>
or provide it with some distinguished value like nil, like white flame said
<White_Flame>
can you specify "unbound" in a type specifier?
<White_Flame>
as an OR option
<Bike>
nope
<mfiano>
No
<Bike>
(short of satisfies)
<White_Flame>
right, thought so
<White_Flame>
so you can't really use a type specifier for that slot if you allow unbound
<asarch>
So, it was the same as: (make-instance 'the-html-element :class nil), right?
<White_Flame>
(make-instance 'the-html-element) => class slot unbound
<asarch>
*It would be the same as...
<Bike>
White_Flame: you can. the type specifier doesn't apply if the slot is unbound.
<White_Flame>
(make-instance 'the-html-element :class nil) => class slot bound to NIL
<White_Flame>
Bike: ah, ok
<White_Flame>
*instance slot
<White_Flame>
erm, instance slot named "CLASS" :-P
Bike has quit [Quit: the night]
<asarch>
That's why I always use name of food :-P
<asarch>
(make-instance 'the-taco :pizza nil)
<mfiano>
It seems strange to represent an HTML element as an standard-object outside of a CST or something.
<White_Flame>
yeah, there are such a huge number of standard fields on them, and the user can add any additional ones they want
<moon-child>
yeah, I should rather model html using hash tables
<mfiano>
Reminds me of fluid slots in cl-json
* mfiano
shudders
<mfiano>
The worst use for the MOP I've ever seen.
<asarch>
"Worst is better"
<asarch>
Anyway, thank you, thank you very much :-)
<asarch>
Have a nice day gentlemen
asarch has quit [Quit: leaving]
tyson2 has quit [Remote host closed the connection]
<mfiano>
I was hoping we'd be spared the taco this time.
<beach>
I was wondering why only gentlemen are allowed to have a nice day.
lispnik has joined #commonlisp
s-liao has quit [Ping timeout: 256 seconds]
masinter has joined #commonlisp
<White_Flame>
at first I thought it was an "all your base" reference
s-liao has joined #commonlisp
<masinter>
The symbols can have pointers to them
lispnik has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<masinter>
you can't expect garbage collection to collect anything
ec has quit [Ping timeout: 276 seconds]
<mfiano>
I created #clprojects and edited CLiki appropriately. I talk to myself a lot when I'm designing a new project, mostly for the log of ideas, and thought it could be a common rather than some scratch log file.
<mfiano>
common ground that is.
lispnik has joined #commonlisp
szkl has quit [Quit: Connection closed for inactivity]
mon_aaraj has quit [Ping timeout: 256 seconds]
mon_aaraj has joined #commonlisp
lispnik has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
mon_aaraj has quit [Ping timeout: 240 seconds]
mon_aaraj has joined #commonlisp
Jing has joined #commonlisp
akoana has quit [Quit: leaving]
mon_aaraj has quit [Ping timeout: 256 seconds]
mon_aaraj has joined #commonlisp
s-liao has quit [Quit: Client closed]
mon_aaraj has quit [Ping timeout: 240 seconds]
mon_aaraj has joined #commonlisp
Everything has joined #commonlisp
perrierjouet has quit [Quit: WeeChat 3.4]
perrierjouet has joined #commonlisp
mon_aaraj has quit [Ping timeout: 256 seconds]
mon_aaraj has joined #commonlisp
<phoe>
mfiano: #clprojects
<phoe>
?
<phoe>
oh, I see
<beach>
I still don't.
alfonsox has joined #commonlisp
<phoe>
beach: I guess if the focus is on a project and its architecture design, rather than on CL topics, a discussion can go there
<beach>
Hmm. OK.
Everything has left #commonlisp [#commonlisp]
mon_aaraj has quit [Ping timeout: 256 seconds]
<edgar-rft>
#clprojects is a new registered channel, but probably not all network servers are already updated yet. I can't see it in /list either, but I was there and talked to mfiano about that.
<beach>
That's fine, but I would like to understand the purpose before considering joining.
<edgar-rft>
collecting ideas about howto design and setup new CL projects from scratch
<mfiano>
That's not the purpose.
mon_aaraj has joined #commonlisp
<phoe>
mfiano: gasp
<phoe>
what is then?
<phoe>
oh, wait, I misread edgar-rft's post
<mfiano>
The purpose is to discuss ideas, architectural decisions, etc for your currently active project, that would be too broad and/or off-topic for a dedicated language channel such as this one.
<edgar-rft>
mfiano knows best but the channel topic says: Common Lisp community project discussions. Discuss the design or anything about your current active project that might be too focused for #commonlisp.
<mfiano>
I am using it to document my ramblings that would otherwise be to myself :)
<beach>
So that sounds like one should join only if one is interested in your projects.
<beach>
No?
<mfiano>
Or if you want others to be interested in your projects.
<beach>
I see.
<moon-child>
I think the point is that you join to ramble about your own projects
<moon-child>
and, in exchange, have (get?) to listen to others' ramblings
<mfiano>
Think #sicl content, but general to anyone's project
<beach>
Got it.
ogamita has joined #commonlisp
wacki has joined #commonlisp
aartaka has joined #commonlisp
ASau has joined #commonlisp
<beach>
LOOP was one of the first SICL modules I wrote, and I think it is ripe for extraction to a separately-maintained repository.
<beach>
SICL LOOP is more strict than MIT LOOP with respect to clause ordering, and also more strict about how it assigns loop variables. For instance, in SBCL, you can't do (loop for x of-type (integer 0 3) for x from 0 to 3 ...).
<beach>
SICL LOOP represents LOOP clauses as standard objects, so it should be easier to extend than MIT LOOP, though no protocol for such extensions has been designed.
<beach>
There are also some things that I am not so pleased with. For one thing, there is a flaw in how AND is handled (there is an issue describing it).
<beach>
And I am not happy with the parsing technique used for clauses. Currently I use a simplified version of combinator parsing.
<beach>
Ultimately, I think the way to go is to use scymtym's library for S-expression syntax, but that library may not be quite ready yet. I am suggesting it because I think that, once it is ready, we should use it in other parts of SICL and Cleavir as well.
<beach>
Anyway, if someone is interested in being the LOOP maintainer, let me know.
<beach>
Oh, and SICL LOOP does not have the defect that MIT LOOP does which is that MIT LOOP copies the last list when APPEND is used.
<beach>
Anyone who would like more information can ask here or in #sicl.
ante_ has joined #commonlisp
nature has joined #commonlisp
s-liao has joined #commonlisp
<moon-child>
'doesn't have the defect' I think it does still perform extraneous traversals for append/nconc, though, right? Or was that fixed?
masinter has quit [Ping timeout: 256 seconds]
<beach>
Does it? You may be right.
<beach>
Though if there is a trade-off between correctness and performance, I much prefer correctness.
cage has joined #commonlisp
pve has joined #commonlisp
shka has joined #commonlisp
ante_ has quit [Ping timeout: 240 seconds]
<moon-child>
actually, thinking about it a bit more, I think MIT's behaviour (the 'defect') may be correct. Or, at least, it is different; I'm not sure what is correct, but it is more consistent
<moon-child>
thinking about mutation
<moon-child>
(loop with x = (list 1 2 3) with y = (list 5 6 7) append x do (nconc x (list 4)) append y do (loop-finish))
<moon-child>
should return (1 2 3 5 6 7) with mit but (1 2 3 4 5 6 7)
<moon-child>
with sicl
<moon-child>
hyperspec says: 'The append keyword causes its list values to be concatenated into a single list, as if they were arguments to the function append'
<beach>
Yes, and APPEND does not copy its last argument.
<moon-child>
when appending many lists, structure is shared _only_ with the last one. But clearly it is not possible to know ahead of time which value APPENDed in a loop will be the last one
<moon-child>
hence it seems arbitrary to preserve mutation only of the value most _recently_ APPENDed
<beach>
No, but I detect it dynamically.
<moon-child>
see my above snippet. If we switch around the clauses and instead do: append x append y do (nconc x (list 4)) that change does not show up in the loop's result
<moon-child>
in sicl loop
<beach>
I can't easily follow that example. But I do know that for the simple case, MIT loop does not behave as if the APPEND function had been used.
<moon-child>
can you explain what you find difficult to follow about it?
<moon-child>
my point is that it is impossible, in general, to consistently behave as though the APPEND function had been used
<beach>
Oh, the problem is likely with me rather than with the example.
<beach>
I am willing to believe that, especially for more twisted cases.
<beach>
It is not even clear at which point in time the APPEND function should be used.
<beach>
Perhaps we are supposed to accumulate each individual list and then do a big (reduce #'append...) in the end.
etiago has quit [Ping timeout: 250 seconds]
<moon-child>
that was my interpretation. But that does not work since you can APPEND INTO and view intermediate states
<beach>
Yes, and you can mix APPEND and COLLECT.
<moon-child>
yeah
<beach>
So we seem to have a case for WSCL.
xaltsc has quit [Remote host closed the connection]
<jackdaniel>
no, yellow ducks don't quack so I thought about providing sfx
<phoe>
oh
<phoe>
thank you
artchad has joined #commonlisp
s-liao has quit [Quit: Client closed]
s-liao has joined #commonlisp
pranavats has joined #commonlisp
Everything has joined #commonlisp
MajorBiscuit has joined #commonlisp
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life_ is now known as Lord_of_Life
ante_ has joined #commonlisp
santiagopim has quit [Remote host closed the connection]
amk has quit [Ping timeout: 256 seconds]
amk has joined #commonlisp
attila_lendvai has quit [Ping timeout: 245 seconds]
amb007 has quit [Ping timeout: 256 seconds]
amb007 has joined #commonlisp
aeth has quit [Ping timeout: 256 seconds]
aeth has joined #commonlisp
amb007 has quit [Ping timeout: 256 seconds]
amb007 has joined #commonlisp
Dynom has joined #commonlisp
random-nick has joined #commonlisp
lisp123 has joined #commonlisp
MajorBiscuit has quit [Ping timeout: 256 seconds]
mon_aaraj has quit [Ping timeout: 256 seconds]
mon_aaraj has joined #commonlisp
lisp123_ has joined #commonlisp
lisp123_ has quit [Client Quit]
lisp123 has quit [Ping timeout: 256 seconds]
MajorBiscuit has joined #commonlisp
occ has quit [Ping timeout: 256 seconds]
Bike has joined #commonlisp
McParen has joined #commonlisp
tyson2 has joined #commonlisp
<McParen>
hello, what is nowadays the recommended way to deal with naming clashes with symbols from the default cl package? just shadow them in your own package and avoid :use-ing your own package at once and use fully qualified symbols?
<beach>
Yes.
<beach>
And use package-local nicknames if your package names are too long.
<beach>
Er, I mean, don't :USE
<beach>
No need to :SHADOW.
<McParen>
I would need to shadow to use the symbol in my own package?
<beach>
Right.
<beach>
You :SHADOW them in the package that defines symbols with the same name as those in the CL package, but not in the client package.
<McParen>
Okay.
<McParen>
Is the use of package local nicknames and using fully qualified symbols that can be "expected" from downstream users? Or do people still mostly :use other packages?
<phoe>
both
<phoe>
a lot of existing code depends on :USE, hence e.g. Alexandria cannot export new symbols without the risk of breaking 90% of the FOSS Lisp world
<phoe>
but new code can freely use PLNs
<beach>
McParen: Most people here seem to favor :USE-ing only the CL package.
<beach>
McParen: So I think that is going to be the preferred way in new systems.
<McParen>
beach, phoe: thank you, that is reassuring to know.
<beach>
Pleasure.
<McParen>
Maybe it would be useful to encourage that style (local nicknames + fully qualified symbols) in the cookbook or other well known documents, if that isnt the case already
<phoe>
good idea
* phoe
takes a note for CLR2
paulapatience has joined #commonlisp
paulapatience has quit [Remote host closed the connection]
paulapatience has joined #commonlisp
paulapatience has quit [Remote host closed the connection]
<McParen>
phoe: are you working on a follow-up of weitz' recipes book? that sounds great. do you have an idea how long the writing is going to take?
<McParen>
beach: thanks, i was not aware at all of that site.
<beach>
Metamodular? Oh, it's just my stuff.
<phoe>
McParen: second edition, I hope to be done in 2022
<jackdaniel>
beach: regarding your remark of dubious usefullness of the function validate-superclass, I've just remembered it because I've recently wrote a method where it makes (imo) sense: https://plaster.tymoon.eu/view/2923#2923
<jackdaniel>
s/where it/where such method/
dlowe has joined #commonlisp
<jackdaniel>
i.e by limiting inheritance only to the standard-object
dlowe has quit [Remote host closed the connection]
dlowe has joined #commonlisp
<beach>
Thanks.
MajorBiscuit has quit [Ping timeout: 256 seconds]
ec has joined #commonlisp
occ has joined #commonlisp
szkl has joined #commonlisp
s-liao has quit [Quit: Client closed]
artchad has quit [Read error: Connection reset by peer]
artchad has joined #commonlisp
yewscion has joined #commonlisp
mister_m has quit [Remote host closed the connection]
yewscion has quit [Quit: Connection closed]
yewscion has joined #commonlisp
psf has quit [Ping timeout: 240 seconds]
psf has joined #commonlisp
semz_ is now known as semz
mister_m has joined #commonlisp
sloanr has quit [Ping timeout: 256 seconds]
mon_aaraj has quit [Ping timeout: 240 seconds]
mon_aaraj has joined #commonlisp
mason has left #commonlisp [#commonlisp]
wyrd_ has quit [Ping timeout: 276 seconds]
<jackdaniel>
beach: http://metamodular.com/CLOS-MOP/effective-slot-definition-class.html contains a broken link to a class "effective-slot-definition"; in the book it is " The value returned is a subclass of the class effective-slot-definition-class." (mind the suffix -class)
<beach>
Thanks. Fixing...
<beach>
Does the book really say effective-slot-definition-class? That doesn't sound right. Let me check...
igemnace has joined #commonlisp
McParen has left #commonlisp [#commonlisp]
yewscion has quit [Ping timeout: 240 seconds]
<Bike>
also, effective-slot-definition actually is a class.
<beach>
Yeah.
<jackdaniel>
I can tell that it is a class in all implementations I'm aware of, but it is not specified in amop (at least it is not in the index)
<jackdaniel>
and yes, I'm sure that my edition of the book says effective-slot-definition-class
<beach>
It does. But I think it's wrong.
<beach>
Because there is no such class defined.
<beach>
I'll fix the link and I'll write a note.
<jackdaniel>
neither is defined, also standard-slot-definition is not defined either (looking at your inheritance graph)
<beach>
effective-slot-definition is a specified class.
<beach>
Yes, the link is wrong, and the book is wrong about the name of the class.
<beach>
So, again, I'll fix the link and I'll write a note.
<jackdaniel>
I see, it is mentioned in the table for the superclass relationship
<beach>
"it"?
<jackdaniel>
the class "effective-slot-definition"
<beach>
Right.
<jackdaniel>
I couldn't find it in the index, because it didn't have a separate entry
Everything has quit [Quit: leaving]
<beach>
In the index of the book?
<jackdaniel>
yes
Bike has quit [Quit: Connection closed]
<beach>
Yes, the organization of the book is a disaster.
Bike has joined #commonlisp
<beach>
That's why I felt the need to create this site.
<jackdaniel>
for me it is well organized (for a book that has sequential pages that is)
<beach>
Of course.
<jackdaniel>
beach: "of course" is a bit amgiguous to me - "of course" that /it is clear for me/, or "of course" that /it is well organized for a book that has sequential pages/?
<jackdaniel>
ambiguous*
<beach>
The former.
<beach>
OK, fixed now I think.
<beach>
Thanks again.
<beach>
Let me know if it looks better.
<jackdaniel>
I see, then I don't understand what you have said
<jackdaniel>
sure, thanks for fixing it
<beach>
Oh, I am just getting used to saying things that people disagree with. I guess I need to think harder before uttering stuff.
<beach>
Sure. I think this is a valuable site to have, so I appreciate any reports of errors, or suggestions for improvements.
<jackdaniel>
I did't disagree that you find the organization bad; yes, I'm using the website frequently, thanks for hosting it
yewscion has joined #commonlisp
lisp123 has joined #commonlisp
OlCe has joined #commonlisp
tyson2 has quit [Read error: Connection reset by peer]
OlCe has quit [Ping timeout: 250 seconds]
dlowe has quit [Remote host closed the connection]
alfonsox has quit [Remote host closed the connection]
<dbotton>
Is there a way to tell quicklisp (or asdf maybe is more correct) to rescan the directories it uses for systems?
<phoe>
(ql:register-local-projects)
<dbotton>
doesn't work
<dbotton>
I create the new project in ~/common-lisp
<phoe>
oh! that might be the reason
<phoe>
this only works for local-projects dirs
<dbotton>
I need all the possible directories used scanned ideal
<dbotton>
and esp the one most reliable dir ~/common-lisp
<dbotton>
(as hard coded in to asdf)
<dbotton>
is there a way?
masinter has joined #commonlisp
<lisp123>
dbotton: Don't you get an error
<lisp123>
When you try to load the project?
<lisp123>
Usually its an option 'Clear Configuration and Retry Loading' or something like that
ec has quit [Ping timeout: 276 seconds]
derelict has quit [Quit: bye]
derelict has joined #commonlisp
<etimmons>
dbotton: (asdf:clear-source-registry) should do it
<dbotton>
sorry, will try now
<etimmons>
(that's also what the restart lisp123 mentioned calls if you try to load-system and ASDF doesn't know how to find that system)
<dbotton>
using (ql:register-local-projects) - [Condition of type QUICKLISP-CLIENT:SYSTEM-NOT-FOUND]
<dbotton>
using (asdf:clear-source-registry) - worked
<dbotton>
thanks!
mon_aaraj has quit [Ping timeout: 256 seconds]
<dbotton>
with the asdf call also work for the local-projects dir?
<dbotton>
or I need to call both?
cosimone has joined #commonlisp
<Xach>
dbotton: ql:register-local-projects is invoked automatically if a project directory's timestamp is newer than its project index file.
<Xach>
if you put a project deeper than that, you need to call it manually.
amb007 has quit [Ping timeout: 240 seconds]
<dbotton>
These are new projects
amb007 has joined #commonlisp
mon_aaraj has joined #commonlisp
<Xach>
it should happen automatically in that case.
<dbotton>
great
MajorBiscuit has joined #commonlisp
cuz` has joined #commonlisp
Guest4432 has joined #commonlisp
<dbotton>
works
<dbotton>
thank you all
yewscion has quit [Quit: Connection closed]
ebrasca has joined #commonlisp
<dbotton>
Xach what is the reason for creating the system-index.txt file in the local-project dir?
<Xach>
dbotton: it is a cache so the path is not scanned fresh all the time. for a big tree it can take time.
<phoe>
Guest4432: (ql:who-depends-on "herodotus") says that no QL system depends on it
<dbotton>
Is there a convention for documenting in the doc string of a function that one of its parameters is a lambda and what parameters that lambda would take?
<dbotton>
for example I have - (defun walk-files-and-directories (path process) "Walk PATH and apply PROCESS on each (path and file)"
<Xach>
dbotton: i don't think there's a firm convention, but i write something like "PROCESS should be a function that accepts a single argument, a pathname" or similar
<Xach>
Or "a function of one argument, a <foo>"
<Guest4432>
phoe ok, thanks
OlCe has joined #commonlisp
OlCe has quit [Ping timeout: 250 seconds]
OlCe has joined #commonlisp
waleee has joined #commonlisp
cuz` has quit [Read error: Connection reset by peer]
MajorBiscuit has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
mon_aaraj has quit [Ping timeout: 240 seconds]
mon_aaraj has joined #commonlisp
Jing has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
lisp123 has quit [Remote host closed the connection]
mon_aaraj has quit [Ping timeout: 245 seconds]
mon_aaraj has joined #commonlisp
lisp123 has joined #commonlisp
lisp123 has quit [Client Quit]
mon_aaraj has quit [Remote host closed the connection]
mon_aaraj has joined #commonlisp
mon_aaraj has quit [Ping timeout: 256 seconds]
mon_aaraj has joined #commonlisp
attila_lendvai has joined #commonlisp
tyson2 has joined #commonlisp
rain3 has quit [Ping timeout: 252 seconds]
OlCe has quit [Ping timeout: 250 seconds]
gaqwas has joined #commonlisp
Guest4432 has quit [Ping timeout: 256 seconds]
tyson2 has quit [Remote host closed the connection]
kevingal has joined #commonlisp
treflip has quit [Quit: good night!]
gaqwas has quit [Remote host closed the connection]
santiagopim has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<_73`>
Question about how I can bring the variables of a lambda-list argument for a macro in scope immediately: https://dpaste.com/6FDSA84XD
<phoe>
what is (string num1) supposed to evaluate to
amb007 has quit [Ping timeout: 250 seconds]
<phoe>
or rather, what is the final note string supposed to look like?
<phoe>
do you mean (format nil "A function that uses ~S" 'num1)?
amb007 has joined #commonlisp
_73`` has joined #commonlisp
<phoe>
also, that ACONS call is a no-op because the consed alist cell is then immediately discarded
<phoe>
did you mean PUSHNEW with :KEY #'CAR?
<_73``>
sorry phoe it seems I timed out when you sent your first message so I missed it
_73` has quit [Ping timeout: 256 seconds]
<masinter>
beach I'd like to know more about LOOP implementations
<masinter>
Interlisp has "iterative statements" and an extensibillity method ("is.opr").
<_73``>
phoe: ahh should have looked up. Now I see that I am all mixed up because I want (STRING NUM1) to evaluate to its runtime value (say 12 or something).`
<phoe>
...wait a second
<phoe>
how do you want to get that outside the function itself
<phoe>
how do you get the runtime value of a variable without binding that variable, and binding that variable only happens upon calling the function
<_73``>
phoe: Well you helped me find the crux of the problem...
<_73``>
the function itself needs to have the side effect
<phoe>
side effect of what exactly
<phoe>
setting the values somewhere else?
<phoe>
what if it's called multiple times?
<_73``>
consing to *MY-FUNCTION-NOTES*. I can add a guard that checks if its already a member.
<phoe>
seems like you want SETF of ALEXANDRIA:ASSOC-VALUE
<phoe>
in that case you need to insert an appropriate form before your ,CODE
sloanr has joined #commonlisp
mrcom has quit [Quit: This computer has gone to sleep]
Guest4446 has joined #commonlisp
mon_aaraj has quit [Ping timeout: 260 seconds]
jkordani has joined #commonlisp
ggb has joined #commonlisp
mon_aaraj has joined #commonlisp
robin__ has joined #commonlisp
robin has quit [Ping timeout: 250 seconds]
_73`` has left #commonlisp [ERC 5.4 (IRC client for GNU Emacs 28.0.90)]
<jkordani>
style question. If you write a function that needs to compute something given a list of values, is it better to write it such that it accepts a list of inputs, or an optional number of arguments, or both
ogamita has quit [Ping timeout: 256 seconds]
<Xach>
jkordani: if you are passing around lists already, &rest arglists mean you have to apply the function, and sometimes that is a little inconvenient.
<masinter>
&rest is ugly
<phoe>
jkordani: depends on how likely you are to hit the CALL-ARGUMENTS-LIMIT
<jkordani>
oh right arg limits
<Xach>
If you are using it mostly interactively, I find &rest to be pretty convenient and easy to read.
<phoe>
as one example from standard CL, see #'CONCATENATE
<phoe>
as another example from standard CL, see #'MAP
<phoe>
as they say, inside you there are two wolves
Dynom has quit [Read error: Connection reset by peer]
artchad has quit [Ping timeout: 256 seconds]
shka has quit [Quit: Konversation terminated!]
artchad` has quit [Quit: ERC (IRC client for Emacs 27.2)]
artchad has joined #commonlisp
robin has joined #commonlisp
Oladon has joined #commonlisp
karlosz has quit [Quit: karlosz]
mrcom has joined #commonlisp
aartaka has quit [Ping timeout: 256 seconds]
cjb has joined #commonlisp
mon_aaraj has quit [Ping timeout: 250 seconds]
mon_aaraj has joined #commonlisp
ante_ has quit [Ping timeout: 250 seconds]
logand has joined #commonlisp
<sm2n>
Is there a way to get a "slice" of a stream?
<sm2n>
For example, I have a stream *standard-input*, and I'd like to get a stream that is just *standard-input* except it returns eof when it sees a #\Newline
<sm2n>
Something like that
<sm2n>
So that sentinel detection logic can be factored out of logic that just reads and flushes an entire stream
wyrd has joined #commonlisp
<mfiano>
phoe helped me with a slice-stream Gray streams interface about a year ago. I'm not sure if it is what you're after though
<sm2n>
link?
<phoe>
mfiano: wait, have I?
<phoe>
please gimme a link
<phoe>
I need to remember that
<mfiano>
phoe: Can you gist it? It's in that tarball I sent you