tzlm454 has quit [Remote host closed the connection]
tzlm454 has joined #commonlisp
jaykru has quit [Remote host closed the connection]
kagevf has joined #commonlisp
tzlm454 has quit [Ping timeout: 245 seconds]
akoana has left #commonlisp [Leaving]
akanouras has quit [*.net *.split]
akanouras has joined #commonlisp
Lycurgus has joined #commonlisp
akanouras has quit [*.net *.split]
akanouras has joined #commonlisp
akanouras has quit [*.net *.split]
Lycurgus has quit [Quit: Exeunt]
daybreaks has joined #commonlisp
daybreaks has quit [Client Quit]
mindCrime has joined #commonlisp
akanouras_ has joined #commonlisp
<hexology>
if i am using roswell and i want to set up an asdf source registry, do i use ~/.config/common-lisp as normal? or does roswell have its own location?
karlosz has quit [Quit: karlosz]
<akanouras_>
hexology: does ~/.roswell/local-projects/ work for you?
<hexology>
akanouras_: that's for quicklisp right? i don't want to keep my source code there, i just want to tell asdf where to find my source code
akanouras_ has quit [Quit: Konversation terminated!]
mindCrime has quit [Ping timeout: 268 seconds]
horar has joined #commonlisp
leeb has joined #commonlisp
<hexology>
is qlot supposed to install dependencies when i run `qlot install` ? i have "ql hunchentoot 2021-04-11" in my qlfile. it appears that hunchentoot was installed but no deps were installed; i get "Component :CHUNGA not found" when i do (asdf:load-system "hunchentoot")
Nilby has quit [Ping timeout: 264 seconds]
MichaelRaskin has quit [Ping timeout: 272 seconds]
tzlm454 has joined #commonlisp
mindCrime has joined #commonlisp
horar is now known as infurl
contrapunctus has left #commonlisp [#commonlisp]
etimmons has quit [Quit: node-irc says goodbye]
etimmons has joined #commonlisp
contrapunctus has joined #commonlisp
karlosz has joined #commonlisp
<mister_m>
Does slime/sly have any facility that would let me determine if a function is unused, or if a generic function does not have an implementation?
dieggsy has joined #commonlisp
<beach>
Good morning everyone!
<beach>
mister_m: You can't tell whether a function is unused or not. It is always possible to construct its name, find the function with that name, and then call it.
<beach>
mister_m: This function will tell you whether a generic function has any methods.
ircseeker has joined #commonlisp
<mister_m>
Thanks; I still get a little lost in emacs with what is defined and what isn't
<beach>
The function GENERIC-FUNCTION-METHODS has nothing to do with Emacs. It is a Common Lisp function.
<beach>
Or, rather, a MOP function.
<mister_m>
Right - but I can use the repl to see what is in the image I am working in
<beach>
Sure.
Lord_of_Life has quit [Ping timeout: 264 seconds]
Lord_of_Life_ has joined #commonlisp
Lord_of_Life_ is now known as Lord_of_Life
infurl has quit [Quit: Client closed]
danieli has joined #commonlisp
tzlm454 has quit [Remote host closed the connection]
tzlm454 has joined #commonlisp
tzlm454 has quit [Remote host closed the connection]
xlei has quit [Ping timeout: 265 seconds]
Mandus has quit [Ping timeout: 272 seconds]
Mandus has joined #commonlisp
xlei has joined #commonlisp
Mandus has quit [Ping timeout: 264 seconds]
Mandus has joined #commonlisp
srhm has quit [Quit: Konversation terminated!]
horar has joined #commonlisp
ircseeker has quit [Remote host closed the connection]
RedPhoton has joined #commonlisp
Oladon has joined #commonlisp
tzlm454 has joined #commonlisp
tzlm454 has left #commonlisp [#commonlisp]
tzlm454 has joined #commonlisp
tzlm454 has quit [Remote host closed the connection]
tzlm454 has joined #commonlisp
tzlm454 has left #commonlisp [#commonlisp]
tzlm454 has joined #commonlisp
tzlm454 has left #commonlisp [#commonlisp]
tzlm454 has joined #commonlisp
tzlm454 has left #commonlisp [#commonlisp]
tzlm454 has joined #commonlisp
tzlm454 has left #commonlisp [#commonlisp]
tzlm454 has joined #commonlisp
tzlm454 has left #commonlisp [#commonlisp]
tzlm454 has joined #commonlisp
tzlm454 has quit [Remote host closed the connection]
tzlm454 has joined #commonlisp
RedPhoton has quit [Quit: And then there was darkness!!]
Jach has quit [Quit: Leaving.]
Oladon has quit [Quit: Leaving.]
mindCrime has quit [Ping timeout: 268 seconds]
pve has joined #commonlisp
tzlm454 has quit [Remote host closed the connection]
pve has quit [Ping timeout: 268 seconds]
pve has joined #commonlisp
mindCrime has joined #commonlisp
leeb has quit [Quit: WeeChat 3.1]
pve_ has joined #commonlisp
pve has quit [Ping timeout: 252 seconds]
selwyn has joined #commonlisp
mindCrime has quit [Ping timeout: 268 seconds]
MichaelRaskin has joined #commonlisp
pve_ is now known as pve
MichaelRaskin has quit [Read error: Connection reset by peer]
MichaelRaskin has joined #commonlisp
johan_ has joined #commonlisp
johan_ has quit [Client Quit]
selwyn has quit [Read error: Connection reset by peer]
hendursaga has quit [Ping timeout: 252 seconds]
hendursaga has joined #commonlisp
pve_ has joined #commonlisp
pve has quit [Ping timeout: 265 seconds]
pve_ has quit [Ping timeout: 268 seconds]
waleee has joined #commonlisp
<srji>
contrapunctus: ty!
<srji>
im looking at the source of cl-http and found this func: (defun %save-tag (it its-pd parser) ...) what is the meaning of the % sign?
<srji>
is it just a personal preference by the author to name functions?
<beach>
It is a convention that indicates "private" or "dangerous".
<beach>
It has no semantic significance otherwise.
<srji>
i see ty
<beach>
ywlcm
<beach>
I use that prefix for my class slots, because nobody should ever refer to slots by name.
<srji>
any idea why is it the percent sign? or was it just historical decisions?
<srji>
it seems a weird to me, because in other language env the convention for privat members, or functions is the underscore sign
<srji>
e.g. javascript and python
<beach>
I don't know. Like with most conventions, it is hard to figure out the origin or why that particular convention "won".
<srji>
i see
<White_Flame>
it's not used all _that_ often in CL. Its packages and deciding which symbols to export define the "public" interface
<beach>
Right.
<White_Flame>
but yeah, in certain bootstrap code, or components inside exported things are meant to be internal, then it's a reasonable flag
<beach>
I use it as a slot-name prefix because often there is reason to have a similar name for the slot and the accessor, but not identical. So it's a simple way of indicating a difference, and at the same time send a signal that the slot name should not be used.
<White_Flame>
also other langauges use underscore because their set of punctuation valid within names are very limited
<beach>
Also, both Python and JavaScript are more recent than Common Lisp (CLtL1), so the question should be asked the other way around: Why didn't those languages choose the established convention of using %?
<srji>
i guess the ppl didnt know about it
<beach>
Right. Common Lisp programmers are expected to know everything, as usual, whereas others are excused for being ignorant.
<srji>
i dont know, i never had this kind of social experience
<beach>
What kind is that?
<srji>
lisp programmers are expected to know everything
<srji>
and other ppl being ignorant
<beach>
Like when someone asks "any pandas clone in clisp?".
Inline has joined #commonlisp
<beach>
It is clear that we are all supposed to know what "pandas" is.
<Inline>
some python thing
<Inline>
maybe todo with documentation, no idea else
<beach>
Inline: That was explained later.
<srji>
i didnt expect everybody knows it
<srji>
but theere could be a chance somebody could know it
<beach>
Inline: My point is that, if I were to go to (say) #python and say something like "any MOP clone in Python", I wonder what the reaction would be.
<Inline>
aha, so mop
waleee has quit [Ping timeout: 268 seconds]
<srji>
i never received a bad reaction for asking in #python
<srji>
maybe its your personal experience?
<beach>
I bet it would be "what is MOP?".
<beach>
srji: yes, but if you had explained the functionality of what you wanted, perhaps a lot more people could have answered, and not only those of us who know Python and its libraries.
<srji>
you are right
<MichaelRaskin>
Well, _if_ someone answers before an explanation, that answer would be more useful to srji
<MichaelRaskin>
(because then you know whom to ask whether API naming conventions are similar in that clone)
<pjb>
well, since we've been programming since 1959, of course, we know everything :-)
<beach>
MichaelRaskin: Again, my point is that it is common to see similar questions here, the assumption being that there is a fair number of Common Lisp programmers who know Python, Perl, JavaScript, whatever. Whereas if I were to go to #python with my MOP question, I am pretty sure almost nobody would know what I am talking about, so they are excused for being ignorant.
<MichaelRaskin>
Common Lisp programmers are not expected to … anything. Programmers who refuse to identify via a single language but who have enjoyed using Common Lisp, we _are_ statistically quite likely to have seen _some_ things Python / Javascript (Perl, not so likely)
<beach>
Now, it is probably true that many Common Lisp programmers know other languages, and also a lot more about software in general, which is why I like hanging out here.
<MichaelRaskin>
Not sure that much better than many other things one or two steps out of mainstream where having used it is a proof of having curiousity and capacity to learn.
<beach>
I don't understand the structure of that sentence, but I think it goes the other way around, i.e. that people who have tried many things and who are more curious, are more likely to be attracted to Common Lisp.
<MichaelRaskin>
Nope.
<beach>
Right. Of course not. How silly of me to suggest such a thing.
<MichaelRaskin>
To be attracted to Common Lisp, curiousity is a prerequisite.
<MichaelRaskin>
There are slightly larger things attracting curious people, too.
<MichaelRaskin>
Among such things it is hard to say that specifically Common Lisp is more attractive.
<MichaelRaskin>
There are also more niche things attracting curious people.
kayprish has joined #commonlisp
<MichaelRaskin>
Sure, curious people are more attracted to Common Lisp than non-curious people because the latter will never find out anything substantial about it.
<beach>
I think that is precisely what I said, to which you answered "Nope".
<beach>
But I think I have had my dose of this debate, so I'll go back to my SICL work.
kayprish has quit [Quit: Leaving]
scymtym has joined #commonlisp
Wombatzus has quit [Ping timeout: 244 seconds]
dickbar__ has quit []
kayprish has joined #commonlisp
kayprish has quit [Quit: Leaving]
Nilby has joined #commonlisp
mrcom has joined #commonlisp
prite has joined #commonlisp
cage has joined #commonlisp
rusua has joined #commonlisp
mrcom has quit [Read error: Connection reset by peer]
silasfox has joined #commonlisp
andreyorst has quit [Ping timeout: 264 seconds]
andreyorst has joined #commonlisp
Nilby has quit [Ping timeout: 268 seconds]
random-nick has joined #commonlisp
royae has joined #commonlisp
<royae>
In fact python (the language) first appeared in february 1991, so it rigourously speaking predates Common Lisp ;)
<Krystof>
The first edition of Common Lisp the Language was published in 1984
<royae>
I once thought of using this argument when at work people said I was using an outdated language. But nevermind...
<Krystof>
"oh yeah? Well you're speaking an outdated language!"
<royae>
:D
<royae>
OK perhaps python -that does not have a real specification- predates ANSI Common Lisp, is an argument that can be used.
royae has quit [Quit: bye.]
cage has quit [Ping timeout: 264 seconds]
akanouras has quit [Ping timeout: 268 seconds]
silasfox has quit [Ping timeout: 268 seconds]
akanouras has joined #commonlisp
Nilby has joined #commonlisp
cage has joined #commonlisp
karlosz has quit [Quit: karlosz]
gaqwas has joined #commonlisp
nature has joined #commonlisp
<gigo>
Is there a convenient way to check if a string a begins with string b? (string-begins "foobar" "foo") -> T, (string-begins "barfoo" "foo") -> F.
<gigo>
I will just go ahead and use uiop:string-prefix-p instead of reinventing the wheel.
<pjb>
Nilby: and com.informatimago.common-lisp.cesarum.sequence:prefixp which also works on sequences. (com.informatimago.common-lisp.cesarum.sequence:prefixp '(#\b) "booboo") #| --> t |#
<Nilby>
gigo: I don't have these things memorized. I just type "(uiop:" or "(alexandria:" and then hit completion to see the list, and then hit completion again to see the function arguments, then hit completion again to see the docstring.
<pjb>
(apropos "PREFIX")
<Nilby>
pjb: I know both you and I have vast libraries that have a utilitiy for nearly every need, but I don't reccommend them, at least for simple things, because they introduce uncommon dependencies, and, as you may know, most projects have already have uiop and alexandria loaded.
<pjb>
Nilby: yes, but (uiop:string-prefix-p #(1 2) #(1 2 3 4)) #| ERROR: The value #(1 2) is not of the expected type (or string symbol character). |# At least alexandria is good on this one.
<Nilby>
Yes. It seems wasteful for uiop to even have it when a function that handles sequences is so easy and fast. I usually avoid uiop stuff myself.
<pjb>
People tend to write over-specific functions.
<pjb>
eg. babel is unusable, until you instanciate your own babel::*string-vector-mappings*.
<Nilby>
pjb: Hmmm, interesting. I assume they did that to try to get the platform specific fastest one.
<pjb>
by copying buffers?
<pjb>
How can your code be fast if you keep copying stuff around!??
<Nilby>
Yes. That bugs be too.
<Nilby>
Like yesterday drmeister code had a big chunk of time in unicode copying.
<gigo>
Is the alexandria author present in this channel?
<beach>
I am listed as an author, but I haven't really contributed.
<beach>
nikodemus is no longer around.
<Nilby>
gigo: I don't know who's maintaining it currently, but flip214 seems to have been doing much of the recent work.
<beach>
luis is listed as an author.
yitzi has joined #commonlisp
ad_absurdum has joined #commonlisp
ad-absurdum has quit [Ping timeout: 268 seconds]
gaqwas has quit [Remote host closed the connection]
<gigo>
do you use &AUX variables often? or do you just use LET? i am confused whether to use &AUX or not?
<beach>
&AUX is not often used in manually written code.
cage has quit [Remote host closed the connection]
<beach>
I guess perhaps because the lambda list then tends to become very long, and line breaks would be required. Then it is often better to use an explicit LET.
<beach>
Now, that doesn't mean that &AUX should be eliminated from the standard, as some people conclude. Because it is very useful sometimes in macro expanders.
<gigo>
what is a typical way to return multiple values? return a list? or use (values ...)? Returning list seems to work fine for me so I am trying to understand why (values ...) exist?
<beach>
With VALUES, the caller can ignore additional return values, and pretend that only one value was returned. With a list, you need to modify the caller to take a list into account. And returning a list also means additional memory allocation.
<beach>
A caller that knows that NIL will never be stored in the hash table, can just do (GETHASH ...) and optionally check for a return value of NIL.
<beach>
If GETHASH were to return a list, all callers would reflect this fact, because they would then have to say (CAR (GETHASH ...)).
ad_absurdum has joined #commonlisp
<beach>
For code that evolves, this can be a critical difference. You may write callers to assume a single return value initially, but at some later stage, decide that a second return value might be useful.
<beach>
You then don't have to modify any existing callers.
<beach>
But if you change the callee to return a list, you now have to find every caller and insert a (CAR ...) there.
ad-absurdum has quit [Ping timeout: 272 seconds]
<beach>
So, if you are in complete control of all code, and you have no intention of ever modifying it, then the only difference is the memory allocation.
<beach>
That, of course, almost never happens.
<gigo>
beach: thanks. that makes a lot of sense. so I will switch over to using (values ...) instead of using lists to return multiple values.
<beach>
Great!
Lycurgus has quit [Quit: Exeunt]
tzlm454 has joined #commonlisp
<pjb>
gigo: I don't like to merge local variables with the function signature. But &AUX is a kludge that can be useful when writing macros or defstruct constructors.
<pjb>
gigo: for macros, it let you introduce variables without having to mess with the body, parsing declarations, etc.
<gigo>
pjb: thanks
<beach>
pjb: That's a good description of what I do in that paper. :)
ad-absurdum has joined #commonlisp
<pjb>
so, not in the macro lambda-list , but in the lambda-list generated by a macro.
<gigo>
How does (setf (values a b) (foo)) really work? Normally, (values a b) evaluates to multiple values right? How does (setf ...) manage to turn (values a b) into *places* to update?
<beach>
pjb: Yes, the macro lambda list would fall into the "manually written" category.
<_death>
gigo: (get-setf-expansion '(values a b))
<beach>
gigo: SETF is a macro that examines the place.
<pjb>
beach: http://metamodular.com/SICL/ gives 403: Forbidden ; this makes it difficult to "discover" your work…
ircseeker has joined #commonlisp
<beach>
I should make a directory some day.
<Inline>
i suppose it aligns the places too via destructuring or so
<pjb>
beach: There's a server option to have them made automatically.
<Inline>
so setf a b c d, sets a to b and c to d, and that way it also handles multiple values
<_death>
gigo: also, it's better to think of an instance as an alternative to VALUES, not a list.. so for example TRUNCATE could return the result of (make-truncation :quotient q :remainder r)
<pjb>
Note when multiple-values are involved, the third value of get-setf-expansion contains more than one form. Oftem macros using get-setf-expansion will just reject or ignore that case. (get-setf-expansion '(values a b)) #| --> nil ; nil ; (#:g53184 #:g53185) ; (values (setq a #:g53184) (setq b #:g53185)) ; (values a b) |#
<pjb>
(let ((a 0) (b 0)) (incf (values a b) 2)) #| ERROR: Multiple store variables not expected in setf expansion of (values a b) |#
<pjb>
You'd have to write a mv-incf to deal with it.
* beach
guesses that this information provides way too much detail for gigo to digest, but that guess could be wrong of course.
<jackdaniel>
technically correct is often the worst kind of correct ,)
<pjb>
beach: perhaps. / If you use Apache, you would want to add the Indexes option in the Directory section for your files: Options Indexes # and perhaps also: FollowSymLinks
ad_absurdum has joined #commonlisp
<pjb>
I like to have such additionnal information, since it helps me to make connections.
<beach>
pjb: I am not in control of the server, at least I don't think so.
Inline has quit [Quit: Leaving]
ad-absurdum has quit [Ping timeout: 268 seconds]
<_death>
well, since TRUNCATE doesn't abuse multiple values, and GET-SETF-EXPANSION does, the latter may be a better example for what I just said.. e.g., (defstruct setf-expansion vars vals store-vars writer-form reader-form)
Inline has joined #commonlisp
mariari has quit [Quit: WeeChat 3.1]
<pjb>
beach: Well, the only email on metamodular.com is yours; whois info is masked; it's hosted on vux.netsolhost.com
<Colleen>
Weather in Miami Beach: Possible Drizzle and Humid at 29°C (feels like 34°C), 77% humidity, 3km/h wind, 1018hPa pressure.
<easye>
Colleen: weather in Hossegor
<Colleen>
Weather in Hossegor: Clear at 22°C, 67% humidity, 4km/h wind, 1018hPa pressure.
<beach>
Colleen: Time in Melbourne
<Colleen>
The time in Melbourne is 2021.05.31 01:59:49.
<_death>
Colleen: Time in IRC
<Colleen>
The time in IRC is 2021.05.30 11:59:57.
<flip214>
what happens if I change my nick to "::notify"?
* easye
snorts. "Go ahead!"
<flip214>
oh, what TZ is that?
<flip214>
east coast? why that?
<easye>
Why is that the IRC time?
<easye>
Friggin' Americans...
<flip214>
Colleen: time in nowhere
<Colleen>
The time in nowhere is 2021.05.30 11:01:01.
<flip214>
Colleen: time in everywhere
<Colleen>
The time in everywhere is 2021.05.30 12:01:08.
<easye>
Colleen: time in zulu
<flip214>
Colleen: time on sun
<Colleen>
Invalid command: There were too many arguments to match (&OPTIONAL SIGNIFIER)
<Colleen>
The time in zulu is 2021.05.30 10:01:12.
<flip214>
Colleen: time in in in on on on moon
<Colleen>
The time in in in on on on moon is 2021.05.30 12:01:30.
<easye>
Colleen: weather on mars
<Colleen>
Invalid command: There were too many arguments to match (&OPTIONAL SIGNIFIER)
<easye>
Colleen: weather in on mars
<Colleen>
Weather in 722: Mostly Cloudy at 16°C, 63% humidity, 1km/h wind, 1021hPa pressure.
<flip214>
is that a buffer overflow???
* beach
now regrets having exposed some of the features of Colleen.
<flip214>
Colleen: weather in on Mars
<Colleen>
Weather in 722: Mostly Cloudy at 16°C, 63% humidity, 1km/h wind, 1021hPa pressure.
<flip214>
Colleen: weather in on Venus
<Colleen>
Weather in 11711: Mostly Cloudy at 27°C, 52% humidity, 2km/h wind, 1018hPa pressure.
<flip214>
I don't think that is correct... unless it's a different Venus it's talking about
<easye>
The funny thing, is that is actually the weather on Venus, ~15Km from the surface...
<flip214>
but the number is interesting...
* easye
can't explain the 722.
Lycurgus has joined #commonlisp
<easye>
Perhaps many places that have mars as their reference?
<easye>
Colleen: weather in on Earth
<Colleen>
Weather in 836: Light Rain at 13°C, 84% humidity, 9km/h wind, 1019hPa pressure.
<easye>
There you go...
<easye>
err, more like >50Km for the cloud tops of Venus where it is one atmosphere.
<flip214>
Colleen: weather in on sun
<Colleen>
No location called "on sun" could be found.
<flip214>
Colleen: weather in sun
<Colleen>
Weather in 9540: Mostly Cloudy at 17°C, 73% humidity, 4km/h wind, 1023hPa pressure.
<flip214>
no, I don't think that is correct.
<flip214>
Colleen: weather in Europe, Jupiter moon
<Colleen>
Weather in 4800: Clear at 15°C, 77% humidity, 1km/h wind, 1012hPa pressure.
shka has joined #commonlisp
<easye>
Forget Mars.
* easye
is going hitch a starship to Venus clouds to live in an airship.
* easye
wonders what is making the phosphine.
<easye>
Alright, back to Common Lisp. Sorry.
<Shinmera>
Colleen: tell easye about self
<Colleen>
easye: I'm an installation of the Maiden 3.1.0 chat framework. The core is running 29 consumers, with 148 commands registered. I have been running for approximately 2 days, 21 hours.
<gigo>
How is this working: (defparameter bar '(1 2 3)) (push 4 bar) bar This prints (4 1 2 3). I thought quoted lists are immutable.
<beach>
They are not.
<Shinmera>
there is no list.
<beach>
Er, sorry.
ad-absurdum has quit [Ping timeout: 268 seconds]
<Shinmera>
all you're doing is making a cons that has the cdr being the old 'list'.
<Shinmera>
then you update bar to point to that new cons.
<beach>
gigo: As Shinmera says, you are not mutating the list, but literal lists are not "immutable". It is just that the consequences are undefined if you do it.
ad-absurdum has joined #commonlisp
<beach>
gigo: Your code is roughly equivalent to (SETF BAR (CONS 4 BAR)).
<gigo>
So push creates a new list everytime?
<beach>
It creates a new CONS.
<gigo>
Aha. The equivalent form makes sense. thanks.
Lycurgus has quit [Quit: Exeunt]
<beach>
If you did (PUSH 4 (CDR BAR)) you would be mutating the list.
<gigo>
do you always use hash-table as a rule for performance reasons? or do you use assoc-lists too for arbitrary key value pairs?
ad_absurdum has quit [Ping timeout: 268 seconds]
<beach>
Because that would be roughly equivalent to (SETF (CDR BAR) (CONS 4 (CDR BAR))) and you would then alter the CDR of the list.
<Nilby>
gigo: the lisp printer is a bit misleading (4 1 2 3) is really (4 . (1 . (2 . (3 . nil))))
<beach>
gigo: Hash tables become interesting when you have more than 10-50 elements, depending on how they are implemented.
<gigo>
So assoc-lists for small data and hashtables for big data?
<Nilby>
lists can be okay for pretty big data, it just depends what you're doing.
cage has joined #commonlisp
<gigo>
VERSION
<pjb>
gigo: Note that with (defparameter bar '(1 2 3)) (push 4 bar), bar is bound to a list that is partially mutable and partially immutable.
<pjb>
after (defparameter bar '(1 2 3)) (push 4 bar) (setf (car bar) 42) is ok. But (setf (cadr bar) 42) is bad.
<pjb>
gigo: therefore it is dangerous to do such a thing, even if it's prefectly conforming. But no problem if you don't mutate any list in your program.
<gigo>
thanks pjb
<pjb>
gigo: note that a-lists have acons, (on the other hand, p-list (setf getf) and remf may mutate the p-list).
rgherdt has joined #commonlisp
v88m has quit [Ping timeout: 264 seconds]
yitzi has quit [Quit: Leaving]
Oladon has joined #commonlisp
mindCrime has joined #commonlisp
phantomics has quit [Quit: Ex-Chat]
winter has joined #commonlisp
akoana has joined #commonlisp
dieggsy has quit [Read error: Connection reset by peer]
dieggsy has joined #commonlisp
<gigo>
Why is acons named so? what does that name stand for?
<_death>
the structure is called "association list"
<gigo>
_death: so acons is association cons?
<_death>
it conses an assocation entry
winter has quit [Ping timeout: 268 seconds]
<gigo>
thanks
sjl has joined #commonlisp
<Nilby>
TIL: cons originally had 4 arguments: cons(address, decrement, prefix, tag). good thing they changed that.
<_death>
they had HUNK for that
cage has quit [Remote host closed the connection]
<gigo>
(defparameter alist nil) (acons "a" "apple" alist) (push (cons "b" "ball") alist) => (("b" . "ball")). Why does ("a" . "apple") disappear from alist?
<gigo>
Never mind. I understood. I never saved what (acons ...) returned anywhere.
<gigo>
I forgot that acons does not modify alist. It only returns a new list.
<Nilby>
Even though CL isn't fully immutable, most operations don't actually mutate things.
dieggsy has quit [Read error: Connection reset by peer]
dieggsy has joined #commonlisp
<pl>
Nilby: CONS, CAR, CDR, CPR and CTR were assembler macros
v88m has joined #commonlisp
v88m has quit [Remote host closed the connection]
froggey has joined #commonlisp
v88m has joined #commonlisp
mindCrime has quit [Ping timeout: 272 seconds]
ad_absurdum has joined #commonlisp
ad-absurdum has quit [Ping timeout: 272 seconds]
dieggsy has quit [Read error: Connection reset by peer]
dieggsy has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
contrapunctus has joined #commonlisp
ad_absurdum has quit [Ping timeout: 268 seconds]
ad-absurdum has joined #commonlisp
<gigo>
Is there a good asdf tutorial for soemone who wants to load systems? I understand that I can use (asdf:load-system :foo) but where do I git-clone the foo package to on my local disk?
prite has quit [Ping timeout: 268 seconds]
hendursaga has quit [Quit: hendursaga]
hendursaga has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
<phoe>
gigo: ~/quicklisp/local-projects/
waleee has joined #commonlisp
contrapunctus has joined #commonlisp
mindCrime has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
Oladon has quit [Read error: Connection reset by peer]
Oladon has joined #commonlisp
Lycurgus has joined #commonlisp
shka has quit [Ping timeout: 268 seconds]
Lycurgus has quit [Quit: Exeunt]
contrapunctus has joined #commonlisp
waleee has quit [Ping timeout: 268 seconds]
waleee has joined #commonlisp
amk has quit [Read error: Connection reset by peer]
amk has joined #commonlisp
rgherdt has quit [Ping timeout: 268 seconds]
winter has joined #commonlisp
ceblan has joined #commonlisp
karlosz has joined #commonlisp
hendursaga has quit [Remote host closed the connection]
Lycurgus has joined #commonlisp
hendursaga has joined #commonlisp
random-nick has quit [Ping timeout: 264 seconds]
Lycurgus has quit [Quit: Exeunt]
nature has quit [Quit: Lost terminal]
Krystof has quit [Ping timeout: 272 seconds]
Nilby has quit [Ping timeout: 268 seconds]
skyl4rk has joined #commonlisp
dieggsy has quit [Read error: Connection reset by peer]
dieggsy has joined #commonlisp
<jmercouris>
phoe: and what if you are not using quicklisp?
<jmercouris>
I know the answer, I"m just asking the follow-up hypothetical 11 :-D
<jmercouris>
something something teach a man to fish, I suggest asdf:*central-registry*
<jmercouris>
could also investigate: asdf:*default-source-registries*