jackdaniel changed the topic of #lisp to: Common Lisp, the #1=(programmable . #1#) programming language<http://cliki.net/> logs:<https://irclog.whitequark.org/lisp,http://ccl.clozure.com/irc-logs/lisp/> | SBCL 1.4.5, CMUCL 21b, ECL 16.1.3, CCL 1.11.5, ABCL 1.5.0
SenasOzys has quit [Remote host closed the connection]
SenasOzys has joined #lisp
fikka has joined #lisp
housel has quit [Read error: Connection reset by peer]
housel has joined #lisp
SenasOzys has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 245 seconds]
Fare has quit [Ping timeout: 244 seconds]
phenoble has quit [Quit: ZNC 1.7.0 - https://znc.in]
fikka has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
Essadon has joined #lisp
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
fikka has quit [Ping timeout: 272 seconds]
Fare has joined #lisp
fikka has joined #lisp
lavaflow_ has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
<AeroNotix> no-defun-allowed: link
<AeroNotix> ?
<no-defun-allowed> stupid matrix
<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> aeth: (defgeneric some-generic-function (abstract-value (c concrete-class)))
<AeroNotix> where concrete-class is an existing class. Abstract-value just being any old thing not yet defined
<Bike> what good would that do?
earl-ducaine has joined #lisp
<AeroNotix> I have a generic function that will always take a specific class, but be handled differently
<AeroNotix> imagine like an encoder
dale has joined #lisp
<AeroNotix> (defgeneric image-encode (encoder image-to-encode)))
<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")
SaganMan has joined #lisp
windoze has quit [Quit: http://www.kiwiirc.com/ - A hand crafted IRC client]
SaganMan has quit [Ping timeout: 272 seconds]
fikka has joined #lisp
ym has quit [Quit: Leaving]
fikka has quit [Ping timeout: 245 seconds]
sbadger has joined #lisp
sword has quit [Ping timeout: 240 seconds]
<beach> Good morning everyone!
Pixel_Outlaw has quit [Quit: Leaving]
dented42 has joined #lisp
sword has joined #lisp
razzy has joined #lisp
<drmeister> Hello beach
fikka has joined #lisp
SaganMan has joined #lisp
nly has quit [Ping timeout: 244 seconds]
fikka has quit [Ping timeout: 252 seconds]
wigust has quit [Ping timeout: 245 seconds]
sauvin has joined #lisp
_whitelogger has joined #lisp
dale has quit [Quit: dale]
fikka has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
X-Scale has joined #lisp
steiner has joined #lisp
anewuser has quit [Quit: anewuser]
jlarocco has joined #lisp
Bike has quit [Quit: Lost terminal]
makomo has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
robotoad has quit [Quit: robotoad]
fikka has joined #lisp
<no-defun-allowed> hi beach
fikka has quit [Ping timeout: 244 seconds]
_whitelogger has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
<razzy> hi all
vlatkoB has joined #lisp
Fare has quit [Ping timeout: 252 seconds]
lavaflow_ has quit [Ping timeout: 245 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 272 seconds]
<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
fikka has quit [Ping timeout: 272 seconds]
steiner has joined #lisp
nirved has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
fikka has joined #lisp
caltelt_ has quit [Ping timeout: 252 seconds]
fikka has quit [Ping timeout: 252 seconds]
pjb has quit [Ping timeout: 252 seconds]
pierpal has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
_whitelogger has joined #lisp
zooey has quit [Ping timeout: 256 seconds]
_whitelogger has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
steiner has quit [Remote host closed the connection]
fikka has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
jlarocco has quit [Ping timeout: 252 seconds]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fikka has quit [Ping timeout: 240 seconds]
zxcvz has joined #lisp
lavaflow_ has joined #lisp
steiner has joined #lisp
<slyrus1> phoe: around?
lavaflow_ has quit [Ping timeout: 244 seconds]
fikka has joined #lisp
<phoe> slyrus1: sup
<slyrus1> hey, I made a POC of an hsv-image for opticl
<no-defun-allowed> nice
<phoe> slyrus1: yes, I have noticed
<phoe> <3
<phoe> I'll try using it today or tomorrow
<slyrus1> ok, let me know if it works and if you need support to/from other image types. and then I can push it to the master branch.
<phoe> All I need is 8-bit RGB
<slyrus1> Cool. That works for me.
jlarocco has joined #lisp
<phoe> do you use floats/doubles in the HSV colorspace? if yes, you should be able to export/import from 16-bit images as well
<slyrus1> right. should be pretty trivial to add support for those.
<phoe> since the bitcount just increases resolution
fikka has quit [Ping timeout: 245 seconds]
orivej has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
K1rk has joined #lisp
jmercouris has joined #lisp
fikka has joined #lisp
borodust has quit [Quit: Leavin']
fikka has quit [Ping timeout: 244 seconds]
<slyrus1> phoe: OK, 16-bit (and 2-, 4-, etc..) are trivial. 16-bit works, but I'l commit tomorrow.
<slyrus1> good night.
<jmercouris> goodnight!
fikka has joined #lisp
doubledup has joined #lisp
<phoe> night!
fikka has quit [Ping timeout: 252 seconds]
azimut_ has joined #lisp
azimut has quit [Ping timeout: 244 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
zerobaud has quit [Quit: Page closed]
random-nick has joined #lisp
jlarocco has quit [Ping timeout: 252 seconds]
ebrasca has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
zhlyg has joined #lisp
<zhlyg> Isn't tpapp/LLA used anymore?
astalla has joined #lisp
steiner has quit [Remote host closed the connection]
fikka has joined #lisp
steiner has joined #lisp
steiner has quit [Remote host closed the connection]
steiner has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
kooga has joined #lisp
<phoe> zhlyg: what's tpapp?
<phoe> ooh
<phoe> it's unmaintained AFAIK - tpapp stopped working in Lisp
<phoe> unrelated: https://github.com/phoe/protest/blob/master/doc/common.md I finally have some PROTEST examples pushed
fikka has joined #lisp
borodust has joined #lisp
<zhlyg> phoe: Thanks! I see now he's doing Julia, nice choice!
fikka has quit [Ping timeout: 252 seconds]
scymtym has quit [Ping timeout: 272 seconds]
<razzy> phoe: is it attempt to make universal protocol?
<phoe> razzy: nah
<phoe> more like a library for handling them
<razzy> cool :] it will iterate to one universal eventually
<phoe> I don't think so, I think it's impossible to have one universal protocol for everything™
<phoe> there's way too much variety.
<razzy> phoe: it will be inteligent, self-transforming one
<phoe> now that's some #lispcafe worthy stuff
<razzy> phoe: maybe we should call it auto-comm library
fikka has joined #lisp
<razzy> which will negotiate proper protocol :]
<razzy> sry, carried away :]
<beach> razzy: "universal protocol" doesn't make any sense.
<razzy> beach same as universal character set?
<beach> #lispcafe as phoe suggested.
<razzy> T
fikka has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
scymtym has joined #lisp
fikka has quit [Ping timeout: 272 seconds]
SenasOzys has joined #lisp
pjb has joined #lisp
<phoe> pjb: do you have a package for lorem ipsum generation perhaps?
<pjb> That rings a bell, but no, not currently.
<pjb> Copy-and-paste from the web?
<phoe> I found myself in need of a lorem ipsum generator in Lisp.
<phoe> Like, something that generates paragraphs of arbitary length.
housel has quit [Read error: Connection reset by peer]
<phoe> Sure, I could generate it online and copypaste, but I'd rather craft a library and upload it to QL.
zhlyg has quit [Remote host closed the connection]
fikka has joined #lisp
<pjb> Well, (let ((word-count 10)) (format nil "~{~A~^ ~}" (loop repeat word-count collect (format nil "~(~36R~)" (random 10000000))))) #| --> "3qew7 14uhr 4bqp9 5g5nk 5lgic 4qt4d ra41 n4s3 ru4 53orl" |#
<phoe> pjb: yep, that's trivial, I just want it to look like Latin.
<pjb> Ok.
<phoe> Nah, I'll just write it.
<phoe> Gimme half an hour.
<phoe> pjb: correct, that one is a binding to an online service though.
<pjb> As I said, copy-and-paste from the web :-)
<pjb> Make it look like Kinglon!
<pjb> Klingon, I mean.
fikka has quit [Ping timeout: 252 seconds]
<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?
<scymtym> eminhi: if you use CL:TIME for profiling maybe have a look at https://github.com/Shinmera/trivial-benchmark
<eminhi> beach: I'm looking at how varied the my running times(gc, mem) are on different implementations.
<eminhi> scymtym: Thanks, I'll look into it.
<beach> Oh, I see.
fikka has joined #lisp
jmercouris has quit [Remote host closed the connection]
<phoe> pjb: that was a quickie
jmercouris has joined #lisp
<eminhi> scymtym: Hmm, I've been re-implementing much of *trivial-benchmark* library, thanks for the suggestion.
fikka has quit [Ping timeout: 245 seconds]
FreeBirdLjj has joined #lisp
fikka has joined #lisp
<phoe> eminhi: that's why I usually ask on #lisp before I start writing stuff on my own
<phoe> I had a few moments when I wrote stuff that somebody else already wrote
fikka has quit [Ping timeout: 240 seconds]
gector has quit [Read error: Connection reset by peer]
lavaflow_ has joined #lisp
gector has joined #lisp
<scymtym> eminhi: sure, no problem
<eminhi> phoe: I was doing some simple profiling, it just grew before I thought to look for a library.
lavaflow_ has quit [Ping timeout: 252 seconds]
Kristoft has quit [Quit: Connection closed for inactivity]
<phoe> eminhi: I know the feeling (:
SenasOzys has quit [Ping timeout: 245 seconds]
<eminhi> phoe: Thanks, I should make a habit of looking for a library before abstracting too much.
Essadon has joined #lisp
fikka has joined #lisp
nbunjeva3 has joined #lisp
graphene has quit [Remote host closed the connection]
nbunjeva1 has quit [Ping timeout: 246 seconds]
fikka has quit [Ping timeout: 245 seconds]
graphene has joined #lisp
astalla has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
SenasOzys has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
heisig has quit [Quit: Leaving]
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
jlarocco has joined #lisp
rumbler31 has joined #lisp
fikka has joined #lisp
<AeroNotix> is there a linter that's relatively widely used?
<AeroNotix> like gofmt
<phoe> AeroNotix: you mean something that can format your code?
<AeroNotix> phoe: a mixture between that and hinting at smelly forms
<phoe> emacs for formatting, SBCL compiler for hinting at smelly forms
<AeroNotix> phoe: will it warn about things like (when (not (form))) => (unless (form))
<phoe> nope
<phoe> it'll just compile them
<_death> sometimes (when (not ...) ...) is clearer to me
<AeroNotix> _death: to each their own
<AeroNotix> but it's why I like gofmt. It removes bikeshedding
fikka has quit [Ping timeout: 272 seconds]
<_death> lisp is totally the language for bikeshedding
<AeroNotix> if there was clfmt and it chose one over the other, I'd agree with that. Just to no longer care
<AeroNotix> https://github.com/norvig/paip-lisp huh, totally missed this getting released. Always wanted to read this book!
<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
<scymtym> beach: why? imagine (with-my-dsl-syntax … (when (not …) …) …)
pjb has joined #lisp
fikka has joined #lisp
<_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
<_death> AeroNotix: I doubt that assumption :)
<pjb> Notice the curve! Scientifically proven!
<pjb> Over all countries, even!
<AeroNotix> correlation/causation blah blah blah
madnificent has joined #lisp
<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.
<pjb> madnificent: http://planet.lisp.org/
<madnificent> pjb: that's a nice perspective to take if you're tired programming :P
<madnificent> pjb: I'd prefer something I can automate ^_^
<pjb> madnificent: wget, etc.
<_death> looks like ql-dist:available-update
<pjb> madnificent: alternatively, you may watch the github repo of quicklisp.
<AeroNotix> madnificent: (ql-dist:available-update (ql-dist:find-dist "quicklisp"))
<beach> scymtym: Nice demo!
<madnificent> _death: #'cl-dist:available-versions could work
<beach> Are you using SICL first-class global environments?
mrcom has quit [Ping timeout: 272 seconds]
<madnificent> Ideally, I'd have something I could easily run from a cron-tab. But I could go heavy and do this in lisp...
<madnificent> AeroNotix: that's perfect
<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:
<phoe> #!/home/phoe/.roswell/impls/x86-64/linux/sbcl-bin/1.4.10/bin/sbcl --script
<oni-on-ion> ./take-selfie.fasl ?
<phoe> so, essentially, OS thinks this is a shell script, and executes SBCL with that file.
<phoe> which is essentially what happens with all interpreted languages whenever you launch stuff like ./python_file.py from the shell
<phoe> so you could theoretically compile a (format t "Hello world!~%") into a FASL and run that.
<phoe> gypsydave5: there, that's a tactic for shaving off binary sizes. (;
<oni-on-ion> hmm cool! idk where my fasls are but i found some in ~/.slime/
<phoe> oni-on-ion: you can produce them using
<phoe> clhs compile-file
<phoe> ...
<phoe> oh, minion is dead
<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
SenasOzys has joined #lisp
k-stz has joined #lisp
lavaflow_ has joined #lisp
dueyfinster has quit [Quit: Textual IRC Client: www.textualapp.com]
<Lycurgus> that's odd, but off topic, most clients have a default channel for the server
maarhart has joined #lisp
maarhart has quit [Excess Flood]
maarhart has joined #lisp
maarhart has quit [Excess Flood]
dueyfinster has joined #lisp
maarhart has joined #lisp
maarhart has quit [Excess Flood]
maarhart has joined #lisp
maarhart has quit [Excess Flood]
maarhart has joined #lisp
kristof has joined #lisp
dueyfinster has quit [Ping timeout: 252 seconds]
zxcvz has quit [Quit: zxcvz]
zxcvz has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
<beach> OK, enough work for today.
refpga has joined #lisp
<refpga> Hello, how do I use save-lisp-and-die to create native executables?
<refpga> at the end. But I get an error that variable cd.elf is unbound.
<refpga> I'm currently trying to put (save-lisp-and-die cd.elf :executable t)
<refpga>
zxcvz has quit [Client Quit]
<beach> Try a string.
zxcvz has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<beach> refpga: SAVE-LISP-AND-DIE is a Common Lisp function, so it evaluates its arguments.
<beach> So if you type cd.elf, then that is taken to be a variable to evaluate.
<beach> ... to evaluate in order to get the core-file-name that save-lisp-and-die wants as its first argument.
refpga has quit [Read error: Connection reset by peer]
<beach> Oh well.
<oni-on-ion> great explanation tho. hopefully he still got it
<beach> Thanks.
jmercouris has joined #lisp
eminhi_ has quit [Quit: leaving]
groovy2shoes has joined #lisp
kaun has joined #lisp
lavaflow_ has quit [Ping timeout: 252 seconds]
kaun has quit []
maarhart has quit [Quit: Mutter: www.mutterirc.com]
maarhart has joined #lisp
<slyrus1> phoe: did you try it out yet?
FreeBirdLjj has joined #lisp
nbunjeva1 has joined #lisp
kristof has quit [Remote host closed the connection]
kristof has joined #lisp
Bike has quit [Quit: Lost terminal]
scymtym has joined #lisp
azimut_ has quit [Ping timeout: 252 seconds]
maarhart has quit [Quit: Mutter: www.mutterirc.com]
maarhart has joined #lisp
cage_ has quit [Quit: Leaving]
maarhart has quit [Client Quit]
azimut has joined #lisp
maarhart has joined #lisp
azimut has quit [Ping timeout: 252 seconds]
maarhart has quit [Quit: Mutter: www.mutterirc.com]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
hifitim has quit [Ping timeout: 250 seconds]
kristof has quit [Ping timeout: 245 seconds]
azimut has joined #lisp
gypsydave5 has quit [Ping timeout: 272 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
anewuser has quit [Ping timeout: 244 seconds]
<slyrus1> phoe: there's a new version for you with 16-bit support and properly exported symbols. Let me know if you need anything else!
<slyrus1> it's still on the branch on all 3 repos. If you can give it a review, I'll merge to the master branches.
aindilis has quit [Remote host closed the connection]
gravicappa has joined #lisp
anewuser has joined #lisp
aindilis has joined #lisp
kooga has quit [Quit: :]
azimut has quit [Ping timeout: 246 seconds]
azimut has joined #lisp
kristof has joined #lisp
mkolenda has quit [Quit: Free ZNC ~ Powered by LunarBNC: https://LunarBNC.net]
mkolenda has joined #lisp
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 :)
kristof has joined #lisp
maarhart has quit [Quit: Mutter: www.mutterirc.com]
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> (or any other symbol in that MEMBER type)
<pjb> macroexpand the defun! (setf (symbol-function 'foo) (lambda (…) (block foo …)))
<pjb> kristof: see minimal compilation in clhs.
<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.
<kristof> Yeah, you're right
<aeth> kristof: (defun macroexpand-until-symbols (form) (loop :for macroexpand := (macroexpand-1 form) :then candidate-macroexpand :for candidate-macroexpand := macroexpand :then (macroexpand-1 macroexpand) :until (or (typep (car candidate-macroexpand) '(member do)) (eql candidate-macroexpand macroexpand)) :finally (return macroexpand)))
<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]
SenasOzys has joined #lisp
mercourisj has joined #lisp
rumbler31 has joined #lisp
jmercouris has quit [Ping timeout: 252 seconds]
rumbler31 has quit [Ping timeout: 240 seconds]
SaganMan has joined #lisp
mercourisj has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
atgreen has joined #lisp
_whitelogger has joined #lisp
fikka has joined #lisp
Hu0p has joined #lisp