<fiddlerwoaroof>
Because the string might not be a simple-string
<fiddlerwoaroof>
It's generally a good practice to put your (optimize (speed 3)) code behind another function because the type declarations can cause annoying runtime errors
<fiddlerwoaroof>
e.g. if I have a displaced array of element-type 'character, that's a string but not a simple-string
<fiddlerwoaroof>
^ Puercopop
<PuercoPop>
fiddlerwoaroof: but if you are coercing it to simple-string, shouldn't it be a simple-string?
anewuser has joined #lisp
smasta has quit [Ping timeout: 245 seconds]
<fiddlerwoaroof>
Coerce also converts between data types
<fiddlerwoaroof>
so (coerce (list 1 2 3) 'vector) produces a new vector #(1 2 3)
<PuercoPop>
I'm not sure I'm following you. My understanding is that (coerce data 'simple-string will return a simple string so when calling parse-uri again it will always result in taking the first branch of the ecasetype and go into parse-uri-string. If that is the case why wouldn't the 3rd branch be written as (string (parse-uri-string (coerce data 'simple-string) :start start :end end))
smasta has joined #lisp
robdog has joined #lisp
DGASAU has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
<fiddlerwoaroof>
sorry, I missed that
<fiddlerwoaroof>
Yeah, I suppose fukamachi thought the recursive definition was more elegeant?
<fiddlerwoaroof>
Or else, it's just a mistake
DGASAU has quit [Ping timeout: 246 seconds]
<PuercoPop>
fiddlerwoaroof: Or an oversight in a refactor (although from skimming the git history it didn't look like it). I wanted to check if I wasn't missing something. Never used compiler macros myself
Achylles has quit [Ping timeout: 258 seconds]
robdog has joined #lisp
dale has quit [Quit: dale]
robdog has quit [Ping timeout: 250 seconds]
wxie has joined #lisp
<moldybits>
can i undo a defstruct in sbcl? if i try to (defun make-foo ()) after (defstruct foo) it complains the returned datum is not of the declared type.
robdog has joined #lisp
<fiddlerwoaroof>
maybe (UNINTERN 'MAKE-FOO)
makomo has quit [Ping timeout: 255 seconds]
robdog has quit [Ping timeout: 264 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
ober has joined #lisp
vilivulpine has joined #lisp
edgar-rft has quit [Quit: Leaving]
robdog has joined #lisp
Oladon has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
moei has quit [Ping timeout: 258 seconds]
moei has joined #lisp
robdog has joined #lisp
asarch has quit [Quit: Leaving]
robdog has quit [Ping timeout: 264 seconds]
_whitelogger has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
Essadon has quit [Quit: Qutting]
robdog has joined #lisp
<PuercoPop>
pfdietz: The fuzzing book you shared the other day is awesome! I've been working through it and just with the basic url mutator I've found a bug in quri!
ym555_ has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
nanoz has joined #lisp
ym555 has quit [Ping timeout: 255 seconds]
q9929t has joined #lisp
longshi has quit [Ping timeout: 250 seconds]
gravicappa has joined #lisp
ym555_ is now known as ym555
karlosz has joined #lisp
Josh_2 has quit [Quit: ERC (IRC client for Emacs 26.1)]
ggole has joined #lisp
dale has joined #lisp
Oladon has quit [Quit: Leaving.]
Lycurgus has joined #lisp
ym555 has quit [Ping timeout: 245 seconds]
wanz has joined #lisp
robdog has joined #lisp
ym555 has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
orivej has joined #lisp
ym555 has quit [Ping timeout: 255 seconds]
Bike has quit [Quit: Lost terminal]
smasta has quit [Ping timeout: 245 seconds]
smasta has joined #lisp
<Xach>
PuercoPop: what is its name
smasta has quit [Ping timeout: 255 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
holycow has joined #lisp
akoana has joined #lisp
iovec has joined #lisp
robdog has joined #lisp
jack_rabbit has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
wanz has quit [Quit: wanz]
Autolycus has joined #lisp
marvin2 has quit [Ping timeout: 255 seconds]
jasom has quit [Quit: WeeChat 2.3]
jasom has joined #lisp
libertyprime has joined #lisp
<beach>
Good morning everyone!
<ober>
morning Beach!
Autolycus has quit []
robdog has joined #lisp
q9929t has quit [Quit: q9929t]
Harag has quit [Ping timeout: 255 seconds]
<holycow>
mornin
anewuser has quit [Ping timeout: 246 seconds]
robdog has quit [Ping timeout: 264 seconds]
<fiddlerwoaroof>
PuercoPop: I'm interested too, I can't find the book in the logs...
* fiddlerwoaroof
adds it to my org bookmarks, never to be read
nanozz has joined #lisp
nanoz has quit [Ping timeout: 258 seconds]
smasta has joined #lisp
holycow has quit [Ping timeout: 246 seconds]
smasta has quit [Ping timeout: 255 seconds]
smasta has joined #lisp
terpri has quit [Remote host closed the connection]
robdog has joined #lisp
wxie has quit [Ping timeout: 246 seconds]
terpri has joined #lisp
orivej has quit [Ping timeout: 255 seconds]
smasta has quit [Ping timeout: 246 seconds]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
<fiddlerwoaroof>
I've been working/thinking-about an interesting-ish problem in Clojure at work: given a boolean expression consisting of AND/OR and simple assertions about equality, validate that it passes certain security criteria (it's part of an API that is eventually passed to a database, and we don't want give people the wrong information) and then try to optimize/normalize it to be as short and regular as possible.
<fiddlerwoaroof>
is there any precedent in CL for this sort of problem?
<fiddlerwoaroof>
I think the general problem of simplifying boolean expressions is NP-complete, but I'm looking for inspiration for feasible optimizations for this sort of thing.
robdog_ has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
orivej has joined #lisp
amerlyq has quit [Quit: amerlyq]
robdog has quit [Ping timeout: 264 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
<eschatologist>
That actually doesn’t sound all that hard in any language, depending on what the “security criteria” are.
<eschatologist>
Especially if the expression is free of side effects.
<fiddlerwoaroof>
Hmm, the interesting part is coming up with the smallest tree of boolean operations that is equivalent to the input and, a brief googling suggests that that problem's intractable
<eschatologist>
Normalize the expression to something like an SSA form, do constant sub expression elimination, get a reasonable result.
<eschatologist>
It may be one of those problems where a “full solution” is intractable but a “reasonable solution” is fairly straightforward.
<eschatologist>
And a reasonable solution may still let you apply your security criteria to the expression tree.
robdog has joined #lisp
<eschatologist>
This kind of constraint solving is what optimizing compilers and type systems do routinely.
<fiddlerwoaroof>
Yeah, I think I've already solved the security issues with a tree-rewriting scheme
jack_rabbit has quit [Ping timeout: 264 seconds]
smasta has joined #lisp
wxie has joined #lisp
emaczen has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
smasta has quit [Ping timeout: 244 seconds]
<ggole>
SSA doesn't sound helpful, since you don't have variables (?) or assignment
<ggole>
Maybe conjunctive normal form
<fiddlerwoaroof>
yeah, no variables, just assertions and combinators
wanz has joined #lisp
robdog has joined #lisp
<fiddlerwoaroof>
When I'm working on these kinda problems, I always wish I could use prolog.
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
Harag has joined #lisp
<ggole>
Yeah, things like clpfd might be useful
robdog has quit [Ping timeout: 264 seconds]
Lycurgus has quit [Quit: Exeunt]
nanoz has joined #lisp
<no-defun-allowed>
fiddlerwoaroof: paiprolog?
nanozz has quit [Ping timeout: 245 seconds]
<fiddlerwoaroof>
perhaps
<fiddlerwoaroof>
at work I've been experimenting with core.logic
robdog has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
smasta has joined #lisp
dyelar has quit [Ping timeout: 258 seconds]
moldybits has quit [Ping timeout: 272 seconds]
dyelar has joined #lisp
Harag has quit [Read error: Connection reset by peer]
Harag has joined #lisp
sauvin has joined #lisp
akater has quit [Quit: WeeChat 2.3]
robdog has joined #lisp
rippa has joined #lisp
nanoz has quit [Ping timeout: 246 seconds]
robdog has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
angavrilov has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
shka_ has joined #lisp
pjb has joined #lisp
smasta has quit [Ping timeout: 268 seconds]
<pjb>
Hello!
dale has quit [Ping timeout: 245 seconds]
libertyp1ime has joined #lisp
Necktwi_ has joined #lisp
gigetoo_ has joined #lisp
flip214_ has joined #lisp
hjudt_ has joined #lisp
charh_ has joined #lisp
angavrilov_ has joined #lisp
gurmble has joined #lisp
robdog has joined #lisp
slyrus_ has quit [Remote host closed the connection]
Krystof has quit [Ping timeout: 1042 seconds]
housel has quit [Excess Flood]
sauvin has quit [Excess Flood]
grumble has quit [Quit: fire's in your eyes, and this chaos, it defies imagination]
luis has quit [Excess Flood]
libertyprime has quit [Write error: Broken pipe]
gigetoo has quit [Write error: Broken pipe]
reepca has quit [Remote host closed the connection]
Necktwi has quit [Remote host closed the connection]
hjudt has quit [Remote host closed the connection]
charh has quit [Remote host closed the connection]
gigetoo_ is now known as gigetoo
luis` has joined #lisp
gurmble is now known as grumble
sauvin has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
angavrilov has quit [Ping timeout: 255 seconds]
aindilis has quit [Ping timeout: 255 seconds]
flip214 has quit [Ping timeout: 255 seconds]
nanoz has joined #lisp
dddddd has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
Harag has quit [Ping timeout: 268 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
makomo has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
libertyp1ime has quit [Quit: leaving]
robdog has joined #lisp
<makomo>
minion: memo for moldybits: re post-incf: someone asked the same thing a while ago in #clschool. i did a short analysis of a few versions of the macro which might be useful to you https://plaster.tymoon.eu/view/1015#1015
<minion>
Remembered. I'll tell moldybits when he/she/it next speaks.
robdog has quit [Ping timeout: 264 seconds]
emaczen has quit [Ping timeout: 250 seconds]
wanz has quit [Quit: wanz]
lumm has joined #lisp
space_otter has quit [Remote host closed the connection]
smasta has joined #lisp
smasta has quit [Ping timeout: 255 seconds]
smasta has joined #lisp
FreeBirdLjj has joined #lisp
<makomo>
also, morning :-)
smasta has quit [Ping timeout: 246 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
lumm has quit [Ping timeout: 258 seconds]
robdog has joined #lisp
wanz has joined #lisp
lumm has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
robdog has joined #lisp
wanz has quit [Quit: wanz]
robdog has quit [Ping timeout: 264 seconds]
lumm has quit [Read error: Connection reset by peer]
lumm has joined #lisp
pierpal has quit [Remote host closed the connection]
lumm has quit [Ping timeout: 258 seconds]
dddddd has quit [Remote host closed the connection]
robdog has joined #lisp
lumm has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
random-nick has joined #lisp
lavaflow_ has quit [Read error: Connection reset by peer]
lavaflow_ has joined #lisp
nanozz has joined #lisp
robdog has joined #lisp
Kaisyu has joined #lisp
lumm has quit [Quit: lumm]
fckit has joined #lisp
nanoz has quit [Ping timeout: 246 seconds]
lumm has joined #lisp
nanozz has quit [Ping timeout: 245 seconds]
lumm has quit [Ping timeout: 245 seconds]
robdog has quit [Ping timeout: 268 seconds]
wanz has joined #lisp
shka_ has quit [Ping timeout: 245 seconds]
igemnace has quit [Quit: WeeChat 2.4]
Zaab1t has joined #lisp
rcosta has joined #lisp
robdog has joined #lisp
Krystof has joined #lisp
rcosta has quit [Remote host closed the connection]
smasta has joined #lisp
fckit has quit [Quit: Leaving]
rcosta has joined #lisp
nanoz has joined #lisp
rcosta has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 250 seconds]
rcosta has joined #lisp
rcosta has quit [Remote host closed the connection]
rcosta has joined #lisp
rcosta has quit [Remote host closed the connection]
rcosta has joined #lisp
rcosta has quit [Remote host closed the connection]
rcosta has joined #lisp
rcosta has quit [Remote host closed the connection]
rcosta has joined #lisp
rcosta has quit [Remote host closed the connection]
smasta has quit [Ping timeout: 272 seconds]
rcosta has joined #lisp
robdog has joined #lisp
makomo has quit [Ping timeout: 246 seconds]
robdog has quit [Ping timeout: 246 seconds]
trittweiler has quit [Ping timeout: 246 seconds]
Necktwi_ has quit [Quit: leaving]
robdog has joined #lisp
Necktwi has joined #lisp
makomo has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
karlosz has quit [Quit: karlosz]
ravenousmoose has joined #lisp
rcosta has quit []
robdog has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
robdog has joined #lisp
nanoz has quit [Quit: Leaving]
longshi has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
selwyn has joined #lisp
robdog_ has quit [Ping timeout: 268 seconds]
longshi has quit [Quit: WeeChat 2.3]
makomo has quit [Ping timeout: 255 seconds]
smasta has joined #lisp
robdog has joined #lisp
wanz has quit [Quit: wanz]
JetJej has joined #lisp
nanoz has joined #lisp
smasta has quit [Ping timeout: 246 seconds]
DGASAU has joined #lisp
vilivulpine has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 250 seconds]
<flip214_>
If (expt *large-bignum* 1/3) gives a floating-point-overflow, is there some general iroot function (like isqrt) (in sbcl)?
makomo has joined #lisp
robdog has joined #lisp
selwyn has quit [Ping timeout: 244 seconds]
jb____ has quit [Ping timeout: 244 seconds]
robdog has quit [Ping timeout: 264 seconds]
robdog has joined #lisp
lumm has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
Lord_of_Life_ has joined #lisp
wxie has quit [Ping timeout: 264 seconds]
xkapastel has joined #lisp
Lord_of_Life has quit [Ping timeout: 272 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<nirved>
flip214_: you could use
<nirved>
logarithms, but the precision would suffer
robdog has joined #lisp
Kaisyu has quit [Quit: Connection closed for inactivity]
robdog has quit [Ping timeout: 250 seconds]
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<beach>
Or use Newton's method.
ravenousmoose has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
aindilis has joined #lisp
<flip214_>
nirved: no, I can't -- (log *large-bignum*) gives an overflow again, and there's no ILOG ;)
<flip214_>
beach: yeah, of course I can iterate and approximate ... I just hoped for a simple solution.
<flip214_>
thanks anyway!
<nirved>
well, then newton's, or maybe householder's method
<MichaelRaskin>
For mere ilog I would consider using logand for iterating
robdog has joined #lisp
<nirved>
integer-length would give approximate log base 2 (plus 1)
<beach>
flip214_: Please don't say something like "It's a serious omission not to have included such a function in the Common Lisp standard" as some people would do. :)
<MichaelRaskin>
Wait, there _is_ isqrt
<MichaelRaskin>
And in SBCL it does work for big integers
Lycurgus has joined #lisp
<MichaelRaskin>
Ah, unlike TeX you cannot pass second argument
robdog has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
<makomo>
MichaelRaskin: what's the rationale for not code walking DEFMACRO's and MACROLET's (any others?) bodies?
<MichaelRaskin>
makomo: I code-walk runtime code. defmacro is compile-time code.
<flip214_>
beach: I wouldn't have thought of saying that ... after all, there's quite a lot in CL already!
smasta has joined #lisp
<beach>
flip214_: I know *you* would not have thought of saying that, but I know some people here who might.
<makomo>
MichaelRaskin: "runtime code" meaning "code that's executed at runtime" and not "code that's given to us at runtime" (as WALK-FORM surely operates at runtime), right?
<MichaelRaskin>
flip214_: if you want either a quick one-off calculation, or eventual possibility for careful management of error sizes, you might consider gmp/mpfr bindings
<MichaelRaskin>
makomo: yes
<makomo>
MichaelRaskin: is that a design decision or is there an inherent danger in code walking macros' bodies or something?
<flip214_>
beach: I'll interpret that as a praise and say "thanks!" ;)
<MichaelRaskin>
makomo: I don't expect any inherent dangers, but I ended up special-casing defun and defmethod because lambda handling is different everywhere.
<flip214_>
MichaelRaskin: is an idea, too -- I've got a recursive solution already
<flip214_>
0.000217 seconds of total run time (0.000193 user, 0.000024 system)
<beach>
flip214_: Sure, but the remark was not intended for you. :)
<flip214_>
598,696 processor cycles
<flip214_>
196,496 bytes consed
<flip214_>
looks really cheap, too
<MichaelRaskin>
flip241_: depends on how deep a loop needs that operation!
<flip214_>
MichaelRaskin: sure
Bike has joined #lisp
smasta has quit [Ping timeout: 250 seconds]
sz0 has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
nanoz has quit [Ping timeout: 245 seconds]
robdog has joined #lisp
<makomo>
MichaelRaskin: lambda handling being the various FUNCTION named-lambda dirty tricks, right?
<MichaelRaskin>
basically defun can extract to _anything_
<makomo>
mhm, right
<MichaelRaskin>
And although it doesn't in practice, I am not too fond of what it does expand to
<makomo>
MichaelRaskin: so would still hardwiring defun/defmacro/defmethod but also walking their bodies (as given by the "user") make sense?
<MichaelRaskin>
Yes, sure
<MichaelRaskin>
Although my idea of making sense might be a bit off — I also think that feeding a synthetic defun to macroexpand to analyse and record the structure of lambda-like abominations used by specific compiler makes sense
<MichaelRaskin>
But I didn't implement it
<MichaelRaskin>
Or maybe I haven't implemented it yet…
<MichaelRaskin>
(Agnostics are still allowed to do scientific measurements on their environment and rely on the results!)
<makomo>
MichaelRaskin: hehe :-)
robdog has quit [Ping timeout: 264 seconds]
<MichaelRaskin>
I think this horrible hack is listed in the paper as possible future work
<MichaelRaskin>
A bit sad that (labels ((f () )) (function f)) trick works but is underused
<makomo>
MichaelRaskin: ah yeah, it is
<MichaelRaskin>
This is a standard way of introducing an non-defun named function that compilers support but don't use themselves
<makomo>
mhm, that's the one you mentioned alexandria implements
<makomo>
neat
<makomo>
i haven't looked at it
<MichaelRaskin>
Maybe — last time I wanted it I just coded it from scratch
<MichaelRaskin>
Thanks for reminding that I should look at alexandria more often
<makomo>
:-)
schjetne has joined #lisp
<MichaelRaskin>
There is that old joke about SIGTHTBABW — a signal sometimes sent by Unix to its developer to remind that there has to be a better way.
Nilby has joined #lisp
<MichaelRaskin>
Maybe we should have 'alexandria-should-have-already-implemented-this condition
<flip214_>
nirved: thanks
<_death>
with a restart to quickload it and use the operator
robdog has joined #lisp
<flip214_>
nirved: sadly, that doesn't apply to me -- the input is too large for floats, and I need integer approximations anyway
<flip214_>
never mind, already a few steps further
robdog_ has joined #lisp
orivej has quit [Ping timeout: 268 seconds]
robdog has quit [Ping timeout: 264 seconds]
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
FreeBirdLjj has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
robdog_ has joined #lisp
lumm has quit [Ping timeout: 258 seconds]
robdog_ has quit [Ping timeout: 250 seconds]
ravenousmoose has joined #lisp
Lycurgus has quit [Quit: Exeunt]
dddddd has joined #lisp
lumm has joined #lisp
pierpal has joined #lisp
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
robdog has joined #lisp
ravenousmoose has joined #lisp
lumm has quit [Read error: Connection reset by peer]
robdog has quit [Ping timeout: 268 seconds]
robdog has joined #lisp
lumm has joined #lisp
ebrasca has left #lisp ["ERC (IRC client for Emacs 26.1)"]
ebrasca has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
blackadder has joined #lisp
lumm has quit [Ping timeout: 272 seconds]
jprajzne has joined #lisp
lumm has joined #lisp
lerax has joined #lisp
<lerax>
Hello guys, lerax/ryukinix here, is there a common package to handle multiple quicklisp dist? like a catalog for shirakumo, cl21, bodge and ultralisp?
robdog has joined #lisp
<lerax>
Mostly of softwares outside of central xach quicklisp repository it's need to be provided by another external repository and I didn't find any tool to do this automatically without the need of doing things like (ql-dist:update-dist <url>)
<lerax>
I'm talking about that because the community from Brasil (lisp.com.br) has plans to do that. But we would like to know if already exists something similar.
<lerax>
It's not complicated to do, but would be nice not waste your time with something that is already solved.
* lerax
meant: your -> our
robdog has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
lumm has quit [Quit: lumm]
lumm has joined #lisp
xkapastel has joined #lisp
lumm has quit [Client Quit]
cl-arthur has quit [Ping timeout: 268 seconds]
robdog_ has quit [Ping timeout: 264 seconds]
smasta has joined #lisp
edgar-rft has joined #lisp
lumm has joined #lisp
smasta has quit [Ping timeout: 246 seconds]
robdog has joined #lisp
moldybits has joined #lisp
zaquest has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
lumm has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
volkov has joined #lisp
<volkov>
So it's definitely necessary to break out Emacs and modify that clisp script.
<beach>
volkov: what?
robdog has quit [Ping timeout: 264 seconds]
<beach>
Does Emacs use CLISP?
<beach>
And what does it mean to "break out" Emacs?
Inline has quit [Read error: Connection reset by peer]
robdog has joined #lisp
Inline has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
volkov has quit [Quit: volkov]
<Xach>
lerax: i saw something on github about that - maybe it was from you?
<Xach>
lerax: ah yes, i see it is
lumm has joined #lisp
robdog has joined #lisp
<lerax>
Oh, yes. It's me.
<lerax>
What you think Xach?
<lerax>
Do you think this can be useful or it's a waste of time?
<lerax>
At least for me that would be useful.
<Xach>
lerax: if it is useful for you, it sounds good. i think it would be useful to make the preference system visible in some way.
<Xach>
lerax: that is, if a project is available from two different sources, which one is preferred.
robdog has quit [Ping timeout: 264 seconds]
<lerax>
This is interesting.
robdog_ has joined #lisp
<lerax>
Thank you for the feedback. I'll move forward the development of ql-meta. Thanks for providing and mainting quicklisp for us :). It's a very very useful tool.
<Xach>
glad to hear it
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
robdog_ has quit [Ping timeout: 268 seconds]
makomo has quit [Ping timeout: 245 seconds]
robdog has joined #lisp
ebrasca has quit [Read error: Connection reset by peer]
robdog has quit [Ping timeout: 250 seconds]
smasta has joined #lisp
smasta has quit [Ping timeout: 255 seconds]
lumm has quit [Ping timeout: 246 seconds]
scymtym has joined #lisp
robdog has joined #lisp
blackadder has quit [Ping timeout: 272 seconds]
robdog has quit [Ping timeout: 250 seconds]
robdog_ has joined #lisp
robdog_ has quit [Ping timeout: 250 seconds]
Oladon has joined #lisp
ravenousmoose has joined #lisp
ravenousmoose has quit [Client Quit]
ebrasca has joined #lisp
robdog has joined #lisp
hsrv has joined #lisp
blackadder has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
<fiddlerwoaroof>
MichaelRaskin, makomo: one issue with codewalking is that you can't really "look into" quasiquoted forms since the datastructures behind `(...) are unspecified.
<fiddlerwoaroof>
I suspect this would be particularly bad if you're looking into walking a DEFMACRO
<MichaelRaskin>
Not that bad — in SBCL it expands to a function form
robdog has joined #lisp
<MichaelRaskin>
And I doubt anyone puts a special form there
<lerax>
I would want something like etc /lib/libSDL-1.2.so.0.11.4 instead of only libSDL-1.2.so.0.11.4
<lerax>
I can just prefix with /lib for my system and the problem is solved, but I want this be portable between other machines...
<lerax>
Any suggestion?
robdog has quit [Ping timeout: 264 seconds]
Oladon has quit [Quit: Leaving.]
robdog has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
robdog_ has quit [Ping timeout: 264 seconds]
<sjl>
Question about FORMAT: we can print a float to a given precision with (format t "~,3F" 1.2). That precision can be specified at runtime with (format t "~,VF" 3 1.2). But what if I want to print a list of floats, all with the same precision?
<sjl>
(format t "~{~,VF~^ ~}" 3 (list 1.2 2.2 3.2)) doesn't work, because it expects the V's to be inside the list
<sjl>
I could obviously interleave them with (list 3 1.2 3 2.2 3 3.2) but that's ugly
<sjl>
I could generate the format string at runtime with another format, but that gets hairy
<Bike>
i think that's pretty much what you're stuck with.
<sjl>
There's no other clever solution to this, huh
<sjl>
can't do (flet (print-float ...)) (format t "~{~/print-float/~} ...)) because ~/.../ doesn't work with flet/labels
robdog has joined #lisp
<sjl>
I don't even think I could do something clever with ~@* because the V and F occur in the same directive
robdog_ has joined #lisp
nanoz has quit [Read error: Connection reset by peer]
robdog has quit [Ping timeout: 264 seconds]
smasta has joined #lisp
smasta has quit [Ping timeout: 255 seconds]
robdog_ has quit [Ping timeout: 264 seconds]
devon has joined #lisp
<devon>
G'day all you hackers, where's the spec for default :test args and such?
<fiddlerwoaroof>
sjl: it's not a solution to your problem, but you could also write a helper function to pre-process the list and give each memeber a precision
<fiddlerwoaroof>
(float-precision 3 (list 1.2 1.3 1.44)) or something
<sjl>
same number of chars, but semantically ~:[~;foo~] is better than ~@[~*foo~]
robdog has quit [Ping timeout: 264 seconds]
<devon>
sjl: Thanks, 17.2.1 Satisfying a Two-Argument Test … If neither a :test nor a :test-not argument is supplied, it is as if a :test argument of #'eql was supplied.
robdog has joined #lisp
makomo has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
<fiddlerwoaroof>
sjl: Alternatively, you could use a dynamic variable for the precision and a globally defined print-float function that is something like (format s "~,vf" *float-precision*)
<sjl>
Yeah, and call it with "~//" you mean
FreeBirdLjj has quit [Ping timeout: 250 seconds]
<fiddlerwoaroof>
yes
<fiddlerwoaroof>
something like (let ((*float-precision* 3)) (format t "~{~/my-package::print-float/~}" ...)
charh_ is now known as charh
<fiddlerwoaroof>
"If name does not contain a ":" or "::", then the whole name string is looked up in the COMMON-LISP-USER package.", though...
pmc_ has joined #lisp
<sjl>
yeah, kinda awkward to use
lumm has quit [Ping timeout: 245 seconds]
robdog has joined #lisp
<makomo>
fiddlerwoaroof: re backquote and code walking: yeah, it might be "nasty", but could it ever be so nasty that you could not handle it with standard facilities? sbcl's backquote expands into a macro whose argument is a literal structure, but MACROEXPAND-1 expands it cleanly
<makomo>
i was thinking whether it could expand *just* into a structure or somethig similar that would be specially handled by the evaluator, but i don't think that would satisfy common lisp's semantics then?
jprajzne has quit [Quit: jprajzne]
<makomo>
by the standard's rules, if it expanded into a new special operator, then that operator would need to also be provided as a macro
<makomo>
so i don't know what other nasty options are left really
<pmc_>
What is the idiomatic way to remove whitespace from a string? So I want to turn " a b c" into "abc". I have this so far: (defun remove-whitespace (str) (dotimes (i (length str)) ; do something with (char str i) ... Is there a concatenate function for stirngs?
<makomo>
pmc_: you could use cl-ppcre's replace function
<makomo>
pmc_: maybe common lisp's remove will also work
<makomo>
(remove #\Space " a b c") ;; => "abc"
robdog has quit [Ping timeout: 264 seconds]
Nilby has quit [Read error: Connection reset by peer]
<pmc_>
ok, cool, thanks makomo! :)
<makomo>
you could handle different whitespace characters either with multiple REMOVEs or with REMOVE-IF
<makomo>
:-)
<pmc_>
good to know.
robdog has joined #lisp
<MichaelRaskin>
makomo: I don't think any compiler commits to your interpretation of the standard
<MichaelRaskin>
It might be the only sane one, but…
hsrv has left #lisp ["ERC (IRC client for Emacs 26.1)"]
<makomo>
MichaelRaskin: yeah, the tricks with named-lambda and such already violate the standard in that regard, right? :(
<makomo>
MichaelRaskin: oh btw, which implementation made you hardwire COND? that one surprised me
<fiddlerwoaroof>
makomo: I believe sbcl once expanded quasiquotes to a struct
<fiddlerwoaroof>
It looks like sbcl may have backed those changes out.
<makomo>
fiddlerwoaroof: into a literal structure object that is handled specially be the evaluator?
<makomo>
(instead of as a parameter to an operator or similar, like it is now)
robdog has quit [Ping timeout: 264 seconds]
<fiddlerwoaroof>
The details are fuzzy now, but I think that's what happened
<makomo>
yeah, that's what we have now, but it's not a naked structure
<makomo>
it's wrapped by the quasiquote macro, which is handled fine by MACROEXPAND-1
<fiddlerwoaroof>
Yeah, I was misremembering the details
<makomo>
:-)
<fiddlerwoaroof>
The problem is if you're trying to walk the un-expanded quasiquote, right?
<makomo>
yup, true
<fiddlerwoaroof>
e.g. trying to automatically enforce macro hygiene
<makomo>
i.e. if you're doing naive code walking
<MichaelRaskin>
Well, there are a lot of unexpanded macros that are pain to walk
robdog has joined #lisp
lumm has joined #lisp
mejja has joined #lisp
smasta has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
matijja has joined #lisp
smasta has quit [Ping timeout: 255 seconds]
xkapastel has joined #lisp
lumm has quit [Quit: lumm]
lumm has joined #lisp
buffergn0me has quit [Ping timeout: 258 seconds]
akater has joined #lisp
lumm has quit [Client Quit]
lumm has joined #lisp
lerax has left #lisp ["ERC (IRC client for Emacs 26.1)"]
gravicappa has quit [Ping timeout: 246 seconds]
lumm has quit [Ping timeout: 246 seconds]
lumm has joined #lisp
Harag has joined #lisp
Harag has quit [Client Quit]
robdog has joined #lisp
Harag has joined #lisp
Harag has quit [Client Quit]
Harag has joined #lisp
Harag has quit [Client Quit]
robdog has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
Inline has quit [Quit: Leaving]
Inline has joined #lisp
lumm has quit [Ping timeout: 246 seconds]
robdog has quit [Ping timeout: 264 seconds]
ggole has quit [Quit: Leaving]
robdog has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
smasta has joined #lisp
random-nick has quit [Ping timeout: 246 seconds]
smasta has quit [Ping timeout: 255 seconds]
igemnace has quit [Ping timeout: 255 seconds]
blackadder has quit [Quit: WeeChat 1.6]
fwm9 has quit [Ping timeout: 245 seconds]
myrkraverk has quit [Ping timeout: 246 seconds]
ravenousmoose has joined #lisp
robdog has joined #lisp
dale has joined #lisp
myrkraverk has joined #lisp
lumm has joined #lisp
lumm has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 250 seconds]
buffergn0me has joined #lisp
random-nick has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
robdog has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
buffergn0me has quit [Ping timeout: 264 seconds]
robdog has joined #lisp
matijja has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 264 seconds]
karlosz has joined #lisp
robdog has joined #lisp
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
ravenousmoose has joined #lisp
buffergn0me has joined #lisp
orivej has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
sakalli` has joined #lisp
sakalli` has quit [Remote host closed the connection]
dale has quit [Quit: dale]
robdog_ has quit [Ping timeout: 264 seconds]
abhixec has joined #lisp
dale has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
orivej has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
buffergn0me has quit [Ping timeout: 264 seconds]
lumm has joined #lisp
Inline has quit [Read error: Connection reset by peer]
robdog has joined #lisp
Oladon has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
<fiddlerwoaroof>
For some use cases (like the let over lambda defmacro/g!), a symbol macro seems like a better fit to me
<fiddlerwoaroof>
Why use a codewalker to turn g!foobar into a (GENSYM "FOOBAR"), when you can use something like #!foobar to generate the same form?
<fiddlerwoaroof>
(#! is explicitly reserved to the user, but named-readtables can help here too.)
robdog has joined #lisp
housel has joined #lisp
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<makomo>
fiddlerwoaroof: i would say most people think like that only because code walkers are unreliable, nonportable, etc. (in general an annoyance to use correctly)
robdog has quit [Ping timeout: 250 seconds]
robdog_ has joined #lisp
<makomo>
(unreliable when they're written to be portable*)
Inline has joined #lisp
<makomo>
i think that the situation would be a lot better if they were easier (and less constraining) to use
<makomo>
you could use and compose a lot of useful macros without even thinking about it
<makomo>
MichaelRaskin: how come you had to hardwire COND as well?
<MichaelRaskin>
I don't remember — maybe it is because some of the prior art complained about a performance hit on some (probably older) implementation
robdog has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
<fiddlerwoaroof>
Hmm, I think a reader macro is the right tool for the job here, though
<fiddlerwoaroof>
Why go through the trouble of tree-walking, when the reader will do everything for you?
robdog_ has quit [Ping timeout: 250 seconds]
<fiddlerwoaroof>
And, in a lot of other cases, using MACROLET and letting the implementation's macroexpander will be better anyways.
<fiddlerwoaroof>
I've seen complicated stuff in Racket using syntax-parse and other such sophisticated tree-walking libraries, but I generally find that they tend to obscure your code if you just use them for everything.
Lycurgus has joined #lisp
<fiddlerwoaroof>
I really can't stand what Racket macros tend to turn into...
angavrilov_ has quit [Remote host closed the connection]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
robdog_ has quit [Ping timeout: 250 seconds]
matijja has joined #lisp
robdog has joined #lisp
buffergn0me has joined #lisp
<makomo>
fiddlerwoaroof: you can't just turn #!foo into (gensym "FOO") though, because you want every usage of g!foo to be the same gensym
<makomo>
fiddlerwoaroof: i agree. i very much prefer macrolet when it can do the job, but sometimes it's not possible to use it
<makomo>
for example, because you don't know the names of the macrolets to generate. sometimes the point of the macro is code walk the body and collect the various names that will be used for the macrolets (because you want to relieve the user of having to specify them explicitly, which is the point of the macro, just like with defmacro/g!)
xvx has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
notzmv has joined #lisp
notzmv is now known as Guest56527
Guest56527 has left #lisp [#lisp]
zmv has joined #lisp
zmv is now known as notzmv
robdog has joined #lisp
<makomo>
MichaelRaskin: ah, ok. thought it was a situation similar to DEFUN's which would be surprising
abhixec has quit [Ping timeout: 268 seconds]
<no-defun-allowed>
Is `(find "foo" '("foobar" "quux" "baz") :test #'search)` conforming CL code? It looks a little odd to me, but it works on SBCL.
<makomo>
no-defun-allowed: i assume the backticks aren't part of the code?
<no-defun-allowed>
The backticks are just to delimit the code, sorry.
robdog has quit [Ping timeout: 250 seconds]
Zaab1t has quit [Quit: bye bye friends]
<makomo>
i don't see anything wrong with it. #'search is used a predicate here, meaning that we're looking for the first element which contains the item being searched for
<makomo>
hm, maybe it might be a problem if the order the arguments are passed to the predicate isn't specified
<no-defun-allowed>
I think it is, but I don't remember
<makomo>
yeah, i think it must be
<makomo>
the example in clhs uses #'char>
<makomo>
which obviously isn't symmetric
<makomo>
so i see nothing wrong with using #'search as a predicate