morganw has quit [Remote host closed the connection]
poselyqualityles has joined #commonlisp
Inline has joined #commonlisp
aeth has quit [Ping timeout: 240 seconds]
Inline has quit [Max SendQ exceeded]
Inline has joined #commonlisp
aeth has joined #commonlisp
yauhsien has quit [Ping timeout: 256 seconds]
razetime has joined #commonlisp
poselyqualityles has quit [Ping timeout: 256 seconds]
<char[m]>
For concrete-syntax-tree lambda-lists, what is a good way to specialize on something like the form-mixin? Do I need to check subtypep before calling cst:form?
Inline has quit [Read error: Connection reset by peer]
Spawns_Carpeting has quit [Quit: ZNC 1.8.2+deb2+b1 - https://znc.in]
Spawns has joined #commonlisp
yauhsien has joined #commonlisp
Spawns is now known as Spawns_Carpeting
semz has quit [Ping timeout: 260 seconds]
zeroc00l0 has joined #commonlisp
Guest52 has quit [Ping timeout: 250 seconds]
semz has joined #commonlisp
occ has joined #commonlisp
zacts has joined #commonlisp
occ has quit [Ping timeout: 248 seconds]
occ has joined #commonlisp
clsper03 has joined #commonlisp
<clsper03>
how to handle with API post using Drakma or Dexador?
tyson2 has quit [Read error: Connection reset by peer]
<beach>
Good morning everyone!
<beach>
clsper03: Please don't paste more than one line of code into the channel. And especially not to several channels.
<beach>
clsper03: And your code is not even Common Lisp.
<clsper03>
sorry , I'm newbee
<beach>
char[m]: What is it that you are trying to do?
<clsper03>
using Common lisp to do what Python do,that post some data through API
<beach>
I was asking char[m] with respect to an earlier question about lambda lists.
aeth has quit [Ping timeout: 260 seconds]
occ has quit [Ping timeout: 240 seconds]
<clsper03>
but ,It seems that no matter Drakma or Dexador,just support post string ,rather nested data like arrays
zacts has quit [Quit: Client closed]
aeth has joined #commonlisp
<char[m]>
beach: I want an alist of parameter-name:default-value where default-value is nil if it is not provided or a required parameter.
<beach>
char[m]: And what kind of lambda list is this? An "ordinary lambda list"?
<beach>
char[m]: You are probably better off using the code in SICL. Let me look it up for you...
<char[m]>
beach: ordinary for now and I can adapt it to the others when I get to them.
<beach>
OK, hold on...
Inline has joined #commonlisp
<beach>
char[m]: I recommend you use CLEAVIR-CODE-UTILITIES:CANONICALIZE-ORDINARY-LAMBDA-LIST from the SICL repository. The result of a call to that function should be much easier to process for you.
yauhsien has quit [Remote host closed the connection]
<beach>
char[m]: There are several relatively good comments in Code/Cleavir/Code-utilities/lambda-list.lisp
<beach>
You should be able to figure it out. And feel free to copy the code if you don't want to drag in all of SICL.
semz_ has joined #commonlisp
Inline has quit [Ping timeout: 256 seconds]
<char[m]>
beach: I found cst very nice to work with by defining my own methods on the super classes, but that approach was not working for the mixins, so I had to define the same method on all the subclasses.
<char[m]>
Thank you. I'll look at that (not at computer right now).
semz has quit [Ping timeout: 248 seconds]
<beach>
char[m]: I am not at all happy with the lambda-list parsing code of Concrete Syntax Tree, and I might abandon it in favor of a library that scymtym is working on, called s-expression syntax or something like that.
<beach>
It seemed like a good idea, but then the parsing code became too weird.
<char[m]>
beach: I see. I didn't get into the parsing part of it.
zeroc00l0 has joined #commonlisp
<beach>
I understand. It is just that the code is not fresh in my memory, so it would take me some time to figure out how to do what you want.
<beach>
... and I am kind of busy today, because I have guests over for lunch. :)
akoana has quit [Quit: leaving]
igemnace has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
igemnace has joined #commonlisp
<Nilby>
clsper03: write your data to a string using a json library like e.g. (jsown:to-json `(:obj (foo . 1) (bar . "two") (baz . ,(sqrt 3)))
yauhsien has quit [Remote host closed the connection]
* Nilby
will never touch the trackpad near irc again
occ has joined #commonlisp
IAmRasputin has quit [Ping timeout: 250 seconds]
IAmRasputin has joined #commonlisp
zacts has joined #commonlisp
<char[m]>
beach: is there a reason to the way you name directories? Capital first letter.
<beach>
Historical reasons mainly.
<beach>
They used to show up first in `ls'.
<char[m]>
What is the logic behind putting all systems in one repository? I understand they are worked on my different peoplebeach
<char[m]>
s/my/by
<beach>
We have extracted several already, and we want to extract more when they are ready.
<char[m]>
Interesting.
yauhsien has joined #commonlisp
<beach>
We already extracted Eclector, Cleavirv2, Concrete Syntax Tree, Trucler, Clostrum, Cyclosis, Incless, and probably more that I can't remember right now.
<beach>
I would like to point out that it is not a trivial thing to incorporate independently maintained repositories into a fresh build of a Common Lisp implementation. Most Common Lisp implementations need to have specifically written code for it to be useful to them.
<beach>
Our ambition is to be able to deal with external libraries as part of the core system, and that is why I am (still) working on the details of the bootstrapping technique.
<beach>
We would like to extract more. In particular, FORMAT and LOOP are ready to be extracted and to be separately maintained.
zacts has quit [Quit: Client closed]
aartaka has joined #commonlisp
hashfunc487 has joined #commonlisp
<hashfunc487>
when should someone opt for SETQ instead of SETF?
<hashfunc487>
or vice versa
<rotateq>
hashfunc487: It's again in my opinion to give clear reading intent. SETQ is for setting symbols and also symbol-macros, sure when SETF is called on those it compiles to a SETQ form, but SETF is for places.
<hashfunc487>
rotateq: ok, but can't any arbitrary symbol be considered a place as well?
occ has quit [Ping timeout: 248 seconds]
<rotateq>
Yes it can in this direction, so SETF will always work.
<rotateq>
An important rule is "be specific".
<beach>
hashfunc487: You can consider SETQ obsolete, just like RPLACA and RPLACD.
<rotateq>
beach: Oh.
IPmonger has joined #commonlisp
IPmonger has quit [Remote host closed the connection]
<hashfunc487>
ok fair enough
<hashfunc487>
beach: rotateq: thanks for the feedback
<rotateq>
hashfunc487: Yes better go with the other advise then. I'll do that too from now on, but it was totally new to me.
<rotateq>
So it's good there no ROTATEQ symbol and just ROTATEF or I would be obsolete by now too.
<rotateq>
It makes much sense if I think about it, so one can change a symbol place to a non-symbol place in a SETF form with changing SETQ to SETF.
<jackdaniel>
wait till you learn what SET does :)
<rotateq>
jackdaniel: Never used it. So ... :)
<jackdaniel>
it sits in the corner and waits for better days for symbolic computing
<rotateq>
Those will rise again as the world needs exact computing too.
<rotateq>
But maybe it would be good knowing really every standard symbol some day or the differences to CLtL1 when it comes up refactoring older code base somewhere.
<jackdaniel>
sure, also some seemingly obsolete operators sometimes come handy
zeroc00l0 has quit [Ping timeout: 250 seconds]
<jackdaniel>
so perhaps out of fashion is a better term (some operators are dubbed deprecated in the spec, but I don't remember any labelled obsolete)
<rotateq>
Or keywords like those `:test-if-not`.
zeroc00l0 has joined #commonlisp
<rotateq>
jackdaniel: Or when we write a new cool implementation and bootstrap this with SICL of course.
<mfiano>
jackdaniel: Closest thing is probably GENTEMP
occ has joined #commonlisp
occ has quit [Ping timeout: 246 seconds]
pillton has quit [Quit: ERC 5.4 (IRC client for GNU Emacs 28.1)]
occ has joined #commonlisp
hashfunc487 has quit [Remote host closed the connection]
jeosol has quit [Ping timeout: 250 seconds]
<jackdaniel>
require and provide are also explicitly deprecated
<aeth>
so when are we going to get a new standard passed just to remove the deprecated functions?
<aeth>
that's what everyone wants, after all
akoana has joined #commonlisp
shka has joined #commonlisp
MichaelRaskin has joined #commonlisp
<zeroc00l0>
aeth: Does passing a new standard mean something different than just getting all of the compiler writers to agree?
MajorBiscuit has joined #commonlisp
<aeth>
see, that's an actually serious quesiton now :-p
occ has quit [Ping timeout: 240 seconds]
<aeth>
zeroc00l0: but, yes, that's all you really need. A consensus of compiler writers. See Scheme's standards process. It's just a PDF. There is an official standard that's roughly r4rs or something, but that's way outdated for the same reason that CL's official standard is outdated
<aeth>
(money)
<zeroc00l0>
What is the advantage for me (or any other CL dev) to have IEEE promote some PDF as 'official'?
clsper03 has quit [Quit: Client closed]
<jackdaniel>
some grants may require an official standard for the language to be used in the project
<aeth>
government/bureaucracy stuff in general
<jackdaniel>
also saying: c99 is less ambiguous than saying cc or gcc or clang
<zeroc00l0>
Well, we can write a PDF and give it a name and all of that. But point taken w.r.t. bureaucratic issues.
<jackdaniel>
'a portable common lisp program but using sb-ext' sounds like an oxymoron too, but without a standard you can't tell what is portable
<jackdaniel>
does sbcl manyal constitue a standard? if not, perhaps a document hosted by lispworks? what if they update it to include capi?
<jackdaniel>
manual
<aeth>
jackdaniel: zeroc00l0 is talking about the difference between a standard that's just a consensus-backed PDF and a standard that goes through one of ANSI, ECMA, IEEE, etc.
<aeth>
and the answer is that there really isn't one, unless you're a bureaucracy
<aeth>
bureaucracy isn't really an office-ocracy as the name implies... it's a rules-ocracy. And you can't really have rules without someone official providing something objective to go off of, even though you or I could tell the difference between a de facto standard PDF and some random self-proclaimed CL community leader's attempt at a new CL
<aeth>
but the point of a bureaucracy is to get rid of these individual judgement calls
<jackdaniel>
the fact that >25y after the standard was published there is no consensus for quitting the program but all have gentemp implemented shows, that official standards have some weight ;)
<aeth>
because that one person who causes lots of drama mostly talked about in #lispcafe who I won't name could just as easily promote a new CL "standard" as a consensus of compiler writers
<aeth>
and the point of standards bodies is so the government of Aethopia can tell the difference
<aeth>
(which isn't an issue because they just go off of ANSI)
<zeroc00l0>
How would it work otherwise? Someone at ANSI would go out and pick people who he wants on the new standard committee?
Dynom has joined #commonlisp
<Nilby>
if microsoft or google wanted a new CL standard i bet it would get approved in few months, and probably suck, but people without pre-"authority" have to create authority by authoring something becomes defacto, or widely cooperating which seems unlikely
<Josh_2>
aeth: you dont need a new standard, fork SBCL and remove them :)
treflip has joined #commonlisp
<Josh_2>
If you can convince enough influential people that it was the right move, perhaps we will have a new informal standard
MajorBiscuit has quit [Ping timeout: 256 seconds]
<Nilby>
i think you don't have to convince anybody, someone(s) just have so step up and do a huge diffucult job well enough that people want it
occ has joined #commonlisp
<zeroc00l0>
Probably someone who already has credibility in the CL community.
<Josh_2>
Nilby: pretty much
<zeroc00l0>
But yeah, it'd be hundreds (or thousands) of hours of work, with likely no financial compensation.
<Nilby>
mostly the credibility for the CL commitee was to have an written an existing working implementation
karlosz has joined #commonlisp
<zeroc00l0>
How have these types of committees been structured historically, or their specific roles on them?
<zeroc00l0>
s/their/there
karlosz has quit [Ping timeout: 250 seconds]
<Nilby>
it think it changed a bit over the 10+ years it took, but mostly it was getting lisp implementors (+ some other random troublemakers [rms]) to agree. i forget where, but somewhere there's an archive of email exchanges of people on committee, so you can read for yourself some of how it worked
<Nilby>
s/troublemaker/GNUisance/
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
<zeroc00l0>
GNUfather
cage has joined #commonlisp
MajorBiscuit has joined #commonlisp
yauhsien has quit [Ping timeout: 250 seconds]
azimut has quit [Ping timeout: 240 seconds]
<beach>
zeroc00l0: I think you have the wrong general idea. ANSI or ISO or anybody else doesn't have any competence of their own in the domain. The committees are formed by people who care and who are willing to pay the cost. The main role of the standardization organization is to publish a document that the people doing the implementation do not control in any way.
azimut has joined #commonlisp
s-liao has joined #commonlisp
<zeroc00l0>
When you say, "the cost", what do you mean more specifically?
<zeroc00l0>
The people doing the implementation are the same people who write the document, right? So what do you mean that those people do not control the document?
<beach>
zeroc00l0: Having people travel to meetings, taking time off from work to design the standard, etc.
<beach>
When the document is published by ANSI or ISO or some other standardization organization, it is then copyright by that organization, and can not be altered by the people using the document to create an implementation.
<beach>
zeroc00l0: You could accomplish the same thing by having all maintainers agree on a particular version of the document and then freeze it in some way.
<zeroc00l0>
If everyone agrees on a particular version of the document, why does it matter if its frozen or not?
unixlisp has joined #commonlisp
<beach>
zeroc00l0: Another thing you seem to have misunderstood is that standardization organizations have no power to declare something as preferable over something else. They are either private organizations or associations, but (despite the name) have no legal power to impose the standards they publish.
<zeroc00l0>
(or, I'm not sure what additional fact 'freezing' conveys that agreeing to a particular version doesn't)
<MichaelRaskin>
If everyone is currently in agreement about something, it is useful to have an unambiguously referenceable version of this agreement for the later times when consensus changes or disappears
<beach>
zeroc00l0: If it is not frozen, then new implementors and users can not rely on it being stable.
<zeroc00l0>
What does 'frozen' mean?
<beach>
I guess the same thing as "agreeing to it".
<MichaelRaskin>
Well, this plus creating an immutable way to refer to it
<beach>
But it has to be clearly labeled so that it can not be altered, and one way of doing that is to have it published by a standardization organization.
<beach>
Right.
<zeroc00l0>
Or just by publishing a SHA-256 hash of the document.
s-liao has quit [Ping timeout: 250 seconds]
<beach>
That would be possible.
<zeroc00l0>
And getting all of the collaborators to sign it.
karlosz has joined #commonlisp
s-liao has joined #commonlisp
<beach>
Getting everybody to agree is a costly thing, though.
waleee has joined #commonlisp
<zeroc00l0>
Getting the compiler writers to agree is good evidence that they will in fact adopt the standard. So, maybe it's worth it.
<Josh_2>
"The original design of the Common Lisp language, culminating in the 1984 publication of Common Lisp: The Language was designed not by an ANSI committee but just by a set of interested individuals. "
waleee has quit [Ping timeout: 240 seconds]
yauhsien has joined #commonlisp
<zeroc00l0>
Thanks for the link.
karlosz has quit [Quit: karlosz]
occ has quit [Ping timeout: 246 seconds]
dickbar__ has joined #commonlisp
<beach>
zeroc00l0: The problem is that they don't agree, so there has to be some kind of organization that everybody agrees upon, i.e., who are the members, how is an issue voted on (unanimity, simple majority, something else. We can't just accept anybody as a member of such an organization. As I often point out, many suggestions for new features exposed here would make it almost impossible to write a good compiler.
<pjb>
That's a good idea. Let's create a new organization that everybody agrees upon! https://xkcd.com/927/
<unixlisp>
And even Standards are not mainly technical, but somewhat social, such as antitrust.
<Josh_2>
Talking about a standard is a waste of time when someone has to push the boat out and implement new features anyway ;)
* jackdaniel
resists the temptation to suggest making a channel #commonlispstandarddiscussions ,)
<jackdaniel>
Josh_2: extensions does not invalidate the standard, they provide hints what is and what is not useful
<jackdaniel>
standardization is a process of embracing existing practices in an uniform way
<Josh_2>
Standardization would only be necessary if you had a situation similar to that which prompted the standardization originally
<jackdaniel>
I don't know what that means
<Josh_2>
There aren't a variety of different implementations of CL that do their own things
<jackdaniel>
ekhm, each has slightly different api for threading, operating system interface, foreign function interface, basically numerous features that are not standardized
<Josh_2>
Perhaps there is simply no need for any serious additional features beyond "standardizing" those nuisances
<jackdaniel>
the fact that they may be accessed in a semi-uniform way is thanks to portability libraries, but that's not that much different than #ifdef SUNOS_GCC_4_1_HAS_A_PIKABOO
<Josh_2>
So really there is no need at all
<jackdaniel>
I'm not arguing for a new standard, but your line of thought seems to be incosistent to me
<Josh_2>
I'm not arguing for one either
<jackdaniel>
that I can tell
lisp123 has joined #commonlisp
<Josh_2>
If someone forked SBCL and implemented some killer new feature that was then implemented in 5 different ways by 5 different vendors then perhaps a standard would have to be considered, or a compatibility library
<Josh_2>
The effort is not worth it for a consistent threading API
<lisp123>
pjb: the same xkcd can also apply to languages
s-liao has quit [Ping timeout: 250 seconds]
<lisp123>
EVERY big tech organisation has their own
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
yauhsien has quit [Ping timeout: 246 seconds]
kpoeck has joined #commonlisp
WBarends has joined #commonlisp
zeroc00l0 has quit [Ping timeout: 250 seconds]
yauhsien has joined #commonlisp
zeroc00l0 has joined #commonlisp
semz_ is now known as semz
pranavats has left #commonlisp [Error from remote client]
aartaka has quit [Ping timeout: 256 seconds]
unixlisp has quit [Quit: Client closed]
kpoeck has quit [Quit: Client closed]
Inline has joined #commonlisp
dickbar__ has quit []
pranavats has joined #commonlisp
aartaka has joined #commonlisp
Oddity has quit [Ping timeout: 248 seconds]
sander is now known as sandercat
d4ryus has quit [Quit: WeeChat 3.5]
occ has joined #commonlisp
perrierjouet has quit [Ping timeout: 250 seconds]
kpoeck has joined #commonlisp
perrierjouet has joined #commonlisp
Inline has quit [Remote host closed the connection]
d4ryus has joined #commonlisp
s-liao has joined #commonlisp
akoana has quit [Quit: leaving]
Inline has joined #commonlisp
tyson2 has joined #commonlisp
aartaka has quit [Ping timeout: 240 seconds]
aartaka has joined #commonlisp
random-nick has joined #commonlisp
Inline has quit [Read error: Connection reset by peer]
Inline has joined #commonlisp
yauhsien has quit [Remote host closed the connection]
triffid has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
Inline has quit [Read error: Connection reset by peer]
triffid has joined #commonlisp
yauhsien has quit [Ping timeout: 248 seconds]
Inline has joined #commonlisp
Inline has quit [Remote host closed the connection]
Inline has joined #commonlisp
Inline has quit [Read error: Connection reset by peer]
s-liao has quit [Quit: Client closed]
s-liao has joined #commonlisp
zacts has joined #commonlisp
occ has quit [Ping timeout: 246 seconds]
MajorBiscuit has quit [Ping timeout: 256 seconds]
razetime has quit [Ping timeout: 248 seconds]
lisp123 has quit [Remote host closed the connection]
razetime has joined #commonlisp
MajorBiscuit has joined #commonlisp
zeroc00l0 has quit [Quit: Client closed]
gaqwas has joined #commonlisp
occ has joined #commonlisp
wyrd has quit [Remote host closed the connection]
wyrd has joined #commonlisp
lisp123 has joined #commonlisp
Bike has joined #commonlisp
gaqwas has quit [Remote host closed the connection]
<char[m]>
jackdaniel: require and provide are famously deprecated (only in clhs?). Provide is obviously replaced by asdf, but I can load asdf systems just fine by using require.
<jackdaniel>
char[m]: I've said that earlier; I've even mentioned these two
<jackdaniel>
what I've said that I'm not aware of any operator declared 'obsolete' in the standard, there is a difference between the two
<jackdaniel>
also provide is not replaced by asdf because asdf is not part of the standard; we could agree that there is no standard system managament facility in common lisp (although asdf is so called de-facto standard)
<jackdaniel>
n.b the term 'system' is not defined in the spec afaict
igemnace has quit [Remote host closed the connection]
<char[m]>
Yeah, they are different. Provide makes a file loadable, while asdf make a system loadable. The latter is just more useful.
<char[m]>
s/loadable/requireable
<jackdaniel>
the difference I'm trying to emphasize is that one is a common lisp standard operator, while the other is a common lisp program
<char[m]>
Point made. I'm just asking is it wrong to use require instead of asdf:load-system, being that require isn't going anywhere.
lisp123 has quit [Remote host closed the connection]
<jackdaniel>
require and provide are underspecified, so that heavily depends on the implementation
<jackdaniel>
sometimes require is the only way to get the implementation extension, so asdf includes (:require …) dependency type to make it accessible in asd
<jackdaniel>
on the other hand some implementations provide a hook to extend the require mechanism and asdf plugs itself there, so sometimes (require "alexandria") will work thanks to that if alexandria is available in asdf central registry
Inline has joined #commonlisp
occ has quit [Ping timeout: 250 seconds]
<jackdaniel>
but module and system are not equivalent terms - module is underspecified object, while system is a standard class in the library called asdf
<jackdaniel>
and require operates on "modules"
aartaka has quit [Ping timeout: 240 seconds]
<jackdaniel>
the prime reason to not use REQUIRE and PROVIDE is that they are underspecified, not that they are deprecated (because indeed they are not going anywhere)
aartaka has joined #commonlisp
aartaka has quit [Ping timeout: 248 seconds]
occ has joined #commonlisp
aartaka has joined #commonlisp
<dlowe>
they could have been a lot more useful if a hook mechanism had been proposed
<char[m]>
dlowe: I would like a lot more standard hooks to be provided.
sandercat has quit [Quit: So long! :)]
sander has joined #commonlisp
aartaka has quit [Ping timeout: 248 seconds]
waleee has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
<mfiano>
Is it just me, or does SLIME/SLY sort keyword arguments in the eldoc signature alphabetically? Why have I never noticed this before. I was beginning to think my image was out of sync with my code...
<mfiano>
No wait, it's not even lexicographic order...it seems random?
<Nilby>
it should be the same order as the definition
tyson2 has quit [Remote host closed the connection]
Oladon has joined #commonlisp
ldb has joined #commonlisp
tyson2 has joined #commonlisp
aeth has quit [Ping timeout: 256 seconds]
razetime has quit [Ping timeout: 256 seconds]
aeth has joined #commonlisp
kpoeck has quit [Quit: Client closed]
MajorBiscuit has quit [Ping timeout: 256 seconds]
razetime has joined #commonlisp
occ has quit [Ping timeout: 240 seconds]
MajorBiscuit has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
kpoeck has joined #commonlisp
ldb has quit [Ping timeout: 250 seconds]
Oladon has quit [Quit: Leaving.]
Oladon has joined #commonlisp
<flip214>
jackdaniel: oh, I thought you meant an unicode RTF character - that would simply turn the reading direction around
Oladon1 has joined #commonlisp
<jackdaniel>
heh; I was bantering either way
Oladon has quit [Ping timeout: 240 seconds]
MajorBiscuit has quit [Ping timeout: 260 seconds]
morganw has joined #commonlisp
<White_Flame>
_death: "didn't get rtl right" heh
<jackdaniel>
details are /left/ as an excercise to the /reader/
<jackdaniel>
s/to/for/
razetime has quit [Ping timeout: 248 seconds]
kpoeck has quit [Quit: Client closed]
<rotateq>
jackdaniel: ah like easy things as "all zeros lie on Re = 1/2"
tyson2 has joined #commonlisp
Oladon1 is now known as Oladon
Oladon has quit [Quit: Leaving.]
Oladon has joined #commonlisp
<dieggsy>
i'm fairly certain the answer is yes, but as a sanity check: the list of a package's external symbols must be a strict subset of the list of it's internal symbols, right?
Inline has quit [Quit: Leaving]
Inline__ has joined #commonlisp
Inline__ has quit [Remote host closed the connection]
Inline__ has joined #commonlisp
Inline__ has quit [Remote host closed the connection]
Inline has joined #commonlisp
yauhsien has joined #commonlisp
yauhsien has quit [Remote host closed the connection]
Inline has quit [Client Quit]
osp has joined #commonlisp
Inline has joined #commonlisp
yauhsien has joined #commonlisp
karlosz has joined #commonlisp
<mfiano>
Right. Why do you ask?
yauhsien has quit [Ping timeout: 250 seconds]
notzmv has quit [Ping timeout: 248 seconds]
<White_Flame>
dieggsy: if you import a symbol, you can export it without it being an internal symbol, if my definitions are correct
<White_Flame>
(however, that import might make it internal, so whatever)
livoreno has quit [Ping timeout: 240 seconds]
<mfiano>
It would still be internal just not homed to that package, right?
<White_Flame>
yeah, I guess so. re-reading the definition, it doesn't require it to be interned there
<dieggsy>
mfiano: trying to figure out some odd behavior in with-package-iterator in allegro
* mfiano
slowly side-steps away.
<dieggsy>
it behaves as i'd expect with multiprocessing, but not the same way without multiprocessing. i would almost just call that a bug but shrug
[deleted] has quit [Ping timeout: 248 seconds]
dra has joined #commonlisp
aeth has quit [Ping timeout: 256 seconds]
aeth has joined #commonlisp
karlosz has quit [Ping timeout: 256 seconds]
livoreno has joined #commonlisp
yauhsien has joined #commonlisp
karlosz has joined #commonlisp
IAmRasputin has quit [Ping timeout: 250 seconds]
jeosol has joined #commonlisp
Inline has quit [Quit: Leaving]
karlosz has quit [Ping timeout: 240 seconds]
pranavats has left #commonlisp [Error from remote client]
IAmRasputin has joined #commonlisp
pranavats has joined #commonlisp
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 240 seconds]
aeth has quit [Ping timeout: 256 seconds]
djuber has joined #commonlisp
yauhsien has quit [Remote host closed the connection]
aeth has joined #commonlisp
Inline has joined #commonlisp
yauhsien has joined #commonlisp
yauhsien has quit [Ping timeout: 240 seconds]
treflip has quit [Remote host closed the connection]
kpoeck has joined #commonlisp
Brucio-61 has quit [Quit: Client Quit]
scymtym has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
Guest74 has quit [Quit: Connection closed]
IAmRasputin has quit [Quit: WeeChat 3.4]
aeth has quit [Ping timeout: 246 seconds]
aeth has joined #commonlisp
scymtym has joined #commonlisp
osp has quit [Quit: Leaving]
Brucio-61 has joined #commonlisp
Bike has quit [Quit: Connection closed]
tyson2 has quit [Remote host closed the connection]
Bike has joined #commonlisp
Oddity has joined #commonlisp
Bike81 has joined #commonlisp
Bike has quit [Killed (NickServ (GHOST command used by Bike81))]
Bike81 is now known as Bike
Oladon has quit [Ping timeout: 250 seconds]
dra has quit [Quit: Leaving]
aeth has quit [Ping timeout: 248 seconds]
aeth has joined #commonlisp
Oladon has joined #commonlisp
NotThatRPG has joined #commonlisp
<NotThatRPG>
Random jargon question: we talk about function "calls" what about macros? Are they called? Is there a different word? Note that I'm not asking about macro expansions, which is what happens in execution, I'm wondering about in invocation: what do you call the piece of code "(foo x)" where foo is a macro?
<White_Flame>
the call side code is just a form, s-expression, and macro usage
<NotThatRPG>
@White_Flame: macro usage or function invocation. I can work with that...
hashfuncf9 has joined #commonlisp
<NotThatRPG>
(it's for putting in a manual)
<White_Flame>
I don't think that "macro call" is wrong either, it's just that the call happens at compile-time instead of run-time
<NotThatRPG>
This is for code literals (s-expressions), so in this case there won't be much of a distinction between compile and run-time...
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
NotThatRPG has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
yauhsien has quit [Ping timeout: 256 seconds]
<Bike>
macro form
NotThatRPG has joined #commonlisp
NotThatRPG has quit [Client Quit]
sander has quit [Ping timeout: 246 seconds]
cage has quit [Quit: rcirc on GNU Emacs 27.1]
Guest25 has joined #commonlisp
NotThatRPG has joined #commonlisp
Guest25 has quit [Client Quit]
sander has joined #commonlisp
Inline has quit [Quit: Leaving]
<White_Flame>
NotThatRPG: in case you missed it, <Bike> macro form
<White_Flame>
so yeah speaking about the source code data element, function form, etc, is applicable there, too
<NotThatRPG>
White_Flame: Thanks, yes I did miss it -- had to carry my laptop upstairs and was off briefly