<edgar-rft>
gabbiel: you can define generic functions with &rest paameters
<edgar-rft>
there's also &allow-other-keys
<gabbiel>
aeth: yeah I was thinking, if symbols weren't restricted to one function, one could define many functions for a symbol, but that'd require declaration of types like in methods
<aeth>
well, no, if the library is robust enough, then you'd get runtime dispatch or compile-time dispatch, but the compile-time dispatch would be (1) only on certain implementations that have the proper extensions and (2) only if you have type declarations in your code because the type inference isn't exposed even to the extensions from point #1
<LdBeth>
You mean ad hoc overloading
igemnace has quit [Ping timeout: 245 seconds]
<gabbiel>
aeth: you'd certainly need type declarations to distinguish between these two
<gabbiel>
(defun foo (x y) (+ x y))
<gabbiel>
(defun foo (a b) (- a b))
<aeth>
gabbiel: Yes, I was talking about in the caller, not in the definition. The definition would need types.
<gabbiel>
oh ok, you're right then
<aeth>
gabbiel: And there's nothing (other than pulling in yet another dependency) stopping a defun wrapper from using something like defspecialization as a backend when requested.
<aeth>
Also e.g. defmethod
<aeth>
That wouldn't even need a dependency
_nir_ has joined #lisp
abhixec has joined #lisp
krwq has joined #lisp
semz has quit [Ping timeout: 264 seconds]
Oladon has joined #lisp
Tristam has quit [Excess Flood]
semz has joined #lisp
semz has joined #lisp
semz has quit [Changing host]
joast has quit [Ping timeout: 245 seconds]
ltriant has quit [Ping timeout: 245 seconds]
jgodbout has joined #lisp
ltriant has joined #lisp
Kundry_Wag has joined #lisp
statically has joined #lisp
statically has left #lisp [#lisp]
Jeanne-Kamikaze has joined #lisp
statically has joined #lisp
jao has quit [Remote host closed the connection]
Kundry_Wag has quit [Remote host closed the connection]
statically has left #lisp [#lisp]
Kundry_Wag has joined #lisp
jao has joined #lisp
t58 has quit [Quit: Night]
ggoes has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
igemnace has joined #lisp
jao has quit [Remote host closed the connection]
liberiga has joined #lisp
jao has joined #lisp
jao has quit [Remote host closed the connection]
Kevslinger has quit [Quit: Connection closed for inactivity]
Oladon has quit [Quit: Leaving.]
gko__ has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
maxxcan has joined #lisp
maxxcan has quit [Remote host closed the connection]
gabbiel has quit [Ping timeout: 245 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 248 seconds]
q9929t has joined #lisp
vms14 has joined #lisp
<krwq>
is there any ecl specific irc group?
<aeth>
#ecl
parab has quit [Quit: parab]
xkapastel has quit [Quit: Connection closed for inactivity]
torbo has joined #lisp
wigust- has joined #lisp
wigust has quit [Ping timeout: 268 seconds]
ntbre has quit [Ping timeout: 268 seconds]
Bike has quit [Quit: Lost terminal]
<beach>
Good morning everyone!
<aeth>
good morning beach
<edgar-rft>
good one
asarch has joined #lisp
<asarch>
Hallo, hallo! Wie geht es Ihnen? :-)
<edgar-rft>
Geht so, warum fragst du?
<asarch>
One very very very stupid question: If I compile the newest release of SBCL (1.5.5) with an old version (1.4.8) will this resulting binary differ from the one compiled with the newest release (1.5.5 with the resulting binary from 1.4.8)?
<asarch>
I mean, I use 1.4.8 to compile 1.5.5 then I use this 1.5.5 to re-compile 1.5.5
<no-defun-allowed>
Probably not.
<beach>
asarch: The result ought to be the same. If it is not, then that might indicate a problem.
<edgar-rft>
asearch: you could try it out and compare the resulting binaries with cmp(1)
<asarch>
I see
<asarch>
cmp ./src/runtime/sbcl $( which sbcl ): ./src/runtime/sbcl /usr/local/bin/sbcl differ: char 307242, line 681
Jeanne-Kamikaze has quit [Remote host closed the connection]
<beach>
asarch: There could be trivial differences such as time stamps.
libertyprime has quit [Ping timeout: 246 seconds]
<asarch>
Both sizes are: 1206448
<asarch>
Ok. Let's enjoy it! :-)
dddddd has quit [Remote host closed the connection]
<akoana>
asarch: beach is right, the sbcl binary contains a build timestamp like hostname-user-yyyy-mm-dd-HH-MM-SS
<akoana>
asarch: may be you can see it with grep -a -o -w yourhostname....................... ./src/runtime/sbcl
khisanth_ has quit [Ping timeout: 248 seconds]
<edgar-rft>
cmp -b <binary-1> <binary-2> will print the bytes that are different
karswell_ has quit [Remote host closed the connection]
karswell_ has joined #lisp
<akoana>
cmp -b -l <binary-1> <binary-2> | tail will show you more than the first bytes even
gravicappa has joined #lisp
* akoana
suspects that could be done in a few lines of Common Lisp, display n bytes of both files starting from the difference
<asarch>
OpenBSD's cmp doesn't support the -b flag, however, this its output (every ; represents a newline): 307242 61 62; 307244 60 61; 307248 62 70
<asarch>
From: cmp -l $( which sbcl ) ./src/runtime/sbcl
<asarch>
$( which sbcl ): /usr/local/bin/sbcl <- This was the 1.5.5 compiled with the old 1.4.8 version without '--fancy'
khisanth_ has joined #lisp
torbo has quit [Remote host closed the connection]
Necktwi has joined #lisp
Ricchi has quit [Read error: Connection reset by peer]
Ricchi has joined #lisp
<asarch>
Anyway, that's ok for me :-)
vlatkoB has joined #lisp
asarch has quit [Remote host closed the connection]
__jrjsmrtn__ has quit [Ping timeout: 245 seconds]
jgodbout has quit [Ping timeout: 258 seconds]
gko__ has quit [Quit: Connection closed for inactivity]
lalitmee has joined #lisp
EvW has joined #lisp
flamebeard has joined #lisp
Necktwi has quit [Ping timeout: 268 seconds]
dale has quit [Quit: My computer has gone to sleep]
ltriant has quit [Ping timeout: 248 seconds]
EvW has quit [Ping timeout: 250 seconds]
ltriant has joined #lisp
sonologico has quit [Remote host closed the connection]
<akoana>
beach: now I've done a quick and dirty (and bad style but working) cmp replacement in Common Lisp :)
<beach>
Nice!
<akoana>
that was great fun to do for such a newbee as me - I'm loving lisp more and more
<beach>
Great!
<akoana>
beach: thanks for encouragement!
sauvin has joined #lisp
<beach>
Anytime.
<edgar-rft>
I think we did a little mistake. The sbcl binay is only the loader, while the Lisp image on my machine is stored under /usr/lib/sbcl/sbcl.core. IMO it would make much more sense to cmp(1) the Lisp images instead of the loader.
vlatkoB_ has joined #lisp
permagreen has quit [Remote host closed the connection]
vlatkoB has quit [Ping timeout: 272 seconds]
FennecCode has quit [Quit: ERC (IRC client for Emacs 26.2)]
<akoana>
edgar-rft: good point, seems sbcl-core also has that build timestamp, beginning at byte 32
nmg has joined #lisp
<akoana>
edgar-rft: the cmp will get tricky if you compare identical versions compiled at different times, how to ignore false positives only differing in some build info...
superkumasan has quit [Ping timeout: 244 seconds]
quazimodo has joined #lisp
__jrjsmrtn__ has joined #lisp
makomo has quit [Ping timeout: 244 seconds]
<edgar-rft>
akoana: I'd just simply count the number of different bytes. If they're more than say 10% of the whole binary size then there's something fishy. If they're only a few then it's probably because of timestamps and similar things that can be ignored. In case of doubt I'd ask on #sbcl.
lalitmee has quit [Ping timeout: 258 seconds]
varjag has joined #lisp
<akoana>
edgar-rft: agreed, let's use some heuristics :)
<edgar-rft>
If you really want you could use a hex editor (or Emacs hexl-mode) to look at the context where the different bytes occur.
<akoana>
edgar-rft: oh, didn'nt know hexl-mode, does it handle big files well? (fearing my emacs to suck up all my memory)
zotan has quit [Ping timeout: 246 seconds]
fouric has quit [Ping timeout: 245 seconds]
* akoana
shying to watch an exploding emacs ;)
zotan has joined #lisp
<edgar-rft>
akoana: I just tired it, Emacs loads a 47M file without problems, after M-x hexl-mode it took appox 15 seconds to convert the binary mess into a scrollable hexdump, Emacs needed appox 100MB RAM for that.
<edgar-rft>
* I just tried it...
fouric has joined #lisp
liberiga has quit [Ping timeout: 260 seconds]
<akoana>
edgar-rft: thank you for sharing and trying so now I'm ready to dare to use hexl-mode :)
schweers has joined #lisp
<edgar-rft>
akoana: there are also hexdump tools for the command-line that don't load the whole file in one piece, but I don't know their name or their usage off-head right now.
<edgar-rft>
...one of them is obviously named hexdump(1) :-)
<akoana>
edgar-rft: yes, on linux I'm using xxd, hexdumü or od for that - they can easily handle GB sized files
<akoana>
s/hexdumü/hexdump/ as you said
<akoana>
lol
<edgar-rft>
hexdumü is the death metal version
<akoana>
haha
<akoana>
hexdumü -> hexidi
manualcrank has quit [Quit: WeeChat 1.9.1]
<edgar-rft>
hexidi? I only know Heidi, the little girl, who lived with her grandpa in the mountains
<akoana>
sorry that works only in german hex-i-di = häckst du mich (you hack me)
<ck_>
akoana: looks more like the other way around to me
<akoana>
I mean hex-i-di = hack ich dich (I'll hack you)
<akoana>
we are on the hexdump trail since asarch asked how to compare sbcl binaries hours ago - lol
<akoana>
meanwhile I've hacked a (more dirty than quick) lisp version of cmp
<akoana>
scymtym: but I'll study (and faint then) your utilities.binary-dump
<scymtym>
akoana: sure. let me know if you find any problems
lalitmee has joined #lisp
<akoana>
scymtym: thank you - appreciating your offer!
hhdave has joined #lisp
jprajzne has joined #lisp
quazimodo has quit [Read error: Connection reset by peer]
t58 has joined #lisp
quazimodo has joined #lisp
mingus has quit [Remote host closed the connection]
Lord_of_Life has quit [Ping timeout: 245 seconds]
Lord_of_Life has joined #lisp
schweers has quit [Remote host closed the connection]
bjorkintosh has quit [Ping timeout: 264 seconds]
akoana has left #lisp ["Leaving"]
libertyprime has joined #lisp
libertyprime has quit [Quit: leaving]
orivej has quit [Ping timeout: 246 seconds]
amerlyq has joined #lisp
nowhere_man has joined #lisp
jonatack has quit [Ping timeout: 260 seconds]
<JohnMS_WORK>
Does anyone know of an example code for passing a C++ class object to the embeded common lisp library?
m00natic has joined #lisp
random-nick has joined #lisp
nowhere_man has quit [Ping timeout: 245 seconds]
lalitmee has quit [Quit: Leaving]
orivej has joined #lisp
JohnMS has joined #lisp
JohnMS_WORK has quit [Ping timeout: 245 seconds]
orivej has quit [Ping timeout: 245 seconds]
jprajzne has quit [Quit: Leaving.]
ivansviatenko has joined #lisp
orivej has joined #lisp
Frobozz has quit [Read error: Connection reset by peer]
shrdlu68 has quit [Ping timeout: 248 seconds]
karswell_ has quit [Remote host closed the connection]
karswell_ has joined #lisp
nmg has quit [Remote host closed the connection]
alexande` has joined #lisp
alexanderbarbosa has quit [Ping timeout: 276 seconds]
shrdlu68 has joined #lisp
Lycurgus has joined #lisp
shrdlu68 has quit [Ping timeout: 258 seconds]
jprajzne has joined #lisp
samlamamma has joined #lisp
<samlamamma>
Opinions on if and maybe how we should get multiple packages of the same name and perhaps nested:packages:in:lisp?
shrdlu68 has joined #lisp
frgo has quit [Ping timeout: 244 seconds]
shrdlu68 has quit [Ping timeout: 258 seconds]
Necktwi has quit [Quit: leaving]
ebrasca has joined #lisp
shrdlu68 has joined #lisp
dddddd has joined #lisp
alexande` has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
Lycurgus has quit [Quit: Exeunt]
Finnfinn has joined #lisp
<lieven>
hierarchical package names is a fairly common extension
<heisig>
samlamamma: There was a paper discussing this topic on this year's ELS, called 'Symbols as Namespaces in Common Lisp'
<heisig>
In practice, the Common Lisp package system works well as it is.
<samlamamma>
lieven: I saw that the ABCL devs had a thing about that, I couldn't find it in the docs though
<LdBeth>
There’s local nicknames
<samlamamma>
heisig: It works well because we're forced to make it work. Having versioned packages would let system maintainers keep older dependencies without updating to the bleeding edge. I'll look up the paper
<LdBeth>
Versioning is handled by ASDF rather than defpackage
<samlamamma>
LdBeth: Assume A and B both depend on system C (and defining packages A, B and C respectively). C updates with some incompatible change, B wants to update and A wants to stay. I use both A and B, how do I load both A and B in my Lisp image?
cosimone has joined #lisp
<LdBeth>
samlamamma: use rename-package
<LdBeth>
But it not very common breaking backwards compatibility in CL
hhdave_ has joined #lisp
<samlamamma>
I know, that's my point. We're forced into a certain culture because of the limitations of CL.
<LdBeth>
But what’s the benefits of breaking it?
<LdBeth>
Smaller image?
<heisig>
Some problems cannot be solved, only avoided. Dependency hell is such a problem.
hhdave has quit [Ping timeout: 246 seconds]
hhdave_ is now known as hhdave
<heisig>
So let's all just design mature, stable APIs and be done with it.
longshi has joined #lisp
<LdBeth>
One can just create the package hierarchy with domain.dir.filename:symbol
<LdBeth>
It’s nothing to do with versioning
<LdBeth>
The two packages from different versions could probably still use the same name
ggole has joined #lisp
papachan has joined #lisp
<beach>
samlamamma: first-class global environments these problems, but they are obviously not standard, and no implementation uses them (yet).
<beach>
samlamamma: I take it you like Scandinavian progressive rock, yes?
gareppa has joined #lisp
<beach>
samlamamma: Oh, and if you want more information about SICL and Cleavir, we hang out in #sicl.
<samlamamma>
beach: I don't listen to it much anymore, but yes that's where my uname is from :-). I'm idling in #sicl as we speak!
<beach>
Great!
heisig has quit [Quit: Leaving]
cosimone has quit [Quit: WeeChat 2.5]
gjvc has joined #lisp
Bike has joined #lisp
cosimone has joined #lisp
Frobozz has joined #lisp
lucasb has joined #lisp
longshi has quit [Quit: WeeChat 2.4]
<Xach>
There will be a quicklisp update available soon!
<beach>
Great1
<beach>
Great! I mean.
<gjvc>
hooray
<Josh_2>
noice
JohnMS has quit [Read error: Connection reset by peer]
Josh_2 has quit [Ping timeout: 245 seconds]
LiamH has joined #lisp
<Xach>
Ok, it is now available.
<dlowe>
*explosions in the distance*
<Xach>
I am glad someone told me that my github common lisp projects feed was busted
<Xach>
I missed it and now that it's fixed I'm very glad to read it every day
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
cosimone has quit [Quit: WeeChat 2.5]
FreeBirdLjj has quit [Ping timeout: 245 seconds]
papachan has quit [Quit: Leaving]
Lycurgus has joined #lisp
shrdlu68 has quit [Quit: WeeChat 2.3]
hhdave has quit [Quit: hhdave]
waron has quit [Quit: WeeChat 2.4]
karlosz_ has joined #lisp
m00natic has quit [Remote host closed the connection]
<Josh_2>
What would be the lispy way to solve this problem, print out numbers 1 - 10 in a random order
karlosz_ has quit [Quit: karlosz_]
<Josh_2>
I have a solution but I don't think It's very good. I am just curious this is not for anything serious
<aeth>
1 to 10 is easy because you can just have a sequence
<dlowe>
Just do a Fisher-Yates shuffle
<Josh_2>
See that's what I thought
<dlowe>
(alexandria:shuffle (loop i from 1 upto 10 collect i))
Jesin has quit [Quit: Leaving]
<Josh_2>
I just removed one element at random then got my random ele from the new list
<Josh_2>
seems really slow
<aeth>
What I would do not knowing the correct algorithm for shuffling or anything like that would be to make an adjustable vector with the contents #(0 1 2 3 4 5 6 7 8 9 10) and swap the number I'm removing with the last item and then vector-pop
<aeth>
Repeat, getting a smaller random index each time until there is nothing left
<dlowe>
White_Flame: I've done that before but it's actually not a very good shuffle
<dlowe>
also zerop
<White_Flame>
yes, it is straight from the Department of Less Than Good Ideas
<ck_>
is that right next door from the department for redundancy department?
vms14 has quit [Ping timeout: 245 seconds]
<dlowe>
I mention that because I didn't actually know it wasn't a good shuffle for a long time
vms14 has joined #lisp
<pjb>
White_Flame: sort doesn't guarantee much on the order of elements if you don't give it an order function. You will have "elements [will be] scrambled in some unpredictable way". Which doesn't mean it will be a random shuffle.
Necktwi has quit [Quit: leaving]
karlosz_ has quit [Quit: karlosz_]
<White_Flame>
pjb: while it may just look like a spurious trailing comment, I did put a smiley at the end for a reason
<pjb>
Ok.
<ck_>
White_Flame: I think he has a problem with humor. I tried before.
<ck_>
also, Fisher-Yates is the same thing as the Knuth shuffle, right? I wonder how many months between the implementations
ggole has quit [Quit: Leaving]
<Bike>
huh, the fisher in fisher-yates is the population geneticist
<Bike>
in 1938
<Bike>
so kind of a while until knuth got to it
<dlowe>
I invented it myself in 2007, so it should obviously be the knuth-dlowe shuffle
<dlowe>
ah the knuth bit was swapping to the end, which is clever
<aeth>
Here's "my" algorithm with the efficiency adjustment dlowe (Knuth?) gave of not even having to pop an adjustable, and just working on the index directly
<aeth>
I think that's correct... technically 16-bit Lisps might not like me using fixnum instead of alexandria:array-index, but you probably won't notice this on a modern 64-bit Lisp, and either way, you'd just get an out of bounds error if I'm wrong.
<dlowe>
I mean, the shuffle can work fine with an untyped vector
<dlowe>
not sure why you specified it
<aeth>
dlowe: This is specifically for integers starting with 1, and it will have to be a fixnum because it will also have to double as an array index
<aeth>
The inner loop could've been a separate function, I guess.
<aeth>
since that's the real algorithm
sauvin has quit [Read error: Connection reset by peer]
<Bike>
you don't use the elements at all. what are you talking about? you just shuffle them
parab_ has joined #lisp
<aeth>
Bike: it's shuffling the numbers 1 to 10 (or 1 to n in my generalization) so it's a more specific problem. In this case, the elements can't be any larger than array-dimension-limit which must be a positive fixnum or the algorithm won't work
parab has quit [Ping timeout: 244 seconds]
parab_ is now known as parab
<Bike>
why not
<Bike>
looks fine to me
<Bike>
i'm seriously confused here, all you're doing is swapping the elements
<Bike>
you don't do (aref vector (aref vector ...)) or anything
<aeth>
Bike: since the problem was specifically for numbers from 1 to n, the elements are necessarily of the type `(integer 1 ,array-dimension-limit) which is necessarily a subset of fixnum. I should probably check-type for the more specific type, though
<Bike>
but you said they double as array indices. but they don't do that
<Bike>
the actual shuffle, the inner loop, is completely insensitive
parab has left #lisp [#lisp]
<aeth>
Bike: I meant to say that the type doubles as an array index, but that's not true, either, since it's actually shifted up by 1
Bike has quit [Remote host closed the connection]
<aeth>
s/an array index/the array index type/
Bike has joined #lisp
Frobozz_ is now known as Frobozz
Achylles has joined #lisp
hiroaki has quit [Ping timeout: 248 seconds]
cosimone has quit [Quit: WeeChat 2.5]
hiroaki has joined #lisp
Josh_2 has quit [Ping timeout: 272 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
vms14 has quit [Changing host]
vms14 has joined #lisp
saravia has joined #lisp
maxxcan has quit [Quit: maxxcan]
karswell has quit [Ping timeout: 245 seconds]
cosimone has joined #lisp
cosimone has quit [Client Quit]
saravia has quit [Quit: Leaving]
saravia has joined #lisp
saravia has quit [Remote host closed the connection]
permagreen has joined #lisp
gravicappa has quit [Ping timeout: 248 seconds]
vlatkoB_ has quit [Remote host closed the connection]
Josh_2 has joined #lisp
gareppa has joined #lisp
iarebatm` has joined #lisp
<iarebatm`>
How would you guys go about implementing a 'throttle'? ex, I want to use dexador to issue http requests against a web service, but that service has a maximum requests/per-second that I'm allowed to use.
gareppa has quit [Remote host closed the connection]
ggoes has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
fragamus has joined #lisp
dddddd has quit [Remote host closed the connection]
nullman has quit [Ping timeout: 248 seconds]
scottj has left #lisp [#lisp]
nullman has joined #lisp
LiamH has quit [Quit: Leaving.]
akoana has joined #lisp
v0|d has quit [Remote host closed the connection]
v0|d has joined #lisp
hhdave has quit [Quit: hhdave]
t58 has quit [Quit: Night]
Achylles has quit [Quit: Leaving]
hhdave has joined #lisp
man213 has quit [Quit: Going offline, see ya! (www.adiirc.com)]
Bike has joined #lisp
iarebatm` has joined #lisp
<iarebatm`>
pjb: thank you
lucasb has quit [Quit: Connection closed for inactivity]
Josh_2 has quit [Remote host closed the connection]
Josh_2 has joined #lisp
cosimone1 has joined #lisp
cosimone has quit [Read error: Connection reset by peer]
ltriant has joined #lisp
vms14 has quit [Quit: WeeChat 2.3]
pplzk has joined #lisp
<aeth>
I think I'm going to do a CommonMark implementation to generate static sites for Github/Gitlab pages. There are two markdown implementations in Quicklisp, but neither give any indication that they implement the CommonMark spec, i.e. https://spec.commonmark.org/