random-jellyfish has quit [Ping timeout: 244 seconds]
veqq has joined #commonlisp
veqq has quit [Remote host closed the connection]
rtypo has quit [Ping timeout: 245 seconds]
yazz has quit [Ping timeout: 244 seconds]
yazz has joined #commonlisp
veqq has joined #commonlisp
akoana has joined #commonlisp
veqq has quit [Quit: veqq]
veqq has joined #commonlisp
veqq has quit [Client Quit]
akoana has quit [Quit: leaving]
random-nick has quit [Ping timeout: 245 seconds]
veqq has joined #commonlisp
idlecat has quit [Quit: going dull...]
random-nick has joined #commonlisp
idlecat has joined #commonlisp
surabax has quit [Quit: Leaving]
kevingal has quit [Ping timeout: 248 seconds]
rocc_ has joined #commonlisp
rocc_ is now known as rocc
rocc has quit [Changing host]
rocc has joined #commonlisp
Guest47 has joined #commonlisp
Guest47 has quit [Client Quit]
montxero has joined #commonlisp
random-nick has quit [Ping timeout: 252 seconds]
decweb has quit [Quit: Konversation terminated!]
<montxero>
I just wrote a macro CONDLET which is like cond but each clause is of the form ((symbol predicate) form). I would appreciate your opinoins on it as well as potential bugs in the implementation. https://plaster.tymoon.eu/v/76JUXYLE2#4785
jeffrey has quit [Quit: jeffrey]
vardhan_ has joined #commonlisp
<nil>
montxero: I'm not noticing any bugs, but I guess I'd have to use it to see, but bravo on the nice docsting with example.
asciiascetic has joined #commonlisp
stanrifkin_ has joined #commonlisp
asciiascetic has quit [Client Quit]
stanrifkin has quit [Ping timeout: 272 seconds]
<montxero>
nil: thanks.
<montxero>
nil: I am still trying to understand why condletter works albeit on my simple examples. Especially because each call creates a new backquoted list thay may be embeeded in another backquoted list.
bilegeek has joined #commonlisp
<beach>
montxero: A "backquoted list" is a macro that expands as usual, so nesting is not a problem.
<nytpu>
montxero: just normal recursion. keep in mind that a quoted list (backquoted or not) is just a normal list, so `(... ,`(thing)) is the same as just `(... (thing))
<jackdaniel>
beach: what makes you think that a '"backquoted list" is a macro'?
<jackdaniel>
I'll have to read the backlog later, see you \o
veqq has quit [Quit: veqq]
<beach>
Well, the standard recommends that a backquoted expression is turned into something like (QUASIQUOTE ...) where QUASIQUOTE is the name of a macro.
<beach>
,(car '`x)
<ixelp>
(car '`x) => QUOTE
<beach>
,(car '`(foo ,x)))
<ixelp>
(car '`(foo ,x)) => LIST*
<beach>
*sigh* It is too smart.
<jackdaniel>
cltl2 suggests tgat I believe, and thar has problems of its own
<beach>
If you do that in SBCL, you will get the name of a macro function.
<jackdaniel>
I know, but in light of the standard it is an implementatipn detail
* jackdaniel
really is afk now, I'll elaboratd later uf asked
<jackdaniel>
if*
<beach>
montxero: I attempted a pedagogical simplification to explain to you how backquote works, but I should probably reserve pedagogical simplification to #clschool.
ixelp has quit [Ping timeout: 260 seconds]
bpanthi977 has quit [Ping timeout: 248 seconds]
ixelp has joined #commonlisp
pranav has quit [Remote host closed the connection]
pranav has joined #commonlisp
<montxero>
Folks, thanks a lot, I've got it.
dra has joined #commonlisp
Guest47 has joined #commonlisp
edgar-rft` has joined #commonlisp
edgar-rft has quit [Ping timeout: 260 seconds]
triffid has quit [Quit: triffid]
triffid has joined #commonlisp
dra has quit [Ping timeout: 268 seconds]
istewart has quit [Quit: Konversation terminated!]
pranav has quit [Read error: Connection reset by peer]
pranav has joined #commonlisp
montxero has quit [Ping timeout: 252 seconds]
zxcvz has joined #commonlisp
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 260 seconds]
Lord_of_Life_ is now known as Lord_of_Life
zxcvz has quit [Quit: zxcvz]
waleee has quit [Ping timeout: 268 seconds]
seanw` has quit [Remote host closed the connection]
shka has joined #commonlisp
seanw has joined #commonlisp
pranav has quit [Remote host closed the connection]
mishoo has joined #commonlisp
pranav has joined #commonlisp
rtypo has joined #commonlisp
random-jellyfish has joined #commonlisp
random-jellyfish has quit [Changing host]
random-jellyfish has joined #commonlisp
apac has joined #commonlisp
apac has quit [Ping timeout: 244 seconds]
apac has joined #commonlisp
bilegeek has quit [Quit: Leaving]
apac has quit [Ping timeout: 245 seconds]
Guest47 has quit [Ping timeout: 268 seconds]
jrx has joined #commonlisp
tjbw has quit [Ping timeout: 244 seconds]
Guest47 has joined #commonlisp
X-Scale has joined #commonlisp
Josh_2 has joined #commonlisp
pranav has quit [Remote host closed the connection]
oneeyedalien has quit [Remote host closed the connection]
svm has joined #commonlisp
msv has quit [Remote host closed the connection]
apac has joined #commonlisp
wbooze has joined #commonlisp
pranav has quit [Remote host closed the connection]
RDMengineer4 has joined #commonlisp
RDMengineer has quit [Ping timeout: 248 seconds]
RDMengineer has joined #commonlisp
RDMengineer4 has quit [Ping timeout: 245 seconds]
matt`` has joined #commonlisp
triffid has quit [Read error: Connection reset by peer]
chiselfuse has quit [Read error: Connection reset by peer]
chiselfuse has joined #commonlisp
triffid has joined #commonlisp
matt`` has quit [Ping timeout: 245 seconds]
pranav has joined #commonlisp
triffid has quit [Ping timeout: 264 seconds]
triffid has joined #commonlisp
cage has quit [Remote host closed the connection]
cage has joined #commonlisp
<mathrick>
given a lambda list with (foo &rest rest &key bar &allow-other-keys), what is the correct way to extract only the extra positional and extra key arguments?
cage has quit [Client Quit]
cage has joined #commonlisp
<mathrick>
since REST contains all the keys, both known and unknown, as well as any extra positional arguments, I can't really see a way to separate those without reimplementing most of the parsing that goes into built-in lambda list machinery
<gilberth>
You can use REMF on a copy of the rest argument.
Perflosopher03 has joined #commonlisp
<mathrick>
gilberth: so I still need to do the parsing there myself to figure out where keyword arguments begin, and list every known keyword argument again?
<gilberth>
This is from my CLIM. A function takes a lambda list that allows for &REST after &KEY and returns an ANSI-CL lambda list.
<gilberth>
I made this because I was facing this very task so often that I got bored of saying COPY-LIST and REMF for each single &KEY I mentioned.
Pixel_Outlaw has joined #commonlisp
<mathrick>
gilberth: thanks, this does confirm what I thought, which is that there's no real way to do it in vanilla CL that isn't ugly and annoying
<gilberth>
Yes, indeed.
<mathrick>
does TRANSLATE-LAMBDA-LIST account for extra positional arguments too?
<gilberth>
Extra? It copes with e.g. (A B &KEY X Y &ALLOW-OTHER-KEYS &REST R) just fine.
<gilberth>
Saying (A B &REST ALL &KEY X Y &ALLOW-OTHER-KEYS &REST REMAINING) works too.
<mathrick>
in this case, will ALL contain the keywords too, or only positional arguments after B but before X?
<gilberth>
It would do as if you said (A B &REST ALL).
<mathrick>
ah, so it's only a partial solution, got it
<gilberth>
Partial? What is missing?
<mathrick>
I'm very used to python's way of saying def foo(x, y, *args, bar=None, **kwargs), and not having args and kwargs built into the language is pretty annoying
<mathrick>
gilberth: the equivalent of *args above
<gilberth>
I don't speak Python.
veqq has joined #commonlisp
<gilberth>
You said you wanted a rest parameter that has the keyword arguments not consumed by your &KEY. And my function does just that.
<mathrick>
it means that if I call foo(1, 2, 3, baz=42), args will be equal to [3] (a list containing one element, 3), and kwargs will be {"baz": 42} (a hash map mapping "baz" to 42)
<mathrick>
i.e. TRANSLATE-LAMBDA-LIST solves the **kwargs part, but not the *args part
<mathrick>
either way, I'm just going to have to implement that helper myself, since I also need it in Elisp
<gilberth>
You want to confuse yourself and have something like ((LAMBDA (A B &REST R &KEY X) R) 1 2 3 4 :X 10) => (3 4)?
<mathrick>
in a nutshell, yes, though you do make a good point, I tend to forget that mixing variable positional and keyword arguments in CL is not a good idea
JuanDaugherty has joined #commonlisp
<mathrick>
again, I have done a lot of python in my life
<gilberth>
Also with your idea of &REST: (DEFUN FOO (A B &REST R &KEY X) R) (DEFUN BAR (X) (FOO 1 2 X 42)) and then what is (BAR :X)?
<mathrick>
but it's fundamentally different in that the runtime actually passes the arguments in differently so it's easy to distinguish them, but the way lambda lists are implemented in CL, you just get a single list of values so there are inherently ambiguous situations
<gilberth>
Or even (APPLY #'FOO ARGS). As the above could be solved by FOO being a macro.
<gilberth>
mathrick: Yes. That was my point.
<mathrick>
I know, that's why I said you made a good point about it not being a good idea :)
Guest6381 has quit [Quit: WeeChat 4.6.0]
* JuanDaugherty
wonders how much life mathrick has had
apac has quit [Ping timeout: 276 seconds]
zwr has quit [Read error: Connection reset by peer]
<mathrick>
umm, it's really not very hard, I started using python ~20 years ago and have worked professionally almost exclusively in Python, so I don't think it's terribly surprising that I'm very familiar with the language
<JuanDaugherty>
i c
rocc has quit [Quit: Connection closed for inactivity]
ColinRobinson has quit [Quit: praxis.meansofproduction.biz (juan@acm.org)]
<khinsen>
Hi everyone,
<khinsen>
If you want to play with a new toy, here is a demo of my live hypertext documentation system for explorable and explainable Web-publishable software:
chiselfuse has quit [Remote host closed the connection]
triffid has quit [Remote host closed the connection]
anticomputer has quit [Remote host closed the connection]
chiselfuse has joined #commonlisp
anticomputer has joined #commonlisp
triffid has joined #commonlisp
pranav has joined #commonlisp
kevingal has quit [Ping timeout: 245 seconds]
<jackdaniel>
so according to the spec quasiquotation is a feature of the reader; the algorithm is even clearly laid out -- all is resolved at read time
<jackdaniel>
historically cltl2 suggested that quasiquote should be a macro, and that's what sbcl implements, but there are a few nuances that lead to preserving (after read) objects that are not forms
<|3b|>
according to the spec, the only thing specified is what it evaluates to
<jackdaniel>
backquote is specified as a standard macro character and behavior is explained in the section about syntax, not about macros
<|3b|>
sorry, the only thing specified is the result of evaluating the result of calling the reader macro function, and some cases where the reader macro function will be called :
<jackdaniel>
right
<jackdaniel>
to be fair, 2.4.6.1 hints that if the implementor doesn't have a particular reason to do otherwise, they may refer to ieee scheme standard for quasiquotation (that would explain beach remark from earlier) that indeed specifies special forms quote, quasiquote and unquote
<|3b|>
yeah, a macro form is probably one of the 2 more reasonable results, but could be ((lambda () ...)) or (funcall #<backquote ...>) or (expand-backquote #<...>) etc
<|3b|>
(other reasonable result being (list...) and similar that just directly construct the result)
<mathrick>
backquote is one of the many unfortunate areas where core aspects of the language are made a black box with everything inside being implementation details that probably are <some useful thing> most of the time, but aren't guaranteed to be <some useful thing>, thus you can't rely on that, but also can't access by any portable means, so you can't meaningfully interact with them outside of the handful of scenarios explicitly prescribed by the standard
<mathrick>
most of the reader really is that
remexre has quit [Ping timeout: 252 seconds]
<jackdaniel>
I suspect that it was a result of agreeing between implementors at the time
Eoco has quit [Ping timeout: 248 seconds]
<mathrick>
sure, like most of the unfortunate black boxes in CL
<mathrick>
a lot of them are specified to be <some useful thing> in CLtL or CLtL2, but the standard explicitly rescinds that
<jackdaniel>
I mean - I suspect that some implementations did it another way, and there are sound arguments in favor of keeping backquote as part of the syntax (i.e automatic transformation to (list* ...)), most notably there is no risk of "unsplicing" escaping its context
<reb>
What's the best way in source code to arrange for the compiler to see a form only if some condition is true? Kind of like #+feature (the-form) but for an arbitrary condition evaluated at load or compilation time.
<jackdaniel>
so there were, say three "useful" things with different pros and cons
markb1 has quit [Ping timeout: 245 seconds]
<|3b|>
reb: load time is a bit late for the compiler to see things
<jackdaniel>
reb: #.(if (foobar) (a b c) nil)
<|3b|>
but #+ can do more than just symbols
<jackdaniel>
well, maybe not exactly
<jackdaniel>
scratch my remark (about #.if ..)
<|3b|>
even #+#.(cl:if ... '(and) '(or)) if you have to
anticomputer has quit [Remote host closed the connection]
<jackdaniel>
^ clever
anticomputer has joined #commonlisp
<|3b|>
though technically read time rather than compile or load
<|3b|>
macro can also do arbitrary checks at compile time
<reb>
|3b|: OK, I guess I want read time, not load time.
<reb>
|3b|: Thanks! That's the magic I have seen before.
* |3b|
suspects #+#. for anything much more than a version check is a sign of trying to add too much magic though
<|3b|>
or maybe find-symbol for the equivalent of a version check
<reb>
The things I'm interested in are stuff like "expand to #\Linefeed when the current Lisp system does not consider #\Linefeed and #\Newline to be the same character" ...
<|3b|>
yeah, that's also reasonable
<reb>
or "add this case when long-float and double-float are not the same type
<mathrick>
jackdaniel: yes, sometimes, but a lot of the time the pros boiled down to "we did it that way for historical reasons, and don't want to change it now", or even "we did it that way, and we really want to be able to market our implementation as CL today, but the change would take more than <a very short time>, so the standard should loosen guarantees until our way is good enough"
<mathrick>
I understand that CL is a compromise made in order to have _some_ standard out, but it's still a compromise language, and some parts of it are much more painful than others
<jackdaniel>
I personally dislike the interpretation with backquote being a special operator
markb1 has joined #commonlisp
<jackdaniel>
but I'm sure many people find it more lispy - I guess what I'm trying to say is that I'm glad that the specification is (at least) the way it is in this regard
<nil>
unlike most languages CL can be turned into a relatively uncompromising language by the user
zwr has quit [Read error: Connection reset by peer]
zwr has joined #commonlisp
<Pixel_Outlaw>
I think it turned out very good for something that's "designed by committee". I guess you just need to have the right kind of people on the committee. The included functions usually are thoughtfully designed and don't fall into "for the sake of simplicity we don't support" trap.
shawnw has quit [Read error: Connection reset by peer]
shawnw_ has joined #commonlisp
McParen has left #commonlisp [#commonlisp]
<aeth>
Pixel_Outlaw: there are things that are left out that shouldn't have, it's just that between macros and everything being namespaced, there's no real limitations (other than reader ones, I guess... reader macros aren't fully powerful and tools won't understand them)
<aeth>
at least, no real limitations if you can convince people to USE something other than CL, and otherwise, some symbol name limitations
<aeth>
Pixel_Outlaw: although CL seems to be a committee that erred on the side of leaving things in, such as RPLACA, that serve no real purpose anymore.
<aeth>
A compatibility wrapper for legacy Lisps could've DEFUN'd a RPLACA from (SETF CAR) with no loss at all.
<aeth>
Although the ugliest part is probably EVAL-WHEN because I doubt anyone uses that without copying and pasting (or defining a macro with more memorable semantics, or relying on an IDE, etc.)
dra has joined #commonlisp
<aeth>
I've written too many lines, but before someone asks me about "things that are left out that shouldn't have [been left out]", I'll just point out Alexandria for some of the least controversial parts left out of the language. The ones that are macros (or even forced-inline functions) wouldn't have been definable in most languages. You'd just have to require another revision of the standard.
bleb has left #commonlisp [#commonlisp]
random-jellyfish has joined #commonlisp
mishoo has quit [Ping timeout: 276 seconds]
bpanthi977 has quit [Ping timeout: 260 seconds]
pranav has quit [Read error: Connection reset by peer]
bpanthi977 has joined #commonlisp
cage has quit [Quit: rcirc on GNU Emacs 30.1]
bpanthi977 has quit [Ping timeout: 260 seconds]
<veqq>
aeth: What use was there for rplaca?
<|3b|>
same as now, running old code that uses it
remexre has joined #commonlisp
Eoco has joined #commonlisp
<|3b|>
and before there were other ways to do so, modifying the car of a cons
bpanthi977 has joined #commonlisp
bpanthi977 has quit [Ping timeout: 248 seconds]
pranav has joined #commonlisp
<nil>
one might conceivably use rplaca functionally e.g. ,(map 'list #'rplaca '((foo . 1) (bar . 2) (baz . 3)) '(one two three))
<aeth>
veqq: RPLACA existed before SETF (probably)
bpanthi977 has joined #commonlisp
<aeth>
nil: (setf car) is a function ... I think, anyway. It could also be a macro, etc. A bit weird to have functions with lists as the name as long as the CAR of the list is SETF, but it's there. So #'(setf car) is possibly a thing.
Eoco has joined #commonlisp
<aeth>
It doesn't behave the same way, though.
remexre has joined #commonlisp
<aeth>
nil: But mutation in higher-order-functions like that is too error-prone, anyway. For instance, your own example. I think that has to be (list (cons 'foo 1) (cons 'bar 2) (cons 'baz 3)) instead of a literal if that's mutating the literal.
<jackdaniel>
setf functions were added as an afterthought to support accessor option in slots
<jackdaniel>
i ansi. previously tgese were only macros
<jackdaniel>
in*
bpanthi977 has quit [Ping timeout: 260 seconds]
<aeth>
jackdaniel: presumably they wouldn't have been as much of an after thought if (setf car) was designed as a full replacement to rplaca
Eoco has quit [Ping timeout: 252 seconds]
remexre has quit [Ping timeout: 260 seconds]
Eoco has joined #commonlisp
<thuna`>
Huh. SBCL apparently doesn't define STREAM-READ-CHAR for concatenated-streams.
bpanthi977 has joined #commonlisp
remexre has joined #commonlisp
puke has quit [Remote host closed the connection]
puke has joined #commonlisp
<thuna`>
And ECL errors on (INTERACTIVE-STREAM-P *STANDARD-INPUT*)
bpanthi977 has quit [Ping timeout: 272 seconds]
<nil>
thuna`: I don't think Gray stream methods are required to be defined built in stream types. And interactive-stream-p works on ECL running by itself, so it seems that swank/slynk doesn't define it for it's streams.
wacki has quit [Quit: Leaving.]
owen has joined #commonlisp
owen has quit [Quit: byebye]
owen has joined #commonlisp
bpanthi977 has joined #commonlisp
bpanthi977 has quit [Remote host closed the connection]
bpanthi977 has joined #commonlisp
shawnw_ is now known as shawnw
bpanthi977 has quit [Ping timeout: 248 seconds]
garlic0x1 has joined #commonlisp
shka has quit [Quit: Konversation terminated!]
<thuna`>
nil: Ah, that would make sense
bpanthi977 has joined #commonlisp
bpanthi977 has quit [Ping timeout: 246 seconds]
luna-is-here has quit []
bpanthi977 has joined #commonlisp
bpanthi977 has quit [Ping timeout: 246 seconds]
msv has joined #commonlisp
svm has quit [Ping timeout: 272 seconds]
markb1 has quit [Ping timeout: 248 seconds]
markb1 has joined #commonlisp
bpanthi977 has joined #commonlisp
dra has quit [Ping timeout: 248 seconds]
bpanthi977 has quit [Ping timeout: 260 seconds]
bpanthi977 has joined #commonlisp
matt` has quit [Remote host closed the connection]