<jasom>
at least partly because it's very hard to be both very general while still doing the "Right Thing"
polezaivsani has quit [Ping timeout: 244 seconds]
<Fare>
and as far as ASDF goes, there was a clear mission creep as to what makes it "good enough" from danb's ASDF 1.85 to Gary King's 1.369 to my 2.000 to my 2.26 to my 3.0.1 to my 3.1.2 to my 3.2.0 to my 3.3.0.
<jasom>
build systems that e.g. track the OS environment as a dependency are very rare.
<Fare>
vestasys was one of the first.
<Fare>
these days, it's bazel and clones vs nix and clone.
<jasom>
tup was the first one I discovered that does this; not sure if it's still around
<Fare>
vestasys I believe vaguely survives. Probably at a CMUCL level of use.
<aeth>
jasom: adding a dummy lisp file doesn't work for my purposes because this is a language that's compiled to CL so there is a two step foo.bar -> foo.lisp -> foo.fasl process.
<Fare>
aeth, in this case I find that a component with a new operation works.
<aeth>
the foo.lisp must go somewhere, ideally handled by ASDF
<Fare>
i.e. have compile-op depend on preprocess-op
<jasom>
aeth: that should still work just fine, as dependencies are loaded before a given file is compiled, right?
robdog has joined #lisp
<Fare>
I remember doing that. Maybe it was for the Python to CL implementation, maybe for the FORTRAN to CL compiler. Or maybe some FFI that compiled to C.
robdog has quit [Ping timeout: 252 seconds]
<Fare>
aeth, if generated, the foo.lisp will typically be redirected by the OUTPUT-TRANSLATIONS.
keep_learning_M has joined #lisp
polezaivsani has joined #lisp
robdog has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
Lord_of_Life_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
Lord_of_Life has quit [Ping timeout: 272 seconds]
Lord_of_Life_ is now known as Lord_of_Life
meepdeew has joined #lisp
<aeth>
jasom: I'm not sure what you mean
<aeth>
jasom: The problem is that to transparently use ASDF to have foreign-to-CL dependencies you need to be able to have a simple foo.bar -> foo.lisp -> foo.fasl and have ASDF treat those FASLs as if they were CL
<aeth>
Fare: output-translations doesn't sound familiar so I think I might have been missing that.
jmercouris has quit [Remote host closed the connection]
robdog has joined #lisp
<aeth>
Fare: Another problem I was getting a lot iirc is that I couldn't modify ASDF and use those modifications in the same place iirc. The issue was adding support for .scm files in general in cl-scheme while also having some of the implementation of cl-scheme be in .scm files
<aeth>
(cl-scheme is not my intended final name but if I say the intended final name that I have in mind, the likelihood of the domain names being grabbed greatly increases)
<aeth>
(I say intended because I can't even search for the domain name without increasing the chance of it being camped by expressing interest in the domain name so it could already be taken...)
eddof13 has quit [Quit: eddof13]
robdog has quit [Ping timeout: 252 seconds]
meepdeew has quit [Remote host closed the connection]
ym555 has quit [Ping timeout: 245 seconds]
Selwyn has quit [Remote host closed the connection]
nowhere_man has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
dale has quit [Quit: dale]
robdog has quit [Ping timeout: 252 seconds]
lumm has quit [Quit: lumm]
lumm has joined #lisp
lumm has quit [Remote host closed the connection]
lumm has joined #lisp
<verisimilitude>
Those two IRC log images are interesting.
Essadon has quit [Quit: Qutting]
<verisimilitude>
You haven't matured much from what I see, Xach, with my experiences with you.
robdog has joined #lisp
<no-defun-allowed>
Immaturity isn't a problem, but to not seem unfriendly you have to hide it behind a lot of wit at least.
robdog has quit [Ping timeout: 252 seconds]
keep_learning_M has quit [Quit: This computer has gone to sleep]
keep_learning_M has joined #lisp
Josh_2 has joined #lisp
lumm has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
Nomenclatura has quit [Quit: q]
didi has left #lisp ["O bella ciao bella ciao bella ciao, ciao, ciao."]
kajo has joined #lisp
<Fare>
aeth, I sorry was not on IRC. I don't know what you're trying to do, but whatever it is, I will gladly help with telling you what to do and not to do with ASDF.
<Fare>
I also have suggestions of names for a Scheme implementation. Such as "Agley" (because "The best laid schemes o' mice an' men / Gang aft a-gley.").
<Fare>
for a cut-down Scheme implementation, bobbit.
<Fare>
I wanted to call a scheme Pyramid, but the name is already taken.
robdog has joined #lisp
<Fare>
Ponzi is still available, though.
<Fare>
AdvanceFee would work, too.
igemnace has joined #lisp
<Fare>
Or for an implementation with a strictly size-limited kernel, 419 Scheme.
robdog has quit [Ping timeout: 252 seconds]
keep_learning_M has quit [Quit: This computer has gone to sleep]
<aeth>
Fare: This isn't very cut down.
<aeth>
Fare: One reason why I want to do proper ASDF integration is that then you could run any library in Quicklisp that doesn't use elaborate (especially tree-walking) macros with a few wrapper files that could probably even be semi-automated.
robdog has joined #lisp
keep_learning_M has joined #lisp
<aeth>
One of the reasons it's incomplete is because I need to solve the integration and performance issues before finishing it.
kajo has quit [Quit: From my rotting body, flowers shall grow and I am in them and that is eternity. -- E. M.]
<aeth>
Fare: it looks like what I was trying to do last time I attempted anything was a perform compile-op and perform load-op for a new scheme-source-file class. I was also looking into output-files. I wasn't aware of output-translations.
robdog has quit [Ping timeout: 252 seconds]
<aeth>
Iirc, what made me stop experimenting is that I didn't know where to put the method definitions. These have to somehow run *before* the defsystem afaik, but I can't just put them above the defsystem in the .asd file.
robdog has joined #lisp
akoana has joined #lisp
<aeth>
The real challenge is that probably half of the code implementing the Scheme will eventually be in Scheme .scm files, but the scm-to-lisp compilation function will be done in a .lisp file as part of the implementation details.
<aeth>
I guess I'll have to break it into at least two systems, possibly with two separate .asd files.
kajo has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
<Fare>
aeth, do you want to discuss it on a video call? It might be faster to get information through.
<Fare>
I understand ASDF but not your cl-scheme. You understand your cl-scheme but not ASDF.
<Fare>
IRC is a bit low-throughput.
anewuser has joined #lisp
<Fare>
And yes, often separating your code in multiple .asd files can help, especially if you need to use defsystem-depends-on.
robdog has quit [Ping timeout: 252 seconds]
SpikeMaster has joined #lisp
SpikeMaster has left #lisp [#lisp]
<aeth>
hmm... I don't think I have a functional web cam on my desktop. I purchased a microphone for gaming, but not a camera. Years ago, I plugged in a bunch of old webcams from probably pre-2005 and none of them had functional Linux drivers.
sjl has quit [Quit: WeeChat 2.2-dev]
<aeth>
(and my laptop is an XPS with the very poorly placed camera)
nanoz has joined #lisp
AeroNotix has quit [Quit: ZNC 1.6.5+deb1+deb9u1 - http://znc.in]
robdog has joined #lisp
okeg has quit [Quit: WeeChat 1.6]
rumbler31 has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
sumwun has joined #lisp
rumbler31 has quit [Ping timeout: 272 seconds]
dale has joined #lisp
smasta has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
Aruseus has quit [Remote host closed the connection]
space_otter has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
keep_learning_M has quit [Quit: This computer has gone to sleep]
keep_learning_M has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
CuriousCain has quit [Quit: WeeChat 2.2]
orivej has quit [Ping timeout: 245 seconds]
varjag has joined #lisp
varjag has quit [Ping timeout: 255 seconds]
notzmv has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
Bike has quit [Quit: Lost terminal]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
Fare has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
bilb_ono has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
brettgilio has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
dddddd has quit [Remote host closed the connection]
robdog has joined #lisp
bilb_ono has quit [Quit: bilb_ono]
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
keep_learning_M has quit [Quit: This computer has gone to sleep]
robdog has quit [Ping timeout: 252 seconds]
bilb_ono has joined #lisp
bilb_ono has quit [Client Quit]
eschatologist_ has joined #lisp
eschatologist_ has quit [Excess Flood]
eschatologist_ has joined #lisp
eschatologist has quit [Ping timeout: 258 seconds]
robdog has joined #lisp
bilb_ono has joined #lisp
eschatologist_ is now known as eschatologist
keep_learning_M has joined #lisp
bilb_ono has quit [Client Quit]
Fare has joined #lisp
keep_learning_M has quit [Client Quit]
robdog has quit [Ping timeout: 252 seconds]
bilb_ono has joined #lisp
keep_learning_M has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
sumwun has quit [Ping timeout: 245 seconds]
<beach>
Good morning everyone!
robdog has joined #lisp
bilb_ono has quit [Quit: bilb_ono]
robdog has quit [Ping timeout: 252 seconds]
vlatkoB has joined #lisp
robdog has joined #lisp
keep_learning_M has quit [Quit: This computer has gone to sleep]
sjl has joined #lisp
<gilberth>
Good morning, beach.
mrSpec has quit [Ping timeout: 245 seconds]
robdog has quit [Ping timeout: 252 seconds]
Fare has quit [Ping timeout: 245 seconds]
notzmv has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
sauvin has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<beach>
Hey gilberth. I am preparing my ELS talks, so I spend more time in #sicl than here in #lisp.
Fare has joined #lisp
Necktwi has quit [Quit: leaving]
froggey has quit [Ping timeout: 240 seconds]
froggey has joined #lisp
anewuser has quit [Ping timeout: 246 seconds]
nanoz has quit [Quit: Leaving]
rumbler31 has joined #lisp
brettgilio has quit [Remote host closed the connection]
rumbler31 has quit [Ping timeout: 250 seconds]
bilb_ono has joined #lisp
JuanDaugherty has joined #lisp
<dtw>
There are several command-line parser packages in Quicklisp distribution but I have been unhappy with all of them: too fancy object system which I don't want to use, too much automatic messages or return value is unnecessarily complicated to parse. So I have used my own parsers which I have now generalized and published as a package: https://github.com/tlikonen/cl-just-getopt-parser Maybe someone wil find that useful.
JuanDaugherty has quit [Quit: Exeunt]
rippa has joined #lisp
<verisimilitude>
Have you considered using the CC0 instead of just public domain, dtw?
<verisimilitude>
This only affects those who live in countries that don't recognize public domain.
<verisimilitude>
I like how it's one file.
robdog has joined #lisp
<verisimilitude>
This seems rather nice, so far, dtw.
<dtw>
Thanks. Perhaps I have to consider CC0.
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog_ has quit [Ping timeout: 252 seconds]
nalkri has joined #lisp
<flip214>
Is there a YAML parser that records line numbers on the input, so that meaningful error messages on _semantically_ invalid data can be thrown?
Fare has quit [Ping timeout: 272 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
p9fn has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
heisig has joined #lisp
robdog has joined #lisp
JohnMS_WORK has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
wxie has joined #lisp
bilb_ono has quit [Quit: bilb_ono]
mrSpec has joined #lisp
space_otter has quit [Remote host closed the connection]
la_mettrie has joined #lisp
karlosz has joined #lisp
elazul has joined #lisp
wigust- has joined #lisp
Zaab1t has joined #lisp
wigust has quit [Ping timeout: 250 seconds]
angavrilov has joined #lisp
frodef has joined #lisp
robdog has joined #lisp
micro has quit [Remote host closed the connection]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog_ has quit [Ping timeout: 252 seconds]
nowhere_man has joined #lisp
holycow has joined #lisp
heisig has quit [Ping timeout: 246 seconds]
Ukari has quit [Ping timeout: 250 seconds]
Ukari has joined #lisp
micro has joined #lisp
shka_ has joined #lisp
karlosz has quit [Quit: karlosz]
robdog has joined #lisp
dgi has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
heisig has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
dgi has quit [Quit: reboot]
holycow has quit [Quit: Lost terminal]
aerique has quit [Read error: Connection reset by peer]
<cl-arthur>
I'm having trouble with a macro: (defmacro tt (ht) `(,ht (k) `(gethash ,k ,,ht))), and then (macroexpand-1 '(tt lowlink)) -> (LOWLINK (K) `(GETHASH ,K ,LOWLINK)).
<cl-arthur>
But my target is to expand into e.g. (lowlink (k) `(gethash ,k lowlink)). Having trouble figuring out how to get a simple "lowlink" into the double-backquoted list.
smasta has joined #lisp
aeth has quit [Ping timeout: 250 seconds]
<Bike>
,',ht i think
<Bike>
which will get you `(gethash ,k ,'lowlink)
aeth has joined #lisp
<Bike>
or you could just do (list 'gethash k 'lowlink) and save brain time.
robdog has quit [Ping timeout: 250 seconds]
jprajzne has quit [Quit: jprajzne]
smasta has quit [Ping timeout: 268 seconds]
jmercouris has joined #lisp
<jmercouris>
I have been thinking, if everything is an object, symbols must be objects, right?
<jmercouris>
and if symbols are objects, do they have two slots? one for a function, and one for a variable?
<jmercouris>
how does that work exactly?
Ukari has quit [Ping timeout: 255 seconds]
<jmercouris>
if it is an implementation detail, how does it work, on an implementation? I don't care which one, just curious
jprajzne has joined #lisp
dreamcompiler has joined #lisp
<jackdaniel>
it is an implementation detail
<jackdaniel>
in the past symbol property lists were used more extensively and there were indeed a slot for a function and a variable
<jmercouris>
so look-up time was probably rather slow?
<jmercouris>
if you had a lot of symbols within a package, yeah?
<jackdaniel>
if you have a function denoted by a particular symbol, said symbol exists in your image
<jmercouris>
okay, so here's a different question then
<beach>
jmercouris: Not everything is an object. A comment is not an object for instance.
meepdeew has joined #lisp
<jmercouris>
let's say we have package X and package Y, both package X and package Y use symbol Z
<jmercouris>
does Z exist in two spots within the image? or how exactly is that handled?
FreeBirdLjj has quit [Remote host closed the connection]
<beach>
jmercouris: Two pointers to one object.
<jmercouris>
to be clear I mean that X::Z and Y::Z are distinct
<beach>
jmercouris: Oh.
<beach>
That's different.
nanozz is now known as nanoz
<jackdaniel>
there may exist different symbols with the same name
<_death>
packages don't USE symbols
FreeBirdLjj has joined #lisp
<jmercouris>
_death: but symbols are declared within the context of a package
<jackdaniel>
not necessarily
<jackdaniel>
'#:foobar
<jmercouris>
ok ok, that is a good counter example
<jmercouris>
however, that's not the essence of my question
<jackdaniel>
please share the essence!
<jmercouris>
I'm trying to understand how the implementation knows that X::Z and Y::Z point to different things, and an example of how that is implemented
<beach>
jmercouris: All the standard says is that there exist functions SYMBOL-NAME, SYMBOL-PACKAGE, SYMBOL-VALUE, etc. It doesn't say how those are found.
<jmercouris>
so it could be literally anything
<jackdaniel>
symbol may be interned in a package
<jackdaniel>
so each package maintains a collection of symbols
<beach>
jmercouris: The implementation knows that they are different because the pointer values are different.
<jackdaniel>
names of symbols in said collection must be unique
<beach>
jmercouris: The addresses are not the same.
<jmercouris>
Okay
<jmercouris>
now I am getting a bit closer to understanding I think
* jackdaniel
still waits for the essence (i.e the reason why you ask)
<beach>
jmercouris: Conceptually, every Common Lisp object is manipulated indirectly using a reference.
<jmercouris>
beach: so in your hypothetical example, you're saying pointers, are you referring to actual memory addresses (in the C sense) or just some symbolic address?
<beach>
Yes, real addresses.
<jmercouris>
jackdaniel: the essence being, *what* I am asking, not *why*
<jmercouris>
I just wanted to know how an implementation might implement it
<jmercouris>
and what a symbol really is
<jackdaniel>
the most straightforward way to the former is to peek in the actual implementation, and for the latter is to read in the spec
<jmercouris>
my real real real meta question is why we insist on saying symbol X instead of var X or function X
<pjb>
You say one or the other depending on what you mean.
<beach>
jmercouris: Because symbols are first-class objects in Common Lisp.
<jmercouris>
and I guess I really wanted to understand what a symbol is
<jackdaniel>
I say function list, and I say variable *pretty-print*
<jmercouris>
not just from a user perspective, but from an implementation perspective
<pjb>
There may be several variables named by the symbol X. There may be several functions named by the symbol X.
<beach>
jmercouris: See the SICL definition then.
<jmercouris>
because it seems to be a very big distinction in Common Lisp, and I kind of get why, but I always like to confirm and reinforce my knowledge
<jmercouris>
Yes, I opened a tab
<jmercouris>
why the percent symbol in your slot?
<jmercouris>
so that people know not to access?
<pjb>
(let ((x 42)) (cons x (let ((x 33)) (cons x (flet ((x () pi)) (list (flet ((x () 'foo)) (function x)) (function x))))))) #| --> (42 33 #<Compiled-function x (Non-Global) #x3020024F8B9F> #<Compiled-function x (Non-Global) #x3020024FAAAF>) |#
<_death>
methodologically "essentialism" is flawed, as it leads to trilemma of assumption, circularity, or infinite regress.. so instead of asking "what is a symbol", it's better to ask about how symbols behave, what operators you can use on them, etc.
<beach>
jmercouris: It is a convention I use so that the name of the slot will not be accidentally exported or used in SLOT-VALUE.
Ukari has joined #lisp
<jmercouris>
_death: I don't know, I figured it would be better to simply ask without assuming all questions that are salient *about* symbols whether it is how they behave or what they are
<jmercouris>
pjb: I'll take a look one sec
<pjb>
jmercouris: for example, I could implement a common lisp computer using wool braids. You would still call them references…
<jmercouris>
this will take some time to look at all of this cod
<jmercouris>
s/cod/code, though cod is also funny :D
<jmercouris>
I'm not sure why I find fish so amusing
<beach>
jmercouris: Phrases such as "the function LIST" are short for "the function that has as its name the symbol LIST".
<pjb>
well cod can smell bad, (code smells) and your function can be fishy too.
<pjb>
as ONE of its names.
vlatkoB has quit [Read error: Connection reset by peer]
<jmercouris>
beach: could one also say something like "the function that is pointed to by the symbol LIST"?
<pjb>
(setf (symbol-function 'liste) (function list)) then the function LISTE is the same as the function LIST and it has two names…
<jmercouris>
because name, does a function ever actually have a name? just because a symbol points to it?
meepdeew has quit [Ping timeout: 259 seconds]
<beach>
jmercouris: No, because the symbol might not have a slot for the function, as you saw in the SICL definition.
<jmercouris>
a function is an object? does it have a slot, name?
meepdeew has joined #lisp
<beach>
jmercouris: A function is definitely an object.
<beach>
jmercouris: Not all functions have names.
<beach>
jmercouris: (lambda (x) x) is an example.
vlatkoB has joined #lisp
<beach>
Er, the result of evaluating that form I mean.
notzmv has joined #lisp
robdog has joined #lisp
<pjb>
Well, all functions are anonymous in a way: they're all created with (FUNCTION (LAMBDA …)), theorically. But named functions created with defgeneric or defun have their body wrapped in a block ,fname: (setf (symbol-function 'list) (FUNCTION (LAMBDA (…) (block list …)))) is what (defun list (…) …) does.
<pjb>
<pjb>
So there's theorically a way to distinguish "true" anonymous functions from defun functions, but also you can write (lambda (…) (block foo …)) and consider this anonymous functions could be named foo. Or bar. Or quux. This why even named functions cannot be considered differently than anonymous functions, fbound to some symbol…
<jmercouris>
I'm not understanding what exactly you are saying
<pjb>
I mean that being named
meepdeew has quit [Remote host closed the connection]
<pjb>
"being named" is not a property of a function.
<jackdaniel>
it may make sense to have a "name" property which captures its initial name (for instance for introspection)
<beach>
jmercouris: So as you can see, the function is not contained in the symbol.
<pjb>
(defvar *answer* 42) (let ((size 42)) (write-line "42 is named size and *answer*; is that even meaningful?"))
robdog has quit [Ping timeout: 268 seconds]
robdog has joined #lisp
<_death>
in Lisp, we say that symbols are first-class objects, but we don't say how these objects are represented.. they have function cells and value cells that can be accessed using symbol-function/symbol-value.. they also have a name, an optional package, an a plist associated with them
<beach>
_death: They don't necessarily have function cells or value cells.
<jmercouris>
yeah, that is however an error within the book a gentle introduction to symbolic computation :D
<jmercouris>
which says exactly that
<beach>
jmercouris: Yes, the book is wrong.
<_death>
beach: they may not necessarily be bound, is that what you mean?
<jmercouris>
I think he is saying that they don't have to be associated in any way, it could be an arbitrary data structure
<beach>
_death: No, I mean they may not exist.
<jmercouris>
that contains this data, they don't have to be cells
dreamcompiler has quit [Quit: dreamcompiler]
<_death>
beach: that is an implementation detail
pierpal has quit [Ping timeout: 264 seconds]
<beach>
_death: Yes, it is.
<jmercouris>
_death: that is what I think he is saying
meepdeew has quit [Remote host closed the connection]
<jmercouris>
however, _death, are you saying that calling them cells does not imply an implementation spec, and that a cell is just an abstract way of saying that this bit of data exists with a relation?
smasta has joined #lisp
<beach>
One could mean that, but it would be a very strange use of language to say that the symbol has a function cell if there is no such slot in the symbol.
<pjb>
On the other hand, it always has a plist. That's because (defun symbol-name (s) (get s 'apname)) (defun symbol-value (s) (get s 'value)) (defun symbol-function s (s) (get s 'fexpr)) were an implementation, once upon a time.
<_death>
yes.. to me..
<jackdaniel>
from the spec (symbol-function): " Accesses the symbol's function cell. "; function cell: "function cell n. Trad. (of a symbol) The place which holds the definition of the global function binding, if any, named by that symbol, and which is accessed by symbol-function. See cell. ", cell: "cell n. Trad. (of an object) a conceptual slot of that object. The dynamic variable and global function bindings of a
<jackdaniel>
symbol are sometimes referred to as its value cell and function cell, respectively. "; so traditionally speaking Gentle is not wrong ;)
Kundry_Wag has joined #lisp
<jackdaniel>
s/traditionally/conceptually/ (because of "a conceptual slot")
<pjb>
It's understood that those cells are "virtual" or abstract cells. Even CLOS instance cells don't necessarily represent an allocated place…
<jmercouris>
jackdaniel: if you look at the book, I would say it is definitely wrong despite the linked spec, because it shows very clearly some slots in a table for a symbol
<beach>
If so, symbols also have SETF function cells, method-combination cells, type cells, class cells.
<_death>
beach: I don't associate those with symbols
<beach>
But they *are* associated with symbols.
robdog has quit [Ping timeout: 268 seconds]
<jmercouris>
beach: has SICL beaten SBCL in any benchmarks?
<beach>
jmercouris: SICL doesn't exist, so no.
<jmercouris>
I think you were working on something involving speculative execution of branches or something?
<pjb>
jmercouris: you have to take it with a grain of salt.
<_death>
beach: yes.. but this conceptual association relation I'm talking about is not a symmetric.. see Tversky et al. :)
<jmercouris>
beach: in which sense? you cant even run (print "hello world") in SICL?
<pjb>
anything we explain is always pedagogical metaphore. Even when you try to explain things in the most objective way.
smasta has quit [Ping timeout: 255 seconds]
<pjb>
The only exact explanations AFAWK would be to give the wave function of the system we want to explain.
<beach>
jmercouris: One sort of can, but it is then running inside a host and not as a proper executable.
<pjb>
There's no bits in our computers.
<jmercouris>
I would disagree with that statement
<jackdaniel>
last time I've disassembled it I clearly saw all 64 bits
<jackdaniel>
they were placed in the top-right corner
<jmercouris>
there are most definitely bits, if we define a bit to be a charge or a lack of charge
nalkri has joined #lisp
<pjb>
Nope. You could have seen some lumps of copper and you may have counted 64 of them somewhere, but that's meaningless.
Kundry_Wag has quit [Ping timeout: 272 seconds]
<pjb>
You definitely didn't see bits.
<beach>
_death: I think those associations depend on the person doing the association. I have long thought about SYMBOL-FUNCTION as accessing the environment rather than the symbol.
<jmercouris>
environment?
<jmercouris>
what do you mean by the environment? the context of execution?
<jackdaniel>
I'm certain I did, I've even blinked a few times (or skipped the blink); 6 times in total
cage_ has joined #lisp
<pjb>
Using an oscilloscope, you might have observed some change in the electric electromagnetic field but this is still no bit. And no symbol, no lisp object nothing like it.
<_death>
beach: certainly it's a valid way of thinking, and can lead to useful representations
<beach>
jmercouris: Start on "The startup environment..."
<beach>
_death: I think it did. :) In fact, it is documented in an ELS paper.
<_death>
beach: ;)
Achylles has joined #lisp
<pjb>
That said, CL doesn't specify those environements as first class objects (the other kind of environment are first class objects, even if there's no public constructor and they cannot be introspected in CL).
<beach>
jmercouris: An environment is a mapping from names to objects.
<jmercouris>
environment, a set of bindings...???
<beach>
Yes.
<pjb>
sicl makes them first class objects, which we think will be a good thing.
<pjb>
But it's outside of CL.
<_death>
pjb: but it need not be inconsistent with CL
<jmercouris>
okay, what are names?
<pjb>
Indeed, it's not inconsistent.
<beach>
jmercouris: Symbols, typically.
<pjb>
Also lists like (setf foo)
<beach>
jmercouris: With a few exceptions.
<jmercouris>
I thought symbols have a name representation
<jmercouris>
but are not names themselves
<pjb>
jmercouris: names can have names!
<beach>
jmercouris: (SETF FOO) as pjb points out, and strings for naming packages.
<pjb>
the name of the variable is the symbol X. The name of the symbol X is the string "X".
<jmercouris>
names can have names, I see now
<jmercouris>
that makes sense
<jmercouris>
so symbol-function accessing the enviornment rather than the symbol
robdog has joined #lisp
<jmercouris>
back to that statement
<jmercouris>
an environment is a set of bindings
<beach>
Yes.
<jmercouris>
a set of name -> object relations
<beach>
Yes.
<jmercouris>
a symbol is a name, or can be
<beach>
Yes again.
<pjb>
(defun symbol-function (x) (gethash x (function-table *environment*))) is another valid implementation.
<jmercouris>
so just wait a moment here, I don't see the difference
<beach>
jmercouris: It can be the name of a function, a class, a method combination, a type, etc.
<jmercouris>
environment -> binding-> symbol operation
<jmercouris>
instead of symbol -> symbol operation
<pjb>
CL doesn't specify the implemention of CL operation, only their interface and semantics.
<beach>
jmercouris: What?
<Bike>
What's a "symbol operation".
<jmercouris>
I'm having trouble putting this into words
<Bike>
Are you asking what the difference is between the symbol "having" a cell, and the environment version?
Th30n has quit [Quit: ERC (IRC client for Emacs 26.1)]
<jmercouris>
a symbol operation would be the example given above which was SYMBOL-FUNCTION
<pjb>
AFAIR, there are only 2 algorithms specified in clhs: the reader algorithm, the backquote algorithm. (And we may infer one or two other algorithms more).
<jmercouris>
a function or method that operates on a symbol
<beach>
jmercouris: You can safely forget about that. The prefix SYMBOL- has no meaning.
<pjb>
But even those are only indicative: an implementation can use another algorithm behaving the same and those.
<jmercouris>
okay, however I still don't understand your comment that you made above
<jmercouris>
can you please clarify how you and _death disagree?
<beach>
Me?
<jmercouris>
yes
<_death>
we don't disagree.. we just used two different conceptual models
<beach>
Exactly.
<jmercouris>
ok, can either of you clarify the differences in your conceptual models
<jmercouris>
or perhaps re-explain them, such that I may have the opportunity to understand
<_death>
an analogy can be structure-of-arrays vs. arrays-of-structure
<pjb>
The thing is that you can both forget it or take it at face value, whatever helps you understand what you want to understand. (defstruct symbol name value function package plist) is a perfectly good explaination of symbols too.
<beach>
jmercouris: _death thinks that function cells and value cells are strongly associated with symbols, but not (say) classes.
<jmercouris>
pjb: the struct is actually how I usually imagine them in head, interestingly enough
<_death>
both can serve as property representations of the same conceptual entity
<Bike>
i think this is something where you could talk about it for hours, or just write a simple interpreter and have it be obvious
robdog has quit [Ping timeout: 264 seconds]
<jmercouris>
beach: It makes sense though, why would a function cell be strongly associated with a class?
<beach>
jmercouris: I see symbol-function as similar to find-class, i.e. as operations on the environment.
<jmercouris>
so you think it was erroneously named?
<beach>
jmercouris: I meant "class cell"
<jmercouris>
ok
<beach>
jmercouris: Functions have names, so do classes. There is no particular reason to treat them differnetly.
<jmercouris>
functions are exectuable, classes are not
<jmercouris>
however that may be irrelevant
<beach>
Yes, it is irrelevant
<_death>
you can think of a symbol as an abstract data type, with certain behavior and various accessors, and any representation that fits that behavior will do
<beach>
jmercouris: They corrected the problem when they introduced FDEFINITION.
<pjb>
For example, one strong reason why we would want to have value and function outside of a symbol object, are threads (which are not specified in clhs). And having separate environments in the same lisp image is another reason.
<beach>
jmercouris: I treat symbol-function as deprecated in favor of fdefinition.
<jmercouris>
still though, why is it called fdefinition?
<jmercouris>
it seems to be tied to functions
<jmercouris>
I know it says "or may be an object"
<beach>
jmercouris: Yes, given the name of a function, it returns the function.
themsay has quit [Read error: Connection reset by peer]
themsay has joined #lisp
<beach>
jmercouris: Here is how I see it. In the old days, functions could only be named by symbols, so it was "natural" to store the function in a slot of the symbol, and to have a function called symbol-function. Then they introduced names such as (SETF FOO). Instead of adding a function symbol-setf-function, they created a new function FDEFINITION. It no longer mentions SYMBOL, so it is more "natural" to think of it as accessing the
<beach>
environment.
<jmercouris>
I thought setf is a macro?
<jmercouris>
so symbol-setf-macro-function, no?
<pjb>
Yes. Notice also that in the old time there were several kinds of functions fexpr, subr, etc. Nowadays, two kinds of functions can be bound to symbols: (symbol-function 'x) and (macro-function 'x).
<jackdaniel>
SETF is a macro, (SETF FOO) is not
<jmercouris>
and I don't understand why SETF necessitated the creation of FDEFINITION
<beach>
jmercouris: In this case, it is just a way of naming functions.
<pjb>
and indeed, (setf macro-function) and (setf symbol-function).
<jmercouris>
ok
<pjb>
jmercouris: because symbol-function can take only a symbol, not a list.
<jmercouris>
alright, now I understand the brief explanation at least
<beach>
jmercouris: Given the name (SETF FOO), there was a need to find the corresponding function.
<pjb>
It's a typing question.
<jmercouris>
yes, I see
<jackdaniel>
try: (defun (setf foo) (x object) (break "setting ~s in ~s" x object))
<jackdaniel>
and call (setf (foo 'bam) 42)
robdog has quit [Ping timeout: 268 seconds]
<jmercouris>
fascinating
<jmercouris>
so in fact the function is not named by a symbol
<jmercouris>
but by a list
<beach>
It can be.
<pjb>
Yes.
<jmercouris>
ah, and that is useful for macros in some way?
<beach>
No.
<jackdaniel>
that's why in cltl2 you could compare function names with eql and in ansi cl you can't (in the compiler)
<jmercouris>
why was this functionality useful?
<pjb>
But note that defun still use foo to name the block, not (setf foo), since block names must be symbols!
<pjb>
(defun (setf foo) (x object) (if (integerp object) (return-from foo x)) (error "expected an integer, not ~S" x))
<beach>
jmercouris: Because it is what (SETF (FOO 'BAM) 42) expands to if no setf expander has been defined.
<pjb>
not (return-from (setf foo)).
<jmercouris>
Oh!
<jmercouris>
I see now
<beach>
jmercouris: As jackdaniel showed.
<jmercouris>
Right right
<jmercouris>
okay, the code example really helps yes
<jmercouris>
very interesting
<jackdaniel>
moreover, if you are not interested in being conforming: (defun (setf bar) (a b c object) …) (setf (bar 'xxx) (values 1 2 3))
<beach>
jmercouris: So now do you see why I don't think symbol-function or fdefinition are operations on symbols, but on the environment?
Jesin has quit [Quit: Leaving]
<beach>
jmercouris: And in fact, SYMBOL-VALUE probably doesn't access the "value cell" anyway, at least not in a multi-threaded Common Lisp implementation.
<beach>
... other than perhaps the global value.
pierpal has quit [Ping timeout: 250 seconds]
<beach>
Anyway, time to go fix dinner.
<jmercouris>
I think I may see, not sure, guten appetit
<jmercouris>
I'm going to rest as well, my mind is tired from thinking, thanks for the explanations everyone
robdog has joined #lisp
Jesin has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
smasta has joined #lisp
jprajzne has quit [Quit: jprajzne]
smasta has quit [Ping timeout: 250 seconds]
Achylles has quit [Remote host closed the connection]
<_death>
I think a good followup question you should have, with beach's model in mind, is why symbol-function and friends don't take an environment parameter
robdog has joined #lisp
nicdev has joined #lisp
amerlyq has joined #lisp
pierpal has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
<beach>
_death: Yes, the standard is very inconsistent with things like that.
<beach>
The immediate answer is probably "for historical reasons".
<beach>
For example FIND-CLASS takes an optional environment.
<beach>
"... is used to distinguish between compile-time and run-time environments."
igemnace has quit [Ping timeout: 246 seconds]
<_death>
also, weaker association between names and objects (first-classization) is something that appeals to many scheme-minded people
robdog has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
igemnace has joined #lisp
<pjb>
_death: that's because they're the standard API. (defun symbol-function (sym) (sicl:symbol-function sym sicl:*environment*))
<_death>
pjb: the begs the question.. I asked about the standard functions.. I agree that it's due to historical reasons
robdog has joined #lisp
bilb_ono has joined #lisp
dale has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
CuriousCain has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
polezaivsani has joined #lisp
scymtym has quit [Ping timeout: 240 seconds]
jprajzne has joined #lisp
makomo has quit [Quit: WeeChat 2.2]
jack_rabbit_ has joined #lisp
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
cage_ has quit [Remote host closed the connection]
Posterdati has quit [Ping timeout: 252 seconds]
Selwyn has joined #lisp
Posterdati has joined #lisp
nowhere_man has joined #lisp
Oladon has quit [Quit: Leaving.]
nowhere_man has quit [Ping timeout: 246 seconds]
bilb_ono has quit [Quit: bilb_ono]
bilb_ono has joined #lisp
nowhere_man has joined #lisp
nanoz has quit [Read error: Connection reset by peer]
xkapastel has quit [Quit: Connection closed for inactivity]
<phoe>
Like, if I declare A, B, C locally inline, and A calls B, and B calls C, will everything get inlined?
<pjb>
For global functions, IIRC you will have to declare them both inline and notinline.
<pjb>
So that you can redeclare them inline locally. But check the clhs about that…
<phoe>
To define a function f that is not inline by default but for which (declare (inline f)) will make f be locally inlined, the proper definition sequence is:
<phoe>
(declaim (inline f)) (defun f ...) (declaim (notinline f))
<pjb>
(and the implementation manual, it's rather implementation dependent).
<phoe>
That's what the CLHS says.
<pjb>
It will also depend on the optimize levels.
<pjb>
Yes.
<phoe>
Global optimize levels, or local ones?
<pjb>
local too.
meepdeew has joined #lisp
<pjb>
or global by default.
<phoe>
I can locally set optimize to speed 3.
<phoe>
Will that be enough?
Zaab1t has quit [Ping timeout: 250 seconds]
<pjb>
again, implementation dependent. I would also do (debug 0) to ensure it.
jprajzne has quit [Quit: jprajzne]
Josh_2 has quit [Remote host closed the connection]
jprajzne has joined #lisp
jack_rabbit_ has joined #lisp
meepdeew has quit [Ping timeout: 246 seconds]
<phoe>
If a function is locally inlineable, am I also able to compile it with different optimization settings?
<phoe>
Like, will I be able to compile it locally inline with speed 3 if the original function is compiled with speed 1?
meepdeew has joined #lisp
jprajzne has quit [Quit: jprajzne]
robdog has joined #lisp
jprajzne has joined #lisp
vlatkoB has quit [Remote host closed the connection]