psqueak has quit [Remote host closed the connection]
nanoz has quit [Ping timeout: 246 seconds]
atgreen has quit [Ping timeout: 246 seconds]
psqueak has joined #lisp
dddddd has quit [Remote host closed the connection]
<psqueak>
can someone mention me real quick?
<beach>
psqueak: Sure.
<psqueak>
Thanks, had to test some erc configuration
<beach>
No problem.
psqueak has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
psqueak has joined #lisp
vlatkoB has joined #lisp
quazimodo has quit [Ping timeout: 272 seconds]
psqueak has quit [Remote host closed the connection]
dale has quit [Quit: dale]
rumbler31 has joined #lisp
Oladon has quit [Quit: Leaving.]
emaczen has joined #lisp
rumbler31 has quit [Ping timeout: 240 seconds]
<emaczen>
What does it most likely mean when my computer hangs on loading a foreign library via cffi:define-foreign-library and cffi:use-foreign-library?
<emaczen>
I accidentally left my computer on doing this all last night!
<emaczen>
When I came to it, I really heard the fan going like it was really working hard
quazimodo has joined #lisp
quazimodo has quit [Ping timeout: 240 seconds]
quazimodo has joined #lisp
quazimodo has quit [Ping timeout: 250 seconds]
Bike has quit [Quit: Lost terminal]
clintm has quit [Remote host closed the connection]
jack_rabbit has joined #lisp
<beach>
emaczen: If you insist on using foreign code, I suggest you use code with an existing, well tested and documented Common Lisp interface, so that you don't have to deal with the foreign code aspects.
<beach>
If no such interface exists, I suggest you create one for the code that you are interested in, including tests and documentation, and then you make that interface available for everyone, so that they don't need to have the same problems you do.
<emaczen>
beach: I don't mind, I was wondering if there was a common pitfall that people run into with cffi:define-foreign-library or cffi:use-foreign-library
<emaczen>
every C foreign library that I have used via CFFI worked pretty well
quazimodo has joined #lisp
Inline has quit [Quit: Leaving]
yvy has joined #lisp
iAmDecim has joined #lisp
rippa has joined #lisp
iAmDecim has quit [Ping timeout: 264 seconds]
orivej has joined #lisp
makomo has quit [Quit: WeeChat 2.2]
yvy has quit [Read error: Connection reset by peer]
Elephant454 has quit [Quit: ERC (IRC client for Emacs 26.1)]
JohnMS_WORK has joined #lisp
frgo has joined #lisp
marusich has quit [Ping timeout: 244 seconds]
crsc has quit [Remote host closed the connection]
robdog has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
robdog has joined #lisp
robdog_ has joined #lisp
orivej has quit [Ping timeout: 268 seconds]
<splittist>
morning all
quazimodo has quit [Ping timeout: 246 seconds]
marusich has joined #lisp
<beach>
Hello splittist.
quazimodo has joined #lisp
varjag has joined #lisp
quazimodo has quit [Ping timeout: 240 seconds]
gxt has quit [Ping timeout: 250 seconds]
quazimodo has joined #lisp
yvy has joined #lisp
m0w has quit [Ping timeout: 250 seconds]
jochens has joined #lisp
yvy has quit [Read error: Connection reset by peer]
iAmDecim has joined #lisp
iAmDecim has quit [Ping timeout: 260 seconds]
jochens_ has joined #lisp
jochens has quit [Ping timeout: 240 seconds]
m0w has joined #lisp
scymtym has quit [Remote host closed the connection]
robotoad has quit [Quit: robotoad]
powerbit has joined #lisp
powerbit has quit [Excess Flood]
m0w has quit [Max SendQ exceeded]
m0w has joined #lisp
powerbit has joined #lisp
<dim>
emaczen: you've been lucky, I tend to always have problems with cffi libs, to the point where I would happily use a pure-CL implementation of TLS/SSL really
rumbler31 has joined #lisp
<jackdaniel>
that calls for a fundraiser! ;)
<shka_>
dim: but isn't ironclad just fine?
<jackdaniel>
since when ironclad implements communication security layers?
<shka_>
hmmmm
orivej has joined #lisp
Guest78161 has quit [Ping timeout: 250 seconds]
orivej has quit [Ping timeout: 245 seconds]
crsc has joined #lisp
gxt has joined #lisp
rumbler31 has quit [Remote host closed the connection]
orivej has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
Guest78161 has joined #lisp
Guest78161 has quit [Ping timeout: 252 seconds]
marusich has quit [Remote host closed the connection]
<phoe>
How can i use DRAKMA to dump the whole HTTP request into a file?
<phoe>
I mean both headers and the body.
<shka_>
phoe: request or response?
<phoe>
shka_: actually, both.
<phoe>
But response is simpler.
<phoe>
The request is tricky for me.
atgreen has joined #lisp
<shka_>
ok
quazimodo has quit [Ping timeout: 240 seconds]
<shka_>
phoe: there is *header-stream*
<phoe>
That is for headers.
<phoe>
I want the body.
<shka_>
phoe: but i think you are better off with providing broadcast stream to the send
<phoe>
Once I have the body and headers, I can reconstruct what I want.
<shka_>
HTTP-REQUEST, sorry
<phoe>
I cannot provide a stream to DRAKMA:HTTP-REQUEST. Drakma creates its own streams and connections.
<phoe>
It can only receive streams it returns from HTTP-REQUEST itself.
<jdz>
phoe: It creates the streams, but it also returns them.
<jdz>
phoe: You also can create your own stream, and give it to DRAKMA.
<phoe>
jdz: Can I? It's not mentioned anywhere in the manual.
<phoe>
" stream MUST be a stream returned by a previous invocation of HTTP-REQUEST where the sixth return value wasn't true."
<shka_>
However, you can use the STREAM argument to provide an open socket stream which should be re-used. STREAM MUST be a stream returned by a previous invocation of HTTP-REQUEST where the sixth return value wasn't true.
<phoe>
Sure - and invoking HTTP-REQUEST twice in a row doesn't work if my server always closes the connection.
<phoe>
Which is the case in my situation.
<jackdaniel>
phoe: if stream keyarg is supplied then it is used as http-stream (and wrapper further by drakma)
<jdz>
phoe: DRAKMA returns the must-close value, which client code must respect.
<jackdaniel>
so what you need to do is to create a stream like it is done inside http-request body (usocket:socket-stream (usocket:socket-connect …))
<jackdaniel>
create your own stream for peeking
<jackdaniel>
and create a broadcast stream on those two and pass it to http-request
<shka_>
phoe: did you tried to use continuation with http-request and flexistream as a buffer?
<phoe>
shka_: nope.
<phoe>
jackdaniel: will try that.
<shka_>
i think that it might work
<phoe>
shka_: looks like it means that I will have to construct multipart/form-data myself because when :content is supplied, :parameters are ignored
<shka_>
phoe: yes
<shka_>
phoe: i think that dexador would be slightly easier then drakma in your use case
<ogamita>
phoe: I would do this: (setf (sexp-file-contents "/tmp/http-request.sexp") (multiple-value-bind (data status headers url mc status-text) (drakma:http-request "http://www.informatimago.com") (list (with-output-to-string (out) (puri:render-uri url out)) headers data status status-text)))
<shka_>
but i am not sure about this
<ogamita>
err, I may miss a value, the status-text is the must-close…
hectorhonn has quit [Ping timeout: 256 seconds]
iAmDecim has joined #lisp
<beach>
Is my analysis of LOAD-TIME-VALUE correct in that I think if a LOAD-TIME-VALUE containing other LOAD-TIME-VALUEs is processed by the file compiler, then the nested LOAD-TIME-VALUEs must also be processed by the file compiler?
<phoe>
ogamita: I don't want its SEXP version. I want a literal dump of what the HTTP client sends to the server.
<ogamita>
beach: what difference does it make? Should the whole expression in the topmost load-time-value be already excuted at load-time?
<beach>
No.
<ogamita>
beach: or do you mean if (load-time-value (load "foo")) with al load-time-value in foo?
<beach>
"If a load-time-value expression is processed by compile-file, the compiler performs its normal semantic processing (such as macro expansion and translation into machine code) on form..."
iAmDecim has quit [Ping timeout: 250 seconds]
<beach>
I mean (load-time-value '(f (load-time-value (g))))
<ogamita>
Here the form is a quote-form: it's not evaluated.
<beach>
I mean (load-time-value '(f (load-time-value '(g))))
<beach>
No, but it is compiled
<ogamita>
If you mean (load-time-value (let ((x 42)) (load-time-value (g x)))) the question is whether the second load-time-value is evaluated in the null-environment or in the lexical environment with x, right?
m0w has quit [Remote host closed the connection]
<beach>
I mean (load-time-value '(f (load-time-value '(g))))
<beach>
My thinking is as follows: If the outermost LOAD-TIME-VALUE is processed by COMPILE-FILE, then it makes no sense for the (f (load-time-value '(g))) to be processed by COMPILE, because then (g) would be evaluated at compile time as the Common Lisp HyperSpec page stipulates.
<ogamita>
Here the compiler must generate the code to evaluate at load-time the expression: '(f (load-time-value '(g))) which returns the sexp (f (load-time-value '(g))) which will be considered as a run-time literal .
<ogamita>
In load-time-value the deferd expression must not be quoted.
<beach>
Oh, wait, maybe no quotes.
<beach>
I misread the Common Lisp HyperSpec page.
<beach>
I mean (load-time-value (f (load-time-value (g)))) then
<beach>
Sorry about that.
<ogamita>
Good.
<beach>
So COMPILE-FILE looks at the entire expression, and then it must "perform normal semantic processing..."
<ogamita>
Now, both the call to f and the call to g must be defered. Of course, the call to g would have had to be derefed in any case, since it's in the call to f. So possibly an implementation could avoid processing the embedded load-time-value.
<beach>
and I am thinking that "normal" means, "by COMPILE-FILE".
<ogamita>
But as mentionned above, there's this null-environment rule, which makes me think that the implementations must evaluate specially the inner form, cutting it off from the lexical environment that could be established by the outer form.
<beach>
Yes, interesting.
<beach>
Oh, yes, good catch.
<beach>
So at load time we have an ordered sequence of evaluations that must start with the innermost LOAD-TIME-VALUE forms.
<ogamita>
Yes.
<beach>
Thanks!
<beach>
Time to go off line and contemplate how to organize the compiler to accomplish that.
<beach>
I think Cleavir is doing the wrong thing at the moment. As are some other implementations like CLISP as I recall.
<beach>
They both just store the form and call EVAL on it at load time.
<beach>
Anyway, thanks for talking this through with me.
* beach
vanishes.
zotan has quit [Ping timeout: 250 seconds]
zotan has joined #lisp
* shka_
stares at the place where beach was before he vanished
<shka_>
he can do that?
jochens_ has quit []
flazh has quit [Quit: flazh]
flazh has joined #lisp
elderK has quit [Quit: WeeChat 1.9]
Guest78161 has joined #lisp
iAmDecim has joined #lisp
<beach>
What if we have (LOAD-TIME-VALUE (EVAL-WHEN (:COMPILE-TOPLEVEL) FORM)) to be processed by COMPILE-FILE.
<beach>
?
<beach>
Should FORM be evaluated at compile time?
<beach>
I would think not.
iAmDecim has quit [Ping timeout: 252 seconds]
<beach>
The spirit here is that the entire argument to LOAD-TIME-VALUE be evaluated at load time, except that macros and such are expanded.
<beach>
If I am right, then it is not possible to simply call the file compiler recursively on the argument of LOAD-TIME-VALUE as if that argument were a top-level form.
<beach>
Currently, Cleavir check which compiler was used (COMPILE-FILE, COMPILE, or EVAL) to determine what to do with top-level forms. Now that appears to be slightly incorrect.
<beach>
I am now thinking that instead, there should be an argument to the compiler, say COMPILE-TIME-TOO-P.
<beach>
I guess it is called the "processing mode".
jochens has joined #lisp
<phoe>
Is there any library which provides a bidirectional stream X that dumps all that is read from it to stream Y and all that is written to it to stream Z?
<phoe>
That would solve my DRAKMA problem.
<phoe>
If not, then I'll need to write one.
<shka_>
phoe: i am not aware, sorry
* phoe
grabs his yak shaver
cage_ has joined #lisp
heisig has joined #lisp
<LdBeth>
phoe: how about echo-stream?
Guest78161 has quit [Ping timeout: 252 seconds]
<phoe>
LdBeth: I want to dump both input and output.
<ogamita>
phoe: You want to implement a tee with cl streams. A tee is a kind of pipe with one or more bifurcations. You may have a look at com.informatimago.clext.pipe:pipe for pure 1-1 pipes, and extend it to add the bifurcations.
<ogamita>
phoe: unless (defun make-dumped-stream (i/o input-output output-output) (make-two-way-stream (make-echo-stream i/o input) (make-broadcast-stream i/o output))) is sufficient to your needs?
<jackdaniel>
without intermediate C library (just opengl libraries)
<|3b|>
glop is an OpenGL oriented portability layer for GUI stuff
<|3b|>
like glfw or sdl2
<sjl_>
nice
<|3b|>
with ffi pushed as close to OS as possible, so doesn't need anything aside from normal OS libs on windows/linux (needs a shim lib on osx though)
jsc has joined #lisp
<jackdaniel>
if you finish rewriting it I'll gladly collaborate to write McCLIM backend
jsc is now known as status402
<jackdaniel>
s/to write/with writing/
* |3b|
has been running into impedance mismatches on it (like wanting vulkan instead of GL), and wanting a more complete FFI layer (which doesn't really fit into the "I/O for GL" description) lately, so thinking of starting a new project that doesn't need to maintain compatibility
<|3b|>
(but can ideally share code)
<|3b|>
other goal is to chop it into layers, so for example a mcclim backend could just use the ffi layer (or a thin portability layer over the ffi layers) even if it didn't really map well to the high level layer
dogenpunk has joined #lisp
Zaab1t has joined #lisp
anewuser has quit [Ping timeout: 240 seconds]
Jahnertz has quit [Quit: ZzZz]
status402 has quit [Read error: Connection reset by peer]
status402 has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
Zaab1t has quit [Quit: bye bye friends]
status402 has quit [Quit: status402]
steiner has quit [Remote host closed the connection]
kajo has joined #lisp
orivej has joined #lisp
mooch has joined #lisp
robotoad has quit [Quit: robotoad]
jochens_ has quit [Remote host closed the connection]
jochens has joined #lisp
jochens has quit [Ping timeout: 250 seconds]
jkordani_ has joined #lisp
jkordani_ has quit [Remote host closed the connection]
robotoad has joined #lisp
jkordani has joined #lisp
jack_rabbit has quit [Ping timeout: 268 seconds]
flamebeard has quit []
Jesin has quit [Quit: Leaving]
svillemot has quit [Ping timeout: 272 seconds]
asymptotically has quit [Quit: Leaving]
slyrus2 has joined #lisp
froggey has joined #lisp
m0w has quit [Ping timeout: 268 seconds]
svillemot has joined #lisp
slyrus2 has quit [Ping timeout: 250 seconds]
meepdeew has joined #lisp
mrcom has quit [Read error: Connection reset by peer]
orivej has quit [Ping timeout: 240 seconds]
atgreen has quit [Ping timeout: 250 seconds]
slyrus1 has joined #lisp
themsay has quit [Ping timeout: 250 seconds]
Jesin has joined #lisp
heisig has quit [Quit: Leaving]
mrcom has joined #lisp
varjag has joined #lisp
rnmhdn has joined #lisp
Guest78161 has quit [Ping timeout: 252 seconds]
themsay has joined #lisp
themsay has quit [Ping timeout: 246 seconds]
ebrasca has joined #lisp
Lycurgus has quit [Quit: Exeunt]
ah_ has joined #lisp
ah_ is now known as akoana
fourier has joined #lisp
hiroaki has joined #lisp
atgreen has joined #lisp
kini has quit [Quit: No Ping reply in 180 seconds.]
themsay has joined #lisp
m0w has joined #lisp
themsay has quit [Read error: Connection reset by peer]
themsay has joined #lisp
kini has joined #lisp
Zaab1t has joined #lisp
hiroaki has quit [Ping timeout: 252 seconds]
meepdeew has quit [Remote host closed the connection]
sauvin has quit [Remote host closed the connection]
wint has joined #lisp
wint has left #lisp [#lisp]
hiroaki has joined #lisp
<emaczen>
dim: I've only used a couple...
noobly has joined #lisp
<noobly>
anyone heard of the nyquist program?
hiroaki has quit [Ping timeout: 250 seconds]
<edgar-rft>
noobly: do you mean Roger Dannenberg's Nyquist (XLISP) programming language for audio stuff?
<phoe>
I know that the version used in Audacity has both options to use lisplike syntax and something much more Pythonesque or C-like.
<noobly>
Did you use it at all? I'm just wondering if it's as powerful as something like SuperCollider, because I would certainly prefer programming a lisp than SC's weird Smalltalk/C hybrid
<noobly>
unfortunately it's not very popular (despite being used in audacity), so finding this high level info on it is proving difficult.
<phoe>
Unrelated: I know that some people are doing music programming with Lisp
kajo has quit [Quit: From my rotting body, flowers shall grow and I am in them and that is eternity. -- E. M.]
fourier has quit [Ping timeout: 250 seconds]
lnostdal has joined #lisp
psqueak has quit [Remote host closed the connection]
Denommus has joined #lisp
noobly has left #lisp ["ERC (IRC client for Emacs 26.1)"]
scymtym has joined #lisp
fourier has joined #lisp
<flip214>
Hunchentoot has in its ASDF file a line (:depends-on #-:lispworks :usocket
<flip214>
that means that on non-lispworks implementation the usocket library is a requirement, right?
<pfdietz>
Yes
atgreen has quit [Ping timeout: 272 seconds]
<flip214>
I get an error during compilation: The name "USOCKET" does not designate any package.
<flip214>
hmmm
<flip214>
why isn't it loaded automatically?
<pfdietz>
It should
<pfdietz>
Try removing your cache and doing it again.
<flip214>
using (QL:quickload :usocket) manually before loading HT makes it work again
pjb has joined #lisp
<flip214>
pfdietz: the whole ASDF cache?
<flip214>
then I can just rebuild SBCL from git before ;)
<pfdietz>
~/.cache/common-lisp/*
<pfdietz>
Meh, building sbcl takes me 85 seconds.
<flip214>
well, I'm doing quite a few libraries along with it, as they're needed anyway
<flip214>
and my machine isn't _that_ quick
scottj has quit [Quit: leaving]
<flip214>
pfdietz: but I didn't even add that dependency to HT ... it was already there, so I don't see why the cache should be wrong right now?Q
<flip214>
?!
<pfdietz>
This was a stab-in-the-dark suggestion, like turning it off and on again.
<flip214>
yeah, I know
<flip214>
it bothers me that it helps!
<pfdietz>
I worry ASDF may not be loading all the dependencies when things don't need to be rebuilt.
<pfdietz>
WHich version of asdf is it?
gxt has quit [Ping timeout: 240 seconds]
ebrasca has quit [Remote host closed the connection]
themsay has joined #lisp
scymtym has quit [Read error: No route to host]
kushal has quit [Remote host closed the connection]
kushal has joined #lisp
rumbler31 has joined #lisp
iovec has quit []
atgreen has joined #lisp
gxt has joined #lisp
Bike has quit []
vlatkoB has quit [Remote host closed the connection]
fourier has quit [Quit: ERC (IRC client for Emacs 25.3.50.3)]
<jasom>
just checking that there is no equivalent for "across" in loop that works on multidimensional arrays as row-major-aref
scymtym has joined #lisp
<dlowe>
there is not
dale has quit [Quit: dale]
<jasom>
so my (loop for i from 0 below (array-total-size foo) for item = (row-major-aref foo i ...) is fine.
rumbler31 has quit [Remote host closed the connection]
<dlowe>
yeah, I think that's the right option.
<dlowe>
iterate might have something for that
<pjb>
jasom: (loop for e across (make-array (reduce '* (array-dimensions multi-dimensional-array)) :displaced-to multi-dimensional-array) do (process e))
<dlowe>
if you want to depend on iterate
<pjb>
(let ((multi-dimensional-array #2A((1 2) (3 4)))) (loop for e across (make-array (reduce '* (array-dimensions multi-dimensional-array)) :displaced-to multi-dimensional-array) collect e)) #| --> (1 2 3 4) |#
<jasom>
though that will fail for a zero dimensional array
<pjb>
(let ((multi-dimensional-array #0A1)) (loop for e across (make-array (reduce '* (array-dimensions multi-dimensional-array)) :displaced-to multi-dimensional-array) collect e)) #| --> (1) |#
<pjb>
(let ((multi-dimensional-array #())) (loop for e across (make-array (reduce '* (array-dimensions multi-dimensional-array)) :displaced-to multi-dimensional-array) collect e)) #| --> nil |#
<pjb>
CL is mostly consistenly.
<pjb>
/ly/t/
<jasom>
I think the row-major-aref is probably clearer pjb, but your example is also good (and both fail for #0A())
Zaab1t has quit [Quit: bye bye friends]
<verisimilitude>
You could also, of course, use a nested LOOP, jasom.
<verisimilitude>
Of course, that solution isn't general, then, right.
Denommus has quit [Remote host closed the connection]
<jasom>
verisimilitude: naturally. I'm unsure of which is more clear for an array of known dimensionality, particulary when it's greater than 2.
<jasom>
3 nested loops versus 2 clauses...
<verisimilitude>
That depends, I suppose.
<verisimilitude>
If you want to avoid ``Oh, what's this function do?'' at all costs, you'd use the nested LOOPs; if you don't mind using everything CL has to offer, the ROW-MAJOR-AREF is better, I suppose.
<jasom>
"Process this entier multidimensional array" seems like the clear goal of a loop starting with the two clauses I proposed, but I agree that it's arguable
<verisimilitude>
Oh, I'd also use the ROW-MAJOR-AREF, unless you needed to process it in column-major order, say.
Oddity has quit [Ping timeout: 244 seconds]
orivej has joined #lisp
Bike has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<pjb>
(let ((multi-dimensional-array #0Anil)) (loop for e across (make-array (reduce '* (array-dimensions multi-dimensional-array)) :displaced-to multi-dimensional-array) collect e)) #| --> (nil) |#
<pjb>
(let ((multi-dimensional-array #0A())) (loop for e across (make-array (reduce '* (array-dimensions multi-dimensional-array)) :displaced-to multi-dimensional-array) collect e)) #| --> (nil) |#
<pjb>
nope.
<pjb>
It would fail only in a non-conforming implementation.
<jasom>
a zero dimensional array does not have one element equal to nil, right?
<pjb>
It is a scalar!
akoana has left #lisp ["Leaving"]
<pjb>
Only in CL, non-array objects are not scalar, but there's a bijection between those two sets.
<Bike>
it has one element equal to whatever you put in there
<pjb>
It would be nice to standardize (eq 'foo #0Afoo)
<jasom>
so #0A1 is fine
<Bike>
yep
<pjb>
We could do (+ #0A1 #0A2) -> 3
<pjb>
or #0A3
<jasom>
pjb: so you could do (upgraded-array-element-type 'foo) and get an answer?
<jasom>
then everything would be an array
<pjb>
Yes :-)
<jasom>
Is that legal?
<pjb>
We'd have turned CL into APL!
<pjb>
Not (yet?).
<jasom>
it's not legal because arrays are system classes and you're not allowed to add extra edges to the heirarchy of classes, right?
<jasom>
so e.g. integer being a subclass of array is illegal
<pjb>
isomorphims break class hierarchies. But perhaps not with multiple-inheritance?
orivej has quit [Remote host closed the connection]
nirved is now known as Guest81792
<jasom>
4.2.2 requires a lot of things to be pairwise disjoint, but does not mention array...
themsay has quit [Ping timeout: 240 seconds]
nirved has joined #lisp
<jasom>
and 4.3.7 says that implementations can add other subclass relationships as long as they don't violate the type disjointness, so it might be legal
<pfdietz>
You cannot add methods to standard functions if all the specializers in the methods are standard classes (or eql specializers for objects of from the standard).
<pfdietz>
s/of //
Guest81792 has quit [Ping timeout: 252 seconds]
<pfdietz>
One could extend + (if it were a generic function) with methods on new, user-defined classes.
<jasom>
oh, "A standard class defined with no direct superclasses is guaranteed to be disjoint from all of the classes in the table, except for the class named t."
<jasom>
and array is in the table
<Bike>
jasom: it says array and number are disjoint.
<Bike>
4.2.2 i mean
<jasom>
Bike: oh, I missed array in the list for the first bullet point
<pjb>
4.2.2 is the anti-APL clause of CL :-)
<verisimilitude>
APL does have data that isn't encased in an array.
<pfdietz>
Disjoint also means you cannot add a new subclass that inherits from both.
<verisimilitude>
It's not usually used for anything, though.
<pjb>
verisimilitude: Oh, in that case we're good.
<jasom>
along with 4.3.7 that prevents stnadard classes defined with no direct superclass from inheriting from any class listed except t
<jasom>
so (eq #0A1 1) is disallowed, but I think (= #0A1 1) is allowed, thought (eql #0A1 1) is disallowed since #0A1 is not allowed to be a number.
<verisimilitude>
I'll peruse my bound copy of the APL standard for the details, if you're interested.
m0w has quit [Ping timeout: 272 seconds]
themsay has quit [Ping timeout: 268 seconds]
themsay has joined #lisp
<verisimilitude>
I suppose I may have simply been confusing arrays with no shape and arrays that hold exactly one item, which are still distinct concepts in APL.
<verisimilitude>
So, I suppose, everything is in an array in APL and what I'd confused for objects outside of an array were simply objects in an array with no dimensions, which you could argue is splitting hairs.
<verisimilitude>
The shape primitive returns nothing at all with such an array, as an example.
simendsjo has quit [Ping timeout: 250 seconds]
themsay has quit [Ping timeout: 246 seconds]
<verisimilitude>
Here's an example session:
<verisimilitude>
⍴ 0
<verisimilitude>
<verisimilitude>
⍴,0
<verisimilitude>
1
<verisimilitude>
Anyway, that's enough APL, I suppose.
<phoe>
Xach: I would like to ask for alexandria to be moved to be maintained in sharplispers because the current maintenance on it seems effectively dead to me.