ebrasca has quit [Read error: Connection reset by peer]
Essadon has quit [Client Quit]
dale has quit [Quit: dale]
beknoll has quit [Ping timeout: 240 seconds]
phenoble has joined #lisp
robotoad has quit [Max SendQ exceeded]
SenasOzys has joined #lisp
SenasOzys has quit [Remote host closed the connection]
Achylles has quit [Remote host closed the connection]
<AeroNotix>
Why is it called sb-grovel?
robotoad has joined #lisp
<AeroNotix>
I've seen the word used a few times in Lisp contexts for reading/parsing C headers (among other things)
fikka has joined #lisp
<pjb>
What image does "grovel" bring to your mind?
<AeroNotix>
pjb: someone begging for scraps
<pjb>
Yep, scraps of C.
<AeroNotix>
seems self-depracating
<AeroNotix>
w/e
<pjb>
Growler + shovel : it eats dirt so its stomach growls.
<AeroNotix>
How can I regrovel SBCL contrib modules?
fikka has quit [Ping timeout: 245 seconds]
<AeroNotix>
hmm, actually, probably my distro doesn't ship everything I need for that.
<oni-on-ion>
S craps
<pjb>
You'd need the headers.
<AeroNotix>
Well I have the headers, at least.
<AeroNotix>
I just mean the makefiles for sbcl itself, I can see my distro isn't shipping them
DataLinkDroid has quit [Ping timeout: 256 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
djuber has joined #lisp
fikka has joined #lisp
rptx has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
kristof has joined #lisp
Oddity has quit [Ping timeout: 240 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
fikka has joined #lisp
Oddity has joined #lisp
warweasle_afk is now known as warweasle
fikka has quit [Ping timeout: 252 seconds]
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
<Shinmera>
makomo: My point was to say who makes the website content (didier) and where it is at (on github)
<makomo>
Shinmera: ah, ok
<Shinmera>
I only do technical work, and not even the hosting, just the design and software
v0|d has quit [Remote host closed the connection]
lavaflow_ has joined #lisp
<AeroNotix>
I can't reproduce it now but I managed to break #'sb-posix:get-host-by-name by starting/destroying threads quickly that used the underlying implementation. Calling get-by-host-name would hang. The stacktrace was in a foreign-function so I know the issue isn't with SBCL per se but was wondering if it's worthwhile implementing the asynchronous/re-entrant versions for sbcl and/or if they would be accepted.
fikka has joined #lisp
lavaflow_ has quit [Ping timeout: 245 seconds]
rptx has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 246 seconds]
<Shinmera>
AeroNotix: better ask in #sbcl
<AeroNotix>
sure
fikka has joined #lisp
<no-defun-allowed>
grammarly's blog said they broke get-protocol-by-name in a similar way
<no-defun-allowed>
delete the %crap and it's under "The Hardest Bug I've Ever Debugged"
<AeroNotix>
no-defun-allowed: Oh yes this article. Wish there were far more like it
<AeroNotix>
There's a lot of low hanging fruit with some of the older bsd socket APIs to expose re-entrant versions
kooga has quit [Quit: :]
fikka has joined #lisp
robotoad has quit [Quit: robotoad]
k-hos is now known as nEatoBoRRITO
fikka has quit [Ping timeout: 252 seconds]
jlarocco has joined #lisp
<kristof>
I figured out how emscripten currently does exceptions.
<kristof>
The gist is that asm.js has to save the entire shadow stack hidden in linear memory and then restore it
fikka has joined #lisp
robotoad has joined #lisp
<kristof>
So... that's how you'd do non-local transfer of control in web assembly without blowing the stack. I seriously doubt asm.js's stack saving is fast, though
fikka has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Remote host closed the connection]
zooey has quit [Remote host closed the connection]
zooey has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
pierpa has quit [Quit: Page closed]
kristof has quit [Ping timeout: 244 seconds]
itruslove has joined #lisp
fikka has joined #lisp
ym has joined #lisp
Roy_Fokker has quit [Quit: Leaving]
fikka has quit [Ping timeout: 246 seconds]
djuber has quit [Ping timeout: 245 seconds]
djuber has joined #lisp
X-Scale has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
kristof has joined #lisp
fikka has quit [Ping timeout: 272 seconds]
<LdBeth>
How would one judge CL-PDF, possibly comparing to simple lisp SDL generating PostScript?
<LdBeth>
*DSL
Kristoft has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
jkordani_ has quit [Read error: Connection reset by peer]
kristof has quit [Remote host closed the connection]
jlarocco has quit [Ping timeout: 246 seconds]
<AeroNotix>
Hmm, I kind of want to have a defgeneric where one of the types is known already. It's not possible, right?
<AeroNotix>
I guess it makes no difference since the defmethod forms would still need to include the class specifier
djuber has quit [Ping timeout: 240 seconds]
kristof has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
<aeth>
AeroNotix: can you give an example of what you mean?
<AeroNotix>
And the image data would always be the same, but the encoder could be different depending how you wanted to encodei t
<aeth>
AeroNotix: depending on how you implement it, you could get away with (let ((foo ...)) (defun ...) (defun ...) ...)
<Bike>
i mean what would the actual effect of specifying a class in the generic function be
<AeroNotix>
Bike: well, I understand somewhat why it's not possible
steiner has quit [Remote host closed the connection]
<AeroNotix>
aeth: nah, not a fan
<Bike>
i'm just asking you what you even want
<aeth>
AeroNotix: Or at the very least (let ((foo ...)) (values (lambda ...) (lambda ...) ...))
<AeroNotix>
Bike: well, it'd more be for documentation.
<earl-ducaine>
Lisp-o-manians! I'm running into the getf/get issue again. I feel that they must be exactly the same otherwise I would have surely remembered that there is some difference between them.
<AeroNotix>
the defmethod forms themselves would still have the class specifiers on them
<earl-ducaine>
But saddly I have to ask again, to make sure.
<Bike>
getf and get aren't the same. too bad.
<Bike>
(get x y) = (getf (symbol-plist x) y)
<aeth>
How did they get away with assigning such a common/short word like GET to one of the most niche features in the language?
<no-defun-allowed>
It's probably old.
<kristof>
geneaology
<Bike>
it wasn't niche at the time, which was like seventy years ago
<aeth>
I thought plists were fairly new and alists were the old thing
fikka has joined #lisp
<kristof>
It's right there in the lisp 1.5 manual
<earl-ducaine>
ok, just did a word by word diff between the clhs of the two in my emacs buffer, and I can see the difference now.
<kristof>
Ok, that's really interesting. Property lists were very specially treated in Lisp 1.5
<kristof>
First off, their first element was always -1
fikka has quit [Ping timeout: 252 seconds]
<earl-ducaine>
I swore I tested get and getf both ways, but sadly I screwed up with a clerical error.
SaganMan has quit [Ping timeout: 252 seconds]
caltelt_ has joined #lisp
fikka has joined #lisp
dddddd has quit [Remote host closed the connection]
windoze has joined #lisp
fikka has quit [Ping timeout: 272 seconds]
<windoze>
hello; im trying to run a lisp file with (load "main.lisp")
<windoze>
but SBCL complains that package ASDF does not exist, when it does
<windoze>
if i type the contents of the file into the console manually, it works
<windoze>
there is only a problem when i run (load "main.lisp")
<no-defun-allowed>
are there any good opengl bindings/abstractions similar to pyglut?
steiner has quit [Remote host closed the connection]
<earl-ducaine>
re: getf/get cltl has a nice sumerization: "to clarify the permissible side effects of certain operations; (setf (get symbol indicator) newvalue) is required to behave exactly the same as (setf (getf (symbol-plist symbol) indicator) newvalue). "
<oni-on-ion>
no-defun-allowed: cl-opengl ?
<no-defun-allowed>
that was my first thought
<no-defun-allowed>
i might look at cepl for a bi
<no-defun-allowed>
*bit
<oni-on-ion>
ok
acolarh has joined #lisp
fikka has joined #lisp
<no-defun-allowed>
pyglut was good in how it took care of textures itself
<pjb>
qo' vIvan! ghotvam'e' wa'DIch nID DeSDu' tlhIngan mu'tlhegh!
makomo has joined #lisp
kajo has quit [Quit: From my rotting body, flowers shall grow and I am in them and that is eternity. -- E. M.]
eminhi has joined #lisp
<eminhi>
how to set lisp implementation sources (lisp binary is not built from sources) in emacs-slime?
fikka has joined #lisp
heisig has joined #lisp
<eminhi>
or is it set in a lisp initialization file?
<beach>
eminhi: Do you mean that you want to install the binary and the source separately and still have SLIME be able to find the source? I don't know the answer to the question, but it was not clear to me what you meant.
<eminhi>
yes
<eminhi>
there is bug which isn't allowing me to build from sources, so I want to work with existing binary and available source code.
<scymtym>
eminhi: which implementation are you using? i doubt there is a portable way
<eminhi>
cmucl
<beach>
Wow.
<beach>
eminhi: I suggest you change to SBCL. That way you can build from source.
fikka has quit [Ping timeout: 252 seconds]
<phoe>
cmucl is pretty ancient
<scymtym>
SBCL has SB-EXT:SET-SBCL-SOURCE-LOCATION which sets up "SYS:SRC;", "SYS:CONTRIB;", and "SYS:OUTPUT;" logical pathname translations. maybe CMUCL has something similar (given the relation between the two)
<eminhi>
I have a working sbcl setup, but I am trying something out with cmucl and wanted to see if sources can be setup.
<beach>
What is it that you are trying out, in case you care to share.
<beach>
?
<eminhi>
beach: some profiling for experimental code, trying to get a portable code which does all the profiling work.
<eminhi>
time macro is pretty implementation dependent
<beach>
eminhi: So CMUCL is just one of many implementation that you want to use in order to make sure your code is portable?
<beach>
That's an interesting project though. And Eclector would be the thing to use to read the source code.
<beach>
It can preserve source position, so incorrect indentation could be signaled.
<AeroNotix>
beach: I just like how gofmt has become the standard way of formatting/indenting/etc in Go code. It removes a tonne of useless discussion at dayjobs/open sores projects.
<AeroNotix>
I see lisp code all the time where the indentation especially is really out of whack
<beach>
Indeed, and it would be something to give to newbies who come here with bad code.
lavaflow_ has joined #lisp
<_death>
lisp syntax is context sensitive, in general it makes no sense to suggest such transformations because they may be invalid
<beach>
_death: What do you mean?
<_death>
it may be that (when (not x) ...) cannot be replaced by (unless x ...)
<beach>
I don't think that would ever be the case.
<_death>
you'd be wrong
<beach>
Can you give an example?
<_death>
for example (my-macro (when (not ...) ...))
<_death>
for example (:shadow #:when)
<beach>
What does MY-MACRO do?
<AeroNotix>
_death: why would you shadow when?
<_death>
beach: exactly.. it may treat that form another way
pjb has quit [Ping timeout: 240 seconds]
<beach>
_death: That would be very confusing code to write.
<_death>
AeroNotix: because you can?.. I've shadowed all kinds of symbols throughout my lisp development :)
<AeroNotix>
_death: plus a linter could be informed to macroexpand before linting
<AeroNotix>
actually if I had my way a linter would warn on shadowing :)
<beach>
_death: If you have strange code like that, you deserve a message from a linter.
<_death>
I disagree.. I have all kinds of programs written in different styles and it certainly makes sense to do those things in these contexts
<_death>
if your linter is aimed at newbies only, ok.. there's lisp-critic and such.. but no experienced lisper will find it adequate
rumbler31 has quit [Remote host closed the connection]
<beach>
scymtym: That would be unusual enough that the person writing such code would just ignore the message from the linter.
<_death>
unless you want to give up linguistic abstraction and have your lisp code to look like Go
razzy has quit [Ping timeout: 240 seconds]
<scymtym>
after an amount of experimentation, i have come to the conclusion that a custom reader, a code walker, first class environments and knowing where to stop can get you pretty far in terms of linting. case in point: https://techfak.de/~jmoringe/eclector-cst-toy-2.ogv
orivej has quit [Ping timeout: 252 seconds]
fikka has quit [Ping timeout: 252 seconds]
jlarocco has quit [Ping timeout: 252 seconds]
<_death>
AeroNotix: if you macroexpand it misses the point of the linter, since it's no longer source code
<pjb>
AeroNotix: out of whack indentation is often due to the use of TAB.
<oni-on-ion>
macropacksand
<_death>
sometimes it's due to copying the form from the repl
<pjb>
AeroNotix: remember, it's scientifically proven, programmers who use SPC to indent earn more money. (as are those who use emacs instead of vi).
<AeroNotix>
_death: sure, I get that, it's why I mentioned it should be hidden behind a flag or something. You'd still want to lint macroexpansions as the author of macros.
<AeroNotix>
pjb: they don't think it be like it is but it do
<pjb>
Imagine the poor PHP programmer who uses vi and TABs!
<madnificent>
Xach: Is there a standardised way to discover a new quicklisp release has been made? I'd estimate whether or not it's worth automatically creating docker images for them or not.
<AeroNotix>
and you'd still need to store the version# of the last dist you saw. Might as well just use the ql-dist functions at that point
<AeroNotix>
(ql-dist:available-update (ql-dist:find-dist "quicklisp")) is literally doing what you'd end up doing with wget/crontab though
<AeroNotix>
plus, installing the dist itself would maintain the state. It's like 10 lines of lisp, max
<scymtym>
beach: not currently. the thing uses simple environments for lexical information. i mentioned first class global environments because they provide a way to run reader macro functions and macro expanders in a controlled way (i hope to go into that direction later)
<pjb>
(when (ql-dist:available-update (ql-dist:find-dist "quicklisp")) (format t ";; There's a quicklisp update available.~%")) in your rc file.
<pjb>
rumbler31 has joined #lisp
<madnificent>
AeroNotix: I think I'd prefer to monitor it with a crontab, then push a new configuration to github, push a tag, and let docker hub build it.
<pjb>
Assuming you will boot more than one lisp image per month…
<AeroNotix>
madnificent: you do you
fikka has joined #lisp
<AeroNotix>
pjb: sticking some randomness/once a day checking in that and adding to my rc file
<madnificent>
So it's more from a tooling perspective than anything else. Within lisp, I'd certainly take your route. (but I wouldn't go for updates which I don't overesee on production systems, so then I wouldn't)
<AeroNotix>
madnificent: I'm not sure I follow. Surely if you're implementing a system to automatically build Dockerfiles then you would either be running from a Dockerfile that already has a lisp installed or the system it is running on has lisp installed.
<pjb>
I would never put automatic updates on production systems. The best way to be called back from holidays, or not having any night or week end.
<pjb>
Well once a month for quicklisp, but still…
<AeroNotix>
pjb: no one is saying "automatically updating production" lolwat
<AeroNotix>
madnificent seems to just be preemptively building dockerfiles with the latest quicklisp dist, a fine goal.
<madnificent>
AeroNotix: in practice, I have lisp installed. But the servers don't have a native lisp installed. That runs in docker containers.
<beach>
scymtym: I see.
<AeroNotix>
madnificent: dockerfile+persistent volume is how I'd do it. The quicklisp dist tagger dockerfile would have a lisp installed and install quicklisp into that (with the persistent volume). Add the code we gave above. Run that dockerfile within a crontab.
fikka has quit [Ping timeout: 272 seconds]
rumbler31 has quit [Remote host closed the connection]
froggey has quit [Ping timeout: 260 seconds]
madnificent has quit [Ping timeout: 252 seconds]
froggey has joined #lisp
madnificent has joined #lisp
<madnificent>
Bad connection
<madnificent>
Anyhow, I received an issue on madnificent/lisp-webservice-docker (GitHub) which boils down to "your image has an old version of swank, because you have an old version of quicklisp". As I tried to upgrade, it seems the newer versions require a newer version of SBCL. There I went down the rabbit hole. Docker is now widely accepted as a way of deployment, the lisp community can benefit from that too :)
<AeroNotix>
madnificent: no-one asserted you shouldn't use docker :)
orivej has joined #lisp
<madnificent>
AeroNotix: I don't have your question in my buffer anymore, but I was hoping that that cleared up confusion.
astalla has joined #lisp
isoraqathedh has joined #lisp
anewuser has joined #lisp
fikka has joined #lisp
Fare has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
pjb has quit [Ping timeout: 252 seconds]
nbunjeva3 has quit [Ping timeout: 245 seconds]
madnificent has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
jmercouris has quit [Remote host closed the connection]
jmercouris has joined #lisp
pjb has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
rippa has joined #lisp
SenasOzys has quit [Remote host closed the connection]
fikka has joined #lisp
SenasOzys has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
rpg has quit [Ping timeout: 252 seconds]
lavaflow_ has quit [Ping timeout: 272 seconds]
fikka has joined #lisp
hifitim has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
dueyfinster has joined #lisp
astalla has quit [Ping timeout: 240 seconds]
cage_ has joined #lisp
hifitim has quit [Remote host closed the connection]
razzy has joined #lisp
hifitim has joined #lisp
fikka has joined #lisp
asarch has joined #lisp
jmercouris has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 272 seconds]
astalla has joined #lisp
sabrac has joined #lisp
Bike has joined #lisp
gypsydave5 has joined #lisp
<gypsydave5>
I was having a conversation with a friend about CL - they're pretty in to Go - and he was wondering how to write a CL program that compiled to a binary. I had a go with ECL, which worked - but required a the ECL dylib to be on the libraries path. Does anyone know if there's a way to compile ECL which would produce a (mostly) portable binary in the way that Go does?
fikka has joined #lisp
<beach>
gypsydave5: You would have to ask jackdaniel. But other implementations can certainly produce "standalone" binaries, like SBCL. They get pretty big though, because they must include the entire Common Lisp run-time system.
lavaflow_ has joined #lisp
<pjb>
gypsydave5: don't they use a libgo for the runtime?
<gypsydave5>
beach: Yeah, I did it for SBCL, and using Roswell, which was nice and easy. I was _kinda_ trying to compete/show off with the binary size. The 'hello world' from ECL was comparible with the size of a C binary.
<pjb>
gypsydave5: it's possible to compile libecl as a static library too.
<Bike>
you're probably going to lose that competition most of the time
<beach>
gypsydave5: You can't do that basically. The Common Lisp run-time contains the entire compiler and the garbage collector.
fikka has quit [Ping timeout: 252 seconds]
<pjb>
gypsydave5: remember, C binaries use libc.
<gypsydave5>
pjb: Hmmm... I'm ignorant about what's happening under the hood in Go. So maybe it's comparing apples to oranges.
Roy_Fokker has joined #lisp
<beach>
gypsydave5: Who cares about binary size anyway?
<pjb>
gypsydave5: try: ldd goprogram # to see what shared libraries it uses.
<pjb>
(otool -L goprogram # on macOS).
<gypsydave5>
beach: fair point - more of an academic exercise really
<pjb>
gypsydave5: (actually ldd, and otool -L only gives the minimal set of shared libraries. The program can also dynamically load other libraries at run-time).
<gypsydave5>
pjb: just trying that now... thanks :D
<pjb>
The small sizes of memories in our childhood computers has been a big trauma for all of us…
<beach>
Not me.
<gypsydave5>
pjb: basic hello world has a dependence on `libSystem.B.dylib` on macOS
<pjb>
Yep.
<beach>
So then Go and ECL are comparable?
<gypsydave5>
beach: I'm going to take a poke at the ECL bin with the same tool
<pjb>
gypsydave5: perhaps you may want to consider MoCL.
<pjb>
or clicc for a free software equivalent (but clicc would require some love and updating).
<beach>
gypsydave5: Does go require the compiler to be present at run-time?
<gypsydave5>
pjb: Yes, I was looking at that. When I've got $200 to spare... :D
<pjb>
Try clicc then!
<gypsydave5>
pjb: will do
<gypsydave5>
beach: Don't _think_ so
<beach>
Of not, you are definitely comparing completely different things.
<gypsydave5>
yeah... just looked at the dependencies from otool on the ECL hello world and there were another three libraries it needed.
rumbler31 has joined #lisp
<pjb>
gypsydave5: shared libraries are good. Often programs will depend on 50 or hundreds of shared libraries. This is what makes the size of the binaries small.
mrcom has joined #lisp
<gypsydave5>
Thanks pjb, beach - useful and interesting :D
rumbler31 has quit [Ping timeout: 244 seconds]
scymtym has quit [Ping timeout: 252 seconds]
Jesin has quit [Quit: Leaving]
Jesin has joined #lisp
Jesin has quit [Client Quit]
mkolenda has quit [Remote host closed the connection]
mkolenda has joined #lisp
eschulte has quit [Ping timeout: 252 seconds]
Jesin has joined #lisp
Pixel_Outlaw has joined #lisp
<phoe>
gypsydave5: if anything, you could do a different thing
<phoe>
which is to compile FASLs
<phoe>
in that way, you could treat the SBCL binary as a runtime (and therefore provided by system, doesn't count into your executable size!) and only take into account the FASL size
<phoe>
theoretically, SBCL FASLs are executable, soooo you could try cheating that way.
<beach>
They are?
<phoe>
One sec
<phoe>
Yes
<phoe>
they use a hack
<phoe>
the first line of FASLs compiled on my machine is:
<oni-on-ion>
yea =) i just guess that slime/swank compiles a bunch. i thought that sbcl had some of its own in ~/.sbcl/ but i dont have that. are they bytecode+native ?
<phoe>
there's no bytecode in there
<phoe>
it's basically a dump of Lisp data, straight from memory - plus some data to make it loadable
<oni-on-ion>
hmm i ran sbcl.fasl all it did was dump codes of bytes to my eshell. =P
<oni-on-ion>
ohh. cool cool, so, can it be used for like binary blobs ?
<phoe>
yes - exactly that.
<phoe>
you can distribute Lisp data in binary format via FASLs.
jlarocco has joined #lisp
regreg has joined #lisp
<phoe>
they're volatile though - you need to use the same architecture, the same implementation and the same implementation version.
<phoe>
you can'
<phoe>
you can't execute Windows fasls on Linux, SBCL fasls on CCL, SBCL 1.4.9 fasls on SBCL 1.4.10.
<oni-on-ion>
ah thats understandable =)
<oni-on-ion>
can they be "decompiled" to produce lisp code? ie. proprietary secret codes
<phoe>
not really.
<phoe>
compilation is a one-way street.
<oni-on-ion>
ah nice =) hmm.
<phoe>
theoretically you could use some Lisp debugger to inspect that, since it's all just Lisp data, but in practice, it ain't trivial.
SenasOzys has quit [Ping timeout: 244 seconds]
<oni-on-ion>
cool cool. same with an elf object file pretty much
<phoe>
something like that, yep
<gypsydave5>
phoe: nice one wrt the fasl executables
<phoe>
clhs pi
robotoad has joined #lisp
rumbler31 has joined #lisp
Lycurgus has joined #lisp
regreg has quit [Remote host closed the connection]
Kevslinger has joined #lisp
rumbler31 has quit [Ping timeout: 240 seconds]
lavaflow_ has quit [Ping timeout: 240 seconds]
oni-on-ion has quit [Read error: No route to host]
eminhi_ has joined #lisp
housel has joined #lisp
oni-on-ion has joined #lisp
<PuercoPop>
phoe: you use roswell? :O How do you like it so far?
eminhi has quit [Ping timeout: 272 seconds]
<phoe>
PuercoPop: it's a good tool for my use cases
<phoe>
and they're simple - running SBCL and upgrading SBCL
steiner has quit [Remote host closed the connection]
<PuercoPop>
phoe: what are your use cases? For running shell scripts I use cl-launch (mainly to launch StumpWM and used it to try out lem)
<phoe>
PuercoPop: running SBCL and upgrading SBCL. (:
<PuercoPop>
^_^, I just compile from source. I've been meaning to give guix a try though. I'm surprised it has SBCL, SLY, StumpWM, etc as readily available packages
rumbler31 has joined #lisp
<phoe>
fe[nl]ix: do you know the nickserv passwords for specbot and minion?
<phoe>
they can't join #lisp because they don't identify with nickserv.
<phoe>
and we can't make them identify because both nicks are taken, and #common-lisp.net doesn't know the passwords.
<beach>
They can join #clasp apparently.
rumbler31 has quit [Ping timeout: 244 seconds]
<phoe>
Yep
<phoe>
only users registered with nickserv can join #lisp though.
<phoe>
That's fallout from the recent spam attacks.
jlarocco has quit [Ping timeout: 245 seconds]
<oni-on-ion>
most of my channels need registration, but i cant talk to nickserv without a channel joined associated with the server, so then i can join everything by hand after identifying manually. this is the reason i dont shut off my desktop as often as i'd like
groovy2shoes has quit [Ping timeout: 250 seconds]
<oni-on-ion>
i think ##lisp is what i use for my landing strip or runway
pjb has quit [Read error: Connection reset by peer]
refpga has joined #lisp
pjb has joined #lisp
rumbler31 has joined #lisp
H4ns has joined #lisp
vaporatorius has joined #lisp
rumbler31 has quit [Ping timeout: 244 seconds]
azimut has quit [Ping timeout: 252 seconds]
azimut has joined #lisp
<phoe>
slyrus1: <3
<phoe>
I'll check it out tomorrow
<phoe>
Have no time today.
steiner has joined #lisp
<slyrus1>
ok, sounds good!
hifitim has joined #lisp
dueyfinster has joined #lisp
dueyfinster has quit [Client Quit]
dueyfinster has joined #lisp
azimut has quit [Ping timeout: 244 seconds]
azimut has joined #lisp
Lycurgus has quit [Quit: Exeunt]
Oladon has joined #lisp
vlatkoB has quit [Remote host closed the connection]
_whitelogger has joined #lisp
jmercouris has quit [Ping timeout: 246 seconds]
refpga has quit [Remote host closed the connection]
Hu0p has quit [Ping timeout: 272 seconds]
holycow has joined #lisp
maarhart has joined #lisp
azimut has quit [Ping timeout: 244 seconds]
buffergn0me has quit [Remote host closed the connection]
buffergn0me has joined #lisp
kristof has quit [Ping timeout: 252 seconds]
atgreen has quit [Ping timeout: 252 seconds]
rumbler31 has joined #lisp
<phoe>
Can I (locally (declare (inline foo)) ...) if FOO is a function bound globally?
<|3b|>
yes, might not do anything though
<phoe>
; Call to FOO:BAR could not be inlined because its source code was not saved. A global INLINE or SB-EXT:MAYBE-INLINE proclamation must be in effect to save function definitions for inlining.
<phoe>
welp
<|3b|>
in particular, you should declaim the global function inline before defining it to tell implementations you would like them to save data for inlining
<phoe>
yep
<|3b|>
and then declaim it notinline after defining it for the local declaration to not be redundant
<phoe>
looks like I'll cannibalize some code because of that
<phoe>
either that, or submit a PR to that library...
holycow has quit [Ping timeout: 240 seconds]
<|3b|>
yeah, if it isn't your function you'd have to resort to hacks :/
rumbler31 has quit [Ping timeout: 244 seconds]
<|3b|>
like defining the package manually to declaim it before loading, or putting something on *macroexpand-hook* to do so during the DEFUN, neither really suitable for released code :)
lnostdal has quit [Read error: Connection reset by peer]
hifitim has quit [Ping timeout: 240 seconds]
graphene has quit [Remote host closed the connection]
jmercouris has joined #lisp
graphene has joined #lisp
azimut has joined #lisp
graphene has quit [Read error: Connection reset by peer]
graphene has joined #lisp
astalla has quit [Ping timeout: 240 seconds]
sabrac has quit [Quit: Konversation terminated!]
azimut has quit [Ping timeout: 252 seconds]
astalla has joined #lisp
azimut_ has joined #lisp
fikka has joined #lisp
<flip214>
anyone to help with cl-sat? SAT:SOLVE throws an error "the value NIL is not of type NUMBER" in PRINT-CNF
lnostdal has joined #lisp
<jmercouris>
I guess you'll just have to M-. :\
hifitim has joined #lisp
<phoe>
Does roswell install SBCL 1.4.11 successfully?
<phoe>
Running `ros install sbcl-bin` pulls 1.4.10 which isn't the newest.
jack_rabbit has joined #lisp
nirved has quit [Quit: Leaving]
hifitim has quit [Remote host closed the connection]
<kristof>
So... I had been planning on offloading macro-expansions (and especially read-time expansions!) of a common lisp source file to sbcl or some other expansion but
anewuser has quit [Ping timeout: 245 seconds]
<kristof>
I had forgotten that most facilities in lisp are defined as macros which expand into internal implementations, such as sb-impl::%defun
varjag has joined #lisp
<kristof>
does anyone know of a "suitably minimal lisp implementation" built over macros?
dueyfinster has quit [Quit: My iMac has gone to sleep. ZZZzzz…]
<pjb>
kristof: all CL implementations are suitably minimal lisp implementations built over macros.
<kristof>
touche. I don't know what I'm asking for.
gravicappa has quit [Ping timeout: 245 seconds]
<aeth>
kristof: do you mean something like repeatedly doing macroexpand-1 until you stop getting portable forms?
<kristof>
And I don't even want a minimal one, either. For instance, I'd want defun to be a special form, not a top-level set-fdefinition...
<pjb>
kristof: there are 35 special operators (not all of them are semantically significant), about 70 macros (they can all be written with a conforming expansion), about 30 reader macros, and plenty of functions, of which only a few are "primitive" for some meaning of the term (for example, APPLY).
<kristof>
aeth: Yeah. Basically I want a small, comprehensible IR that I can compile.
<pjb>
kristof: so you can implement a CL by implementing only those special operator and a few functions.
<kristof>
pjb: The special forms are not the issues, actually. In fact, now that I think about it more, what I don't want is a small lisp, what I want is one that's larger than what they usually expand to
<pjb>
I don't understand.
<aeth>
kristof: Then I guess the way I'd do it is I'd repeatedly macroexpand-1 until I get to a desired form (i.e. part of a MEMBER type that I defined based on the HyperSpec).
<aeth>
i.e. stop macroexpanding if you get a DEFUN
<aeth>
There's also e.g. (macroexpand-1 `(dotimes (i 42))) ; in SBCL it's built on DO, in some implementations I think it uses an internal macro or its own TAGBODY
<kristof>
I see now that I can't have my cake and eat it, too. Basically, I don't want to write a lisp to handle macroexpansion, existing lisps are plenty good. But I also wanted to suppress the macroexpansion of certain commonplace forms like defun, because that high level information is useful to me.
<kristof>
or maybe it's not?
<|3b|>
might try sicl or sacla, though not sure either will give you 100% of what you want
<|3b|>
sicl+cleavir
<kristof>
I would hope to use sicl eventually. I just wanted to do my own thing for a while, for instructive purposes. I have not heard of sacla.
<kristof>
pjb: I will check that out.
dueyfinster has joined #lisp
oni-on-ion has quit [Quit: WeeChat 1.9.1]
<|3b|>
you could try expanding the macros yourself using implementation macroexpander where it works and your own if needed
<|3b|>
so you write a code walker but hopefully can reuse some of the implementation's macros
<aeth>
kristof: I think you want something like this: (let ((candidate-macroexpand (macroexpand-1 foo))) (if (typep (car candidate-macroexpand) member-type-with-forms-to-stop-on) #| continue on the candiate-macroexpand |# #| return the old macroexpand |#))
housel has quit [Read error: Connection reset by peer]
<kristof>
aeth: Oh, there's an idea
<PuercoPop>
kristof: maybe CMUCL/SBCL's IR1 would work for what you want? The CMUCL design document describes as a subset of CL
<|3b|>
or just read things into a package that shadows things like DEFUN where you don't like the built-in definition
<aeth>
kristof: e.g. (macroexpand-1 `(dotimes (i 42))) in SBCL gives a form beginning with DO and (macroexpand-1 (macroexpand-1 `(dotimes (i 42)))) gives a form beginning with BLOCK over a LET over a TAGBODY
<aeth>
So you just need to define where to stop macroexpanding
<PuercoPop>
except instead of plain sexps, you get a graph of structs
<kristof>
Although I also like |3b|'s idea, to be honest. I could write my own package that doesn't use CL and imports only the macroexpansions I want.
<aeth>
(Note I put the comments in my IF backwards)
<kristof>
PuercoPop: if I'm going to eventually port to Cleavir I see no reason to devote myself to someone else's IR, but I appreciate the suggestion
astalla has quit [Ping timeout: 240 seconds]
Fare has quit [Ping timeout: 272 seconds]
oni-on-ion has joined #lisp
<pjb>
kristof: if you want more "primitive" then go ahead! ALL the operators in CL can be primitives! The macros in CL can be special operators (but you must still provide macros for the user programs to macroexpand them), and all the functions in CL can be open-coded.
<pjb>
ie. basically implemented as special opertors too.
<aeth>
That stops macroexpand-1 on either DO or exhausting the macroexpansion (i.e. the macroexpand being itself)
<kristof>
stashing that somewhere
<aeth>
one test is: (macroexpand-until-symbols '(dotimes (i 12)))
housel has joined #lisp
<aeth>
hmm, doesn't work on (defmacro foo (i &body body) `(dotimes (,i 42) ,@body)) (macroexpand-until-symbols '(foo a))
random-nick has quit [Read error: Connection reset by peer]
<aeth>
This one works on both: (defun macroexpand-until-symbols (form) (loop :for macroexpand := form :then candidate-macroexpand :for candidate-macroexpand := (macroexpand-1 macroexpand) :until (or (typep (car candidate-macroexpand) '(member do)) (eql candidate-macroexpand macroexpand)) :finally (return candidate-macroexpand)))
<aeth>
You have to have two versions of the macroexpand to eventually terminate in the case that it's not part of the member type, in this case an example would be '(defun foo ())
kooga has joined #lisp
<aeth>
kristof: poke in case you stored the bugged version instead of the corrected version
<kristof>
oh, I see
<kristof>
:P
<kristof>
I'll correct and test
<pjb>
Or you can macroexpand in an environment where you've removed all the macros that are implemented as special operators.
<kristof>
That was what I said earlier was a better idea.
<kristof>
At that point I might as well "start fresh"
<kristof>
On the bright side, I don't have to reimplement read and friends.
a7f4 has quit [Ping timeout: 252 seconds]
kajo has joined #lisp
kristof has quit [Ping timeout: 272 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
dueyfinster has quit [Quit: My iMac has gone to sleep. ZZZzzz…]
kristof has joined #lisp
rumbler31 has joined #lisp
marusich has joined #lisp
varjag has quit [Ping timeout: 244 seconds]
Essadon has quit [Quit: Qutting]
rumbler31 has quit [Ping timeout: 244 seconds]
elem6 has joined #lisp
SenasOzys has quit [Remote host closed the connection]
elem6 has quit [Ping timeout: 252 seconds]
SenasOzys has joined #lisp
SenasOzys has quit [Remote host closed the connection]
SenasOzys has joined #lisp
doubledup has quit [Quit: Leaving]
elem6 has joined #lisp
elem6 has quit [Ping timeout: 240 seconds]
SenasOzys has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 240 seconds]
housel has quit [Remote host closed the connection]
housel has joined #lisp
elem6 has joined #lisp
elem6 has quit [Remote host closed the connection]
fikka has joined #lisp
jack_rabbit has quit [Ping timeout: 252 seconds]
makomo has quit [Read error: Connection reset by peer]
azimut_ has quit [Ping timeout: 272 seconds]
fikka has quit [Ping timeout: 245 seconds]
SaganMan has quit [Ping timeout: 244 seconds]
Tristam has quit [Remote host closed the connection]
CraigL64 has joined #lisp
Tristam has joined #lisp
azimut has joined #lisp
dented42 has joined #lisp
fikka has joined #lisp
jack_rabbit has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
azimut has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
jlarocco has joined #lisp
ckonstanski has joined #lisp
fikka has joined #lisp
SenasOzys has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
SenasOzys has quit [Remote host closed the connection]