<PuercoPop>
no-defun-allowed: I don't see (nth-value 0 ), but I'm guessing the extra (values ) is also a way to 'convince' the compiler that there is only one value
<no-defun-allowed>
yeah, those are equivalent afaik
<Bike>
yes.
<Bike>
a call to values is more common ime.
<Bike>
they are semantically identical, since VALUES is just a normal function and its argument forms have values past the primary discarded.
orivej has quit [Ping timeout: 250 seconds]
arescorpio has quit [Remote host closed the connection]
jack_rabbit has joined #lisp
Kaisyu7 has joined #lisp
smokeink has quit [Quit: Leaving]
arescorpio has joined #lisp
arescorpio has quit [Max SendQ exceeded]
fitzsim has quit [Remote host closed the connection]
fitzsim has joined #lisp
jack_rabbit has quit [Ping timeout: 268 seconds]
ealfonso has joined #lisp
jack_rabbit has joined #lisp
deba5e12 has quit [Quit: WeeChat 2.1]
esrse has joined #lisp
jack_rabbit has quit [Ping timeout: 268 seconds]
Kundry_Wag has joined #lisp
ealfonso has quit [Ping timeout: 240 seconds]
iAmDecim has joined #lisp
dale has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
Kundry_Wag has quit [Ping timeout: 268 seconds]
dddddd has quit [Remote host closed the connection]
wusticality has joined #lisp
esper0s has joined #lisp
chens has quit [Remote host closed the connection]
wusticality has quit [Ping timeout: 250 seconds]
fikka has joined #lisp
nicdev has joined #lisp
terminal625 has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
mejja has quit [Quit: mejja]
terminal625 has quit [Client Quit]
<beach>
Good morning everyone!
anamorphic has joined #lisp
<aja042>
beach: thanks, that made me smile. It's very very dark here right now.
<beach>
I know what you mean. But in two weeks it turns again, provided you are on the northern hemisphere, of course.
dacoda has joined #lisp
<esper0s>
ah, one of the reason i dont like winter is that
<esper0s>
it is so damn depressive
<no-defun-allowed>
hopefully summers are milder in the northern hemisphere
<no-defun-allowed>
it's 38 degrees right now
<esper0s>
i live in england i know haha, i do enjoy the summers here its true
<esper0s>
but it does not compare to greece
eminhi has joined #lisp
<beach>
How about we try to move to an on-topic discussion?
<esper0s>
the police is here
<beach>
If anyone is good with LaTeX, I would like to see the dpANS document(s) converted to a single LaTeX file. Any takers?
<no-defun-allowed>
i'm okay at LaTeX but probably not good
<beach>
esper0s: It is just that there is so much to do in the Common Lisp world that I am trying to direct attention to it, in the hopes that some of it will get done by someone other than me.
<esper0s>
beach: thats nice :) thank you for your work.
* beach
blushes.
<beach>
Now, if we can turn the dpANS into a LaTeX document, we could slowly turn it into a specification of WSCL (which means Well Specified Common Lisp, and is pronounced like "whistle").
dacoda has quit [Remote host closed the connection]
<beach>
I am not complaining though. Lots of good work is getting done on McCLIM on a daily basis by jackdaniel, slyrus, loke, and several others. And I am convinced that McCLIM is going to be an essential part of any end-user application written in only Common Lisp.
q-u-a-n has quit [Ping timeout: 244 seconds]
dacoda has joined #lisp
wusticality has joined #lisp
vlatkoB has joined #lisp
CCDell_ has joined #lisp
wusticality has quit [Ping timeout: 250 seconds]
dacoda has quit [Ping timeout: 264 seconds]
Necktwi_ has joined #lisp
Necktwi has quit [Remote host closed the connection]
<rumbler31>
really?
fikka has joined #lisp
aja042 has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 245 seconds]
<beach>
Yes.
<no-defun-allowed>
erm, i changed phone and my 2fa codes aren't working for gitlab.c-l.net, who should i contact about that?
xkapastel has quit [Quit: Connection closed for inactivity]
wigust has joined #lisp
sauvin has joined #lisp
Bike has quit [Quit: Lost terminal]
<beach>
admin@common-lisp.net
<no-defun-allowed>
right, thanks
CCDell_ has quit [Quit: Leaving]
Kundry_Wag has joined #lisp
pierpal has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
Inline has quit [Quit: Leaving]
anamorphic has quit [Ping timeout: 250 seconds]
<slyrus>
beach: why a single document?
elderK has quit [Quit: WeeChat 1.9]
Elephant454 has joined #lisp
wusticality has joined #lisp
makomo has joined #lisp
drewes has joined #lisp
<beach>
slyrus: So that I can do citations, cross references, etc.
<slyrus>
Hrm... That's an awfully big file. Seems to me the source should be lisp s-expressions (in one or many files) from which the LaTeX is generated.
wusticality has quit [Ping timeout: 240 seconds]
<beach>
The source code for the dpANS is already TeX (but not LaTeX). Converting it to something else would be an even harder task.
<beach>
Plus, then we get to debate all over again exactly what the source format would be.
<no-defun-allowed>
parsing TeX shouldn't be too hard, should it?
<beach>
And, as usual, we won't get any real work done.
<beach>
no-defun-allowed: It is not trivial at all, given the macros and such.
<no-defun-allowed>
ah yeah, damn
<no-defun-allowed>
but since there isn't anything too modern like TikZ, i thought it'd be like collecting commands and bracketed things
<beach>
slyrus: Oh, I am sorry. I didn't mean a single LaTeX source file. I meant a single LaTeX document.
<beach>
It can be spread over several files, of course.
<slyrus>
Ah, OK, thanks.
<beach>
slyrus: Currently, each chapter is a separate document, which makes things like cross referencing and citations hard.
ebrasca has joined #lisp
<ebrasca>
Hi
buffergn0me has joined #lisp
<beach>
Hello ebrasca.
pierpal has quit [Ping timeout: 250 seconds]
rumbler31 has quit [Remote host closed the connection]
drewes has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Demosthenex has quit [Ping timeout: 240 seconds]
Demosthenex has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 272 seconds]
igemnace has joined #lisp
yvy has joined #lisp
pierpal has joined #lisp
nirved is now known as Guest19490
nirved has joined #lisp
Guest19490 has quit [Ping timeout: 252 seconds]
meepdeew has quit [Remote host closed the connection]
mange has quit [Remote host closed the connection]
esrse has quit [Ping timeout: 240 seconds]
yvy has quit [Read error: Connection reset by peer]
schweers has joined #lisp
ggole has joined #lisp
Kundry_Wag has joined #lisp
varjag has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
angavrilov has joined #lisp
shrdlu68 has joined #lisp
dacoda has joined #lisp
dacoda has quit [Remote host closed the connection]
dacoda has joined #lisp
dacoda has quit [Remote host closed the connection]
dacoda has joined #lisp
dacoda has quit [Remote host closed the connection]
dacoda has joined #lisp
sjl has quit [Ping timeout: 252 seconds]
drewes has joined #lisp
elfmacs has joined #lisp
shrdlu68 has quit [Ping timeout: 250 seconds]
dacoda has quit [Remote host closed the connection]
dacoda has joined #lisp
<dacoda>
:w
<no-defun-allowed>
ew, vi
varjag has quit [Ping timeout: 246 seconds]
<no-defun-allowed>
i got my bordeaux-fft song transcribing program to work somewhat
shifty has quit [Ping timeout: 240 seconds]
wusticality has joined #lisp
asarch has joined #lisp
wusticality has quit [Ping timeout: 246 seconds]
gxt has quit [Quit: WeeChat 2.3]
xkapastel has joined #lisp
<asarch>
One stupid question: is, the binary from SBCL, fast enough as any binary from any C/C++ compiler is?
<jdz>
Yes, it's fast enough.
<asarch>
Thank you jdz!
<asarch>
Thank you very much! :-)
<asarch>
How would you fetch a file from Internet using SBCL?
<jdz>
Using drakma.
<asarch>
Thank you very much once again jdz :-)
<schweers>
Yesterday I learned that binaries produced with sbcl can startup pretty quickly.
<no-defun-allowed>
yep, they can
yvy has joined #lisp
<schweers>
Well, they also do, at least in my case :)
Elephant454 has quit [Quit: ERC (IRC client for Emacs 26.1)]
<no-defun-allowed>
the more i look at this cover generated by b-fft, the more i like it
heisig has joined #lisp
<no-defun-allowed>
no matter how i put it against the original, it remains consistent
<no-defun-allowed>
actually it stinks after the first solo
fikka has joined #lisp
dacoda has quit [Ping timeout: 268 seconds]
Guest14049 has joined #lisp
goreye has joined #lisp
<aeth>
asarch: You can expect a 3x to 5x slowdown at the worst case, probably for code that a C compiler would heavily optimize, e.g. vectorized code. You're also going to use a lot more RAM (at least 10x as much) and you have different performance tradeoffs with a garbage collector active.
cmjones has quit [Ping timeout: 268 seconds]
cmjones has joined #lisp
<aeth>
(Obviously using more RAM won't be 10x as much if you e.g. load a 1 GB PNG file or something. It's not constantly 10x as much.)
<asarch>
Thank you aeth
<asarch>
Thank you very much for the details :-)
<asarch>
See you later
<asarch>
Have a nice day :-9
<asarch>
:-)
<aeth>
bye
asarch has quit [Quit: Leaving]
mathrick has quit [Ping timeout: 246 seconds]
goreye has quit [Quit: ERC (IRC client for Emacs 26.1)]
goreye has joined #lisp
orivej has joined #lisp
yvy has quit [Read error: Connection reset by peer]
nydel has joined #lisp
jochens has joined #lisp
dmitigr has joined #lisp
<dmitigr>
hi all
<no-defun-allowed>
hi dmitigr
<dmitigr>
Is it possible to specialize a generic (define a method) in the package other than where the generic is defined?
<no-defun-allowed>
yep, as long as you can access the symbol
<dmitigr>
no-defun-allowed: how can I do it, please?
varjag has joined #lisp
<no-defun-allowed>
say you're me writing magrathea and you have a method you're specializing on magrathea-acceptor for hunchentoot:acceptor-dispatch-request
<dmitigr>
But you're specializing acceptor-dispatch-request in the "hunchentoot" package.
<dmitigr>
I'm asking about the way to specialize it in the another one, for example, "cl-user".
Mr-Potter_ has joined #lisp
<dmitigr>
Or it is a nonsence?
<schweers>
dmitigr: the code no-defun-allowed just pasted can be executed from any package. that’s the point. He is defining a method (from, say, CL-USER) on a generic in hunchentoot.
<no-defun-allowed>
well, if you're in package A and you're trying to specialise package B's FOO, you'd defmethod B:FOO
<no-defun-allowed>
you're still doing it from A but it affects the gf in B
<no-defun-allowed>
also, s/she/he thanks
<no-defun-allowed>
dammit, wrong way around. s/he/she
<dmitigr>
schweers: execute from != define in
themsay has quit [Ping timeout: 246 seconds]
<schweers>
no-defun-allowed: sorry about the wrong pronoun, hard to tell on IRC.
<schweers>
mathrick has joined #lisp
<no-defun-allowed>
np, happens a lot
<no-defun-allowed>
you are defining a method in a package other than where defgeneric happened
<dmitigr>
no-defun-allowed: so, the specializations will go to the package where the generic is defined?
<no-defun-allowed>
yes, as long as you use the symbol from that package
<aeth>
Try it yourself. Write a name generic. As in (defgeneric name (object))
<no-defun-allowed>
(note A:FOO /= B:FOO, so you'd need to use-package B which i've heard is bad nowadays or write B:FOO)
Necktwi_ has quit [Quit: leaving]
<dmitigr>
schweers: (defmethod A::foo ...) says : "define a method foo of A in A" or "define a method foo of A in B" ?
<schweers>
I think you are confusing something. The symbol used to name a generic function or a method is what belongs to a package. Neither the GF, not the method do. They have nothing to do with packages.
sjl has joined #lisp
<schweers>
so if you’d call the GF as A:foo, you can also define a method as (defmethod A:foo).
hhdave has joined #lisp
Necktwi has joined #lisp
hhdave_ has joined #lisp
hhdave has quit [Ping timeout: 250 seconds]
hhdave_ is now known as hhdave
<beach>
dmitigr: It helps to understand what packages are about. They contain no definitions, no generic function, no methods, no classes. Only symbols.
<beach>
dmitigr: The name of a generic function is a symbol.
<beach>
dmitigr: If you want to write a method on such a generic function using DEFMETHOD, you must use the correct name of the generic function, so you have to use the same symbol that was used in the DEFGENERIC form.
mathrick has quit [Ping timeout: 250 seconds]
Kundry_Wag has joined #lisp
<dmitigr>
beach: thank you!
<beach>
Sure.
<dmitigr>
beach: your definitions is what I'm looking for.
Kundry_Wag has quit [Ping timeout: 250 seconds]
<dmitigr>
schweers: yes, I'm was confused by C++'s namespaces.
<schweers>
dmitigr: I think most of us had to unlearn some weird patterns from other languages.
<aeth>
CL packages are pretty unusual
<aeth>
They're just namespaces for symbols.
<schweers>
Yeah, I don’t know of any other language that does this. I must say that I really like this approach.
<schweers>
Although I would like package local nicknames to be in the standard :/
slyrus has quit [Ping timeout: 244 seconds]
slyrus1 is now known as slyrus
slyrus1 has joined #lisp
moei has joined #lisp
goreye has quit [Ping timeout: 272 seconds]
fikka has quit [Ping timeout: 250 seconds]
Essadon has joined #lisp
iAmDecim has quit [Ping timeout: 252 seconds]
frgo has quit [Remote host closed the connection]
goreye has joined #lisp
fikka has joined #lisp
Bronsa has quit [Remote host closed the connection]
<Odin->
Lisp's direct exposure of symbols is pretty unusual in general.
shakdwipeea has joined #lisp
<Odin->
That level of indirection isn't usually visible to the programmer.
<ogamita>
Even to scheme programmers :-)
* Odin-
notes that this peculiarity is one of the things on full display in the Lisp 1.5 manual he got somewhere.
shrdlu68 has joined #lisp
dtornabene has joined #lisp
<ecraven>
didn't javascript gain symbols recently?
<ecraven>
ruby I think has them too?
<ecraven>
of course, it all depends by what you actually mean by "symbol" ;
frgo has joined #lisp
<Odin->
ecraven: JavaScript did get them recently, but they're an extra. Don't know Ruby.
<Odin->
But JavaScript isn't exactly what you'd call normal either. :)
<White_Flame>
Symbol("foo") is a heck of a lot different than var foo;
fikka has quit [Ping timeout: 246 seconds]
fikka has joined #lisp
<Odin->
It seems to me like Lisp's use of symbols stems from the way eval and apply were the basis of defining the language.
fikka has quit [Ping timeout: 240 seconds]
ebrasca has quit [Remote host closed the connection]
eminhi has quit [Quit: leaving]
<jackdaniel>
isn't it the other way around (the symbolic computation thingy?)
flazh has quit [Ping timeout: 268 seconds]
scymtym has quit [Remote host closed the connection]
vlatkoB has quit [Remote host closed the connection]
vlatkoB has joined #lisp
scymtym has joined #lisp
<dtornabene>
hey all, quicklisp question
<dtornabene>
I'm getting weird compilation errors from ironclad, I see that my installed release is one dot version behind, whats the best way to update it?
<jackdaniel>
compilation errors from ironclad may be a result of (i.e) changing your implementation internals
<jackdaniel>
I think there was a case like that lately
<dtornabene>
not sure I follow
<dtornabene>
sorry
<jackdaniel>
please try to update your sbcl and see, if the newest ironclad compiles fine with it
<dtornabene>
ahh
<dtornabene>
I'll give it a shot, thanks
<jackdaniel>
I think that ironclad uses some sbcl internals which were recently chagned, so ironclad got broken, and newest release has been fixed to use these new internals
<jackdaniel>
but this is based on a vague memory of mine
<dtornabene>
I mean, my sbcl install is a full dot release behind sbcl so it... maybe?
<dtornabene>
I'm on debian testing
<jackdaniel>
error may also result from the fact, that bye default ironclad uses 64 bit seed for something (fortune (?)) and earlier it used 32 bit, so you may need to update your sources
<jackdaniel>
by*
<jackdaniel>
I don't know what is a full dot release
<dtornabene>
1.2 vs 1.3
<dtornabene>
point release would be 1.9 vs 2.0
<dtornabene>
actually I think I have that backwards
<dtornabene>
now that I see it written out
<jackdaniel>
I have SBCL 1.4.12 and ironclad builds fine on my host
<dtornabene>
yeah I'm on 1.3.14
<dtornabene>
time for some apt pinning fun
<jackdaniel>
installing sbcl from sources (instead of apt stuff) is (imho) way better
<jackdaniel>
also you may download precompiled version which you could simply install in /usr/local/
<dtornabene>
yeah, I just realized this machine is actually stable, which is waaaay worse
<dtornabene>
that sounds like a plan
<Odin->
jackdaniel: From what I see in the "LISP 1.5 Programmer's Manual" the meta-language wasn't intended to have direct access to symbols. Constant values are also referred to as "atomic symbols" in that.
dtornabene has left #lisp ["Leaving"]
dtornabene has joined #lisp
<jackdaniel>
oh, and I was just about to make my first pun today (poking at stable machines being better than unstable ones), but daniel left ;(
<dtornabene>
I'm back!
<dtornabene>
glitches
<jackdaniel>
Odin-: I believe you, thanks for bringing this up
<Odin->
jackdaniel: The need for QUOTE arose because when working with s-expressions to feed into the evaluator you needed to be able to have data objects for both the object being referred to and the name being used to refer to it...
<jackdaniel>
dtornabene: even if you are back, my joke wouldn't have much impact now when I've spoiled it
<dtornabene>
lol
* Odin-
runs on Debian unstable.
<Odin->
I've had ... three instances of the window system going AWOL.
* jackdaniel
runs on a coffee
<Odin->
Over ... lessee ... seventeen years.
<jackdaniel>
and tries to figure out what's a big deal with clx refusing to work with pixmaps as clipping masks
<Odin->
unstable is plenty stable for workstation use, and it usually has recent software. :D
Kundry_Wag has joined #lisp
fikka has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
<schweers>
concerning symbols in ruby: as far as I know, ruby only has (something likewhat) we would call keyword symbols.
<schweers>
s/likewhat)/like) what/
<Odin->
The usage of symbols in JavaScript is more or less intended to be that way, too.
fikka has quit [Ping timeout: 272 seconds]
Zaab1t has joined #lisp
<schweers>
So yes, the fact that Common Lisp has first class symbols means that hardly any language out there could have adopted a similar package system.
flazh has joined #lisp
dddddd has joined #lisp
kajo has quit [Quit: From my rotting body, flowers shall grow and I am in them and that is eternity. -- E. M.]
fikka has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
<dtornabene>
:jackdaniel thanks for the suggestion, I grabbed a binary, nuked the system sbcl and setup (some of) the links and lo and behold ironclad loaded
Guest14049 has quit [Ping timeout: 252 seconds]
milanj has joined #lisp
<ogamita>
Yes, there is a Symbol class in ruby, but there's nothing ressembling homoiconicity.
wigust- has joined #lisp
Lycurgus has joined #lisp
wigust has quit [Ping timeout: 250 seconds]
<jackdaniel>
excl feature is for allegro?
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
<heisig>
I am working on a portable type inference library for Common Lisp. Am I reinventing someone's wheel here?
igemnace has quit [Ping timeout: 272 seconds]
<dtornabene>
interested in this as well heisig
<fe[nl]ix>
heisig: what kind of type inference ?
<heisig>
Only functions, and only for a fixed number of arguments with known types.
<heisig>
Now I am working on a library that essentially allows one to write (restrict #'+ '(double-float double-float)) to obtain a funcallable instance with a lot of metadata (including return values).
gxt has joined #lisp
ebrasca has joined #lisp
<heisig>
These restricted functions also have an auto-generated function name, as well as an fdefinition and a compiler macro.
<heisig>
My goal is to use it for code generation, but it might also be useful for type checking.
<heisig>
Any feedback is most welcome.
<dtornabene>
i've been interested in doing something along those lines since discovering rosette
pierpal has quit [Read error: Connection reset by peer]
Zaab1t has quit [Ping timeout: 250 seconds]
<scymtym>
heisig: in simplify-type-specifier.lisp, separating the syntatic simplifications form the approximating transformations could be useful
orivej has quit [Ping timeout: 246 seconds]
rippa has joined #lisp
Zaab1t has joined #lisp
clintm has quit [Read error: Connection reset by peer]
clintm has joined #lisp
<heisig>
scymtym: That is probably a good idea. But I am not sure how to separate these issues. Maybe I should just return a second value indicating whether the simplification is precise or not.
<dtornabene>
jdz: i have, haven't tried to use it yet for anything. I'm working on some sml/ocaml stuff at the moment, but when I'm done one of the things I want to dive into is constraint solving
<dtornabene>
jdz: have you used it for anything?
phoe has quit [Read error: Connection reset by peer]
<jdz>
Just playing around. I was pleasantly surprised when a combination-generating function using screamer was actually faster than my hand-rolled one.
<dtornabene>
thanks for that link, hadn't seen that blog post yet somehow
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
random-nick has joined #lisp
gravicappa has joined #lisp
swflint has quit [Ping timeout: 252 seconds]
swflint has joined #lisp
razzy has quit [Ping timeout: 246 seconds]
mindCrime has joined #lisp
zch has joined #lisp
<Xach>
So many lisp AOC repos this week!
Inline has joined #lisp
<beach>
Appellation d'origine contrôlée?
<Xach>
Advent d'Code
<beach>
Ah.
<pfdietz>
I have to say, I much prefer AoC to NN November.
orivej has joined #lisp
zch has quit [Remote host closed the connection]
zch has joined #lisp
nicksmaddog has joined #lisp
dtornabene has quit [Quit: Leaving]
elfmacs has quit [Ping timeout: 250 seconds]
warweasle has joined #lisp
Bike is now known as Bicyclidine
robdog has joined #lisp
dale_ has joined #lisp
dale_ is now known as dale
jmercouris has joined #lisp
themsay has joined #lisp
elderK has joined #lisp
heisig has quit [Quit: Leaving]
schweers has quit [Ping timeout: 268 seconds]
Bike has joined #lisp
themsay has quit [Ping timeout: 244 seconds]
Lycurgus has quit [Quit: Exeunt]
nicksmaddog has quit [Remote host closed the connection]
nicksmaddog has joined #lisp
varjag has joined #lisp
<ogamita>
Odin-: you're wrong. The code written in M-expressions has direct access to symbols: cons[CONS,NIL] -> (CONS) atom[car[cons[CONS,NULL]]] -> 1
<ogamita>
Odin-: even more so than S-expressions in a way, since literals in M-expressions are written directly as S-expressions, without a need for QUOTE!
<ogamita>
Odin-: On the other hand, it's true that the symbol corresponding to cons in the M-expression atom[car[cons[CONS,NULL]]] cannot be accessed in any direct way.
<Odin->
ogamita: It has direct access to S-expression symbols, but not its own.
<ogamita>
Odin-: you would need to call the M-expression parser, to obtain a S-expression sexp = (ATOM (CAR (CONS (QUOTE CONS) (QUOTE NULL)))) and then use car[cdr[cdr[sexp]]]
<ogamita>
Odin-: but now, consider how you do it with S-expressions!
<ogamita>
usually, you don't use a symbol editor (cf. my sedit). you use a text editor such as emacs, and to obtain the S-expressions, we have to READ the text!
<ogamita>
So you can do the same for M-expression. Actually, while I implemented my M-expression as a parser, it could as well be implemented as lisp reader macros.
<Odin->
Err.
<ogamita>
You could have (car (cadr (cadr #M[atom[car[cons[FOO,BAR]]]]))) -> CONS
<ogamita>
or rather, you need quote here: (car (cadr (cadr '#M[atom[car[cons[FOO,BAR]]]]))) -> CONS
<ogamita>
So, it's more a question of having access to the reader (parser) than a fundamental restriction.
<Odin->
Both approaches wind up transforming M-expressions into S-expressions, more or less.
<ogamita>
They're both representations of the same thing, so…
dmitigr has quit [Ping timeout: 256 seconds]
<Odin->
Aside from the fact that M-expressions were never fully defined, yes.
<ogamita>
The problem in C, scheme, etc, (but not in perl), is that their tools don't give access to their reader/parser.
<ogamita>
Odin-: well, they were rather well defined, given that all the examples in the LISP 1.5 user manual were written in it, as well as all the code in the papers about lisp until some advanced date (at least later than 1962 anyways).
<ogamita>
Note that you could by way of "pre-processors" give access to the source of programs of other programming languages. Imagine defining reader macros in C to read C sources! :-) (cf. elpp for example).
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
vtomole has joined #lisp
<Odin->
ogamita: Well, yes. And I'm saying Lisp's use of symbols arose because the language ultimately developed around the internals of the evaluator, not entirely on top of it.
mathrick has joined #lisp
<Odin->
M-expressions are defined to the extent required for a formalism. S-expressions were developed to the point of being a practical programming language.
shakdwipeea has quit [Remote host closed the connection]
<shrdlu68>
ogamita: Interesting point about perl.
shrdlu68 has quit [Quit: WeeChat 2.2]
zch has quit [Ping timeout: 256 seconds]
<ogamita>
Odin-: but there was a purpose to all this: it was invented to write AI programs, and it was expected to be needing introspection and reflexion.
<ogamita>
So if JMC designed lisp around a reflexive eval, it's because he had this purpose for AI.
<ogamita>
And note that lists based on conses already existed: they were invented by NSS, and they had the FLPL fortran library to manipulate those lists.
Demosthenex has quit [Ping timeout: 244 seconds]
<Odin->
ogamita: It's a logical result of the design parameters, but one I don't think was directly intentional.
<ogamita>
"Linked lists were developed in 1955-1956 by Allen Newell, Cliff Shaw and Herbert A. Simon at RAND Corporation".
<Odin->
That is, the importance that symbols came to have in Lisp programming.
eminhi has joined #lisp
<Odin->
Simon? The author of Administrative Behaviour?
<Odin->
Intriguing.
<p_l>
Most importantly, the language was designed for manipulating symbolic data
<p_l>
Whole you could do that in fortran etc, it was not nice nor easy
<p_l>
That was before fortran had structured the programming facilities
<p_l>
It's a time hwne master's theses were written about if/else
<p_l>
*when
<Odin->
The bit that I find most intriguing is the way the LISP 1.5 manual draws no distinction whatever between 'atom' and 'symbol'.
<Odin->
That's conceptually still the case, but loses the name-versus-thing distinction that's the defining feature of symbols as used now.
robotoad has quit [Quit: robotoad]
nirved is now known as Guest37343
nirved has joined #lisp
Guest37343 has quit [Ping timeout: 252 seconds]
buffergn0me has quit [Ping timeout: 264 seconds]
igemnace has joined #lisp
buffergn0me has joined #lisp
LiamH has joined #lisp
<p_l>
Odin-: if you look at old source code, you'll see symbols used as primary data structure often
<p_l>
with symbols and their property lists used like objects
<p_l>
and more complex structures weaved from that
Demosthenex has joined #lisp
<Odin->
p_l: Yeah, and I think that sort of thing is the reason a full and precise definition of the M-expression language never came to fruition.
<Odin->
They realised that the direct access to symbols was pretty useful. :p
wusticality has joined #lisp
<p_l>
I also think it was simply of lesser importance for people involved
jochens has quit [Remote host closed the connection]
jochens has joined #lisp
<pfdietz>
Once the importance of macros became clear, why would anyone want M-exprs?
jochens has quit [Ping timeout: 246 seconds]
<TMA>
pfdietz: they look better in proportional font
marvin2 has quit [Ping timeout: 272 seconds]
Guest14049 has joined #lisp
hhdave has quit [Ping timeout: 250 seconds]
<Odin->
pfdietz: ... why would you need macros for that?
<Odin->
M-expressions are surprisingly opaque.
jochens has joined #lisp
dacoda has joined #lisp
jochens has quit [Ping timeout: 268 seconds]
varjag has quit [Ping timeout: 268 seconds]
cage_ has joined #lisp
<pjb>
Odin-: why do you say so? There's a 1-1 correspondance between M-expressions and S-expressions.
robdog has quit [Ping timeout: 260 seconds]
eminhi has quit [Ping timeout: 250 seconds]
swflint has quit [Ping timeout: 260 seconds]
<pjb>
In some sentences they consider integers as symbols to (ie. the confusion between atom and symbol), but this was also stressed by the fact that numbers were not combined with arithmetic operators 42+33, but with lisp functions: (TIMES 42 33) and when you had it as data, it had nothing numeric, it is a symbolic expression, so TIMES, 42 and 33 are symbols like any other atom.
<pjb>
What is a number?
<pjb>
42 is not a number. It's the representation of a number. There are other representations of the same number: #b101010 for example.
<pjb>
Symbols are used to represent things.
arbv has quit [Ping timeout: 252 seconds]
swflint has joined #lisp
<Odin->
pjb: Which thing I said are you asking about? :p
robdog has joined #lisp
shifty has joined #lisp
eminhi has joined #lisp
<pjb>
Odin-: "M-expressions are surprisingly opaque."
<Odin->
pjb: That was poorly worded.
Guest14049 has quit [Ping timeout: 245 seconds]
<Odin->
Given an M-expression and an equivalent S-expression, I find the S-expression easier to understand.
arbv has joined #lisp
<pjb>
Only lispers realize that…
ggole has quit [Quit: ggole]
<elderK>
Odin-: I find the M-expression syntax horrible.
<elderK>
And I did before I grew familiar with, and used to, S-exps.
slyrus1 has quit [Read error: Connection reset by peer]
marvin2 has joined #lisp
jmercouris has quit [Remote host closed the connection]
shifty has quit [Remote host closed the connection]
zch has joined #lisp
dacoda has quit [Ping timeout: 268 seconds]
sauvin has quit [Remote host closed the connection]
<Bike>
clos mop kind of question. reinitialize-instance isn't called on the generic function for every method definition, is it?
igemnace has quit [Quit: WeeChat 2.3]
frgo has quit [Remote host closed the connection]
lemoinem has quit [Ping timeout: 246 seconds]
lemoinem has joined #lisp
mason has joined #lisp
<aeth>
Odin-: The advantage to something like an m-expression isn't that it's easier to understand (although it could be easier to learn), it's that you could (well, with something similar, probably not exactly an m-expression) port existing code almost verbatim from another language.
kajo has joined #lisp
<Odin->
aeth: Dunno, M-expressions aren't exactly similar to ALGOL-likes.
<aeth>
Odin-: Exactly, they're a failed experiment. New infix reader macros are much closer.
<Odin->
Except M-expressions were originally positioned as the main syntax, not a portability layer...
<beach>
Bike: I think you are right, it is not called.
<beach>
Bike: It is enough to call ADD-METHOD.
<beach>
Bike: REINITIALIZE-INSTANCE is called when you want to pass modified initialization arguments to it.
<Bike>
right.
<Bike>
thanks.
<beach>
Sure.
* beach
vanishes to spend time with his (admittedly small) family.
random-nick has quit [Read error: Connection reset by peer]
<Odin->
On a completely unrelated note, though: Is there a go-to webserver aside from Hunchentoot?
<sjl_>
But, Clack is more like Python's WSGI or Clojure's Ring -- it's an abstraction over top of existing servers like Hunchentoot so you can swap them out, not really a server itself
meepdeew has quit [Ping timeout: 252 seconds]
Demosthenex has joined #lisp
<Odin->
I noticed. That can be a benefit, but the documentation feels a little ... lacking. :/
<sjl_>
Yep.
themsay has quit [Ping timeout: 246 seconds]
frgo has joined #lisp
Zaab1t has quit [Quit: bye bye friends]
frgo has quit [Ping timeout: 245 seconds]
zcid has joined #lisp
vtomole has quit [Quit: Page closed]
cage_ has quit [Remote host closed the connection]
gxt has quit [Ping timeout: 250 seconds]
wusticality has quit [Remote host closed the connection]
wusticality has joined #lisp
gravicappa has quit [Ping timeout: 245 seconds]
wusticality has quit [Ping timeout: 268 seconds]
razzy has joined #lisp
Demosthenex has quit [Ping timeout: 245 seconds]
flazh has quit [Ping timeout: 250 seconds]
Demosthenex has joined #lisp
<jasom>
Odin-: if you are confused by anything at all after using my tutorial, let me know, either here or file an issue in github.
<jasom>
Clack itself has a lot of moving parts, but actually using it is fairly easy.
gendl has joined #lisp
Demosthenex has quit [Ping timeout: 245 seconds]
<Odin->
Seems clear enough.
Demosthenex has joined #lisp
eminhi has quit [Remote host closed the connection]
_spm has joined #lisp
zch has quit [Quit: Leaving]
random-nick has joined #lisp
jkordani has quit [Read error: Connection reset by peer]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
yvy has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
<LdBeth>
good afternoon everyone
<no-defun-allowed>
Hi LdBeth
varjag has joined #lisp
eminhi has joined #lisp
meepdeew has joined #lisp
meepdeew has quit [Remote host closed the connection]
warweasle has quit [Quit: home]
nicksmaddog has quit [Ping timeout: 260 seconds]
Arcaelyx has joined #lisp
<esper0s>
good evening
orivej has quit [Ping timeout: 244 seconds]
mindCrime has quit [Ping timeout: 252 seconds]
equwal has joined #lisp
Demosthenex has quit [Ping timeout: 250 seconds]
Demosthenex has joined #lisp
josemanuel has quit [Quit: leaving]
Demosthenex has quit [Ping timeout: 246 seconds]
Demosthenex has joined #lisp
sjl has quit [Quit: WeeChat 2.2-dev]
Bike has quit []
LiamH has quit [Quit: Leaving.]
sjl_ has quit [Ping timeout: 250 seconds]
vlatkoB_ has quit [Remote host closed the connection]
CCDell has joined #lisp
Guest14049 has joined #lisp
rumbler31 has joined #lisp
graphene has quit [Remote host closed the connection]
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
irdr has quit [Ping timeout: 246 seconds]
graphene has joined #lisp
orivej has joined #lisp
random-nick has quit [Ping timeout: 268 seconds]
kajo has quit [Ping timeout: 252 seconds]
meepdeew has joined #lisp
Bicyclidine is now known as Bike
eminhi has quit [Quit: leaving]
<margaritamike>
Hello friends
<esper0s>
hello friend
<equwal>
goodbye stranger
<margaritamike>
I'm not sure if anyone remembers from last time, but I'm hoping to get Common Lisp added to more competitive programming websites, where you can solve algorithmic problems. The effort is progressing for Kattis and there is a possibility of getting SBCL added to Codeforces as well. I was asked a technical Lisp question I did not have the experience to answer. I'm hoping someone could help, because it seems like this may be
<margaritamike>
the last technical portion in the way before SBCL is added to the Kattis online judge. The question is kind of long so I put it on paste bin