morganw has quit [Remote host closed the connection]
s-liao has quit [Quit: Client closed]
s-liao has joined #commonlisp
waleee has quit [Ping timeout: 240 seconds]
waleee has joined #commonlisp
waleee has quit [Ping timeout: 240 seconds]
s-liao12 has joined #commonlisp
s-liao has quit [Ping timeout: 256 seconds]
waleee has joined #commonlisp
s-liao12 has quit [Quit: Client closed]
s-liao has joined #commonlisp
_patrice has quit [Ping timeout: 240 seconds]
varjag has quit [Ping timeout: 240 seconds]
random-nick has quit [Ping timeout: 240 seconds]
eugercek has quit [Remote host closed the connection]
waleee has quit [Ping timeout: 250 seconds]
_patrice has joined #commonlisp
zacque has joined #commonlisp
waleee has joined #commonlisp
Devon has joined #commonlisp
waleee has quit [Ping timeout: 250 seconds]
molson has joined #commonlisp
c has joined #commonlisp
c has quit [Client Quit]
c has joined #commonlisp
c is now known as Common-Lisp
_patrice has quit [Ping timeout: 256 seconds]
waleee has joined #commonlisp
waleee has quit [Ping timeout: 260 seconds]
s-liao has quit [Ping timeout: 256 seconds]
yewscion has quit [Ping timeout: 272 seconds]
Common-Lisp has quit [Quit: Leaving]
perrierjouet has quit [Quit: WeeChat 3.4]
s-liao has joined #commonlisp
Oladon has joined #commonlisp
<ns12>
Hello, how do I use Unix/Linux features in Common Lisp? How do I use fork(), exec(), sigprocmask() in Common Lisp? https://lispcookbook.github.io/cl-cookbook/os.html doesn't really say much about these.
tyson2 has quit [Read error: Connection reset by peer]
s-liao has quit [Ping timeout: 256 seconds]
<White_Flame>
ns12: sbcl has the sb-posix package with a lot of stuff in it, not sure about compatiblity libraries for them
<White_Flame>
it's not standard CL
<ns12>
White_Flame: Most sb-posix functions do not seem to be documented in the SBCL manual http://www.sbcl.org/manual/
<White_Flame>
right, check their docstrings & refer to posix knowledge
<White_Flame>
I know usockets uses select() in its backend
<White_Flame>
as one example to poke into
epony has quit [Ping timeout: 240 seconds]
<White_Flame>
I do wonder what you're doing, though, as many of these things should more be viewed in terms of the functionality you're going for, not the specific posix api
<beach>
Maybe ns12 is writing a Unix shell.
<ns12>
White_Flame: I have no particular project. I have been learning about the POSIX API, and I am evaluating Common Lisp's existing ability in this area.
<beach>
ns12: It is not about the language Common Lisp.
<ns12>
beach: Is it off-topic here?
<beach>
No.
<beach>
But you said you are evaluating Common Lisp.
<ns12>
Yes, the Common Lisp ecosystem. Not the language itself.
Guest74 has joined #commonlisp
semz_ has joined #commonlisp
<Guest74>
how many implementations have posix functions? is there much difference between the implementations? I figure everybody would stay pretty close to the c definitions.
semz has quit [Ping timeout: 250 seconds]
<ns12>
Guest74: "how many implementations have posix functions?" - From my observations, it is not a priority for many Common Lisp implementations.
<beach>
Guest74: It gets tricky when the C API uses C structs.
<White_Flame>
the implementation is a mudball as I was adding features
<Guest74>
I'm sure there's a few. I've taken to using nibbles for the reading/writing that everything deconstructs to.
<White_Flame>
but it's the spec (and knowledge that it is unambiguously implementable) that's the important part
<ns12>
Does LispWorks and Allegro have comprehensive POSIX APIs?
<ns12>
s/Does/Do/
<Guest74>
white_flame: I hope to have some that reads more like common lisp with a small precise specification.
<White_Flame>
well, this is a declarative data specification. the lisp stuff then uses it to interpret how to pull in a file into a tree of values
<White_Flame>
and take a tree of values and write it into bytes
<White_Flame>
because all sorts of file formats do all sorts of crazy things, it needs a very comprehensive library
<White_Flame>
I didn't want a bunch of black-box imperative code defining things
<White_Flame>
s/library/vocabulary/
<Guest74>
I'm thinking I don't want to support stupid things.
<Guest74>
Many years ago I thought I would write a buffer replacement for clx to work with modern extensions. but it's just too stupid.
<beach>
Guest74: We seem to be talking about different aspects. I think as an implementation technique, stuffing things in a Common Lisp vector might work. I am more interested in what data structures will be presented to the Common Lisp application programmer. That's what my page on that link is about.
<beach>
... and that's why I mentioned that structs are tricky.
<White_Flame>
ns12: ocaml probably fits the C process structure more cleanly?
<White_Flame>
lisp really grew big _as_ an OS
<Guest74>
beach: for my current work on ioctls I autogenerate a lisp struct with the same fields, and also generate a reader for that struct that populates the c struct. I find it a bit tedious. I also have the option for the lisp function to take an alist of slots and values which populates the c structs/arrays for the ioctl.
<Guest74>
s/reader/reader & writer/
<Guest74>
I'm guessing lisp function built upon those autogenerated structs/readers/writers will just take keywords?
<Guest74>
though I think I need still allow to pass lisp structs(and maybe even c structs?) for things where it makes sense. e.g. force feedback effects for controllers are nicely contained within c-structs, and having a library of them you could send to the device seems like something useful.
<White_Flame>
it wouldn't seem like the end of the word to marshall between a reused lisp struct and a reused C struct
<Josh_2>
Good morning
<White_Flame>
but I get that some of them can get quite large
<White_Flame>
and of course that wouldn't work if they're holding volatile values
<Guest74>
I don't reuse any c structs at the moment. A new one is created for every ioctl call. I don't know if that's as bad as I think it might be.
<White_Flame>
if it's stack-allocated that's reasonable
<Guest74>
It only reads or writes to a lisp struct if it was provided by the caller.
<Guest74>
i.e. the default is it will just return values as a plist of slot value.
_patrice has joined #commonlisp
_patrice has quit [Remote host closed the connection]
<Guest74>
thankfully it doesn't seem like there's anything too crazy in c stuff for ioctls. The worst I've run across so far is nested structs and pointers to arrays within the struct, but it's all seemed to work out so far.
<Josh_2>
beach: Has anyone worked on a practical implementation of a posix interface like the one you have started specifying?
<Guest74>
sb-posix doesn't seem so bad.
<Guest74>
well, except sb-posix:ioctl doesn't really work and I have to use sb-unix:unix-ioctl, but besides that, i'm not sure how much more lispy you can get for posix calls.
<Guest74>
actually, i shouldn't say it doesn't work. It probably works as specified by posix but linux changed how it works and bsd users were made sad.
s-liao has joined #commonlisp
jmes has joined #commonlisp
patrice has quit [Quit: Leaving]
wacki has joined #commonlisp
<pillton>
There must be a better way to expose OS functionality then via C APIs.
Oladon has quit [Quit: Leaving.]
<Guest74>
i guess it depends on what OS functionality you are talking about. We could write our own interfaces to file systems.
<Guest74>
and love it or hate it, since everything is a file in unix, you can just open-file.
* edgar-rft
suggests using assembly interrupts again instead :-)
<pillton>
I am not sure that is true. I can't open a file which connects to a website for example. I also can't open a file to execute a command.
s-liao has quit [Ping timeout: 256 seconds]
<Guest74>
execute a command?
raeda has quit [Quit: Leaving]
<Guest74>
you can talk directly to the virtual terminals if you want.
<opcode>
anyone here run a swank/slynk repl on a remote server accessible via the internet? if so how do you secure it?
<pillton>
Guest74: Start another process e.g. fortune.
<White_Flame>
pretty sure you can open a file to a website in Plan9
<White_Flame>
unix just sucks ;)
<Guest74>
but i'm not sure how that's even a complaint when we have drakma/dexador?
<White_Flame>
but as long as OSes have a C heritage, it will expose its APIs in C
<Guest74>
So all you have to do is write your OS in lisp.
<White_Flame>
yep
<White_Flame>
or do something other than function calls
<pillton>
Why do you have to write your OS in lisp? What does it solve?
<White_Flame>
the OS API wouldn't be exposed in C
<pillton>
Then the people who like C will complain about it being in CL.
<White_Flame>
stuff 'em
<White_Flame>
;)
<Josh_2>
opcode: Yes, you should use ssh tunnels
<opcode>
i was going to use wireguard
<White_Flame>
opcode: swank by default only listens to localhost, not external ports
<beach>
Josh_2: I don't think so.
<opcode>
White_Flame: can't you just set swank::*loopback-address* ?
<beach>
pillton: Do you not think my proposal is better than the C API?
<beach>
Actually, never mind. I should be quiet.
<pillton>
beach: I'd have to think about it. I'd rather people write libraries which solve specific problems rather than offer interfaces to APIs of other languages.
<beach>
I fully understand.
<White_Flame>
opcode: I mean its default is secured away from outside connections, so it's less of a concern. But anybody with access to execute code on the box can access swank
<opcode>
White_Flame: maybe i'm not clear, but I want to have a long-running lisp process on a server, and i want to expose a repl so I can hack on it from home
<White_Flame>
right, I've done that
<opcode>
but obviously as you said, the repl presents a security concern
<White_Flame>
it wasn't on an internet-accessible box, technically, btu we could tunnel in
<opcode>
yeah, I was planning to use nftables to only expose swank on a wireguard tunnel
<White_Flame>
and I don't think you should open the listener to anything but the loopback device, and externalize the access via ssh or whatever
<opcode>
it's my box, I'm not worried about other users
<opcode>
ah ok
<opcode>
that's probably much simpler than what I'm trying to get going here
dirtcastle has joined #commonlisp
<Josh_2>
You should just use ssh tunnels
epony has joined #commonlisp
<Josh_2>
I have 3 lisp images running on one of my VPS's and I can just open my ssh connection with tunnelling and then I can connect to them
<pillton>
beach: For example, asynchronous I/O, synchronous I/O and non-blocking I/O. I think CL can do a much better job of offering interfaces to these I/O strategies that actually helps the user organise /their/ application. The underlying C API does not do that. The functionality is "exposed" by a convoluted set of C constants, functions and file descriptor modes, obfuscating each individual strategy. I think the C constants aren't even
<pillton>
consistent across the different unixes. And, once you're done with the unix world, you also have to consider the non-Unix world as well.
<beach>
pillton: I see.
<beach>
The idea of my suggested protocols was to do it in 2 layers. The lower layer would be closer to the C API, and the upper layer would present something much more convenient to the Common Lisp application programmer. Perhaps the upper layer would be the place to do a better job.
<beach>
Actually, I didn't come up with the 2-layer idea. But I forget who it was who did.
<beach>
Not that it matters. I won't have time to work on it in the near future anyway.
<pillton>
beach: Sure. I am just giving my two cents.
<beach>
Yes, what you say makes a lot of sense.
rain3 has joined #commonlisp
<dirtcastle>
i installed slime. but If I M-x slime , it shows " searching for program: No such file or directory,lisp"
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<White_Flame>
dirtcastle: you probably have to define which lisp it's going to call, and is just defaulting to "lisp"
<dirtcastle>
I fixed it .
<White_Flame>
however it's easier to use portacle for an all-in-one solution, or quicklisp-slime-helper to install slime individually
<dirtcastle>
u r right
<White_Flame>
ah, k
<dirtcastle>
I set inferior lisp program sbcl
<dirtcastle>
it's there in my init but it won't load properly because my init produces errors
dirtcastle has quit [Remote host closed the connection]
jealousmonk has quit [Quit: ERC 5.4.1 (IRC client for GNU Emacs 27.1)]
<molson>
yeah, emacs doesn't load the init if it has errors.
s-liao has joined #commonlisp
<jmes>
Question for Parenscript users: how do I call a macro inside a PS form? When I want to use MY-MACRO (which should spit out some Parenscript code) and I write (ps (my-macro)) it gets compiled to myMacro. I tried to RTFM but my brain might be too small
<jmes>
I have a situation more like this, where if I use Parenscript's LISP like so (ps (let ((something 1)) (lisp (my-macro something)))) then SOMETHING will be unbound
hashfunca51 has joined #commonlisp
<hashfunca51>
White_Flame: i did the exercise of constructing a templated macro without using quasiquotes. but i've been stuck on how i get around splicing lists without using ,@
amb007 has quit [Read error: Connection reset by peer]
<hashfunca51>
White_Flame: especially arguments given to an &body parameter in said macro, because the argument passed is wrapped in a list ... (1 2) => ((1 2)) ... thus the list must be spiced, since, if not, an erroneous function call is made. e.g., ... (1 2) => ((1 2)) => "illegal function call". i've been at it for a long time and still haven't found a way around not using ,@
<jmes>
Josh_2: ah, somehow I missed that, thanks! I hope this does the trick :)
amb007 has joined #commonlisp
s-liao has quit [Ping timeout: 256 seconds]
shka has joined #commonlisp
<hashfunca51>
White_Flame: sorry, you were involved in that conversation but it was @moon-child that recommended that exercise
<hashfunca51>
annnd he/she isn't online
hashfunca51 has quit [Remote host closed the connection]
<White_Flame>
you have to use append
<White_Flame>
aaaaand he/she isn't online
attila_lendvai has quit [Ping timeout: 240 seconds]
<beach>
I think this has been said already. Oh well.
<White_Flame>
hmm, you sure about explicit CONS calls? also dot notation
<White_Flame>
for splicing in the middle of lists
<flip214>
depending on the input data an (alexandria:flatten (cons list1 (cons list2 (cons list3 nil)))) might work for you as well ;)
lottaquestions has joined #commonlisp
lottaquestions has quit [Client Quit]
lottaquestions has joined #commonlisp
cosimone has joined #commonlisp
lottaquestions_ has quit [Ping timeout: 240 seconds]
eugercek has joined #commonlisp
Arcsech has quit [Quit: You have been kicked for being idle]
karlosz has joined #commonlisp
MajorBiscuit has joined #commonlisp
Dynom has joined #commonlisp
rain3 has quit [Ping timeout: 250 seconds]
azimut has quit [Remote host closed the connection]
azimut has joined #commonlisp
s-liao has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
attila_lendvai has joined #commonlisp
morganw has joined #commonlisp
karlosz has quit [Ping timeout: 240 seconds]
<neominimum>
Anyone know of projects that are looking for hands? I have two brain cells that I would like to put to good use.
<beach>
Tons! What do you know how to do, and what kind of project would you prefer?
admich has joined #commonlisp
<neominimum>
I'd like to take the opportunity to work in a variety of domains to further my knowledge. I don't think I really have a preference as to what I want to work on, as I hope the problems can be interesting in and of themselves. That being said I have recently begun some study into basic computer architecture, up through to high-level language compilers and I found it pretty interesting. I am sorely lacking in theoretical foundations, but am
<neominimum>
willing to learn.
<beach>
I'll keep that in mind. You could also start a new project.
<beach>
We would help you with advice, code reviews, etc.
<beach>
Or you could check with Shinmera (games) and jackdaniel (McCLIM, ECL).
<neominimum>
I've been developing an actor runtime for message passing style concurrency, it's rather primitive still, but it has been the vehicle by which I've been learning common lisp. I have coupled that with a basic syntax for coordinating the execution of lisp code using an asynchronous evaluation semantics, so that one can continue to code in direct style as opposed to a continuation passing style.
<neominimum>
Okay great I'll take a look, thanks.
s-liao has quit [Quit: Ping timeout (120 seconds)]
s-liao has joined #commonlisp
cage has joined #commonlisp
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #commonlisp
kevingal has joined #commonlisp
random-nick has joined #commonlisp
kevingal has quit [Ping timeout: 272 seconds]
kevingal has joined #commonlisp
pillton has quit [Quit: ERC (IRC client for Emacs 27.2)]
<Shinmera>
Games touch on a ton of domains
specbot has quit [Remote host closed the connection]
minion has quit [Read error: Connection reset by peer]
pranavats has left #commonlisp [Error from remote client]
patrice has joined #commonlisp
<neominimum>
I like the world building aspect of game development, not so much gameplay mechanics though, but I'd like to have a go at creating some imersive 3d environements one day. AIUI there is an absolute ton of work that goes into the implementation of game engines.
s-liao has quit [Quit: Client closed]
varjag has joined #commonlisp
amb007 has quit [Ping timeout: 240 seconds]
<jackdaniel>
usually you start from something that is interesting to you and you end god knows where :)
amb007 has joined #commonlisp
amb007 has quit [Ping timeout: 272 seconds]
Brucio-61 has joined #commonlisp
cosimone` has joined #commonlisp
amb007 has joined #commonlisp
<neominimum>
true! :) Honestly sometimes I feel overwhelmed with how many forks and detours there seem to be in the path. Theres way to much to master in a single lifetime, I get a bad case of analysis paralysis at times.
cosimone has quit [Ping timeout: 250 seconds]
pjb has quit [Remote host closed the connection]
pjb has joined #commonlisp
<jackdaniel>
no worries, if it is true that the world is just, then everyone must have the same share- in other words we reincarnate as each possible person in each possible time with all possible scenarios ,-)
treflip has joined #commonlisp
amb007 has quit [Ping timeout: 252 seconds]
amb007 has joined #commonlisp
pranavats has joined #commonlisp
iamFIREcracker has quit [Ping timeout: 256 seconds]
jeosol has joined #commonlisp
<neominimum>
Personally I can't wait to reincarnate as a sea cucumber. No care in the world, gently being tossed around by the warm sea currents. Magnifique.
<neominimum>
Night all
<beach>
'night neominimum.
notzmv has joined #commonlisp
mgl has quit [Quit: Client closed]
zacque has quit [Quit: Goodbye :D]
dirtcastle has joined #commonlisp
dirtcastle has quit [Client Quit]
dirtcastle has joined #commonlisp
patrice has quit [Quit: Leaving]
IPmonger has joined #commonlisp
IPmonger has quit [Remote host closed the connection]
rain3 has joined #commonlisp
patrice has joined #commonlisp
s-liao has joined #commonlisp
iamFIREcracker has joined #commonlisp
theBlackDragon has quit [Quit: Boom.]
mogan90 has joined #commonlisp
Bike has joined #commonlisp
clos-encounters has quit [Quit: ERC (IRC client for Emacs 27.2)]
admich has quit [Ping timeout: 272 seconds]
s-liao has quit [Quit: Client closed]
cage has joined #commonlisp
rain3 has quit [Ping timeout: 256 seconds]
kevingal has quit [Ping timeout: 240 seconds]
kevingal has joined #commonlisp
ebrasca has joined #commonlisp
theBlackDragon has joined #commonlisp
theBlackDragon has quit [Client Quit]
theBlackDragon has joined #commonlisp
dirtcastle has quit [Remote host closed the connection]
gxt has quit [Remote host closed the connection]
gxt has joined #commonlisp
euandreh has joined #commonlisp
kevingal has quit [Remote host closed the connection]
mogan90 has quit [Ping timeout: 245 seconds]
amb007 has quit [Ping timeout: 272 seconds]
amb007 has joined #commonlisp
waleee has joined #commonlisp
<jmes>
Does anyone know of an Argon2 implementation (or bindings) in CL? My cursory search reveals nothing
kevingal has quit [Remote host closed the connection]
rtoy has joined #commonlisp
perrierjouet has joined #commonlisp
<edgar-rft>
inert gas bindings are tricky :-)
attila_lendvai has quit [Ping timeout: 240 seconds]
MajorBiscuit has quit [Ping timeout: 240 seconds]
ghost4096 has joined #commonlisp
MajorBiscuit has joined #commonlisp
ec has joined #commonlisp
ec has quit [Remote host closed the connection]
MajorBiscuit has quit [Ping timeout: 272 seconds]
easye has quit [Remote host closed the connection]
rain3 has quit [Quit: Leaving]
nature has joined #commonlisp
karlosz has joined #commonlisp
Oladon has quit [Quit: Leaving.]
aartaka has quit [Ping timeout: 256 seconds]
aartaka has joined #commonlisp
hashfunc1818 has joined #commonlisp
easye has joined #commonlisp
karlosz has quit [Ping timeout: 240 seconds]
alfonsox has quit [Read error: Connection reset by peer]
attila_lendvai has joined #commonlisp
patrice has quit [Quit: Leaving]
sabra has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
dirtcastle has quit [Ping timeout: 240 seconds]
dirtcastle has joined #commonlisp
dirtcastle has quit [Ping timeout: 240 seconds]
mogan90 has joined #commonlisp
treflip has quit [Quit: ERC (IRC client for Emacs 27.2)]
Oladon has joined #commonlisp
tane has joined #commonlisp
v88m has quit [Ping timeout: 272 seconds]
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
tyson2 has quit [Remote host closed the connection]
mgl has quit [Quit: Client closed]
Lord_of_Life_ is now known as Lord_of_Life
Dynom has quit [Quit: WeeChat 3.4]
Dynom has joined #commonlisp
sabra has joined #commonlisp
karlosz has joined #commonlisp
<jmes>
Let's say I have 2 macros A & B where A calls B. With Sly, if I make a change to B I (seemingly) have to re-evaluate B and then A for the change to fully take effect. If A is a set of macros all using B this gets unwieldy. Is there a clever or obvious way to manage this better?
karlosz has quit [Client Quit]
<jmes>
other "solutions" I've been using are reloading the whole file containing A & B, or reloading the whole project with quickload when A & B are in different files/systems/etc.
aartaka has quit [Ping timeout: 240 seconds]
karlosz has joined #commonlisp
perro_ has quit [Quit: WeeChat 3.0.1]
<Bike>
when you say "calls", do you mean the A macroexpander uses the B macro, or that A forms expand into B forms?
<jmes>
Bike: I mean the A macroexpander uses the B macro
<Bike>
mm, well, yes, the compilation process expands all macros, so changes to the definition of a macro don't affect previously compiled uses
<Bike>
usually i just do the broad recompiles you described. another thing you can do sometimes is make macros fairly minimal, e.g. have a with-whatever macro expand into a call of the call-with-whatever function
<Bike>
then you can change the definition of call-with-whatever and expect that to affect things properly
<jmes>
Okay thanks! For my small-ish project it's still fine to reload everything but it doesn't feel right. I just wanted to check and see if any lispers could steer me straight
<White_Flame>
do you use an .asd file?
<Xach>
For complex macros I sometimes implement it by collecting the incoming source into an object, and then use functions to generate the resulting source code, so changing & compiling the component functions has an immediate effect. That's not super-common for me, but it happens sometimes.
tyson2 has joined #commonlisp
Oladon has quit [Quit: Leaving.]
<jmes>
White_Flame: yes
<jmes>
Xach: sounds a little odd but if it works it works!
<Xach>
The last time I did it, it was for a defclass-like macro that had a lot of interacting component pieces, so gathering the bits in one place and passing it around to simpler functions helped.
<Xach>
I didn't have to get everything right in one complicated template-heavy pass
hashfunc1818 has quit [Ping timeout: 240 seconds]
cage has quit [Quit: rcirc on GNU Emacs 27.1]
Dynom has quit [Quit: WeeChat 3.4]
jeosol has quit [Quit: Client closed]
mogan90 has quit [Ping timeout: 250 seconds]
utis has quit [Ping timeout: 256 seconds]
utis has joined #commonlisp
karlosz has quit [Quit: karlosz]
ec has joined #commonlisp
ec has quit [Ping timeout: 240 seconds]
ebrasca has quit [Remote host closed the connection]
Oladon has joined #commonlisp
ec has joined #commonlisp
<dbotton>
When doing a change-class will the initforms be set on the slots being added?
<Shinmera>
Yes as per shared-initialize.
<Bike>
assuming an initarg wasn't provided for them
<dbotton>
That is case. I’m seeing some unbound for some strange reason
<dbotton>
I’ll keep hunting why
<dbotton>
Thanks you, was user error on my part as expected :)
attila_lendvai has quit [Ping timeout: 240 seconds]
stylewarning has quit [Changing host]
stylewarning has joined #commonlisp
wacki has quit [Quit: Leaving.]
nature has quit [Ping timeout: 256 seconds]
<dbotton>
Is there an easy way to reverse the order of maphash?
dmh has quit [Quit: rip]
<Shinmera>
maphash has no guaranteed order anyway, so what do you mean?
morganw has quit [Remote host closed the connection]
<dbotton>
I wanted to try an experiment with the order that was being returned. I’ll just not be lazy about it. Somehow I was thinking things were returned in order of the keys but no idea why was thinking that.
<dbotton>
I think time to take a break. :(
wmblathers has quit [Quit: Leaving...]
Oladon has quit [Quit: Leaving.]
karlosz has joined #commonlisp
Bike has quit [Quit: Lost terminal]
tane has quit [Quit: Leaving]
amb007 has quit [Ping timeout: 256 seconds]
pve has quit [Quit: leaving]
eugercek has quit [Remote host closed the connection]
eugercek has joined #commonlisp
eugercek has quit [Read error: Connection reset by peer]
shka has quit [Ping timeout: 272 seconds]
igemnace has quit [Remote host closed the connection]