gitgood has quit [Read error: Connection reset by peer]
<antonv>
Ah, I understood your question little better now. You mean (return-from test), whould abandon (block foo ...), so (return-from foo) should not work...
MrVulcan has quit [Remote host closed the connection]
<antonv>
Well, considering that "abandoned" should happen as the step 1, you may be right.
<antonv>
The fact that it works on some exisging impls may be justified by "The consequences are undefined if an attempt is made to transfer control to an exit point whose dynamic extent has ended."
<antonv>
So in this case the undefined consiquence is that it works as if not abandoned.
<antonv>
But that's just my incompenent thoughts.
rgherdt has quit [Ping timeout: 246 seconds]
ex_nihilo has joined #lisp
choegusung has joined #lisp
<phoe>
this sounds plausible
varjag has quit [Ping timeout: 260 seconds]
hiroaki__ has quit [Ping timeout: 272 seconds]
charles` has joined #lisp
VincentVega has quit [Quit: Connection closed]
random-nick has quit [Quit: quit]
notzmv has joined #lisp
rtypo has quit [Ping timeout: 245 seconds]
antonv has quit [Ping timeout: 245 seconds]
jonatack_ has quit [Read error: Connection reset by peer]
purpleLizard has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
dbotton has joined #lisp
choegusung has quit [Ping timeout: 264 seconds]
mindCrime has joined #lisp
ljavorsk has quit [Ping timeout: 245 seconds]
<Alfr>
phoe, did you try that with safe code? That should be an error.
<ex_nihilo>
phoe: isn't foo an intervening exit point since it lies between (return-from test 42) and the exit point; i.e., foo is no longer a valid exit point after (return-from test 42)? This would seem to make the behavior undefined
dbotton has joined #lisp
karlosz has joined #lisp
dorketch has joined #lisp
dbotton has quit [Quit: Leaving]
akoana has left #lisp ["Leaving"]
karlosz has quit [Quit: karlosz]
brandflake11 has quit [Ping timeout: 240 seconds]
dorketch has quit [Quit: WeeChat 2.9]
jeosol has joined #lisp
<beach>
Good morning everyone!
Josh_2 has quit [Ping timeout: 260 seconds]
<phantomics>
Morning beach
Alfr is now known as Guest1969
Alfr has joined #lisp
Guest1969 has quit [Ping timeout: 260 seconds]
zaquest has quit [Quit: Leaving]
zaquest has joined #lisp
<purpleLizard>
does the size of the lisp language ever bother anyone?
<beach>
Not really. I like that it's tiny compared to (say) C++.
<moon-child>
that depends on how you measure. Fewer primitives, maybe, but overall I think the two are a similar size
<ex_nihilo>
compared with, e.g., C++, Common Lisp is pretty consistent
<beach>
Common Lisp is mostly standard library functions. Not a collection of special cases for syntax.
<beach>
purpleLizard: Anyway, that's a pretty strange question. What if it did bother someone?
<purpleLizard>
I guess you would adjust to it
<purpleLizard>
but it irks me
<beach>
So it wasn't really a question.
<ex_nihilo>
purpleLizard: even using a smallish language like C, you end up using libraries to get things done, and that means learning a lot more than the base language, and dealing with a lot of api inconsistencies; you just learn what you need and get on with things
<beach>
purpleLizard: The smaller the language is, the more you have to write yourself or rely on third-party contributions that people may not agree upon.
<edgar-rft>
I think C plus it's standard library is bigger than Common Lisp.
<beach>
ex_nihilo: Heh. Seems we agree.
<edgar-rft>
*its not it's :-)
<purpleLizard>
ok, it seems I was mistaken then
<purpleLizard>
I care more about specs that say how the language works, not library functions, that's ok
<beach>
purpleLizard: Common Lisp has a very simple core compared to most languages. It is much easier to learn because of that.
<ex_nihilo>
beach: quite so! but I don't think that it is really a controversial position ;)
<beach>
ex_nihilo: Right. That fact doesn't mean it can't be debated on #lisp.
<ex_nihilo>
beach: so very true....
<beach>
purpleLizard: It seems you are new here. If you are having problems learning Common Lisp, then just ask. We will show you how simple things are, given the semantics of Common Lisp.
<purpleLizard>
I was looking for a language to write a compiler in, and also fit my peculiarites. No problems yet
<beach>
Common Lisp is ideal for writing compilers.
<beach>
CLOS is the only sane object system I know of.
<beach>
... and I wouldn't try to write a compiler without CLOS.
emma is now known as em
<purpleLizard>
interesting, didn't think the object system would come up here, maybe for games :P
<beach>
Maybe that's because you haven't looked into CLOS yet?
<purpleLizard>
I know that it's an object system, that's about it
<beach>
Also, except for very few other languages (like PL/I for instance), Common Lisp has the only sane condition system around. Exceptions in other languages just don't cut it, as phoe's book clearly explains.
<beach>
And in a compiler, you would want to capture syntactic commonalities in the form of macros, and, again, Common Lisp has the only (possibly with a few exceptions) sane macro system around.
<beach>
Because of the macro system, Common Lisp programmers don't have to wait for a new version of the standard in order to have some new desired feature. That also means that the standard is stable, so that your programs will mean the same in the future as they do now.
<beach>
And for a compiler, things like exact rational arithmetic mean that you can make it behave in the same way no matter what platform it executes on.
<beach>
As heisig pointed out yesterday, that's an important feature of a compiler.
<ex_nihilo>
beach makes a lot of good points; I would add that, while I really like Scheme and Racket, too, I find that Common Lisp just feels better when working interactively in a decent environment (which is emacs/Slime for me)
<ex_nihilo>
geiser works pretty well with Chez Scheme or MIT Scheme, and racket-mode works pretty well with Racket, but both feel clunky compared with CL and Slime
<beach>
Interesting.
<beach>
I think the most significant weakness of Common Lisp is our mediocre tools. But you are saying that Scheme tools are even worse?
<purpleLizard>
I arrived at common lisp because I didn't really find what I liked in scheme ... for various reasons
<ex_nihilo>
beach: I guess I am saying that ;)
<ex_nihilo>
beach: with Scheme I have had a lot more problems with crashing the repl, for example
<beach>
Hmm.
<ex_nihilo>
beach: I have heard more than once that the state of CL tooling used to be much better; are there any particular grievances that you have wrt mediocre tools?
aartaka has joined #lisp
<beach>
None of the free Common Lisp implementations provides a real debugger where you can set breakpoints, step, and inspect variables. Staring at a backtrace when things go wrong is not what I call a "debugger", as my paper explains: http://metamodular.com/SICL/sicl-debugging.pdf
<beach>
And there are many situations where the output of the compiler is not clickable, so you end up looking at compiler messages and trying to match them to the source code manually.
<beach>
But we are working on improving the situation. We just need a few more years. :)
<purpleLizard>
neat project
<beach>
Thanks.
_whitelogger has joined #lisp
pankajsg has quit [Ping timeout: 265 seconds]
ech_ has quit [Ping timeout: 268 seconds]
Nilby has joined #lisp
<White_Flame>
ex_nihilo: the state of CL tooling when there were major commercial offerings of Lisp OSes is probably when they were better
<White_Flame>
emacs is basically a pale imitation of a lisp os (and elisp is a pale imitation of CL)
<White_Flame>
but, we're not yet back to full daily driver lisp OSes
<White_Flame>
until then, emacs/slime is pretty much the premiere "IDE" for CL development
mindCrime has quit [Ping timeout: 240 seconds]
thmprover has quit [Quit: And Let's Away, to Part the Glories of This Happy Day]
<beach>
And it won't have to be a bootable OS to be useful. An IDE with most of the good features would be a great step in the right direction.
_z_ has joined #lisp
_z_ has left #lisp [#lisp]
<moon-child>
the next real lisp os will probably run under linux as pid 1, at least to start
mindCrime has joined #lisp
<moon-child>
(maybe not probably. But I certainly think it's reasonably likely)
<purpleLizard>
beach: what features do lisp programmers want in an IDE?
<purpleLizard>
apart from the debugger ;)
toop has quit [Ping timeout: 260 seconds]
_z_ has joined #lisp
<_z_>
is there a dialect of lisp that doesnt require the lisp virtual machine
<beach>
purpleLizard: Most Lisp programmers seem to think that Emacs+SLIME is the best IDE every, no matter the language.
karlosz has joined #lisp
<beach>
_z_: Not sure what that means, but this channel is specifically dedicated to Common Lisp, so other dialects are off topic. It is not even widely agreed upon what would qualify as a Lisp dialect.
<beach>
_z_: Every language needs a "run time". For C, that run time is Unix. Languages that diverge a lot from C need their own. For instance, you would absolutely need a garbage collector.
<purpleLizard>
I like the idea behind emacs, but I found it pretty meh
<purpleLizard>
windows also has a C runtime
<_z_>
C has the standard library yes
<beach>
When I say "Unix" I include Windows. They are basically the same.
<_z_>
but the standard library is not always unix specific
<_z_>
k
<_z_>
you can use C without the standard library too however
<beach>
_z_: That's very doubtful. You would need to rely on unspecified features that are defined by the particular compiler you use.
<_z_>
the standard library does not define the entire language
<_z_>
the features are the keywords and syntax really
<moon-child>
beach: the standard specifies a freestanding environment
<_z_>
I ask this because I was wondering how genera and mezzano work
<beach>
moon-child: Oh, OK. That's new since I last looked.
<beach>
_z_: What do you mean?
<_z_>
because how can it work when lisp requires the lisp VM
<beach>
_z_: There is nothing special about the way they work, as far as I am concerned.
<_z_>
common lisp*
<beach>
_z_: What is this Lisp VM you are talking about? There is no such thing in the Common Lisp standard.
<beach>
_z_: Common Lisp runs fine on stock hardware these days. Most modern implementations compile to native code. For a bootable OS, you just need the code that the processor requires in order to start running.
<_z_>
cool
xanderle_ has joined #lisp
<beach>
It's amazing how people can be so simultaneously opinionated and ignorant as Fralley shows here.
xanderle has quit [Ping timeout: 260 seconds]
<Nilby>
Some people have a habit/career of writing complete bullshit on quora.
<beach>
Oh. I see. Never heard of Quora before. Thanks for letting me know I can safely ignore it.
<_z_>
yeah im sick of quora spamming my gmail
<beach>
_z_: So was that the trouble you had with understanding? You didn't know that Common Lisp compilers generate native code?
Oladon has quit [Quit: Leaving.]
<_z_>
I knew lisp compiled to assembler
<_z_>
yes
<_z_>
but I thought you needed to run lisp in a VM and so an "Real" OS wouldnt be possible
karlosz has joined #lisp
<beach>
Actually, a typical Common Lisp compiler doesn't generate traditional assembly code. They might have some internal representation of machine instructions instead.
<beach>
I am not sure what such a "VM" would consist of and that couldn't also be written in Common Lisp.
phantomics has quit [Remote host closed the connection]
elflng has quit [Ping timeout: 245 seconds]
phantomics has joined #lisp
<_z_>
I heard theres embedded lisp
<beach>
Are you referring to ECL?
<beach>
It was designed to be embeddable in applications written in C. But jackdaniel will know more.
marusich has joined #lisp
luni has joined #lisp
purpleLizard has quit [Quit: Konversation terminated!]
__jrjsmrtn__ has joined #lisp
karlosz has quit [Quit: karlosz]
_jrjsmrtn has quit [Ping timeout: 245 seconds]
flazh has quit [Read error: Connection reset by peer]
flazh has joined #lisp
orivej has joined #lisp
bitmapper has quit [Quit: Connection closed for inactivity]
waleee-cl has quit [Quit: Connection closed for inactivity]
elflng has joined #lisp
tiwEllien has joined #lisp
ex_nihilo has quit [Remote host closed the connection]
tiwEllien has quit [Ping timeout: 260 seconds]
tiwEllien has joined #lisp
karlosz has joined #lisp
charles` has quit [Ping timeout: 276 seconds]
mindCrime_ has joined #lisp
mindCrime has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 276 seconds]
mindCrime_ has quit [Ping timeout: 240 seconds]
epony has quit [Remote host closed the connection]
ex_nihilo has joined #lisp
JokerAscensionEx has quit [Read error: Connection reset by peer]
iskander has quit [Quit: bye]
JokerAscensionEx has joined #lisp
rgherdt has joined #lisp
epony has joined #lisp
<jackdaniel>
_z_: this short paper may be a good reference: http://pages.di.unipi.it/attardi/Paper/LUV94.pdf -- ecl doesn't work exactly like that anymore, but this gives a good overview of some concepts
<jackdaniel>
most notably blending different runtimes in a single common runtime (based on C)
tiwEllien has quit [Ping timeout: 240 seconds]
tiwEllien has joined #lisp
froggey has quit [Ping timeout: 265 seconds]
froggey has joined #lisp
surabax has joined #lisp
iskander has joined #lisp
karlosz has quit [Quit: karlosz]
luni has quit [Quit: Connection closed]
_whitelogger has joined #lisp
mindCrime_ has joined #lisp
anticrisis has quit [Read error: Connection reset by peer]
luni has joined #lisp
hendursa1 has joined #lisp
hendursaga has quit [Ping timeout: 268 seconds]
jprajzne has joined #lisp
rtypo has joined #lisp
ex_nihilo has quit [Quit: Leaving]
contrapunctus has quit [Ping timeout: 260 seconds]
zupss has joined #lisp
iskander has quit [Quit: bye]
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 265 seconds]
ewd has joined #lisp
kopiyka has quit [Remote host closed the connection]
aartaka has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
Noisytoot has quit [Ping timeout: 260 seconds]
ewd has joined #lisp
aindilis has joined #lisp
Noisytoot has joined #lisp
heisig has quit [Quit: Leaving]
shka_ has joined #lisp
hiroaki__ has joined #lisp
nicktick has quit [Ping timeout: 260 seconds]
johannes_ has joined #lisp
nicktick has joined #lisp
Noisytoot has quit [Ping timeout: 245 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
Noisytoot has joined #lisp
gitgood has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
edgar-rft has quit [Quit: Leaving]
Noisytoot has quit [Remote host closed the connection]
Noisytoot has joined #lisp
ljavorsk has joined #lisp
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
rogersm has joined #lisp
ljavorsk has quit [Ping timeout: 245 seconds]
iskander has quit [Quit: bye]
contrapunctus has quit [Ping timeout: 260 seconds]
mrchampion has quit [Ping timeout: 264 seconds]
<mfiano>
Ran my lines of code report script in the wrong directory. Wanted to check on my project, but ran it in the parent CL code directory. Wow, never knew I wrote 803kloc :)
bitmapper has joined #lisp
tiwEllien has quit [Ping timeout: 240 seconds]
tiwEllien has joined #lisp
supercoven has joined #lisp
ex_nihilo has joined #lisp
ex_nihilo has quit [Client Quit]
<Nilby>
That's an awful lot of Lisp code. Did you really count that right?
orivej has quit [Ping timeout: 264 seconds]
rogersm has quit [Remote host closed the connection]
<mfiano>
Yeah, I'm afraid to know what the count is after macro expansions for macros I have wrote. This is the effect of 12 hours a day of 15 years though.
<Nilby>
That's nearly 1/6 of everything in quicklisp.
rogersm has joined #lisp
tiwEllien has quit [Ping timeout: 272 seconds]
Trieste has quit [Ping timeout: 264 seconds]
<_death>
does it contain tables of data?
tiwEllien has joined #lisp
galex-713 has quit [Ping timeout: 246 seconds]
<mfiano>
_death: For the most part, just that glsl-metadata project I showed you
<mfiano>
My game math library is roughly 15kloc, which is included in Quicklisp, so subtract that and others from that 1/6 figure
<Nilby>
Also, for most people the code checked out in the repo is only the code that survived. There's usually a lot of dead code in the git history.
<mfiano>
90% of my code was never published to Quicklisp or in any public repository
* Nilby
is feeling the true weight of all the unpublished and gone code.
__jrjsmrtn__ has quit [Ping timeout: 276 seconds]
__jrjsmrtn__ has joined #lisp
long4mud has quit [Quit: WeeChat 3.0.1]
eoyath has quit [Quit: Connection closed for inactivity]
rogersm has quit [Remote host closed the connection]
galex-713 has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 260 seconds]
__jrjsmrtn__ has joined #lisp
add^_ has joined #lisp
cage_ has quit [Quit: Leaving]
cage_ has joined #lisp
ech has joined #lisp
mrchampion has joined #lisp
ljavorsk has joined #lisp
massma has joined #lisp
tiwEllien has quit [Ping timeout: 264 seconds]
tiwEllien has joined #lisp
orivej has joined #lisp
Lycurgus has joined #lisp
iskander has joined #lisp
kenran has quit [Ping timeout: 260 seconds]
galex-713 has quit [Ping timeout: 246 seconds]
gitgood has quit [Read error: Connection reset by peer]
johannes_ has joined #lisp
Trieste has joined #lisp
montxero has joined #lisp
dddddd has quit [Ping timeout: 256 seconds]
Lycurgus has quit [Quit: Exeunt]
kevingal has joined #lisp
Fare has joined #lisp
dddddd has joined #lisp
iskander has quit [Quit: bye]
_z_ has quit [Ping timeout: 265 seconds]
jonatack has joined #lisp
ljavorsk has quit [Ping timeout: 245 seconds]
kenran has quit [Quit: leaving]
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 276 seconds]
tiwEllien has quit [Ping timeout: 260 seconds]
ym has joined #lisp
tiwEllien has joined #lisp
ym is now known as Guest58262
Guest58262 has quit [Client Quit]
ewd has quit [Remote host closed the connection]
notzmv has quit [Ping timeout: 264 seconds]
kini has quit [Quit: bye]
waleee-cl has joined #lisp
kini has joined #lisp
rogersm has joined #lisp
<em>
I'm no expert in coding AT ALL. I'm barely a hobbyist and I struggle a lot, but I think it's crazy to poke fun at lisp for all its parentheses when other languages end with stuff that looks like this: ;});});
<beach>
It is. But then, people need to defend their (often wrong) choices in life, or else their heads will blow up.
curtosis has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
<Alfr>
em, likely the reason why they want to close pending delimiters on separate lines.
jerme_ has quit [*.net *.split]
terpri_ has quit [*.net *.split]
luna_is_here has quit [*.net *.split]
madand has quit [*.net *.split]
Oddity- has quit [*.net *.split]
bjorkintosh has quit [*.net *.split]
cpt_nemo has quit [*.net *.split]
lottaquestions_ has quit [*.net *.split]
gko has quit [*.net *.split]
eschatologist has quit [*.net *.split]
sgithens has quit [*.net *.split]
jonathan- has quit [*.net *.split]
avicenna has quit [*.net *.split]
housel has quit [*.net *.split]
summerisle has quit [*.net *.split]
greaser|q has quit [*.net *.split]
drdo has quit [*.net *.split]
ilmu has quit [*.net *.split]
johs has quit [*.net *.split]
Patzy has quit [*.net *.split]
gendl has quit [*.net *.split]
mpontillo has quit [*.net *.split]
ffwacom has quit [*.net *.split]
chewbranca has quit [*.net *.split]
lukego has quit [*.net *.split]
voidlily has quit [*.net *.split]
p_l has quit [*.net *.split]
HDurer has quit [*.net *.split]
seisatsu_ has quit [*.net *.split]
spacebat2 has quit [*.net *.split]
physpi has quit [*.net *.split]
ck_ has quit [*.net *.split]
femi has quit [*.net *.split]
bjorkintosh has joined #lisp
ck_ has joined #lisp
madand has joined #lisp
HDurer has joined #lisp
eschatologist has joined #lisp
ilmu has joined #lisp
terpri_ has joined #lisp
jonathan- has joined #lisp
sgithens has joined #lisp
p_l has joined #lisp
mpontillo has joined #lisp
ffwacom has joined #lisp
chewbranca has joined #lisp
drdo has joined #lisp
seisatsu has joined #lisp
thmprover has joined #lisp
<Nilby>
Making fun of Lisp for parentheses seem like making fun of an elephant for it's trunk. It looks funnny, but it's an awesome feature. One could just make of it being old and having funny names, which is legit.
gendl has joined #lisp
luna_is_here has joined #lisp
physpi has joined #lisp
lukego has joined #lisp
avicenna has joined #lisp
johs has joined #lisp
gko has joined #lisp
Patzy has joined #lisp
spacebat2 has joined #lisp
voidlily has joined #lisp
greaser|q has joined #lisp
jerme_ has joined #lisp
housel has joined #lisp
Oddity has joined #lisp
lottaquestions_ has joined #lisp
femi has joined #lisp
even4void[m] has quit [Ping timeout: 240 seconds]
Patzy is now known as Guest19918
infra_red[m] has quit [Ping timeout: 258 seconds]
theothornhill[m] has quit [Ping timeout: 268 seconds]
summerisle has joined #lisp
cloudy[m] has quit [Ping timeout: 240 seconds]
cpt_nemo has joined #lisp
ms[m] has quit [Ping timeout: 246 seconds]
susam has quit [Ping timeout: 240 seconds]
iskander has joined #lisp
jdormit has quit [Ping timeout: 265 seconds]
sepanko_ has quit [Ping timeout: 268 seconds]
arichiardi[m] has quit [Ping timeout: 268 seconds]
ey[m] has quit [Ping timeout: 258 seconds]
loke[m] has quit [Ping timeout: 246 seconds]
quanta[m] has quit [Ping timeout: 240 seconds]
deselby has quit [Ping timeout: 258 seconds]
posthuman_egrego has quit [Ping timeout: 240 seconds]
katco has quit [Ping timeout: 240 seconds]
MrtnDk[m] has quit [Ping timeout: 258 seconds]
ThaEwat has quit [Ping timeout: 240 seconds]
harlchen[m] has quit [Ping timeout: 265 seconds]
Gnuxie[m] has quit [Ping timeout: 265 seconds]
etimmons has quit [Ping timeout: 265 seconds]
kreyren has quit [Ping timeout: 240 seconds]
dieggsy has quit [Ping timeout: 268 seconds]
dmiles[m] has quit [Ping timeout: 260 seconds]
<thmprover>
OK, I'm arguing with myself about literate programming in Common Lisp. I'm writing some educational numerical analysis, and I'd like to explain how to derive the code from mathematics. There are two ways I can see how to write "literate lisp": (1) like vanilla literate programming (as code snippets in a PDF surrounded by commentary), (2) encoding the comments and derivations as S-expressions.
Jeanne-Kamikaze has joined #lisp
<thmprover>
I'm uncertain about the second approach, but it feels more "Lispy" to me.
equwal has quit [Ping timeout: 268 seconds]
contrapunctus has joined #lisp
<Nilby>
I'd do the second way, but it seems like it could be distracting from writing to set up. Anyway there's things like cl-pdf, ccldoc, or CommonDoc/parenml. But to a fool like me, math makes more sense in Lisp than in math notation.
even4void[m] has joined #lisp
infra_red[m] has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
ex_nihilo has joined #lisp
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
anticrisis has joined #lisp
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<jackdaniel>
this question is not comprehensible
<Josh_2>
disregard that one, I've got a new one, hopefully comprehensible :P
<Josh_2>
well
<Josh_2>
I just had to use eval to get rid of a ' so that I get consistent output between a list generated like `( ..) and a list generated like `'(.. )
<Josh_2>
not sure if It's appropriate or not
<aeth>
no
<aeth>
''(foo) is just sugar for (quote (quote foo))
<aeth>
So you can parse it like a list, you don't need to eval it
<Josh_2>
well I tried just using (rest list) as the arg but the returned results werent consistent
<Josh_2>
when I get rid of eval I get varying results between the `( ) and `'( ) lists, I tried using something like (rest list) when (first list) was eql to 'quote
<Josh_2>
I'm basically tryna write a compiler-macro to automatically compile templates when they are constants ie `'( ) lists
<jackdaniel>
when you have ''(a b c) it is equivalent to (quote (quote (a b c))
<jackdaniel>
)
<jackdaniel>
so however you want to access the list, you should start from this representation
<jackdaniel>
(cdr (quote (quote (a b c)))) ;-> (quote (a b c))
<jackdaniel>
etc
<Josh_2>
yes but I don't think I'm using ''
<jackdaniel>
I forgot a quote there
<Josh_2>
I'm using `'()
<jackdaniel>
`'() is equivalent to (list '(quote nil)), so basically (quote (quote nil))
<Josh_2>
ah I see
<aeth>
I think this is the test for quoted and you then separately have to test the cadr if you want its contents to be something specific: (defun quoted-p (form) (and (listp form) (eql (car form) 'quote) (endp (cddr form))))
<jackdaniel>
its late, I might have forgot some parenthesis, but I hope you will figure this out
<aeth>
Note, though that (quoted-p ''a) and (quoted-p `'a) would be T but (quoted-p 'a) would not because the REPL is evaluating the 'a input once
<aeth>
So it's no longer quoted at runtime.
<aeth>
and (quoted-p '`a) would also be false even though quasiquoting like that (no unquoting) is effectively the same as quoting.
<Josh_2>
I'm not sure why I have to use (first ..) to get a result equiv to an input that is unquoted
<aeth>
I guess if you want it to match in style you would replace CAR with FIRSt and CDDR with (rest (rest ...))
<aeth>
(in my function)
anticrisis has quit [Read error: Connection reset by peer]
<Josh_2>
Good point
<Josh_2>
Seems to be working now, thanks!
<aeth>
I personally tend to use the CXRs for syntax where DESTRUCTURING-BIND isn't desirable (it usually is, since errors are good, but in this case, it would error instead of returning NIL)
<aeth>
Mainly because working with syntax tends to have you wind up with cadr, cddr, etc.
<Josh_2>
Now my compiler-macro should automatically compile templates when they start with '
anticrisis has joined #lisp
jonatack_ has joined #lisp
anticrisis has quit [Quit: Leaving]
jonatack has quit [Ping timeout: 245 seconds]
<mfiano>
''(foo) is not (quote (quote foo))
massma has quit [Quit: rcirc on GNU Emacs 26.1]
<jackdaniel>
yes, it is (quote foo) ; for my defense, I've added a disclaimer that it is late :)
iskander has quit [Quit: bye]
anticrisis has joined #lisp
rgherdt has quit [Remote host closed the connection]