dlowe has quit [Remote host closed the connection]
srhm has joined #commonlisp
waleee has quit [Ping timeout: 265 seconds]
djuber has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
Oladon has joined #commonlisp
raeda has quit [Ping timeout: 268 seconds]
kakuhen has joined #commonlisp
kakuhen has quit [Changing host]
kakuhen has joined #commonlisp
raeda has joined #commonlisp
<beach>
Good morning everyone!
CrashTestDummy2 has joined #commonlisp
CrashTestDummy3 has quit [Ping timeout: 252 seconds]
<Josh_2>
Mornin'
Lord_of_Life_ has joined #commonlisp
<phantomics>
Morning beach
<kakuhen>
good evening
Lord_of_Life has quit [Ping timeout: 268 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<phantomics>
A question: normally, you can create lexical aliases of dynamic variables inside a function, reset the values for those aliases and then the new values will be effective inside the function but the dynamic variable outside will not be changed. Is there any reason that the dynamic variable could end up getting changed anyway? I'm having that happen
slyrus has quit [Ping timeout: 268 seconds]
<phantomics>
For example, let's say you have a dynamic var called *io* and then you do this: (defun bla (aa) (let ((*io* *io*)) (setq *io* 33) (* aa *io*)))
<beach>
phantomics: That's not a "lexical alias".
<phantomics>
You run (bla 5) and then you find that the dynamic *io* is set to 33
<beach>
phantomics: When the variable is special, LET creates a dynamic binding.
<phantomics>
Ok, if it's defined as special
<White_Flame>
you sure it's not a simple paren scoping problem?
<beach>
Yeah, I am with White_Flame.
<phantomics>
White_Flame: it shouldn't be, checked that thoroughly
<phantomics>
My test case with *io* worked correctly, and I created *io* with (defvar)
<White_Flame>
and yeah, the asterisk earmuffs are not relevant in any way, just a human-oriented style policy
<phantomics>
Know about the earmuffs
<White_Flame>
it is the defvar/defparameter that make the special declaration
<White_Flame>
in weird cases, you might also do (declare (special *foo*)) if it's not known at compiletime
<White_Flame>
inside a scope
<phantomics>
That test case up there works right but something inside April has a problem and is changing the dynamic var outside the (let) scope
<phantomics>
April's (let) form isn't created until after macroexpansion but that shouldn't affect what happens at runtime afaik
<White_Flame>
right, it's all compile-time decision making as to what access code to generate
<White_Flame>
lexical vs dynamic
Josh_2 has quit [Remote host closed the connection]
unyu has quit [Quit: WeeChat 3.2]
<phantomics>
So the variable scoping is decided at compile time? That could be the cause
<mfiano>
Are you familiar with how special variables form a stack of multiple bindings?
<phantomics>
There are a few stages of macroexpansion before that (let) form is generated, meanwhile inside the macro there's a (setq) changing the value of the dynamic var
<phantomics>
mfiano: not really
<mfiano>
At compile time and during macro-expansion, only the value of the "root" binding is available.
<mfiano>
Ah I suggest you look into special variables or ask a more specific question then. I'm not sure where the end of your knowledge begins :)
<phantomics>
So it would associate the (setq *something* ...) with the dynamic var and not the lexical one whose binding is generated through macroexpansion
<mfiano>
I am not sure what yoiu mean by "lexical"
<mfiano>
a special variable always has a dynamic binding, not lexical
<phantomics>
The (let ((*io* *io*)) ...) binding
<mfiano>
How was *io* initially defined before that form?
<phantomics>
When I run that test case above, *io* is not changed even though I (setq) it in the function
<phantomics>
(defvar *io* 11)
<mfiano>
Then *io* is forever a special variable and there is no lexical
<mfiano>
The value of the "root" binding is 11
<mfiano>
(let ((*io* 'foo)) ...) pushes FOO onto the stack of values for the duration of the LET, even across function call boundaries
<mfiano>
When the LET ends, the binding is popped, and the 11 is back in business
<phantomics>
Ok, I see
dsk has joined #commonlisp
<phantomics>
And what happens if the (let) is generated through macroexpansion? For example...
<phantomics>
(expand-to-fun bla *io* (setq *io* 33) (* aa *io*))
<phantomics>
This macro expands to the (defun bla ...) above
<mfiano>
First, I would urge you to never use SETQ
<mfiano>
SETF will do all it can do and more
<phantomics>
Ok
<phantomics>
That macro should actually be: (expand-to-fun bla (aa) *io* (setq *io* 33) (* aa *io*))
<mfiano>
To answer your question, all that matters is that you have code that expands into (defvar *io* ...) ... (let ((*io* ...)) ...) which will push a new binding onto the special variable's stack at runtime
<mfiano>
As an experiment, try PRINT-ing the value of the variable directly before, inside, and after the all of the nested LET forms
<beach>
phantomics: Again, I agree with White_Flame. There must be something wrong with the expansion so that the assignment is outside the binding scope.
<mfiano>
s/the all/all/
<mfiano>
phantomics: pastebin macroexpand-1 or whatever
<mfiano>
and the macro definition
<phantomics>
Ok, generating the code...
<mfiano>
I agree with White_Flame and beach. We would need to see the macro and client code if it's contained enough
<phantomics>
Lmk if anything else will help, (apl-call ...) is just a (funcall) in this situation and the (apl-assign) just expands to the (setq) here, the important thing is the assignment of the *index-origin*
<mfiano>
Ok this is more complicated than I thought. The docstring says its a reader macro, but it's not, but also says it works in combination with a reader macro that I am not familiar with...if this is generating code that happens at read time, I don't have enough time to step through that
<mfiano>
I also don't see any backquoited expression to generate, so I'm not sure.
<phantomics>
Oh, you mean (in-april-workspace)?
<phantomics>
The reader macro in question is 𝕊
<phantomics>
When it expands it replaces all the 𝕊something with symbols interned in the workspace package
<phantomics>
You can see this happen between Step 1 and 2
<mfiano>
Where is the defvar for *index-origin*?
<phantomics>
It happens when the workspace package is created
<mfiano>
You are using SET, not DEFVAR/DEFPARAMETER
<phantomics>
It's not actually defvared, since workspace creation is done through a macro.
<mfiano>
You need to declare it special somehow if you don't want to assignment to persist
<mfiano>
s/to/the/
<phantomics>
I proclaim the symbol special and the SET it
<mfiano>
Oh let me see
<phantomics>
See the PROCLAIM there
<mfiano>
Wow apl-assign looks complicated
<phantomics>
That's because it has to handle stranded assignment
<mfiano>
I'm sorry but it's very hard to read your code because you are mixing spaces and tab characters for indentation
<phantomics>
I see, I'm just using emacs auto-indent
<phantomics>
Is there a setting I should change? The raw on Github looks fine for me
<mfiano>
Yeah the raw is the only way to make sense out of it :)
<phantomics>
The regular Github view looks fine to me too, I guess my settings are different
<mfiano>
There are a few settings in emacs to use x number of spaces instead of a tab character, but I forget, it's sort of off-topic, and #emacs would be of more help than me
<mfiano>
if i inspect the bytes i can see multiple whitespace characters
<mfiano>
I don't see anything fishy with the code except that i still suspect some compiler phase ordering issue with the way your reader macros/macros are executed
<mfiano>
Sadly I don't have anymore time, bvut might be able to check more later if nobody else can help
<phantomics>
Got it, really appreciate your help
Mandus has quit [Ping timeout: 252 seconds]
Mandus has joined #commonlisp
<phantomics>
The 𝕊 reader macro probably has something to do with it since my test code doesn't have anything like it
wilfred has quit [Quit: Connection closed for inactivity]
IAmRasputin has joined #commonlisp
selwyn has joined #commonlisp
IAmRasputin has quit [Ping timeout: 265 seconds]
Mandus has quit [Ping timeout: 258 seconds]
Mandus has joined #commonlisp
<kakuhen>
when indentation in emacs is normal but looks weird elsewhere, I normally fix that with C-u M-x untabify
<kakuhen>
not sure why, but other editors dont recognize the tabs set by auto-indenting
akoana has joined #commonlisp
unyu has joined #commonlisp
<beach>
Put (setq-default indent-tabs-mode nil) in your .emacs and it will not use TABs.
<phantomics>
I'll see how that works
<moon-child>
probably want an extra guard; tabs are appropriate for most languages other than lisps
<moon-child>
*lisp
<beach>
Why would anyone want to use other languages? :)
<moon-child>
:)
knusbaum has quit [Remote host closed the connection]
CrashTestDummy3 has joined #commonlisp
CrashTestDummy2 has quit [Ping timeout: 265 seconds]
<kakuhen>
sometimes i want to inflict pain on myself, so i use languages that aren't lisp
<kakuhen>
QED
<kakuhen>
anyway, turns out cl-tui has enough comfortable abstractions, and cl-charms has too many C buffer stuff going on under the hood that kept giving unexpected behaviors
<kakuhen>
i still dont like the whole situation with ncurses on common lisp, but to be fair, I should've known what I signed up for when wanting to access a C library of all things via lisp.
lottaquestions has quit [Ping timeout: 244 seconds]
<beach>
gigo: T and NIL are symbols and you can compare symbols with EQ.
<gigo>
beach: thanks
<beach>
Pleasure.
<beach>
Also important in your example, T and NIL evaluate to themselves. So you can't do (EQ MUMBLE MUMBLE) without giving a value to MUMBLE.
<flip214>
Posterdati: sometimes
kakuhen_ has joined #commonlisp
kakuhen_ has quit [Client Quit]
cage has joined #commonlisp
kakuhen has quit [Ping timeout: 244 seconds]
IAmRasputin has joined #commonlisp
IAmRasputin has quit [Ping timeout: 265 seconds]
kakuhen has joined #commonlisp
kakuhen has quit [Changing host]
kakuhen has joined #commonlisp
hendursa1 has joined #commonlisp
hendursaga has quit [Ping timeout: 252 seconds]
<gigo>
Does it bother anyone else that autocomplete in SLIME REPL is a simple <Tab> but autocomplete in source code buffer is <Alt> + <Tab>? I always keep getting the two mixed up while switching between source code and SLIME REPL.
gpiero has quit [Quit: Quitting...]
gpiero has joined #commonlisp
d4ryus has joined #commonlisp
IAmRasputin has joined #commonlisp
frgo_ has quit [Read error: Connection reset by peer]
frgo has joined #commonlisp
abraham has joined #commonlisp
IAmRasputin has quit [Ping timeout: 252 seconds]
rgherdt has joined #commonlisp
yitzi has quit [Ping timeout: 265 seconds]
selwyn has joined #commonlisp
Oladon has quit [Quit: Leaving.]
frgo has quit [Remote host closed the connection]
frgo has joined #commonlisp
Krystof has joined #commonlisp
Guest57 has joined #commonlisp
<dsk>
gigo: You can bind <tab> to 'slime-indent-and-complete-symbol in slime-mode-map or just use M-<tab> in both the REPL and Lisp buffers.
lucerne has quit [Remote host closed the connection]
micro has quit [Remote host closed the connection]
micro has joined #commonlisp
hendursa1 has quit [*.net *.split]
azimut has quit [*.net *.split]
hendursa1 has joined #commonlisp
azimut has joined #commonlisp
lucerne has joined #commonlisp
Quasus has joined #commonlisp
<gigo>
dsk: thanks
azimut has quit [Ping timeout: 244 seconds]
azimut has joined #commonlisp
Guest57 has quit [Ping timeout: 246 seconds]
random-nick has joined #commonlisp
tyson2 has joined #commonlisp
azimut has quit [Ping timeout: 244 seconds]
azimut has joined #commonlisp
zacts has joined #commonlisp
zacts has quit [Client Quit]
lucerne has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
djuber` has joined #commonlisp
djuber has quit [Ping timeout: 268 seconds]
IAmRasputin has joined #commonlisp
kakuhen has quit [Quit: Leaving...]
varjag has joined #commonlisp
CrashTestDummy2 has joined #commonlisp
IAmRasputin has quit [Ping timeout: 258 seconds]
CrashTestDummy3 has quit [Ping timeout: 265 seconds]
lucerne has quit [Remote host closed the connection]
lucerne has joined #commonlisp
silasfox has joined #commonlisp
susam has left #commonlisp [#commonlisp]
dsk has quit [Ping timeout: 265 seconds]
susam has joined #commonlisp
tfb has joined #commonlisp
tfb has quit [Client Quit]
lucerne has quit [Remote host closed the connection]
lucerne has joined #commonlisp
Alfr has joined #commonlisp
waleee has joined #commonlisp
makomo has quit [Quit: WeeChat 3.0.1]
waleee has quit [Ping timeout: 265 seconds]
andreyorst has quit [Ping timeout: 252 seconds]
frgo has quit [Read error: Connection reset by peer]
frgo_ has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
andreyorst has joined #commonlisp
tfb has joined #commonlisp
abraham has quit [Ping timeout: 252 seconds]
dsk has joined #commonlisp
tyson2 has joined #commonlisp
lucerne has quit [Read error: Connection reset by peer]
dickbar__ has joined #commonlisp
Guest5791 has joined #commonlisp
azimut has quit [Ping timeout: 244 seconds]
susam has left #commonlisp [#commonlisp]
susam has joined #commonlisp
gigo has left #commonlisp [#commonlisp]
gigo has joined #commonlisp
<gigo>
Is there a difference between (cons 10 20) and '(10 . 20)?
azimut has joined #commonlisp
<beach>
Yes, the second is a literal and you can't modify it.
<beach>
I mean, the consequences are undefined if you do.
<gigo>
beach: thanks
Josh_2 has joined #commonlisp
<Josh_2>
'ello
<beach>
Hello Josh_2.
<gigo>
Say I have a list like this: '((cons "key1" "val1") (cons "key2" "val2")). Let us say I have two such lists one in variable a and another in variable b. Is there a way to perform equality comparison of both lists?
<beach>
You need to read about the equality predicates, but I think EQUAL will work.
<beach>
Yes, the first list contains the symbol CONS.
<beach>
Not the second.
<beach>
Each sublist in the first list is a list of three elements...
<beach>
The symbol CONS and two strings.
<beach>
Each element in the second list is just a CONS cell with a string in the CAR slot and another string in the CDR slot.
<beach>
So they are not even structurally similar.
tyson2 has quit [Remote host closed the connection]
<beach>
You might want to change the first one from '((cons "foo" "bar") (cons "bar" "qux")) to (list (cons "foo" "bar") (cons "bar" "qux"))
<beach>
Or if you are adventurous, to `(,(cons "foo" "bar") ,(cons "baz" "qux")). Notice the backquote.
<beach>
gigo: Did you faint?
<Josh_2>
Whats the default implementation of a classes accessor? is it just a method by that name that calls slot-value?
<Josh_2>
for reading
<Josh_2>
and then a setf method that sets the slot-value for setting?
<tfb>
Josh_2: for standard-classes I think yes
<Josh_2>
Okay cool beans
<gigo>
beach: Let me try what you said
<beach>
Josh_2: Not necessarily. That would be the default, but the implementation can often optimize.
<tfb>
Josh_2: although obviously it may not actually call slot-value I think (I am not sure what the MOP has to say about that)
<beach>
Josh_2: Then it can often call STANDARD-INSTANCE-ACCESS directly, effectively making the accessor as fast as, or faster then, SLOT-VALUE.
<Josh_2>
rip
<tfb>
beach: yes, that's what I mean: it effectively calls slot-value but it may not actually do that
<tfb>
Josh_2: sorry, I was being confusing / confused
<tfb>
Josh_2: what beach says is more accurate
<Josh_2>
bnkr.datastore requires (with-transaction ..) to be wrapped around setfs. Bit annoying
lucerne has joined #commonlisp
<Josh_2>
Not sure about a nice solution that doesn't require writing a special setter for all of my slots that will be modified
<Josh_2>
Maybe I need a custom metaclass that has a :within-transaction key which automatically writes new setter methods that are within the with-transaction xD
<gigo>
beach: Thanks it worked. The difference also became clear after I put each list in REPL and seeing how REPL printed the list.
<beach>
Right.
<beach>
Also try the DEFUN example to see how literals may behave.
<loke[m]>
Josh_2 you can use SLOT-VALUE-USING-CLASS
<Josh_2>
I already tried that, bknr was complaining about an anonymous transaction
<Josh_2>
I made an :around method on slot-value-using-class then put (with-transaction (<my-label>) (call-next-method)) but I kept getting an error
<loke[m]>
Josh_2 well that should have worked
<Josh_2>
hmm
<Josh_2>
I will try it again
<gigo>
(defun ff () '(10 . 20)) (defparameter *c* (ff)) (setf (car *c*) 234) (ff) => (234 . 20). How is it that it was able to modify the literal? Was it a result of undefined behavior?
<gigo>
beach: ^
tfb has quit [Remote host closed the connection]
tfb has joined #commonlisp
tfb has quit [Client Quit]
<beach>
gigo: Since this is undefined behavior, the implementation is allowed to represent the literal once.
<beach>
gigo: Common Lisp uses what I call "uniform reference semantics".
<beach>
So that each object is referred to by a reference or a pointer.
<beach>
FF returns a pointer to a unique object and it's the same object each time FF is called.
<beach>
A reference to that object is then stored in *c*.
<beach>
Then, when you modify the CAR of that object, the result is what you observe.
<gigo>
beach: okay. would it be correct to say that the above example, specifically, the part (setf (car *c*) 234), is undefined behavior and therefore should be avoided in actual software code?
<beach>
Yes.
<beach>
That form is modifying a literal.
<gigo>
beach: thanks! it is making a lot of sense now
<beach>
Great!
<Josh_2>
Nope doesn't work :(
<Josh_2>
'anonymous transaction in transaction was signalled'
CrashTestDummy3 has joined #commonlisp
CrashTestDummy2 has quit [Ping timeout: 258 seconds]
Guest8 has joined #commonlisp
azimut has quit [Ping timeout: 244 seconds]
<phantomics>
Hi, a question: what's considered the proper way to create a lambda that can reference itself in CL? Similar to "this" in Javascript anonymous functions. I solved my prior problem but it turns out my method for building anonymous self-referencing lambdas was the problem
<luis>
phantomics: labels
<phantomics>
like this? (funcall (labels ((this-fn (a b) ...)) #'this-fn) 1 2)
<edgar-rft>
clhs labels
<luis>
phantomics: yes. See alexandria:named-lambda if that’s too verbose
<phantomics>
I was using labels and having a problem with the value stack of dynamic variables
<luis>
phantomics: what sort of problem?
<phantomics>
I may have just figured out how to solve it. Hang on a minute...
<beach>
phantomics: There is no such thing as "a lambda" in Common Lisp. There is a "lambda expression" and there are functions, named or anonymous.
<phantomics>
Ok, solved. What's going on was that I had a lexical variable that I was assigning a locally scoped variable inside a let, and then inside that let I had an anonymous self-referencing function created with (labels)
<phantomics>
It turns out that the (let) form needs to be inside the (labels) function declaration to work correctly, you can't wrap the (labels) in the (let)
<derelict>
wouldnt flet avoid that issue?
<phantomics>
The goal is to have an anonymous function that can self-reference, can't do that with flet
amb007 has quit [Ping timeout: 258 seconds]
amb007 has joined #commonlisp
<mfiano>
phantomics: Oh you finally got it? Nice!
<phantomics>
Yes
<phantomics>
It turns out the (labels) was the problem
<mfiano>
If the let is inside the labels then it isn't closing over the bindings.
<luis>
phantomics: hard to know what’s correct or not without knowing what you’re trying to achieve
<beach>
I agree with luis.
<phantomics>
It's resolved now, the goal was to create a macro to implement lambda forms creating functions that 1. include a self-reference symbol and 2. always include locally-scoped aliases of external dynamic variables
<phantomics>
This is needed for my APL compiler because in APL functions you can enter ∇ to reference the function itself for recursion. It also needs to be possible to reassign certain system-level variables like the index origin inside a function and have that reassignment only apply to things happening inside the function
azimut has joined #commonlisp
<luis>
What's an external dynamic variable?
<luis>
And what does alias mean in this context? Is it a lexical variable that's bound to the value of a dynamic variable at
<luis>
the time the closure is created?
<phantomics>
Like imagine I start with (defvar *io* 11), and then I create a lambda like so: (let ((*io* *io*)) (lambda (a) (setq *io* 22) (* *io* a)))
<phantomics>
So I'm creating a locally-scoped *io*, that (setq) shouldn't change its value outside of that scope
<phantomics>
My case was more complicated, creating a (labels) form inside the (let), and it turned out that was causing a problem, the outside *io* was getting assigned
<phantomics>
I moved the (let) inside the (labels) declaration and now it works
Guest8 has quit [Quit: Client closed]
<sm2n>
phantomics, another way to do self-referential anonymous functions is to use the Y-combinator
shka has joined #commonlisp
<sm2n>
i.e (Y (lambda (f) (lambda (..) ..))) will give you the inside (lambda (..) ..) with all recursive references to f resolved
<sm2n>
you can use a gensym for f if you're generating code
eddof13 has joined #commonlisp
<_death>
phantomics: the function does not capture the *IO* binding there..
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<_death>
phantomics: what you possibly want is (let ((io *io*)) (lambda ... (setq io 22) ...))
Bike has joined #commonlisp
Bike has quit [Client Quit]
Bike has joined #commonlisp
dickbar__ has quit []
amb007 has quit [Ping timeout: 265 seconds]
amb007 has joined #commonlisp
tyson2 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
<beach>
_death: phantomics was told that the other day, and was also told that this binding is not lexical.
<Josh_2>
with bknr.datastore can I stop some slots from being stored? I have two slots which are local-time:timestamps I dont need these stored as I store a universal-time
Guest63 has joined #commonlisp
<Guest63>
Hi
<Guest63>
My brain is fried trying to get my head around bknr.datastore. I got most things to work, but I'm unable to get restore to work correctly
<Guest63>
Does anybody have experience with this package and are able to get rollback of the datastore smoothly? Every time I try (except for the odd couple of times - so I think the order of steps I'm doing may be wrong), restore just loads the full snapshot
Bike has quit [Quit: Client closed]
<Guest63>
Got my answer
<Guest63>
Doesn't look like restore "until" has been implemented for object subsystems
shka has quit [Quit: Konversation terminated!]
<phantomics>
_death: (let ((io *io*)) ...) doesn't work in my case because I'm compiling code and the *io* needs to be generated the same way whether or not it's inside a closure aliasing *io*
<phantomics>
The problem is solved now, the key was to create the (let) binding inside the (labels) definition for the function
yitzi has joined #commonlisp
<_death>
not sure what you mean, maybe I'm missing some context.. but hey, if it's solved..
shka has joined #commonlisp
selwyn has quit [Read error: Connection reset by peer]
eddof13 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
silasfox has quit [Ping timeout: 265 seconds]
srhm has joined #commonlisp
silasfox has joined #commonlisp
Guest63 has quit [Ping timeout: 265 seconds]
wilfred has joined #commonlisp
x88x88x has joined #commonlisp
Guest5791 has quit [Ping timeout: 246 seconds]
IAmRasputin has joined #commonlisp
x88x88x is now known as x88x88x88x
IAmRasputin has quit [Ping timeout: 265 seconds]
silasfox has quit [Ping timeout: 265 seconds]
silasfox has joined #commonlisp
x88x88x has joined #commonlisp
x88x88x has quit [Client Quit]
x88x88x88x has quit [Quit: WeeChat 2.8]
lucerne has quit [Read error: Connection reset by peer]
dsk has quit [Ping timeout: 264 seconds]
dsk has joined #commonlisp
j0nd0e has joined #commonlisp
j0nd0e has quit [Remote host closed the connection]
Guest5753 has joined #commonlisp
akoana has joined #commonlisp
x88x88x has joined #commonlisp
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #commonlisp
lucerne has joined #commonlisp
selwyn has joined #commonlisp
hendursaga has quit [Remote host closed the connection]
hendursaga has joined #commonlisp
Guest5753 has quit [Ping timeout: 246 seconds]
elf_fortrez has joined #commonlisp
bilegeek has joined #commonlisp
selwyn has quit [Read error: Connection reset by peer]
amb007 has quit [Ping timeout: 265 seconds]
lucerne has quit [Remote host closed the connection]
amb007 has joined #commonlisp
elf_fortrez has quit [Quit: Client closed]
lucerne has joined #commonlisp
waleee has joined #commonlisp
shka has quit [Ping timeout: 265 seconds]
amb007 has quit [Ping timeout: 265 seconds]
dsk has quit [Ping timeout: 264 seconds]
sp41 has quit [Quit: Lost terminal]
amb007 has joined #commonlisp
lucerne has quit [Read error: Connection reset by peer]
kevingal has joined #commonlisp
lucerne has joined #commonlisp
ilshad has joined #commonlisp
jeosol has quit [Quit: Ping timeout (120 seconds)]
yitzi has quit [Quit: Leaving]
ilshad has quit [Remote host closed the connection]
ilshad has joined #commonlisp
ramenbytes has joined #commonlisp
trocado has joined #commonlisp
cage has quit [Quit: rcirc on GNU Emacs 27.1]
Guest5775 has joined #commonlisp
Guest5775 has quit [Client Quit]
tfb has joined #commonlisp
tfb has quit [Client Quit]
nature has quit [Ping timeout: 252 seconds]
kakuhen has joined #commonlisp
kakuhen has joined #commonlisp
kakuhen has quit [Changing host]
taiju has quit [Ping timeout: 258 seconds]
x88x88x has quit [Ping timeout: 258 seconds]
taiju has joined #commonlisp
wilfred has quit [Quit: Connection closed for inactivity]
lucerne has quit [Remote host closed the connection]
tyson2 has quit [Ping timeout: 258 seconds]
lucerne has joined #commonlisp
bilegeek has quit [Quit: Leaving]
IAmRasputin has joined #commonlisp
Krystof has quit [Ping timeout: 265 seconds]
IAmRasputin has quit [Ping timeout: 258 seconds]
ramenbytes has quit [Remote host closed the connection]
wilfred has joined #commonlisp
Oladon has joined #commonlisp
unyu has quit [Quit: WeeChat 3.2]
rgherdt has quit [Ping timeout: 265 seconds]
<jcowan>
beach: I was traveling this weekend so read all the papers available from the SICL page: a master class in CL implementation!
ad-absurdum has joined #commonlisp
bilegeek has joined #commonlisp
tyson2 has joined #commonlisp
rest has joined #commonlisp
rabbit_05 has joined #commonlisp
tyson2 has quit [Ping timeout: 265 seconds]
tyson2``` has joined #commonlisp
tyson2``` has quit [Ping timeout: 265 seconds]
rabbit_05 has quit [Remote host closed the connection]
frgo_ has quit [Remote host closed the connection]
frgo has joined #commonlisp
rest has quit [Quit: Client closed]
varjag has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
Quasus has quit [Ping timeout: 258 seconds]
trocado has quit [Ping timeout: 265 seconds]
cjb has joined #commonlisp
kevingal has quit [Remote host closed the connection]