triffid has quit [Remote host closed the connection]
tyson2 has quit [Remote host closed the connection]
triffid has joined #commonlisp
pmwals094 has quit [Ping timeout: 248 seconds]
<yitzi>
gin: that lambda is a unary function.
<yitzi>
or should be
pmwals095 has joined #commonlisp
irc_user has quit [Quit: Connection closed for inactivity]
tyson2 has joined #commonlisp
sjl has quit [Quit: WeeChat 3.3]
pmwals095 has quit [Quit: leaving]
pranavats has left #commonlisp [Error from remote client]
pranavats has joined #commonlisp
karlosz has quit [Read error: Connection reset by peer]
karlosz has joined #commonlisp
AmateurLisper has quit [Quit: Leaving]
tyson2 has quit [Remote host closed the connection]
triffid has quit [Remote host closed the connection]
triffid has joined #commonlisp
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
mariari has quit [Quit: WeeChat 3.6]
mariari has joined #commonlisp
<flip214>
How can I check whether some symbol exists in a package? Do I need to check (eq (find-symbol (symbol-name foo) (find-package :bar)) foo), or is there something like (package-contains (find-package :bar) foo)?
<contrapunctus>
flip214: check the secondary return value of `find-symbol` too
<flip214>
contrapunctus: yeah, that's why I ask whether there's a function already for that!
<contrapunctus>
oh
<flip214>
I'm also not entirely sure whether a symbol always has to have the same name in another package...
<flip214>
Can I intern eg. a GENSYM into a package later on? (SETF (symbol-package foo) ...) won't work, I guess)
azimut_ has quit [Ping timeout: 268 seconds]
<flip214>
WITH-PACKAGE-ITERATOR might be a way to find a symbol in a package, but it might be a bit slow for my purposes...
<flip214>
ah, SWANK has (symbol-status) and _accessible_ ...
MajorBiscuit has joined #commonlisp
igemnace has joined #commonlisp
triffid has quit [Ping timeout: 268 seconds]
ttree has quit [Ping timeout: 252 seconds]
_cymew_ has joined #commonlisp
triffid has joined #commonlisp
notzmv has quit [Ping timeout: 256 seconds]
triffid has quit [Remote host closed the connection]
triffid has joined #commonlisp
rainthree has joined #commonlisp
scymtym has quit [Ping timeout: 248 seconds]
Brucio-61 has quit [Ping timeout: 248 seconds]
empwilli has quit [Quit: WeeChat 3.0]
empwilli has joined #commonlisp
triffid has quit [Ping timeout: 268 seconds]
karlosz has quit [Quit: karlosz]
scymtym has joined #commonlisp
Brucio-61 has joined #commonlisp
triffid has joined #commonlisp
avocadoist has quit [Ping timeout: 256 seconds]
avocadoist has joined #commonlisp
shka has joined #commonlisp
MajorBiscuit has quit [Ping timeout: 256 seconds]
MajorBiscuit has joined #commonlisp
MajorBiscuit has quit [Ping timeout: 256 seconds]
MajorBiscuit has joined #commonlisp
morganw has joined #commonlisp
triffid has quit [Read error: Connection reset by peer]
triffid has joined #commonlisp
vassenn has joined #commonlisp
notzmv has joined #commonlisp
vassenn has quit [Ping timeout: 248 seconds]
random-nick has joined #commonlisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #commonlisp
pve has joined #commonlisp
<pjb>
gin: instead of (lambda () t) which is a new function, or worse, (constantly t) which builds a new closure each time you call it, you could use a function such as (lisp-implementation-type) which will return a generalized boolean true value always, and which already exists in the image, and (eq (lisp-implementation-type) (lisp-implementation-type)) #| --> t |# so it doesn't even cons.
<pjb>
flip214: and vice-versa with unintern: (let ((s 'foo)) (unintern s) s) #| --> #:foo |#
<Alfr>
pjb, l-i-t might return nil.
<pjb>
DAMNED!
<pjb>
We have to find another function.
<splittist>
It might be the New Implementation of Lisp...
<pjb>
splittist: no, they return (or string null).
<flip214>
pjb: doesn't work for me. Value of SYM1 in (INTERN SYM1 :CL-USER) is #:X, not a STRING.
<Alfr>
pjb, also I'd expect an always-true to take arbitrarily many (up to call-arguments-limit) arguments.
<flip214>
_death: 640k functions, or bytes, or images?
morganw` has joined #commonlisp
<_death>
flip214: 640k of anything :)
morganw has quit [Read error: Connection reset by peer]
<_death>
flip214: pjb didn't use intern, but import
cage has joined #commonlisp
<pjb>
Alfr: well, there are requirements that gin left unspecified, so (constantly t) is the best solution so far, despite its consing.
<gin>
thanks pjb for the messages. gave me a lot more to think about and learnt more lisp too
<flip214>
oh sorry, retrying with import.
<flip214>
thanks!
tyson2 has joined #commonlisp
cage has quit [Remote host closed the connection]
cage has joined #commonlisp
morganw` has quit [Remote host closed the connection]
morganw has joined #commonlisp
triffid has quit [Remote host closed the connection]
<Bike>
sbcl, at least, will optimize (constantly a-constant) to not cons
triffid has joined #commonlisp
cage has quit [Ping timeout: 252 seconds]
cage has joined #commonlisp
rainthree has quit [Ping timeout: 252 seconds]
atgreen has joined #commonlisp
<atgreen>
I just updated sbcl (2.2.7) and quicklisp (latest), and now my app is generating "CORRUPTION WARNING in SBCL pid 16 tid 16:
<atgreen>
Memory fault at (nil) (pc=0x54100a44 [code 0x54100750+0x2F4 ID 0xc530], fp=0x7f94219ef4d0, sp=0x7f94219ef4a0) tid 16
<atgreen>
The integrity of this image is possibly compromised.
<atgreen>
Continuing with fingers crossed.
<atgreen>
" Any advice on next steps?
<hayley>
Do you get a backtrace?
<hayley>
I believe 2.2.7 now puts some constants in a read-only space after SAVE-LISP-AND-DIE, but then there would be a more instructive address rather than (nil).
<atgreen>
No backtrace
<_death>
maybe see if it's reproducible and try to get at a minimal test case
<hayley>
The next step should be to work out how to get a backtrace; I think memory corruptions signal CL errors and so you can work it out from there. Or start SBCL with --lose-on-corruption (I think), then you'll land in a debugger called "ldb", and can issue the "backtrace" command.
<atgreen>
hmm.. this is a little complicated. the app is running on kubernetes, where it needs access to other kubernetes-hosted services to run. I can get in via sly, but will that give me an ldb prompt?
rainthree has joined #commonlisp
jmdaemon has joined #commonlisp
<hayley>
It won't, so I guess ldb might not be feasible then. You'd have to see if something is swallowing the generated exceptions.
<atgreen>
Ah.. --disable-debugger should print the backtrace and exit
<atgreen>
So --lose-on-corruption --disable-debugger
<hayley>
Oh yes, that might work.
Cymew has quit [Ping timeout: 256 seconds]
vassenn has joined #commonlisp
vassenn has quit [Remote host closed the connection]
Dynom_ has joined #commonlisp
Dynom_ is now known as Guest1706
NotThatRPG has joined #commonlisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #commonlisp
<dim>
hi there!
<dim>
can I have a defmethod with an eql specifier on nil, like (defmethod foo (variant (eql nil)))?
<beach>
Sure.
<_death>
also, it's equivalent to specializing on null
<beach>
Indeed.
* beach
was too slow.
<dim>
yeah seems to work
<dim>
(defmethod foo (variant null)) would be of the same effect?
<_death>
well, it's not strictly equivalent.. you'll have two distinct methods
<beach>
The AMOP uses the preposition "to" for specialization, and I think that's a good idea, so a method "on" a generic function specialized "to" null.
<pjb>
dim: this defines a method taking two arguments of any type.
<dim>
well in my case I'm maintaining code that already has (defgeneric adjust-data-types (catalog variant) (:documentation "Adjust PostgreSQL data types depending on the variant we target."))
<beach>
dim: But your defmethod form has a parameter named NULL.
<pjb>
dim: you want: (defmethod foo ((variant null)) )!
<dim>
it just happens that sometimes the variant is nil, I'm not sure why, and I'm okay with it being nil after all (two values are supported at the moment, :pgdg and :redshift, and nil would behave the same as :pgdg, I'm okay with that)
<dim>
(defmethod adjust-data-types ((catalog catalog) (variant (eql nil))) catalog) ; that's what I have in my code now
<dim>
I believe I made a mistake forging code in the IRC input box, right?
<pjb>
equivalent to: (defmethod adjust-data-types ((catalog catalog) (variant null)) catalog)
<pjb>
dim: right. better use copy-and-paste.
<dim>
yeah I tried to be fast and had everyone lose time, sorry about that :/
<dim>
;;; Accept that sometimes the variant hasn't been specified at all.
<dim>
given that context, I think I prefer the (eql nil) specified, it's better aligned with the intention here somehow
<dim>
well I don't know, I just don't read CL code on a daily basis anymore
<dim>
opinions? ;-)
<pjb>
I think using (variant null) is more efficient than using (variant (eql nil)), but that would depend on the compiler.
<pjb>
perhaps the same code is generated by both.
<dim>
oh I don't have a perf issue there, it's done in a costly part of the code and only once
<atgreen>
I don't suppose the maintainer of that hangs out on iirc?
<_death>
nasty (safety 0) in that function (parse-message-binary-parameters) which may hide something else
<pjb>
Never put optimize declarations in code!
waleee has joined #commonlisp
<aeth>
put optimize declarations in code, just don't put (safety 0)
<aeth>
(safety 0) is never a good idea
<White_Flame>
put (safety -1) and have even surrounding code break, too
<_death>
(declare (optimize (safety 3) (spooky 3))) may affect code at distance
<aeth>
The user *may* choose to (safety 0) in a deployed application anyway to avoid type checks on tightly optimized code that has type declarations, but that's on them. Because now any bug that shows up in the real world is completely opaque unless you can reproduce it. And some library code may erroneously rely on type declarations to type *check*, which now becomes a type *assumption* in SBCL (safety
<aeth>
0), completely breaking things. But that should be on the user.
<aeth>
Imo, the only time (safety 0) makes sense is if you absolutely positively must avoid bounds checking inside of a loop where you're absolutely sure that you can't go out of bounds, but that can go inside of a LOCALLY to limit the damage. And the implementation can ignore you and bounds check anyway.
<aeth>
But... that sort of loop usually is operating on data of defined sizes so you usually can get an optimizing compiler to avoid bounds checking by just letting it know that the type is, say, (simple-array single-float (42)). And now something smarter than you is eliminating bounds checks (or not).
<aeth>
And do you really need the extra speed at the expense of dealing with strange out of bounds bugs? Because that's one of the worst parts of C or C++.
<_death>
atgreen: I guess submitting a patch would be ideal, but note that you can also restrict optimization settings using sb-ext:restrict-compiler-policy
<aeth>
_death: (safety 0) is a bug.
<_death>
aeth: I know
<aeth>
99% of code that says `(safety 0)` just recited an incantation off of the internet without realizing the implication to SBCL users (probably > 2/3 of the users of the code in 2022)
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
<NotThatRPG>
White_Flame: That has the effect of switching on the "come-from" operator, too! ;-)
Noisytoot has quit [Remote host closed the connection]
Noisytoot has joined #commonlisp
ttree has joined #commonlisp
Cymew has joined #commonlisp
<jeosol>
good morning all!
thomaslewis has joined #commonlisp
<jeosol>
_death, aeth: I don't remember, does that (declare (optimize (...)) affect all code if done at repl and you load a large system?
<jeosol>
or that those should be at file levels
thomaslewis has left #commonlisp [#commonlisp]
<pjb>
jeosol: don't put optimize declarations in files!
<jeosol>
pjb: thanks. I don't have any of that in my files at all.
<pjb>
Let the user decide on what he wants. He'll set the optimization levels in his rc file.
igemnace has quit [Quit: WeeChat 3.6]
<jeosol>
I was doing some exploration weeks ago, but I didn't see any effect, so thought I didn't set it up correctly
<jeosol>
pjb: thanks
<Fade>
does asdf have any facility for declaring optimisation level in a given build component?
tyson2 has quit [Remote host closed the connection]
<Fade>
I guess it's straight forward to override the applicable method.
<jeosol>
pjb: so declarations in rc file affects everything in the session right?
<pjb>
Yes.
<pjb>
jeosol: but say declaimations or proclaimations.
orestarod has joined #commonlisp
<pjb>
we don't use declare on the toplevel, but declaim.
<jeosol>
pardon my mixing up the terms. I was referring to setting compiler optimization policies referenced earlier
tane has joined #commonlisp
tane has quit [Changing host]
tane has joined #commonlisp
<White_Flame>
jeosol: I believe that's undefined how it spreads across future loads and whatever
<White_Flame>
and IMO toplevel policy really isn't great either
<White_Flame>
I tend to build some form of configuration parameter for optimization, and have scoped declarations for different sections as they need it
<jeosol>
White_Flame: I appreciate the comment. That explains why I didn't see any effect.
<Bike>
"As with other defining macros, it is unspecified whether or not the compile-time side-effects of a declaim persist after the file has been compiled."
<jeosol>
Trying to add that at code or file level is not feasible for me, so I'll just work with the rc level if that works
<White_Flame>
of course, proclaim is an option as well
<jeosol>
White_Flame: interesting.
<White_Flame>
"Such a declaration, sometimes called a global declaration or a proclamation, is always in force unless locally shadowed."
<White_Flame>
(re proclaim)
<jeosol>
After my limited tests, I just use the defaults for now, and just focus on the DSA bits in the code and look for any improvements
<White_Flame>
but again, is that the global environmetn during compilation?
<White_Flame>
as long as your image lasts through all compilation, I would suspect that has some effect
<White_Flame>
then there's also ASDF to consider and what it might shadow for its various compiles & loads it orchestrates
<White_Flame>
(intentionally or not)
Cymew has quit [Ping timeout: 256 seconds]
<NotThatRPG>
jeosol: the scope of declaims is not settled by the ANSI spec.
<NotThatRPG>
Fade: You could use an around-compile-hook in ASDF to achieve this, I believe.
<NotThatRPG>
White_Flame: ASDF does not attempt to shadow, but does nothing to avoid systems it loads from affecting global context of the image. Again, because the spec is so unclear, ASDF doesn't have the ability to do anything portable, so just punts.
<_death>
jeosol: in computation-intensive code declarations can help a lot, so if you already use good algorithms and data structures, you may still benefit by sprinkling them after profiling (maybe after other performance-related operations, such as reduction in consing or caching)
thomaslewis has joined #commonlisp
<NotThatRPG>
_death: On a function-by-function basis, this is easy and its effects predictable. Trying to build an entire system with (optimize (speed 3)) on the other hand...
MajorBiscuit has quit [Ping timeout: 256 seconds]
<jeosol>
_death: yes, that is my plan exactly. I go through the code sections that were written in a hurry and rewriting to avoid unnecessary calculations or consing. It's small stuffs for now. I really on an external exe for benchmarking but hope to write replicate the code in the exe in the future
<_death>
NotThatRPG: indeed.. sometimes it's even more localized.. for example I have a macro where I know the body is going to run for many iterations and often needs performance, so I declare (speed 3) in a locally there.. but then, a few uses aren't critical, so I have to reintroduce (speed 0) (or should it be speed 1? :) manually
<NotThatRPG>
_death: +1
<jeosol>
the exe code is basically Ax=b type systems that are solved repeatedly (fluid mechanics problem)
azimut has joined #commonlisp
<_death>
NotThatRPG: maybe I should split the uses and have two operators instead (another option would be to pass an argument, but I don't think I'd like that)
<_death>
for now the manual exceptions don't bother too much
<NotThatRPG>
Macro argument that controls whether or not the `(locally (declare (optimize (speed 3))))` goes into the expansion?
<_death>
yeah
<_death>
sometimes I just keep the default (speed 3) and add a type declaration or two to avoid the compiler notes.. but I think two operators could be a better signal to the human reading the code
<_death>
if one day I'll think of good names for the two, I may do that ;)
<jeosol>
I am discussing with some folks next week who may ask: what is the CL macros I talk about. I saw this link: https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node97.html#:~:text=The%20Common%20Lisp%20macro%20facility,as%20in%20most%20other%20languages. which I think is good. I don't think they'll understand but I can try to explain in layman terms
<jeosol>
basically, I use macros to generate a lot of functions that have symmetry in the function body.
<NotThatRPG>
It's a deep matter, because CL has the notion of the running image, which macro expansion can access. None of the conventional compiled languages have anything comparable. I'm not sure whether that features in your code.
NotThatRPG is now known as NotThatRPG_away
tyson2 has joined #commonlisp
karlosz has joined #commonlisp
<jeosol>
NotThatRPG: was that response addressed to me?
tyson2 has quit [Remote host closed the connection]
<jeosol>
The key two aspects of CL I highlighted were CLOS and Macros. The person may or may not know or heard about CL but I will ask them first.
<jeosol>
I came across a guy who told me you use Lisp in the early 80's and surprised at use it. He is the deep learning space. I told me one of the compilers has monthly release cycles to this day and he was really surprised
<jeosol>
_death: Thanks. Much appreciated
pranavats has left #commonlisp [Error from remote client]
<jeosol>
*Meant the guy works with Python in the deep learning space
azimut has quit [Remote host closed the connection]
azimut has joined #commonlisp
jolby has joined #commonlisp
<_death>
another one is a simple short-circuiting product operator.. like (* (foo) (bar)) .. if FOO returns 0, why should you evaluate BAR (assuming no side effects) ?
<_death>
(also assuming you don't care for type contagion)
_cymew_ has quit [Ping timeout: 268 seconds]
<_death>
alternatively, the computation could be done in parallel (similar assumptions)
defaultxr has quit [Ping timeout: 268 seconds]
karlosz has quit [Quit: karlosz]
karlosz has joined #commonlisp
enzuru has quit [Changing host]
enzuru has joined #commonlisp
defaultxr has joined #commonlisp
pranavats has joined #commonlisp
rainthree has quit [Ping timeout: 248 seconds]
tyson2 has joined #commonlisp
irc_user has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life_ has joined #commonlisp
Lord_of_Life_ is now known as Lord_of_Life
NotThatRPG_away is now known as NotThatRPG
<NotThatRPG>
jeosol: yes, that was... It's relevant to how CL macros differ from macros in other programming languages
<NotThatRPG>
jeosol: Just waiting for the CL bindings to numpy and pandas to be released! ;-)
attila_lendvai has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
<aeth>
It's possible to get a GPU compute experience for Common Lisp with Vulkan.
<aeth>
Gaming-oriented, but compute's compute.
<aeth>
You just need to compile something to SPIR-V compute shaders.
thomaslewis has left #commonlisp [#commonlisp]
igemnace has joined #commonlisp
thomaslewis has joined #commonlisp
igemnace has quit [Remote host closed the connection]
thomaslewis has left #commonlisp [#commonlisp]
Guest491241242 has joined #commonlisp
dra has joined #commonlisp
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
<Guest491241242>
Hi, currently my ql:quickload command loads a library from ultralisp distribution. I would like to download the library from quicklisps projects. How could I specify this?
<pjb>
Guest491241242: apparently, by manipulating ql-dist:*dist-enumeration-functions*
<pjb>
default value is (ql-dist:standard-dist-enumeration-function)
thomaslewis has joined #commonlisp
<NotThatRPG>
I don't see a way that you can control on a per-system basis which distribution a library comes from. Since quicklisp can make recursive computations, I think you are stuck with a single ordering over all your distributions (i.e., you either always get from ultralisp first or always from ql first).
thomaslewis has left #commonlisp [#commonlisp]
<Guest491241242>
I think I managed to do it by disabling the ultralisp using expression (ql-dist:disable (cadr (ql-dist:all-dists)))
<pjb>
cadr = first
<pjb>
oops cadr = secon
<pjb>
d
<Guest491241242>
thanks for the tip
<pjb>
I find it safer to (ql-dist:find-dist 'ultralisp)
<Guest491241242>
cl-project seems have different owners in ultralisp and in quicklisp
<pjb>
or rather: (ql-dist:find-dist "ultralisp") ; they're named by strings.
<Guest491241242>
pjb, yes. that seems a more appropriate solution
<NotThatRPG>
Guest491241242: Unless you know in exquisite detail all the dependencies of the systems you need, it's not obvious how to control quickloading with > 1 distribution. ISTR there's someone (shinmera?) who has a library that lets you assemble your own distribution.
<NotThatRPG>
Don't know if you can just alias in that....
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
<Guest491241242>
NotThatRPG: thanks, currently I don't have a need to use separate distributions or create my own. At some point I had tried something with ultralisp but had not remembered to change it back quicklisp's distribution.
tyson2 has joined #commonlisp
Guest491241242 has quit [Ping timeout: 252 seconds]
NotThatRPG is now known as NotThatRPG_away
causal has joined #commonlisp
<stylewarning>
Is allowing conda dependencies in ASDF a Bad Idea (TM)
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
<NotThatRPG_away>
stylewarning: ? You mean you want to add a new component type that's a conda package? a conda environment?
<NotThatRPG>
It occurs to me that it would be nice if we could create a new dist that is just pointers into other dists, without having to actually replicate, but I don't know how hard that would be. HTTP redirection?
<Shinmera>
Not hard at all. Each dist includes an URL for the archive.
<Shinmera>
or rather, each dist release includes an url for each project's release that it includes.
<Shinmera>
so just point that wherever.
<Shinmera>
Redist currently doesn't support that, but I want to make it.
<Shinmera>
I also would like to support it using another dist as a project's source (with replication)
cage has quit [Quit: rcirc on GNU Emacs 27.1]
<NotThatRPG>
Shinmera: +1
<stylewarning>
NotThatRPG: I'm not 100% sure. I'm thinking of something like :depends-on which ensures foreign dependencies are loaded (?) or installed (?)
tyson2 has quit [Remote host closed the connection]
<Shinmera>
stylewarning: I have thought about that problem before but I honestly think it's not a great idea because of the massive diversity of system configuration tools out there that would need to be handled, not to mention the massive variance in *versions* those tools provide.
Brucio-61 has joined #commonlisp
<Shinmera>
Instead, if I write a bindings library, I instead ship a version for every platform with the sources.
<Shinmera>
Once Forge is in a more state of actual existance I want to switch to building the foreign libraries, though.
<NotThatRPG>
stylewarning: If you want to do that you need to tell ASDF what a conda dependency is. Thinking not very hard about this, I would suggest: (1) you would need to give ASDF some way to find (or create) a conda env that contains the python systems you want. Maybe make a mixin for class (to add to ASDF system classes) to allow an ASDF lisp system to be associated with a conda env. (2) add a SECOND subclass of ASDF system that
<NotThatRPG>
corresponds to a python package, call it PYTHON-SYSTEM. Then you would have to add (at least) a PERFORM LOAD-OP method for PYTHON-SYSTEM that would know how to load a python system into the conda environment.
tane has quit [Quit: Leaving]
<NotThatRPG>
It's not great that python has so many different loading methods. If your user doesn't have conda installed, and just uses pyenv, for example, they would be SoL.
irc_user has quit [Quit: Connection closed for inactivity]
Guest1706 has quit [Quit: WeeChat 3.6]
shka has quit [Ping timeout: 248 seconds]
pve has quit [Quit: leaving]
waleee has quit [Ping timeout: 248 seconds]
tyson2 has joined #commonlisp
irc_user has joined #commonlisp
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
attila_lendvai has quit [Read error: Connection reset by peer]
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
dra has quit [Ping timeout: 268 seconds]
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
MajorBiscuit has joined #commonlisp
random-nick has quit [Ping timeout: 256 seconds]
morganw has quit [Remote host closed the connection]
NotThatRPG has quit [Read error: Connection reset by peer]