<ixelp>
symbolic-smalltalk-parser/grammar.lisp at master · pve1/symbolic-smalltalk-parser · GitHub
amb007 has joined #commonlisp
<pve>
there is currently no "clean" abstract syntax tree
dcb has quit [Quit: MSN Messenger 3.8]
azimut has quit [Ping timeout: 240 seconds]
azimut has joined #commonlisp
<jackdaniel>
pve: call it a 'dirty speak'
<pve>
jackdaniel: the tree or the language?
<jackdaniel>
tree
<pve>
yeah
<jackdaniel>
the language should hint that it is a smalltalk in lisp, i.e mumble
<pve>
or perhaps thmalltalk
<pve>
but I'm not that funny, unfortunately
<jackdaniel>
all we can do is try, a sad fate of ours, not- coolkids
ec_ has quit [Ping timeout: 240 seconds]
<jackdaniel>
;)
<beach>
"mumble"?
<aeth>
lisptalk?
ec_ has joined #commonlisp
kevingal has joined #commonlisp
<hayley>
Elephant talk?
<jackdaniel>
having lisp and mumbling are two distinct things, but both imply less intelligible speech
<beach>
And how would that be related to small talk?
<jackdaniel>
(se there is a semantical connotation between both, and smalltalk is also about nomen omen talking)
<jackdaniel>
so*
<hayley>
"Squeak" is the sound a mouse makes, which is unrelated to small talk. I don't know what sound a pharo is meant to make.
<beach>
But that's not what small talk means.
<jackdaniel>
beach: word gamrs are not about being technically correct, at least that's what I think
<jackdaniel>
games*
habamax has joined #commonlisp
<pve>
(I should mention that it was originally _death who suggested thmalltalk, credit where credit is due)
random-nick has joined #commonlisp
<mfiano>
The creator of Rust recently wrote an article about what he doesn't like about Rust, and I found this amusing (re: anonymous functions): "I really do dislike equipping it with environment capture and think it's a mistake"
Gleefre has joined #commonlisp
herjazz has joined #commonlisp
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<jackdaniel>
from their memory doctrine I can imagine that they are more fond of a static guarantees about programs
<ixelp>
graydon2 | The Rust I Wanted Had No Future
<hayley>
mfiano: Funny, as nested functions with names cannot capture the environment either. So that's a whole no environment capture whatsoever, in total.
<Josh_2>
"I don't really care either way about having such a literal syntax, but I really do dislike equipping it with environment capture and think it's a mistake," *shakes fist*
<varjag>
there's diminishing practical point in closures that can't close tho
<mfiano>
He argues it's a mistake for systems languages with observable mutability. He then goes on to wish dynamic dispatch was not frowned upon
<hayley>
I argue systems languages are a mistake, so.
<Josh_2>
^
<mfiano>
I'm having a hard time understanding the direction he wanted to take it, as a systems language. It seems Lisp, without some features = not a systems language.
<hayley>
I would've thunk ML with curly braces and Go-ish concurrency.
<mfiano>
Ugh
<hayley>
Well, I think ML is nice (though unpleasant without even simple refinement types, in my experience), and green threads are better than the alternatives.
<Josh_2>
How many people outside of the lisp community are even aware of lisp machines? let alone the capabilities of it
<hayley>
Define "aware".
<mfiano>
those who were unfortunate enough to move to other languages when they lost their ai jobs
<mfiano>
"many"
<aeth>
well, now that AI is back in style, hopefully Symbolics is doing well...
<Josh_2>
:clown:
<hayley>
Lisp machines are popular for necrocomputing, though I have to remind people that compilers exist nowadays.
ec_ has quit [Ping timeout: 240 seconds]
attila_lendvai has joined #commonlisp
* jackdaniel
notes down the word necrocomputing
<mfiano>
you will quickly run out of room in your notebook when hayley is around
<ixelp>
This is worse than retrocomputing; it's necrocomputing, a pathetic attempt to ma... | Hacker News
<jackdaniel>
mfiano: it is not like I enjoy each and every word she says :p
<mfiano>
some of them are great though!
<mfiano>
moar paper. sell it by the pound!
<hayley>
I read someone argue that, with the recent resurgence of Interlisp and the MIT Lisp machine software, Common Lisp should just be used for compatibility between the two. Which - though I appreciate progress in both projects, and don't mean to knock either at all - would be a step back, not least because neither implements the ANSI standard.
<jackdaniel>
let a thousand flowers bloom, then cut the 999
zaymington has joined #commonlisp
occ has quit [Read error: Connection reset by peer]
<beach>
scymtym: Have you had time to look at either the type-specifier or the lambda-list issues in the s-expression-syntax library?
Krystof has quit [Ping timeout: 240 seconds]
ec_ has joined #commonlisp
morganw has joined #commonlisp
ec_ has quit [Ping timeout: 240 seconds]
ec_ has joined #commonlisp
Josh_2 has quit [Ping timeout: 240 seconds]
ec_ has quit [Ping timeout: 240 seconds]
ec_ has joined #commonlisp
ec_ has quit [Ping timeout: 240 seconds]
ec_ has joined #commonlisp
nij- has joined #commonlisp
Josh_2 has joined #commonlisp
<nij->
When (sleep 10) in the main thread, why would the other thread keep working?
<Josh_2>
Cos you didn't tell it to sleep
<nij->
I see. There is no global SLEEP that can sleep every thread all at once?
<Josh_2>
You could bt2:all-threads then interrupt every thread with a function that sleeps
<Josh_2>
excluding whatever thread you are interacting with
<Josh_2>
but idk about doing that
<Josh_2>
If you make the threads you want to sleep yourself this is a lot easier
ec_ has quit [Ping timeout: 240 seconds]
Gleefre has quit [Remote host closed the connection]
ec_ has joined #commonlisp
BierLiebHaber has joined #commonlisp
waleee has joined #commonlisp
tibfulv_ is now known as tibfulv
ec_ has quit [Ping timeout: 240 seconds]
nij- has quit [Ping timeout: 265 seconds]
ec_ has joined #commonlisp
Oddity has quit [Ping timeout: 240 seconds]
ec_ has quit [Ping timeout: 240 seconds]
alcor has joined #commonlisp
ec_ has joined #commonlisp
zaymington has quit [Remote host closed the connection]
ec_ has quit [Ping timeout: 240 seconds]
Gleefre has joined #commonlisp
ec_ has joined #commonlisp
alcor has quit [Remote host closed the connection]
alcor has joined #commonlisp
ec_ has quit [Ping timeout: 240 seconds]
ec_ has joined #commonlisp
kevingal has quit [Ping timeout: 248 seconds]
Josh_2 has quit [Remote host closed the connection]
Josh_2 has joined #commonlisp
ec_ has quit [Ping timeout: 240 seconds]
ec_ has joined #commonlisp
karlosz has joined #commonlisp
ec_ has quit [Ping timeout: 240 seconds]
ec_ has joined #commonlisp
ec_ has quit [Ping timeout: 240 seconds]
occ has joined #commonlisp
herjazz has quit [Quit: leaving]
ec_ has joined #commonlisp
Inline has joined #commonlisp
mgl has joined #commonlisp
ec_ has quit [Ping timeout: 240 seconds]
ec_ has joined #commonlisp
lucasta has joined #commonlisp
ec_ has quit [Ping timeout: 240 seconds]
ec_ has joined #commonlisp
ec_ has quit [Remote host closed the connection]
ec_ has joined #commonlisp
<beach>
scymtym: Oh, I think we have a similar problem with the :USE option of DEFPACKAGE, where (:USE) is different from the absence of the :USE option.
ec_ has quit [Ping timeout: 240 seconds]
ec_ has joined #commonlisp
habamax has quit [Quit: ERC 5.4 (IRC client for GNU Emacs 28.2)]
ec_ has quit [Ping timeout: 240 seconds]
ec_ has joined #commonlisp
ec_ has quit [Ping timeout: 240 seconds]
Inline has quit [Ping timeout: 250 seconds]
<jcowan>
Does Chicken have any "system" threads that are created behind the scenes, like at startup?
ec_ has joined #commonlisp
random-nick has quit [Ping timeout: 268 seconds]
<scymtym>
beach: yeah, :USE is already on my todo list. this is another case of tension between having s-e-s do work for the client (that is, aggregating the possibly multiple :USE options) and not hiding any information from the client. it seems :USE is another case in which the latter must take priority
<scymtym>
i worked on type-specifiers and lambda lists a little bit other things got in the way. i haven't forgotten about it
dnhester has joined #commonlisp
ec_ has quit [Ping timeout: 240 seconds]
ec_ has joined #commonlisp
awkravchuk has joined #commonlisp
<jcowan>
sorry, ww
dnhester26 has joined #commonlisp
kevingal has joined #commonlisp
random-nick has joined #commonlisp
ec_ has quit [Ping timeout: 240 seconds]
ec_ has joined #commonlisp
ec_ has quit [Ping timeout: 240 seconds]
<jcowan>
hayley: I don't know what the story is on the CADR, but the *intention* of the Medley project is to support full ANSI Common Lisp alongside Interlisp. It's just that no one has the resources to make it happen at the moment.
<jcowan>
In the Very Old Days when I was actually being paid to use an Interlisp machine, I was writing Common Lisp (CLtL1 at that time). I still think it's the most comfortable environment I've ever been in for that purpose.
ec_ has joined #commonlisp
<hayley>
Right. And then there are non-standard things that people might expect, and that the emulators introduce an interesting slowdown on my code. Those also can be solved with resources. I only mean to say that some people get too giddy about Lisp machines.
nij- has joined #commonlisp
<nij->
Anyone had experience with grpc for lisp?
<nij->
I wonder if it supports remote object controls.
waleee has quit [Ping timeout: 265 seconds]
<hayley>
jcowan: I really hope I don't sound like I dislike those environments. And I'm still waiting for CDR coding to come back into fashion.
<jcowan>
hayley: No, I realize that. And obviously the idea of CL as the Missing Link is silly nowadays, though the word "common" still shows that that was the original intention.
<jcowan>
Medley is seriously considering ripping out CDR-coding,, I'm sorry to tell you; memory is cheap, cycles are expensive (in relative terms, of course)
<hayley>
I thought main memory was slow, and cycles are fast.
<jcowan>
CDR coding was introduced to save main memory, but we have lots of it nowadays
<jcowan>
even the Medley emulator now has a max memory of 256M
<jcowan>
vs. I think 128K for actual D-machines (don't trust these numbers)
<hayley>
Cache memory is not so plentiful (okay - I say having two 32MB L3 caches in my desktop) and pointer chasing is hard to...superscalar-ise. I guess that's another word for jackdaniel to note down.
<jcowan>
All true.
ec_ has quit [Ping timeout: 240 seconds]
<jcowan>
I'm talking about hard limits on main memory
ec_ has joined #commonlisp
waleee has joined #commonlisp
<jcowan>
It's also a matter of programming style: if you mutate lists much (or at least their cdrs) your cdr-coding will degenerate.
<jcowan>
I wrote a proposal for Kernel which never came to fruition. Kernel has two kinds of conses, mutable and immutable, where immutable lists can be laid out consecutively. (No actual Kernel implementation does this.)
<jcowan>
The proposal was to add a third type: "mutable car, immutable cdr", and these would take the place of vectors.
<jcowan>
(simple vectors, that is)
<hayley>
Sure. On stock hardware it seems that it's much easier to unroll (not quite cdr-coding, but not dissimilar) immutable objects, and immutability would also eliminate any issues surrounding concurrent modification.
<nij->
Hello~ It's a bad idea to use list as a collection data structure. What would you use instead? Any de facto library?
<jcowan>
nij-: It depends what you want it to do, what the demands of your problem are, and what resources you have. For some things lists are optimal.
<hayley>
It depends on what operations you want, and what operations you want to be fast. And jcowan beat me to the rest of my message.
<jcowan>
hayley: What do you mean by "unroll"?
ec_ has quit [Ping timeout: 240 seconds]
<jcowan>
That's because that message is macro'd onto my F9 key.
<hayley>
Appel and Shao wrote of a transformation to turn code which processes conses with one element into code which can process "cons"es with two elements, roughly speaking.
Alfr has quit [Ping timeout: 240 seconds]
<hayley>
*can also process; the generated code can deal with both kinds of cell.
<hayley>
And you'd be out of luck if you wanted to RPLACD in the middle of a two-element cell.
ec_ has joined #commonlisp
nij- has quit [Ping timeout: 256 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
waleee has quit [Ping timeout: 250 seconds]
ec_ has quit [Ping timeout: 240 seconds]
ec_ has joined #commonlisp
Cymew has quit [Ping timeout: 268 seconds]
ec_ has quit [Ping timeout: 240 seconds]
zest has joined #commonlisp
<jcowan>
I see the paper is written in terms of ML, which means mutability isn't an issue
* jcowan
reads on
zxcvz has joined #commonlisp
scymtym has quit [Remote host closed the connection]
Brucio-61 has quit [Quit: Application exit]
rainthree has joined #commonlisp
Alfr has joined #commonlisp
NicknameJohn has joined #commonlisp
JoshYoshi has joined #commonlisp
Josh_2 has quit [Ping timeout: 240 seconds]
dnhester has quit [Ping timeout: 245 seconds]
dnhester26 has quit [Ping timeout: 265 seconds]
scymtym has joined #commonlisp
Inline has joined #commonlisp
JoshYoshi has quit [Ping timeout: 265 seconds]
Brucio-61 has joined #commonlisp
zest has quit [Read error: Connection reset by peer]
Oladon has joined #commonlisp
dnhester26 has joined #commonlisp
tyson2 has joined #commonlisp
<beach>
scymtym: Sounds good. Thanks.
NotThatRPG has joined #commonlisp
dnhester26 has quit [Remote host closed the connection]
tevo has quit [Read error: Connection reset by peer]
lucasta has quit [Quit: Leaving]
tevo has joined #commonlisp
Oddity has joined #commonlisp
<pve>
I'd like to implement something like (call-super #'my-generic-function arg1 arg2 ...), where, in the list of applicable methods, the first method is skipped. Is it "compute-applicable-methods" I should be looking at to achieve this? Or possibly "compute-discriminating-function"?
<jackdaniel>
pve: call-next-method
<jackdaniel>
calling "parent" method does not apply to generic functions because there is no clear function owner (all arguments are specializable)
<pve>
jackdaniel: right, I'm trying to figure out if I can emulate smalltalk's calls to "super", where inside the method body of "foo", a call to "super bar" could be made
<pve>
if I understand correctly, call-next-method won't let me do that
<pve>
i.e. call some other generic function, directly skipping the first method if necessary
<skin>
jackdaniel is correct. call-next-method does do what you want.
<skin>
> the effective method is the most specific method. That method can call the next most specific method by using the function call-next-method
<skin>
Alternatively:
<skin>
(defgeneric foo (bar baz))
<skin>
eh, nevermind. I thought I was on to something, but I'm not. it's `call-next-method`, usually.
<Bike>
there's no way to skip methods for some other function like this
kevingal has quit [Ping timeout: 240 seconds]
<pve>
i understand that generic functions are not "supposed" to work like that, I'm just trying to see if I could cook something up. Would be cool to get it working.
<pve>
bike: ok I see
Krystof has joined #commonlisp
<Bike>
generic functions effectively only have the one entry point that determines the methods based on the arguments. you're asking for multiple entry points with different methods. i'm not sure how you'd map the "super" stuff since as jackdaniel said there's no owner, but the multiple entry points is a more fundamental difference
<Bike>
it's doable with MOP, i'm sure, but you'd be implementing quite a lot yourself
<Bike>
like - just specializing compute-discriminating-function would not be enough - having a single discriminating function is insufficient for your purposes
santiagopim has joined #commonlisp
igemnace has quit [Quit: WeeChat 3.8]
<pve>
bike: alright, thanks.. I need to ponder this
<NotThatRPG>
pve: You can pass arguments to `call-next-method` as a way of overriding things.
<NotThatRPG>
But that sounds like not exactly what you want to do -- you don't want to change the arguments as a way to skip a method, do you?
<NotThatRPG>
You could use an `:around` method to get finer control perhaps. Or you could add an ancillary argument that you use to control what methods you call. Change that ancillary argument's value in a subsidiary call, and you can control which method is invoked.
mgl has quit [Quit: Client closed]
<scymtym>
i think the arguments passed to CALL-NEXT-METHOD must not change the set of applicable methods compared to the applicable methods for the original arguments
rgherdt has quit [Read error: No route to host]
rgherdt has joined #commonlisp
<Bike>
mhm.
<Bike>
i think that given pve is talking about calling a different function, most "easy" solutions with c-n-m are not gonna work
<pve>
ok, I *think* I could try-before-I-buy by wrapping every method defined with (if *super* (progn (setf *super* nil) (call-next-method)) [actual method body here]) and translating every "super foo" call to (let ((*super* t)) [invoke foo]) :)
amb007 has quit [Ping timeout: 250 seconds]
amb007 has joined #commonlisp
<alcor>
Does CL support hierarchical/nested packages? How does one group "related" CL packages idiomatically?
<NotThatRPG>
alcor: It does not.
<alcor>
So… Prefixes?
<yitzi>
Thank g-d it doesn't. That stuff gets carried away on Java, etc.
<yitzi>
alcor: I do slashes sometimes, but only one level deep. foo/bar, foo/quux, etc. Sometimes I just skip it and use hyphens. I'm torn about the usefulness of it.
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #commonlisp
dnhester26 has joined #commonlisp
<alcor>
Are slashes the preferred approach? I read some old internets while searching, where people were using dots.
tyson2 has quit [Remote host closed the connection]
<yitzi>
I've seen dots plenty. I don't know if there is a preferred approach.
* alcor
sighs
rainthree has quit [Ping timeout: 240 seconds]
makomo has quit [Ping timeout: 256 seconds]
rgherdt has quit [Ping timeout: 240 seconds]
rainthree has joined #commonlisp
<yitzi>
I personally don't like dots because b.c I like to leave dots to decimals and dotted pairs. Plus it seems a bit ambiguous here '(foo.bar:quux) Did I forget spaces around the dot and mean '(foo bar:quux)
<yitzi>
er '(foo . bar:quux)
<alcor>
This lack of standardized package-naming practice hurts my TSBOAPOOOWTDI feelings 😔
NicknameJohn has quit [Ping timeout: 268 seconds]
matt` has joined #commonlisp
rgherdt has joined #commonlisp
rainthree has quit [Ping timeout: 240 seconds]
Krystof has quit [Ping timeout: 256 seconds]
<jackdaniel>
some people adapt the naming scheme in the spirit of com.whateverism.library-name{.sub-package}
<jackdaniel>
and I think that this makes the most sense, because now we can use package-local nicknames
<yitzi>
That makes me cry.
<jackdaniel>
yitzi: if you have a local nickname bar, then you type simply bar:foo
<yitzi>
I know. I just think the com.bla... is ugly and excessively long.
<jackdaniel>
on the other hand you know that eu.turtleware. libraries have the highest quality! ,)
<jackdaniel>
allegro has hierarchical package names
<jackdaniel>
ecl did at some point of time but it was removed as clutter
<gilberth>
Indeed. It is some Java-ism that isn't particular useful.
<yitzi>
Of course turtleware is awesome. :)
<gilberth>
One advantage of prefixing your packages by your domain name is that there cannot be conflicts in package names. And as we have relative package names^W^W^Wpackage local nicknames now, the issue is solved. And even before that there was the :USE option with DEFPACKAGE.
<jackdaniel>
not all people fancy :USE though
rgherdt has quit [Remote host closed the connection]
<yitzi>
or PLNs
<jackdaniel>
but yeah, the fact that PLN are widely supported solves the case for them
rgherdt has joined #commonlisp
<jackdaniel>
so we have |3b| to thank for proposing it and phoe for pressuring implementations that did not have it to add the implementation
<jackdaniel>
yitzi: you don't like PLNs?
<jackdaniel>
(I get not liking dots in fully qualified packages names, but is there something icky with the latter?)
tyson2 has joined #commonlisp
<gilberth>
And given those package local nicknames, I wonder if symbol naming habits would change. Before I tended to name symbols in a way that clashes are unlikely when you just :USE a package. E.g. Saying FOO-NODE-NAME instead of just NODE-NAME. With local nicknames it you could as well setup "FOO" (or even "F") as a local nickname and have it FOO:NODE-NAME. Or even FOO:NAME. Not that I would like overly brief symbol names personally.
awkravchuk has joined #commonlisp
<yitzi>
jackdaniel: I prefer good logical (and short if possible) package names. I prefer code that uses fully qualified package names so I know where everything comes from. I think that PLN are useful, but only as a last resort. I find the domain prefix to be silly since it isn't related to the function of the library. It's just noise to me. Just my opinions and probably just a peeve.
<jackdaniel>
I see, thanks for explaining
<yitzi>
No worries, mate. I know I'm probably in the minority on that.
<jackdaniel>
if I had a penny for each opinion I'm in minority with I'd have a bottle of whiskey
<yitzi>
Hehe. Jim Beam, right?
jrm has quit [Quit: ciao]
matt` has quit [Remote host closed the connection]
jrm has joined #commonlisp
<jackdaniel>
highlander in this particular evening case <;
<yitzi>
Good choice.
waleee has joined #commonlisp
Inline has quit [Ping timeout: 256 seconds]
jrm has quit [Quit: ciao]
jrm has joined #commonlisp
Krystof has joined #commonlisp
jmd_ has quit [Ping timeout: 256 seconds]
<NotThatRPG>
@yitzi @alcor : You *might* find that `uiop:define-package` helps with engineering the equivalent of nested packages because it has some more expressive options.
<alcor>
NotThatRPG: Interesting. Thanks.
<pve>
I sometimes like reversing the names in the package name, like util.mylibrary instead of mylibrary.util. Similarly app.initech.com is a bit more pleasing to my eye than com.initech.app
<pve>
not sure why com.initech.app is even a thing
<gilberth>
The reason for prefixing with a reverse domain name is that there cannot be name clashes. Also in self-defense against people using overly short and overly generic package names for their systems.
<NotThatRPG>
pve: one can use the wacko name as a nickname
<pve>
yeah I was just wondering why the order has to be least-specific-first
<|3b|>
sorts better if you have multiple sources if nothing else
<pve>
sure
<gilberth>
And it's like with pathnames. I mean, you don't say lisp.blah/foo/project/joe/home/, do you? IMHO it's domain names that are written in reverse to begin with.
NicknameJohn has joined #commonlisp
<pve>
oh totally, I guess I consider app.foobar.com more of a name, and com.foobar.app more of a path
<gilberth>
A path is a name, too.
<|3b|>
or treat it as a name from a different culture :)
<gilberth>
Symbols are named "big endian" as well. I mean it's *PRINT-PPRINT-DISPATCH* and not *DISPATCH-PPRINT-PRINT*.
tyson2 has quit [Remote host closed the connection]
<pve>
now you made me furiously check all symbols in CL for exceptions
<pve>
couldn't find any :(
<gilberth>
We could argue about ALPHA-CHAR-P.
<|3b|>
some of those are more complex relations than just scoping though
<gilberth>
Or DELETE-FILE.
<pve>
i looked specifically for symbols with a "path" characteristic
<pve>
delete-file, make-package etc i considered "commands"
<edgar-rft>
(alpha-char-p #\β) => ?
<gilberth>
Most are like <datatype>-<property/action>. But not all.
<pve>
like *maybe* USER-HOMEDIR-PATHNAME
<gilberth>
edgar-rft: I do not feel like entering this discussion right now. Besides where is LIGATUREP?
<edgar-rft>
that's a small beta
<gilberth>
pve: Subjective. You could also say this the user's home's pathname, and thus "big endian".
<gilberth>
edgar-rft: You got me!
tyson2 has joined #commonlisp
eddof13 has joined #commonlisp
<pve>
gilberth: hm true
<gilberth>
Funny. English has both ways. It's either the user's home's path's name. Or the name of the path of the home of the user. Never occurred to me.
<gilberth>
And with adjectives it's little endian again. You say "the blue car" not the "the car blue". Curious.
shka has quit [Ping timeout: 240 seconds]
<|3b|>
mostly, you can put adjectives after in some imported phrases or when being poetic
morganw has quit [Remote host closed the connection]
<aeth>
'being poetic' as in, sometimes there are bad translations from the 1800s and earlier that keep the (wrong) word order
<aeth>
so now it kind of works
<|3b|>
or just people swapping things around to make it rhyme :)
<edgar-rft>
PCL = Poetic Common Lisp
<|3b|>
and arguably bad translations would be included in (and/or cause of) the imported phrases category
attila_lendvai has quit [Ping timeout: 240 seconds]
waleee has quit [Ping timeout: 240 seconds]
waleee has joined #commonlisp
jonatack has quit [Ping timeout: 265 seconds]
nij- has joined #commonlisp
<nij->
Hello! I wonder what's the difference between #'XXX and (fdefinition XXX).
<nij->
I changed them blindly to #', still didn't work..
karlosz has quit [Quit: karlosz]
santiagopim has quit [Ping timeout: 240 seconds]
alcor has quit [Read error: Connection reset by peer]
<|3b|>
don't think you can overwrite a local function binding
<gilberth>
This macro is flawed anyway. What happens when you use it twice? Does it recognize that the function was memorized already?
<nij->
gilberth - I'm still implementing it and will take care of that later.
pve has quit [Quit: leaving]
<nij->
can't overwrite local fcn..?? :(
<Bike>
nij-: you can shadow it with fflet
<Bike>
flet
<nij->
(brb in 2 hours.. but I will follow this up)
<nij->
shadow?
<gilberth>
I don't like the general approach of first defining a function and then replacing its definition.
<|3b|>
you can make a new binding that hides existing bindings (which is how all local functions work in the first place)
<gilberth>
You can say (flet ((foo (x) (+ x 1))) (flet ((foo (x) (or (gethash cache x) (foo x)))) ...))
<|3b|>
so you could have a (with-memoize (fun-name) ...) or similar, which expands to (flet ((fun-name ...)) ...)
<|3b|>
but you can't assign to an existing local binding
<gilberth>
The (foo x) in the body of the inner 'foo' refers to the outer foo. Just like with LET.
<|3b|>
CL compilers are allowed to optimize calls to local functions in ways that would prevent assignments
<gilberth>
Yes, like with lexical variables, those lexical functions might not even have a "physical" place. A lexical variable could be optimized away, sit in a register, being renamed or copy-propagated or whatnot.
<|3b|>
yeah, was going to compare it to the inability to refer to local variables by (runtime specified) name
<|3b|>
global functions are more or less specified to have an extra indirection so you can redefine them
ronald has quit [Read error: Connection reset by peer]
nij- has quit [Ping timeout: 240 seconds]
ronald has joined #commonlisp
rgherdt has quit [Remote host closed the connection]
rtoy has quit [Quit: rtoy]
occ has quit [Ping timeout: 250 seconds]
random-nick has quit [Ping timeout: 250 seconds]
<jcowan>
mfiano: You have a link to the "ccreator of Rust criticizes Rust" paper?
random-nick has joined #commonlisp
eddof13 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]