torbo has quit [Remote host closed the connection]
ahlk has quit [Remote host closed the connection]
ahlk has joined #commonlisp
lottaquestions has quit [Ping timeout: 248 seconds]
knusbaum has quit [Ping timeout: 276 seconds]
knusbaum has joined #commonlisp
jack_rabbit has joined #commonlisp
knusbaum has quit [Ping timeout: 240 seconds]
ahlk has quit [Ping timeout: 255 seconds]
<nyx_land>
the real problem with guix IME as a Common Lisp person is that it doesn't feel at all like it's designed to be a fully interactive environment like CL. you write code, you recompile everything, you can't inspect the running system live really (there's Geiser but I found it to be a very subpar experience). on top of that, developing CL with guix tooling feels very unnatural.
ahlk has joined #commonlisp
<nyx_land>
an init system in CL would be really cool, not sure why no one has ever attempted something like that but it's probably way more complicated that I'm aware of
<nyx_land>
a CL package manager would be a slog just based off my experiences making packages for nix and guix
stylewarning has quit [Ping timeout: 248 seconds]
nocko has quit [Ping timeout: 255 seconds]
jsatk__ has quit [Ping timeout: 240 seconds]
griffinmb has quit [Ping timeout: 260 seconds]
conjunctive_ has quit [Ping timeout: 248 seconds]
sgithens has quit [Ping timeout: 244 seconds]
pl has quit [Ping timeout: 260 seconds]
patrix has quit [Ping timeout: 248 seconds]
lottaquestions has joined #commonlisp
sgithens has joined #commonlisp
conjunctive_ has joined #commonlisp
patrix has joined #commonlisp
stylewarning has joined #commonlisp
griffinmb has joined #commonlisp
jsatk__ has joined #commonlisp
jsatk__ has quit [Ping timeout: 258 seconds]
nocko has joined #commonlisp
conjunctive_ has quit [Ping timeout: 276 seconds]
jsatk__ has joined #commonlisp
pl has joined #commonlisp
conjunctive_ has joined #commonlisp
dBc has joined #commonlisp
bilegeek has joined #commonlisp
waleee has quit [Ping timeout: 268 seconds]
<beach>
Good morning everyone!
leo_song has quit [Ping timeout: 255 seconds]
Bike has quit [Quit: sleep]
leo_song has joined #commonlisp
leeb has joined #commonlisp
pillton has joined #commonlisp
yauhsien has quit [Remote host closed the connection]
Andrew is now known as \Andrew
\Andrew is now known as GNU\Andrew
yauhsien has joined #commonlisp
yauhsien has quit [Ping timeout: 256 seconds]
dynab has joined #commonlisp
griffinmb has quit [Ping timeout: 256 seconds]
patrix has quit [Ping timeout: 258 seconds]
conjunctive_ has quit [Ping timeout: 258 seconds]
tyson2 has quit [Remote host closed the connection]
patrix has joined #commonlisp
conjunctive_ has joined #commonlisp
griffinmb has joined #commonlisp
<bitspook[m]>
Good morning!
alvaro121 has joined #commonlisp
alvaro121_ has quit [Ping timeout: 276 seconds]
saura has joined #commonlisp
yauhsien has joined #commonlisp
saura has quit [Ping timeout: 248 seconds]
yauhsien has quit [Ping timeout: 248 seconds]
yauhsien has joined #commonlisp
GreaseMonkey has quit [Ping timeout: 255 seconds]
saura has joined #commonlisp
dBc has quit [Ping timeout: 260 seconds]
saura has quit [Ping timeout: 256 seconds]
dBc has joined #commonlisp
mixotricha has quit [Quit: Client closed]
saura has joined #commonlisp
Colere has quit [Ping timeout: 246 seconds]
Colere has joined #commonlisp
saura has quit [Ping timeout: 248 seconds]
Furor has joined #commonlisp
Colere has quit [Ping timeout: 246 seconds]
greaser|q has joined #commonlisp
rotateq has quit [Quit: ERC 5.4 (IRC client for GNU Emacs 28.1)]
leeb has quit [Ping timeout: 246 seconds]
leeb has joined #commonlisp
cosimone has quit [Remote host closed the connection]
frgo_ has quit [Remote host closed the connection]
aartaka has joined #commonlisp
hisacro has quit [Ping timeout: 276 seconds]
MajorBiscuit has joined #commonlisp
pjb has joined #commonlisp
Alfr has quit [Remote host closed the connection]
saura has joined #commonlisp
Alfr has joined #commonlisp
shka has joined #commonlisp
azimut has joined #commonlisp
saura has quit [Ping timeout: 256 seconds]
greaser|q has joined #commonlisp
greaser|q has quit [Changing host]
greaser|q is now known as GreaseMonkey
cosimone has quit [Remote host closed the connection]
hisacro has joined #commonlisp
saura has joined #commonlisp
ttree has quit [Ping timeout: 240 seconds]
saura has quit [Ping timeout: 240 seconds]
cosimone has joined #commonlisp
attila_lendvai has joined #commonlisp
jack_rabbit has quit [Ping timeout: 240 seconds]
saura has joined #commonlisp
saura has quit [Ping timeout: 246 seconds]
bilegeek_ has joined #commonlisp
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
bilegeek has quit [Ping timeout: 248 seconds]
yauhsien has quit [Ping timeout: 246 seconds]
pok has quit [Ping timeout: 240 seconds]
mm007emko has joined #commonlisp
pve has joined #commonlisp
Dynom has joined #commonlisp
mm007emko has quit [Ping timeout: 252 seconds]
bilegeek has joined #commonlisp
bilegeek_ has quit [Ping timeout: 255 seconds]
yauhsien has joined #commonlisp
bilegeek has quit [Ping timeout: 255 seconds]
saura has joined #commonlisp
saura has quit [Ping timeout: 240 seconds]
karlosz has joined #commonlisp
mm007emko has joined #commonlisp
karlosz has quit [Ping timeout: 248 seconds]
molson has quit [Ping timeout: 240 seconds]
zacque has quit [Quit: Goodbye :D]
Guest69 has joined #commonlisp
rodicm has joined #commonlisp
<Guest69>
Sorry to crosspost from #ecl if that is not good boy behaviour, but I'm having troubles doing basic stuff like getting function info via describe/inspect or requiring uiop; any kind soul to help a noob?
jackdaniel has quit [Changing host]
jackdaniel has joined #commonlisp
<pjb>
Guest69: what toubles?
<Guest69>
Don't know how to tell where to find uiop, for example (on Ubuntu 18.04)
<pjb>
If you use slime, you can use M-x slime-documentation RET fun RET
<Guest69>
It should work in the REPL too, for extensions like c:build-program
<Guest69>
pjb: I have installed cl-asdf on ubuntu, I should be able to specify its path, no?
<jackdaniel>
no, asdf is usually shipped with the implementation
<pjb>
No. Install quicklisp, it makes its own installation of asdf. Avoid cl- packages from linux distributions.
<Guest69>
I see
<Guest69>
Then I just have to load setup.lisp and I'm done, I suppose
<pjb>
check the Getting Started wiki page.
<pjb>
Exactly.
<Guest69>
Still, why does describe/inspect "fail"?
<jackdaniel>
a known issue. it does not fail, it is just that for some core functions the necessary information is not recorded
<jackdaniel>
essentially ecl holds metainformation about functions in a separate file accessed with interface provided by ecl-help module
<Guest69>
I tried (describe #'+) too
<jackdaniel>
that's a subject of change in the future
<Guest69>
Well, good to know
<jackdaniel>
if you define a function in the repl, then the prototype will be available, but unless you save that data, when you load the fasl in the fresh image this information will be gone
<jackdaniel>
a quirk that would be rather easy to solve were we not understaffed ,)
<Guest69>
I know the CL world situation, don't worry
notzmv has quit [Ping timeout: 240 seconds]
<Guest69>
Thanks for your collective help, goodbye
Guest69 has left #commonlisp [#commonlisp]
livoreno has quit [Ping timeout: 248 seconds]
mixotricha has joined #commonlisp
<rendar>
why webassembly syntax is very very similar to lisp's one?
<hayley>
Because they chose to write it like that. But only the text format is similar to Lisp, and it's different enough that trying to read it with a CL reader is not pleasant.
<rendar>
well, i think that's very clear syntax and easy to parse
<hayley>
If I recall correctly, they could benefit from learning that we have #- instead of #_, and don't put our close-parens on their own lines (though I know Z3 also messes up the latter, as smt-lib is also S-expression based).
<hayley>
But it's better not to read too deeply into the same syntax, in my opinion.
<rendar>
hmm, i see.. i'm too new to fully get that, what is #_ ?
<Nilby>
assembly code is already in prefix, e.g. "oper arg arg ...", but is delimited by source lines. turning it into s-exps is trivial and makes so you can group it not by line.
<rendar>
Nilby, indeed!
<hayley>
I mean, say, they spell the instruction br_if rather than br-if or something.
<rendar>
i made a small language with prefix `oper arg arg` where you can specify some arg "out of band data" with [], e.g. `oper arg[opts] arg[opts2]`
<rendar>
oh and it works for command too
<hayley>
But it's irrelevant, like most decisions of surface syntax.
OlCe`` has quit [Ping timeout: 260 seconds]
<Nilby>
one might hope that the wasm people chosing s-exps will reduce people's lisp-o-phobia
rodicm has quit [Ping timeout: 240 seconds]
<hayley>
It won't, because approximately no web developer touches the text serialisation of WebAssembly.
<Nilby>
they might have to when it breaks and they have to run a debugger
<hayley>
(Contrived counter-point: it contributes to the mystification of Lisp, because people will think it's something their favourite compiler spits out. As some have pointed to intermediate representations in GCC and said "Look, Lisp is in your C compiler!" for little reason, after seeing ().)
<hayley>
No source-level debugging? It would be like debugging a C program by starting at the generated assembly.
<Nilby>
well hopefully at the very least it will make life easier for us, when we can just cl:read wasm and use macros on it
<hayley>
I don't see why, and you'd need to modify the reader somewhat.
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
<hayley>
Apologies for my cynicism still. Someone once said that Lisp implementations had good compilers because they saw their favourite compiler (for some other language) use S-expressions, and I had to describe how that is not how anything works. So I am too convinced that showing Lisp exists as a (serialised format of an) "intermediate representation" is worth much.
<Nilby>
all the examples i tried cl:read just fine
<hayley>
Then you haven't encountered a (; ... ;) block comment; wasm2wat would produce a lot of those in my experience.
<beach>
hayley: I am sure you were trying to say something profound, but I just can't parse it.
<hayley>
Oh dear, let me try again.
<beach>
hayley: Does "they" refer to "someone" or to "Lisp implementations"?
<hayley>
The former.
<beach>
How did their discovery of the use of S-expressions force them to describe how "anything works"?
<Nilby>
hayley: i understand your scepticism, but at least i think it's nice to be able to: (write expr) | wat2wasm > foo.wasm and maybe get something you can run
<hayley>
Once I read a comment on a forum, which was an "answer" to the question "Why are Common Lisp implementations quite fast, despite implementing an interactive and dynamically-typed language?" The "answer" was something like "If you look into the implementation of a C compiler, you will find S-expressions there, and Lisp programs are similar to that."
<beach>
If nothing works that way, then neither does their favorite compiler, I would think.
<hayley>
You know, I had better just dig up the original text, I'm sure I can find it somewhere.
<beach>
Ah, much clearer. Thanks.
<beach>
hayley: And how did this observation make you (too) convinced that it is worth much to show that Lisp is used as an intermediate representation?
<beach>
... whatever that might mean.
<hayley>
I meant to write "not too convinced that ... is worth much".
<beach>
No wonder I didn't understand.
<hayley>
Sorry about that.
<beach>
Not a problem for me. I was just curious.
<hayley>
The claim, I think, is based on the (correct) observation that one of the internal representations of GCC can be printed as S-expressions. But that observation has little to do with why GCC and Lisp compilers produce good code.
<hayley>
I found the comment now, and they got the claim wrong; as they claimed LLVM uses some intermediate representation similar to S-expressions, which is definitely not the case. On the other hand, Andrew Appel said that a SSA IR is like functional programming.
<Nilby>
oh, i thought it was regarding gcc's machine descriptions in s-exps
<hayley>
I don't remember exactly, that could be right too.
<Nilby>
llvm's target description language "td" really looks like it would be better as s-exps too
OlCe``` has joined #commonlisp
<Nilby>
except people who don't emacs get scared when they see )))))))))))
<hayley>
Nilby: Anyways. What would you achieve by emitting WebAssembly code that way? Specifically, I guess, what could one achieve, where having a S-expression printer would save a substantial amount of time?
<hayley>
The wasm2ps code generator is quite bad, and just uses FORMAT to produce PostScript code, but it works.
<Nilby>
hayley: it just seem easier. like one could make a small macro set, and have a decent DSL
<jackdaniel>
I saw ')))))' once, I still can't sleep without light on
<hayley>
I'm still not sure what you'd use it for. And, according to Shriram Krishnamurthi, the most interesting (or "expressive") features in programming languages cannot be implemented using macros alone.
<jackdaniel>
surface syntax would be superficial if not for those pesky humans writing code
pillton has quit [Remote host closed the connection]
random-nick has joined #commonlisp
silasfox has joined #commonlisp
gxt has quit [Ping timeout: 268 seconds]
<Nilby>
i used to write a bunch of Dylan, which is very close to infix CL, so i know well the pain points in losing s-exps
<hayley>
For example, it is not possible to give Common Lisp async/await syntax, as it would require some sort of continuations (or transforming the whole program to continuation-passing style), which you cannot do with "local" macros.
gxt has joined #commonlisp
<jackdaniel>
I think that we all agree that macros are not a "silver bullet", but they come handy for /some/ tasks
<hayley>
Honestly syntax doesn't bother me, unless it is too complicated. I usually write my notes in a pseudo-ML language.
<random-nick>
hayley: doesn't async/await only require transforming all the async functions into CPS?
<hayley>
jackdaniel: Sure. I was wondering what Nilby would do by adding macros to the WebAssembly text format still, since there is a lot one could conceivably want to add.
<jackdaniel>
I see
<hayley>
random-nick: Right. But the boundary between async and sync functions is quite painful, and some Common Lisp features like dynamic variables and condition handlers really don't work with CPS transformations.
<Nilby>
i guess i'm thinking of something like just spitting out little pieces of code in web app, instead of using parenscript
<hayley>
Okay. I'd say Parenscript works quite well because it is targeting another high level language (JavaScript), and so a fairly simple translation method works fine. Depending on what you want to compile to WebAssembly, a similar translator could be quite complicated, and might need a more complex IR.
jmdaemon has quit [Ping timeout: 256 seconds]
silasfox has quit [Remote host closed the connection]
silasfox has joined #commonlisp
rodicm has joined #commonlisp
lisp123 has joined #commonlisp
<lisp123>
Guest74: Thanks
<Colleen>
lisp123: Guest74 said 21 hours, 46 minutes ago: I think I'm going to make a github with all the Moby files as I had to dig them out of archive.org. They're also at project gutenberg but they rather stupidly present the readme's as the text so you have to dig and get the links to an ftp site.
<lisp123>
Guest74: based on your later comments, not sure how useful this resource this...I rather a smaller base, but more quality
<lisp123>
Nilby: continuations is my biggest wish for CL
notzmv has joined #commonlisp
mixotricha has quit [Ping timeout: 252 seconds]
<Nilby>
lisp123: what do you want to use continuations for? also "On Lisp" shows one way to do them
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
<lisp123>
Nilby: Yes, I've implemented the On Lisp continuations, quite good but some slight deficiencies
<lisp123>
Continuations are quite useful when writing Artificial Intelligence programs (where Lisp excels)
famicom_guy_ has quit [Quit: ZNC 1.8.2 - https://znc.in]
betonmischa has joined #commonlisp
famicom_guy has joined #commonlisp
famicom_guy has quit [Client Quit]
lisp123 has quit [Remote host closed the connection]
<Guest74>
lisp123: https://github.com/JMC-design/Moby depends on what your needs are. Either way, I've got parsers for most of the stuff there, so you can take an easier look at the data.
<Guest74>
oh, they're gone already.
<Guest74>
So Norvig wrote this https://norvig.com/spell-correct.html , and someone copied it quite literally into CL. I'm not sure what constitutes a good spell checker, but this is a spell checker.
famicom_guy has joined #commonlisp
<Guest74>
I couldn't test with the data he did, but I ran the same tests as Aspell http://aspell.net/test/cur/ and the cl version came up around 45%.
<Guest74>
at the same time, it got almost everything right given as examples in journal articles for 'difficult' cases.
<Guest74>
So if someone is interested in spell checking this might be a good place to start. I'd think less brute forcing might be nice, testing for hand shift on the keyboard, only checking a keys neighbours instead of every character, and for those who want to through context in, there's a really good data set of word frequencies and 4-5 n-grams by
<Guest74>
google. Only 24gigs. Then 50% starts looking not so bad.
<Guest74>
s/through/throw/
lonjil has quit [Quit: No Ping reply in 180 seconds.]
nature_ has quit [Ping timeout: 244 seconds]
lonjil has joined #commonlisp
<Guest74>
on the bright side, detecting/fixing errors like I just made is actually not hard.
mrvdb has joined #commonlisp
nature has joined #commonlisp
<beach>
So you assume English and a US or UK keyboard?
<beach>
And you assume typos are frequently made by someone hitting an adjacent key?
<pjb>
Sometimes, typoes are made because the hands are shifted. ;oel yjod/
<beach>
There is also the "mirror typo", i.e., using the wrong hand but the "same" finger.
silasfox has quit [Ping timeout: 276 seconds]
<beach>
And, yes, if I accidentally hit a neighbor key, then my word will look like the one pjb just showed.
<beach>
I guess when a virtual keyboard is used, like on a phone or a tablet, then adjacent keys are easier to hit.
lisp123 has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
<Guest74>
They've quite narrowed down the types of spelling errors and their probabilities.
<beach>
Hmm, I would think that such probabilities would be highly individual.
<Guest74>
there's also when you're too excited and you forget that your hands work at different speeds so you get all or most of one hands letters.
<Guest74>
beach: and I think I good spell checker would take that into account, allow you to turn on or off certain types of checking.
<beach>
Indeed. I seem incapable of typing "the" for instance. It always comes out as "teh", so in fact I have an Emacs abbrev to fix it.
<beach>
Oh, that would be fantastic.
silasfox has joined #commonlisp
<lisp123>
Guest74: I would just have a standard dictionary, but if you repeat certain words it remembers that that might be acronym or some other term it doesn't know
<Guest74>
For single shifts or omissions I think there might be some merit to exploiting the trie structure as you'll naturally hit a dead end as you traverse and that would seem a likely spot for the error.
<lisp123>
But the way we are headed, its less about spell checking and more about input completion - microsoft produts now suggest responses based on context
<Guest74>
I really would like acronyms to be separate, so if you see something all caps, check there.
<lisp123>
not a bad idea
<Guest74>
I'm going to see what's feasible to separate.
<lisp123>
I've been working on editors, and one thing I'm doing is to try to expose options for the user to choose between alternate sets of inference (in this case for spell checking) rules
<Guest74>
As for more curated dictionaries, I plan on parsing I think websters 1911 because things like 9 a clock are cool, and then the project Gutenberg dictionary. to start.
<lisp123>
Are those free?
<Guest74>
yup. the only problem with really old is pronounciation and usage has changed.
<lisp123>
Oh nice. Yes and especially in recent times
<mfiano>
I have come to really like LTeX for grammar/spell checking
<Guest74>
Which is why Gutenberg should be more up to date.
<Guest74>
anything missing from those you can check if wordnet has it.
<beach>
Pronunciation is also highly dependent on things like geography and social class.
<Guest74>
mfiano: I was never aware it even did that.
<mfiano>
It is seeded with hundreds of thousands of papers
<mfiano>
LTeX, not LaTeX
<Guest74>
beach: yes, i'm looking up if there's some existing classification system for spoken dialects to label pronounciations with a source including time and region.
<beach>
Interesting idea.
dBc has quit [Quit: Lost terminal]
<Guest74>
my personal use case is I'd like to collect pronounciations to be used in speech generation. And having an easy way to say you want a texas drawl from the 1800s would be nice.
<Guest74>
mfiano: do you have a link? I get 0 hits
<Guest74>
mfiano: depends on how you attack the problem.
<dbotton>
I think they have some common tag. Not much in to YouTube to help more.
<Guest74>
it's interesting. Looks like It could be good for someone entering it manually.
<Nilby>
if i just would have collected all the spell checker suggestions and the one i chose, i could have trained a thing by now
<Guest74>
Nilby: So it's your fault then?
yauhsien has quit [Remote host closed the connection]
rodicm has quit [Quit: Leaving]
<Nilby>
yes. but it would probably only work right for me. and why wait a lifetime for spellchecker
<mfiano>
Money always attacks the problem best.
<mfiano>
THen you only need to worry about the mythical man-month.
<Guest74>
I'm a strong believer in being able to run a desktop without an internet connection.
<pjb>
Guest74: LOL. Yes, but.
<pjb>
Guest74: also, with the developpment of centralized AI backed systems, it'll be more and more difficult.
<mfiano>
The adoption rate from "buy once, own forever" to SaaS in ever-increasing.
yauhsien has joined #commonlisp
<mfiano>
Even Adobe products cannot be purchased anymore.
<mfiano>
But I am getting off-topic, so I will go to bed now.
livoreno has joined #commonlisp
<Nilby>
just transition to SooF & FnFF: steal once, own forever & free now, free forever
Bike has joined #commonlisp
<hayley>
You Wouldn't Download A Testing Framework
<Nilby>
yes i'd even sh*t in a testing framework's hat
Furor is now known as Colere
<Nilby>
except i already ran myself over with my own testing framework
<pjb>
Or just use free software, and patch it and compile it yourself to work as you want on the targets you want.
mm007emko has quit [Quit: Client closed]
<Guest74>
Anyways, I think you could do a decent job of spell checking with a core of frequencies of ~10k most popular words with trigrams. that could be augmented with domain specific thesauri
<Guest74>
And even the trigrams aren't absolutely necessary. Word frequency helps you to decide which is the most likely spelling. I'm pretty sure most people who write things can pick the proper spelling of the word they want from a list of candidates.
<jackdaniel>
deploy software and each time someone corrects themself add the pair to the dictionary ,)
grawlinson has quit [Ping timeout: 246 seconds]
<Guest74>
What someone should really do is just implement Aspell's algorithm in CL and then have access to tons of languages. Me all just move ahead with filtering candidates based on pos and pronounciation for english.
rodicm has joined #commonlisp
grawlinson has joined #commonlisp
silasfox has quit [Ping timeout: 255 seconds]
X-Scale` has joined #commonlisp
X-Scale has quit [Ping timeout: 246 seconds]
X-Scale` is now known as X-Scale
dilated_dinosaur has quit [Ping timeout: 248 seconds]
cross has joined #commonlisp
tyson2 has joined #commonlisp
livoreno has quit [Ping timeout: 260 seconds]
lisp123 has quit [Quit: Leaving...]
Guest69 has joined #commonlisp
dilated_dinosaur has joined #commonlisp
sloanr has joined #commonlisp
<Guest69>
Hello, does anyone know how to declare one of the bindings as ignorable in the classic once-only macro? I'm having trouble with it: https://pastebin.com/2NsqwHK9
<Bike>
i think you just don't quote it? quoting it obviously won't work, that'll just be discarded
<jackdaniel>
I think that he wants to put the form in the expansion
scymtym has quit [Remote host closed the connection]
Brucio-61 has quit [Remote host closed the connection]
<jackdaniel>
the short answer is: you can't, you need to define your own once-only* macro, because that's the macro that estabilishes the block context
<Guest69>
That's what I was fearing without wanting to delve in what is still dark magic to me (once-only content)
<jackdaniel>
you may always skip once-only and do
<Guest69>
Yeah, use with-gensyms directly
<Guest69>
I'll probably do that
<jackdaniel>
gensyms are orthogonal to once-only
<jackdaniel>
but right, a gensym-ed symbol would be needed to hold the evaluation result
<Guest69>
Hmmm? Aren't they lower-level, i.e. used by once-only to evaluate stuff once and put it in a gensym?
<jackdaniel>
I wouldn't call them exactly lower level, they address another potential issue with macros, that is the variable capture
<jackdaniel>
while once-only addresses the issue of multiple evaluation
<Guest69>
Well, by "lower level", I meant a dependency
<jackdaniel>
also, re your original question, you may estabilish a local declaration context with the operator locally
<Guest69>
I tried that too, but SBCL isn't happy about using a declaration on an outer var
<beach>
That depends on the declaration I think.
<Guest69>
Possibly, ignorable wasn't ok, though
<jackdaniel>
you may also get silly and do (once-only (a) `(let ((,a ,a)) (declare (ignorable ,a)) 2))
<Guest69>
That IS silly but does work
betonmischa has quit [Quit: Leaving.]
dilated_dinosaur has quit [Remote host closed the connection]
scymtym has joined #commonlisp
Brucio-61 has joined #commonlisp
<Guest69>
Related question: does everyone fumble with horrible quasiquote contraptions in macros when you want optional list splicing (to construct function argument lists, mostly)?
<Guest69>
Or horrible quasiquote contraptions with funcall
<jackdaniel>
an example would make this question esier to understand
yauhsien has quit [Remote host closed the connection]
<Nilby>
quasi-quoting was quasi-hard for me until a got quasi-good at it, but i still get quasi-confused by quasi-overusing it ,@,`,',@,
rotateq has joined #commonlisp
<Guest69>
Is that only "quasi"-overusing it? =)
<jackdaniel>
a bug I sometimes spot is when people use (quote ,@) instead of (list ,@)
<jackdaniel>
in this form --> ',@
<jackdaniel>
in this form --> '(,@)
<jackdaniel>
erm, you know what I mean (I hope :)
<Guest69>
By the way, any other way than apply when not in macro-expansion to achieve the same effect?
<Guest69>
jackdaniel to be honest, not really, heh
<jackdaniel>
Guest69: `(something '(,@var)) and `(something (list ,@var)) are different because the latter does not prevent evaluation of forms in var
<Bike>
what's wrong with apply?
<Guest69>
Isn't it quite slow?
<Guest69>
(yeah, I know CL isn't the good place to do premature optimization)
<Bike>
not really? why do you t hink it's slow?
<Nilby>
i'm always to lazy to write another similar function, so i write a very complicated set of macros to do it for me
<Guest69>
I do remember something about funcall being slow in SBCL
<Bike>
sounds cargo culted. sbcl will compile (foo ...) and (funcall #'foo ...) identically for the most part
<Guest69>
jackdaniel I was confused by the omitted variable name in the first post
<Bike>
the other operator you can use to give functions variable arguments is multiple-value-call, but it's a pretty special operator
<Bike>
apply is more involved than funcall, but not enough that you should worry about it in most circumstances. consing up lists to give to it might take some time, though
<Guest69>
Fun coincidence, I just used multiple-value-call 1 minute ago to write a map-img for opticl
<Guest69>
Well, thanks for the chat, and goodbye
Guest69 has left #commonlisp [#commonlisp]
silasfox has joined #commonlisp
dilated_dinosaur has joined #commonlisp
szkl has quit [Quit: Connection closed for inactivity]
yauhsien has joined #commonlisp
yauhsien has quit [Ping timeout: 256 seconds]
frgo has joined #commonlisp
MajorBiscuit has quit [Quit: WeeChat 3.5]
ttree has joined #commonlisp
saura has joined #commonlisp
saura has quit [Ping timeout: 240 seconds]
ebrasca has joined #commonlisp
[deleted] has joined #commonlisp
orestarod has joined #commonlisp
silasfox has quit [Ping timeout: 244 seconds]
GNU\Andrew is now known as Andrew
silasfox has joined #commonlisp
rodicm has quit [Ping timeout: 276 seconds]
saura has joined #commonlisp
saura has quit [Remote host closed the connection]
saura has joined #commonlisp
causal has quit [Quit: WeeChat 3.5]
silasfox has quit [Ping timeout: 240 seconds]
molson has joined #commonlisp
saura has quit [Ping timeout: 268 seconds]
X-Scale` has joined #commonlisp
X-Scale has quit [Ping timeout: 246 seconds]
X-Scale` is now known as X-Scale
leeb has quit [Ping timeout: 248 seconds]
frgo has quit [Remote host closed the connection]
n1to has joined #commonlisp
rabp has joined #commonlisp
Guest74 has quit [Ping timeout: 240 seconds]
tyson2 has quit [Remote host closed the connection]
sloanr has quit [Remote host closed the connection]
Posterdati has joined #commonlisp
sloanr has joined #commonlisp
ebrasca has quit [Ping timeout: 240 seconds]
Devon has quit [Ping timeout: 248 seconds]
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
Devon has joined #commonlisp
tyson2 has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
waleee has joined #commonlisp
akoana has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
scymtym has quit [Remote host closed the connection]
Brucio-61 has quit [Remote host closed the connection]
tyson2 has joined #commonlisp
rodicm has joined #commonlisp
frgo has joined #commonlisp
jealousmonk has joined #commonlisp
rodicm has quit [Quit: Leaving]
frgo has quit [Ping timeout: 264 seconds]
scymtym has joined #commonlisp
Jach has joined #commonlisp
perro has quit [Ping timeout: 246 seconds]
Brucio-61 has joined #commonlisp
Oddity has joined #commonlisp
perro has joined #commonlisp
SunClonus has joined #commonlisp
orestarod has quit [Quit: Leaving]
thuna` has joined #commonlisp
<thuna`>
Does anyone know why I am getting "Failed to find the TRUENAME of /tmp/packages.lisp" when doing (asdf:load-system)?
<Bike>
you're loading a system in /tmp that includes a packages.lisp but there is no such file?
<thuna`>
Bike: not as far as I'm aware
<Bike>
then i got nothing without more information.
<thuna`>
Hmm, what kind of information is needed?
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
<thuna`>
Odd, the absolute pathname is set to #P"/tmp/", which does explain the issue
<thuna`>
But why would it be set to that?
<Bike>
i mean, kind of anything? what's in tmp, what system you're loading, what the definition of that system is, where asdf is looking for the system, what you are trying to do overall, etc
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
<thuna`>
Bike: I shouldn't be doing anything out of the ordinary. I have a .asd file in a directory with the other components and I'm trying to load it using load-system from the Slime repl. The tmp folder doesn't have anything interesting
orestarod has joined #commonlisp
<thuna`>
Oh, I guess slime's compile is messing it up
tyson2 has quit [Remote host closed the connection]
SunClonus has quit [Read error: Connection reset by peer]
akoana has quit [Quit: leaving]
Dynom has quit [Quit: WeeChat 3.5]
sukaeto1 is now known as sukaeto
thuna` has quit [Remote host closed the connection]
jmdaemon has joined #commonlisp
OlCe``` has quit [Remote host closed the connection]
nature is now known as help
saura has joined #commonlisp
help has quit [Quit: leaving]
nature has joined #commonlisp
saura has quit [Remote host closed the connection]