<jcowan>
fiddlerwoaroof: Except that a lot of people don't actually understand the corner cases, such as that normally . does not match newlines, and ^ and $ match beginning and end of line, not beginning and end of string
<jcowan>
there are s, m flags to change there
<jcowan>
these
ahungry has joined #lisp
<fiddlerwoaroof>
Sure, and there are a half dozen slightly-incompatible implementations
<aeth>
vim/sed regex are the same? I wouldn't be surprised if vim, sed, and ed all are slightly (if not more than slightly) incompatible
<jcowan>
yes, two standards (Posix BRE and ERE) and Ghu knows how many non-standards
<aeth>
Also, I think pcre and Perl regex are different
<jcowan>
chibi irregex/show FTW
<jcowan>
They are different
watkinsr has joined #lisp
notzmv has joined #lisp
notzmv is now known as Guest26468
ayuce has quit [Remote host closed the connection]
renzhi has joined #lisp
v0|d has joined #lisp
Oladon has joined #lisp
Guest26468 is now known as notzmv
bitmapper has quit [Ping timeout: 250 seconds]
<asarch>
One stupid question: how is that, that in Caveman2 you can actually write expressions like @route GET "/" if, as far I know, every Lisp expression should be enclosed in parentheses?
<fiddlerwoaroof>
aeth: vim/sed I think both can take options to make their syntaxes roughly compatible
<fiddlerwoaroof>
similar to how grep is one syntax and grep -E is a different one
<no-defun-allowed>
asarch: That would require a "reader macro", which sets a function to read the rest of that expression after the @ character.
<no-defun-allowed>
and honestly, it's really dumb and looks out of place, but indeed it's possible.
<fiddlerwoaroof>
vim also adds "magic" mode where you have to put a backslash before certain regex chars
<asarch>
How would you create such expression? (defmacro @ () ...)?
* asarch
scratches his head...
<no-defun-allowed>
Did I not just say reader macro?
kotrcka has quit [Quit: ChatZilla 0.9.94 [SeaMonkey 2.53.1/20200321023949]]
<asarch>
Mmmm... the server is down. Let's sudo apt-get -y install hyperspec
<no-defun-allowed>
It works here.
<no-defun-allowed>
In the MOP, are accessors guaranteed to use SLOT-VALUE-USING-CLASS?
ebzzry_ has joined #lisp
space_otter has joined #lisp
Kundry_W_ has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
<asarch>
How could I "expand" @ to see what is actually doing (a la macroexpand)?
Kundry_Wag has quit [Ping timeout: 250 seconds]
cyberoctopi has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
I think you could prefix it with ' to get the generated code; but you would probably also need the expression after it that it annotates too.
Kaisyu72 has quit [Quit: ERC (IRC client for Emacs 26.3)]
cyberoctopi has joined #lisp
karstensrage has joined #lisp
cyberoctopi has quit [Ping timeout: 258 seconds]
cyberoctopi has joined #lisp
Kaisyu7 has joined #lisp
ebzzry_ has quit [Read error: Connection reset by peer]
ebzzry_ has joined #lisp
<no-defun-allowed>
Okay, if I have a class C1 with a metaclass M1, with a superclass C2 which has metaclass M2 and a slot S, should (slot-value <instance of C1> 'S) invoke the SLOT-VALUE-USING-CLASS method specialised on C1?
<pjb>
asarch: using macroexpand or macroexpand-1.
ebzzry_ has quit [Read error: Connection reset by peer]
<pjb>
asarch: oh, you mean the @route, not the macro you defmacro @'ed.
<pjb>
It's a reader macro, so: (read-from-string "@route GET \"/\"")
<pjb>
asarch: note however that some reader macro perform some processing.
<pjb>
asarch: for example, #S creates and return the structure. (defstruct point x y) (read-from-string "#S(point :x 1 :y 2)") #| --> #S(point :x 1 :y 2) ; 19 |#
<pjb>
asarch: on the other hand, #' doesn't: (print-conses (read-from-string "#'sin")) #| (function . (sin . ())) --> #'sin |#
<pjb>
asarch: it would probably be better to read the source…
Steinberg2010 has joined #lisp
ebzzry_ has joined #lisp
Steinberg2010 has quit [Ping timeout: 256 seconds]
rumbler31 has quit [Read error: Connection reset by peer]
<rpg>
Anyone know of any CL library that will take an OpenAPI/Swagger spec and synthesize a *server* stub? There are two libraries that, although they look unmaintained, promise to provide OpenAPI clients, but I don't see any mention of servers.
nicktick has quit [Ping timeout: 265 seconds]
rumbler31 has joined #lisp
swills has left #lisp [#lisp]
gko has joined #lisp
shifty has joined #lisp
Oladon has quit [Quit: Leaving.]
ebzzry_ has quit [Read error: Connection reset by peer]
<matzy_>
sorry that's a shitty way to paste code i know
ayuce has quit [Remote host closed the connection]
<matzy_>
but i'm not sure what command to run in SLIME or sbcl to "kick it off"
<no-defun-allowed>
You can use (load "filename") to load a file, or start sbcl using sbcl --load filename.lisp
<matzy_>
wow i feel like an idiot. that's exactly what i was missing. thanks a million!
eck has joined #lisp
cyberoctopi has joined #lisp
eck has quit [Client Quit]
eck has joined #lisp
eck is now known as Guest96678
Guest96678 has quit [Client Quit]
ayuce has joined #lisp
eck_ has joined #lisp
ayuce has quit [Remote host closed the connection]
cartwright has quit [Remote host closed the connection]
hdasch has quit [Ping timeout: 265 seconds]
ayuce has joined #lisp
eck_ is now known as daddy
daddy is now known as eck``
eck`` is now known as `eck`
hdasch has joined #lisp
cartwright has joined #lisp
Bourne has quit [Ping timeout: 264 seconds]
Kundry_Wag has joined #lisp
random-nick has joined #lisp
Kundry_W_ has quit [Ping timeout: 260 seconds]
nicktick has quit [Quit: Leaving.]
esrse has joined #lisp
Bourne has joined #lisp
dddddd has quit [Remote host closed the connection]
wsinatra has quit [Remote host closed the connection]
wsinatra has joined #lisp
stux|RC-only has quit [Ping timeout: 256 seconds]
yang has quit [Ping timeout: 256 seconds]
yang has joined #lisp
stux|RC-only has joined #lisp
heisig has joined #lisp
tiwEllien has joined #lisp
greaser|q has quit [Ping timeout: 256 seconds]
greaser|q has joined #lisp
PuercoPop has joined #lisp
`eck` is now known as eck
cyberoctopi has quit [Ping timeout: 250 seconds]
Cymew has joined #lisp
ayuce has quit [Remote host closed the connection]
ayuce has joined #lisp
Oddity has quit [Ping timeout: 264 seconds]
tiwEllien has quit [Remote host closed the connection]
tiwEllien has joined #lisp
gxt has quit [Quit: WeeChat 2.8]
Oddity has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
gxt has joined #lisp
jackhill_ has joined #lisp
kim\ has joined #lisp
gingerale- has joined #lisp
jackhill has quit [Ping timeout: 246 seconds]
kim_ has quit [Ping timeout: 246 seconds]
gingerale has quit [Ping timeout: 246 seconds]
Tordek has quit [Ping timeout: 258 seconds]
Tordek has joined #lisp
gingerale- is now known as gingerale
vhost- has quit [Ping timeout: 264 seconds]
CrazyEddy has quit [Remote host closed the connection]
CrazyEddy has joined #lisp
hdasch has quit [Ping timeout: 256 seconds]
hdasch has joined #lisp
<matzy_>
ok i have another question if anyone's around, hopefully it's less stupid
<matzy_>
so if i define an *acceptor* (I believe it is a class) and pass it to (hunchentoot:start *acceptor*) (literally that's my code), I get an error
<matzy_>
but if i do a one-liner with (hunchentoot:start) it works fine
<matzy_>
so this: (hunchentoot:start (make-instance 'hunchentoot:easy-acceptor :port 4242))
<matzy_>
from everything i've learned so far about lisp this makes no sense
<Shinmera>
From your description I have no idea what you're doing, so
<matzy_>
whereas the one-liner (hunchentoot:start (make-instance 'hunchentoot:easy-acceptor :port 4242)) run without any errors
<Shinmera>
That still doesn't tell me what you're doing.
hdasch has quit [Ping timeout: 265 seconds]
hdasch has joined #lisp
<matzy_>
so the first example doesn't work either. I should clarify. Directly under the "Simple Webserver" huge heading, there's another "Serve Local Files" big header, and then under that is a "Hunchentoot" header, and it's the subsequent codeblocks that i'm literally pasting in emacs and they're not working
<Shinmera>
The code is obviously correct so whatever you're actually doing that isn't code must be wrong.
PuercoPop has quit [Ping timeout: 250 seconds]
xaotuk has joined #lisp
frgo_ has quit [Remote host closed the connection]
frgo has joined #lisp
vaporatorius has joined #lisp
CrazyEddy has quit [Remote host closed the connection]
matzy_ has quit [Ping timeout: 260 seconds]
z147 has joined #lisp
frgo_ has joined #lisp
frgo_ has quit [Remote host closed the connection]
frgo_ has joined #lisp
frgo has quit [Ping timeout: 260 seconds]
frgo has joined #lisp
frgo has quit [Remote host closed the connection]
amerlyq has joined #lisp
frgo has joined #lisp
frgo__ has joined #lisp
frgo_ has quit [Ping timeout: 260 seconds]
postit_ has joined #lisp
postit_ has quit [Client Quit]
postit has joined #lisp
frgo has quit [Ping timeout: 260 seconds]
sauvin has quit [Ping timeout: 258 seconds]
markong has joined #lisp
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 265 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<no-defun-allowed>
Is Ironclad supposed to be fast?
<no-defun-allowed>
I suppose so; it's probably not the bottleneck in my program. Never mind.
hdasch has quit [Ping timeout: 250 seconds]
hdasch has joined #lisp
<Shinmera>
It won't be as fast as crypto algorithms that were hand tuned by tons of people, but it's good enough (at least on SBCL)
markong has quit [Ping timeout: 264 seconds]
<no-defun-allowed>
Yeah, it's about 1/4 the speed of OpenSSL on my laptop.
markoong has joined #lisp
* no-defun-allowed
continues to look for the bottleneck
<loke`>
Is anyone maintaining ironclad?
<loke`>
I'd like support for SHA-3 for example.
<phoe>
loke`: yes, the sharplispers collective.
<MichaelRaskin>
Note that assembly implementations of cryptographic algorithms are usually also tuned against timing leaks.
<p_l>
sharplispers collective, eh?
<p_l>
might seek place there if I get more "free" time
<jackdaniel>
if I ever start a collective I'll call it dulllispers, three "l" there look like a great typo
<phoe>
dul³ispers
<jackdaniel>
no
<phoe>
:(
<no-defun-allowed>
Yeah, you could square the S while you're at it
<jackdaniel>
sure, but that wouldn't be a collective then
<aeth>
s/l/λ/ and you have a half life 3 joke there, too
<aeth>
while also being relevant to Lisp because of the lambda.
<jackdaniel>
:) /me gets back to ecl
Shepard has joined #lisp
narimiran has quit [Ping timeout: 256 seconds]
cyberoctopi has joined #lisp
ayuce has quit [Remote host closed the connection]
sauvin has joined #lisp
xaotuk has quit [Ping timeout: 258 seconds]
xaotuk has joined #lisp
zaquest has quit [Quit: Leaving]
Shepard has quit [Remote host closed the connection]
jmercouris has joined #lisp
space_otter has quit [Remote host closed the connection]
<drainful>
What about embracing the typo look with dullllispers
froggey has joined #lisp
hdasch has quit [Ping timeout: 250 seconds]
EvW has joined #lisp
hdasch has joined #lisp
frgo__ has quit [Remote host closed the connection]
zaquest has joined #lisp
frgo has joined #lisp
karlosz has quit [Quit: karlosz]
CrazyEddy has joined #lisp
<jackdaniel>
are these lambda lists [gf] (A &REST ARGS &KEY FOO &ALLOW-OTHER-KEYS) and [method] (A &KEY PAYLOAD) congruent?
<jackdaniel>
reading 4th point carefully seems to say: "no", because "each method must accept all of the keyword names mentioned after &key, either by accepting them explicitly, by specifying &allow-other-keys, or by specifying &rest but not &key."
Bourne has quit [Remote host closed the connection]
<Shinmera>
jackdaniel: But point 5 says &allow-other-keys may be omitted as long as it is on at least one method or the gf.
xaotuk has quit [Ping timeout: 250 seconds]
rippa has joined #lisp
xaotuk has joined #lisp
<jackdaniel>
Shinmera: point 5. says "any keyword arguments may be mentioned in the call to the generic function. ", not "then method doesn't have to accept all of the keyword names mentioned after &key"
<jackdaniel>
so as I read it it says about calling the function, not about defining a method
<Shinmera>
7.6.5 also says: If the lambda list of any applicable method or of the generic function definition contains &allow-other-keys, all keyword arguments are accepted by the generic function.
<Shinmera>
hmm.
<jackdaniel>
still it says about calling the function
<Shinmera>
Well, I'll give you the practical answer of: if you made it illegal to omit keyword arguments you would break a lot of code out there :)
<jackdaniel>
only one library breaks on quicklisp (maiden)
<Shinmera>
Oh, really?
<jackdaniel>
affirmative
<jackdaniel>
hm, maybe not -- I don't know. only one library in the pivot table from testing
<kpoeck>
in this case the github version seems to be abandonned and is missing 1 year of changes
libertyprime has quit [Read error: No route to host]
libertyprime has joined #lisp
postit has quit [Quit: Connection closed for inactivity]
jmercouris has quit [Remote host closed the connection]
loli has quit [Quit: WeeChat 2.7.1]
Bike has joined #lisp
Bourne has quit [Ping timeout: 256 seconds]
Steinberg2010 has joined #lisp
frgo has quit [Read error: No route to host]
frgo_ has joined #lisp
narimiran has joined #lisp
<Xach>
kpoeck: i can explain for zacl
<kpoeck>
please
<Xach>
kpoeck: zacl was paid work and the payor demanded i use common-lisp.net. after the payment was done i switched to github, because that's what i prefer.
<kpoeck>
ok, so i did the pr in the right repository
<Xach>
well
<Xach>
i'm not sure that's true!
<kpoeck>
huh?
<Xach>
I just looked and quicklisp pulls from clnet, which is a surprise to me.
<Xach>
So I will check on the difference between repos and see which should truly be used.
<kpoeck>
sorry i read you message exactly backwors
<Xach>
No - it's not a clear situation
JohnMS has joined #lisp
<kpoeck>
A technical question, in zacl - or better in zaserve - I have the problem that the "MP" package is used both in zacl and in clasp
<kpoeck>
And 2 symbols clash in the definition
<kpoeck>
Is this a case where package local nicknames can help me out?
<Bike>
clasp should probably rename it clasp-mp or something, then.
<phoe>
MP, short for multiprocessing, is a pacakge name that is likely collide
<phoe>
likely to collide*
Bourne has joined #lisp
<kpoeck>
Bike, that would be the best idea
<Xach>
kpoeck: it looks as though the clnet one is the most up-to-date and i can accomodate PRs there
JohnMS_WORK has quit [Ping timeout: 260 seconds]
<eta>
is there a way to check whether a string is valid UTF-8?
orivej has quit [Ping timeout: 256 seconds]
<Shinmera>
strings have no encoding.
<Bike>
pretty easy to do with a byte vector, tho.
<eta>
Shinmera, okay, is there a way to check whether a string would *encode* to valid UTF-8? ;P
<eta>
I guess I could try using babel:string-to-octets and catch an error
<Bike>
how would it not encode? like if a character isn't in unicode?
<Shinmera>
if your implementation uses the unicode character set then it must.
<Shinmera>
no need to check.
<eta>
oh right
<eta>
so it's impossible for SBCL to read a string that isn't unicode?
<loke`>
eta: sure it is
<Shinmera>
unicode attempts to cover every character set out there, meaning the chance you get a string with a character set not covered by unicode is extremely slim.
<eta>
basically I'm debugging a crash where a "Illegal :UTF-8 character starting at position 0." error got thrown
troydm has quit [Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset]
<Shinmera>
well then you're dealing with bytes, not strings.
<Bike>
okay, so you have a stream of _bytes_
<loke`>
Shinmera: actually it depends on Lisp implementation. Unicode only support 21 bits (well, a bit over 20 bits to be precise).
<eta>
urgh
<loke`>
If you have an implementation that allows characters above that, then you have invalidUnicode.
<eta>
I should just try and get a backtrace I guess
<Bike>
are you reading from a file or something?
<eta>
Bike, no I'm building a whatsapp bridge
<Shinmera>
loke`: Well I did say if your implementation uses the unicode character set.
<Bike>
well you're reading some kind of stream.
<eta>
and I think some idiot might have managed to set their whatsapp status to a non-UTF-8 string
<loke`>
But, in SBCL as far as I can remember, a character is defined to be a valid Unicode codepoint, in that implementation there is no such thing as an invalid string.
<eta>
oh yeah, multiple all over the place
<eta>
which is why a backtrace would help :p
<eta>
lessee here
<eta>
there isn't a BREAK-ON-SIGNALS that only breaks on error, or is there?
troydm has joined #lisp
<Bike>
you can set *break-on-signals* to 'error
<Bike>
it's a type of conditions to break on, not a boolean.
<loke`>
eta: You can use the INCOV package (on quicklisp). It has the most robust error recovery parsing.
<eta>
well check out {\\\"status\\\":\\\"\\\\ud83c\\\\uddf5\\\\ud83c\\\\uddf9\\\\ud83c\\\\uddec\\\\ud83c\\\\udde7\\\"}
<Shinmera>
unless you're talking about BSON, which is another deal entirely.
<eta>
whatever this string is, it seems to be causing Problems
<Shinmera>
those are the raw codepoints.
<eta>
yeah
<Shinmera>
so there is no encoding.
<Shinmera>
you need to replace every \uX by the result of (code-char X)
<eta>
Shinmera, no, but is it possible that encoding that string as UTF-8 throws an error
* Shinmera
gives up
<eta>
sorry :(
<Bike>
what shinmera is trying to say is that you seem to be persistently confusing strings and their encodings as byte sequences. That string is perfectly encodable as UTF-8; but you're not dealing with a string, you're dealing with a byte sequence you got from the wire or something.
<eta>
Bike, what if it contained an unpaired UTF-16 surrogate?
<eta>
(or can lisp strings not contain those)
<Bike>
there are no UTF-16 surrogates in strings. Strings are composed of characters.
<jcowan>
When you represent characters in JSON strings as backslashed \uxxxx, you havd to use UTF-16 conventions. But the encodijng of a JSON value should always be UTF-8.
<eta>
Bike, so what you're saying is, strings are always sequences of valid characters?
<jcowan>
so "\D800" is an invalid string
<Bike>
eta: Yes, and in fact there are no "invalid characters".
shifty has quit [Ping timeout: 265 seconds]
<eta>
just invalid byte sequences?
<Bike>
No!
<Bike>
There are no bytes! A string is made of characters.
<Bike>
It's a high level data type.
<eta>
sure
<eta>
what I meant to say is
<eta>
encoding errors only arise when you're going to/from byte sequences?
<Bike>
Well, yes. How would you get an encoding error except while encoding?
<eta>
...this is a good point ;p
<jcowan>
At that level, yes. But then JSON string values can generate errors if they contain invalid escape sequences. Those are encoding/decoding errors at a different level
<Bike>
The error you showed looks like you're trying to decode a stream of bytes into a string, but the byte sequence is not actually UTF-8.
<eta>
jcowan, that's exactly what I was thinking!
<eta>
well I managed to crash SLIME with this weird string, somehow
<eta>
oh wait, no
<eta>
jcowan, you mean if the \uXXXX isn't actually a valid codepoint
cyberoctopi has joined #lisp
<jcowan>
Or pair of surrogates.
<edgar-rft>
let's introduce NOT-ENCODING-ERROR conditions for errors that happen while not encoding
<eta>
aha!
<mood>
That does not apply to the string posted though, that (with some \\ removed) appears to be a Portuguese flag followed by a British flag
<Bike>
so i suppose more pedantically we would say that UTF-8 is an encoding of code points to bytes, not characters to bytes
<eta>
Bike, but you aren't allowed
<eta>
> Since RFC 3629 (November 2003), the high and low surrogate halves used by UTF-16 (U+D800 through U+DFFF) and code points not encodable by UTF-16 (those after U+10FFFF) are not legal Unicode values, and their UTF-8 encoding must be treated as an invalid byte sequence.
<Shinmera>
UTF-16 is a curse that will never leave us, much like CRLF and Tab characters
<eta>
maybe I should switch to another JSON library... :p
<Bike>
well, it looks like yason handles it correctly
<Shinmera>
what about jsown and jonathan and... what was the other one
<Shinmera>
*the other two thousand that no doubt exist
<eta>
st-json?
<mood>
st-json
<eta>
urgh
<eta>
which one do I pick now
<beach>
eta: While we are at it, errors are not "thrown" in Common Lisp. They are signaled. It is important because THROW means something entirely different in Common Lisp.
<eta>
beach, sorry! I do know that, just don't take much care and abuse the term 'throw' >_< I'll try and be more careful though!
Steinberg2010 has quit [Ping timeout: 240 seconds]
<Bike>
oh, i see, cl:code-char is defined to return NIL if the code doesn't correspond to a character
<Bike>
weird but whatever
PuercoPop has joined #lisp
bitmapper has joined #lisp
<jcowan>
Why is that bad? Think of code-char as searching a notional association list between codes and chars.
<Bike>
jcowan: because i'd prefer a "code X does not correspond to a character" to a "NIL is not of type CHARACTER"
wxie has quit [Ping timeout: 260 seconds]
<jcowan>
Fair enough
<_death>
Bike: it's worse than that, if NIL is interpreted as something else.. this is another pitfall (maybe it should've been called code-char-p)
<Bike>
true, NIL is also a string designator
<Bike>
that could get funky
<jcowan>
There really are a whole lot of conventions for representing the behavior of partial functions: value vs. NIL, value vs. no values, two values (some value and validity flag), a Maybe class object
<Bike>
indeed
<jcowan>
nil is a designator?? for what string?
<White_Flame>
all symbols are string designators
<Bike>
"NIL"
<jcowan>
Oh, of course
<Bike>
what tangled webs we weave...
<jcowan>
... when we engage in data punning
<Bike>
so (length (string (code-char whatever))) could be either 1 or 3
<White_Flame>
eta: then clone it and symlink the directory from ~/quicklisp/local-projects/
<White_Flame>
then it's in (your) quicklisp
<eta>
Shinmera, babel can't do what I want though
<eta>
White_Flame, well that's no good, I'm writing a library :P
<eta>
eh, I'll just include it
<White_Flame>
ah
<White_Flame>
yeah, it's CC0
<kpoeck>
Make a request to add it to quicklisp
<Shinmera>
eta: like what? You can stuff your integers into a byte vector and hand them to babel to do the decoding.
<eta>
Shinmera, oh that'd probably work actually, thanks
<eta>
let's try
<eta>
hrm, it still passes through unpaired surrogates
<eta>
Shinmera, no it doesn't work, because your integers aren't octets
wxie has joined #lisp
<Shinmera>
's what ldb is for
<eta>
what what?
<eta>
oh, that ldb
frgo_ has quit [Ping timeout: 240 seconds]
ahungry has joined #lisp
random-nick has quit [Ping timeout: 256 seconds]
kslt1 has joined #lisp
jprajzne has quit [Ping timeout: 258 seconds]
jprajzne has joined #lisp
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
Inline has joined #lisp
davepdotorg has quit [Ping timeout: 264 seconds]
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
jprajzne has quit [Client Quit]
wxie has quit [Ping timeout: 256 seconds]
jprajzne has joined #lisp
libertyprime has quit [Ping timeout: 264 seconds]
ayuce has joined #lisp
libertyprime has joined #lisp
jprajzne has quit [Remote host closed the connection]
frgo has joined #lisp
frgo_ has joined #lisp
jonatack_ has joined #lisp
bjorkintosh has quit [Remote host closed the connection]
frgo has quit [Ping timeout: 260 seconds]
jonatack has quit [Ping timeout: 256 seconds]
frgo_ has quit [Ping timeout: 256 seconds]
frgo has joined #lisp
jprajzne has joined #lisp
jprajzne has quit [Read error: Connection reset by peer]
varjagg has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
varjag has quit [Ping timeout: 256 seconds]
jprajzne has joined #lisp
varjagg has left #lisp [#lisp]
jprajzne has quit [Remote host closed the connection]
jprajzne has joined #lisp
EvW has quit [Ping timeout: 246 seconds]
revtintin has joined #lisp
jprajzne has quit [Remote host closed the connection]
Ven`` has joined #lisp
jackhill_ is now known as jackhill
monokrom has joined #lisp
jprajzne has joined #lisp
jprajzne has quit [Remote host closed the connection]
jmercouris has joined #lisp
<jmercouris>
is there a syntax for declaring a struct? e.g. not using (make-xyz ...) where xyz is the name of the struct?
<beach>
Declaring?
<Inline>
a constructor ?
<jmercouris>
yeah, like some sort of notation
<beach>
In a (declare ...) expression?
<jmercouris>
no, that's not what I mean
<jmercouris>
I don't want to have to do (list (make-xyz) (make-xyz))
<jmercouris>
just wondering if there is a more succinct way to express that
<Inline>
right so you want a constructor
<Inline>
heh
<jmercouris>
is make-xyz not a constructor?
<Inline>
might be
<_death>
jmercouris: what do you want to do?
<beach>
It is.
<Inline>
instantiator, instance constructor or initializer
<Inline>
but you want a second wrapper it seems
<jmercouris>
I want to set the value of a slot to a list of my struct
<beach>
A "list" of your struct?
<jmercouris>
but I just want the value to exist without it being funcalled into existence
<beach>
Like (list (make-xyz...))?
<jmercouris>
yes
<jmercouris>
as I also wrote above
<beach>
Ah, yes you did.
<jmercouris>
maybe I should just use a list of lists
<beach>
What do you have against (make-xyz)?
<jmercouris>
make-xyz has to exist before I can use it in a form
<jmercouris>
otherwise I will get a compile error
<jmercouris>
that's what I primarily have against it
<jmercouris>
and that will change the order in which thigns are loaded, which I don't like
jprajzne has joined #lisp
<beach>
It will exist if you define the structure first.
<beach>
Then use eval-when?
<jmercouris>
maybe, that could work
notzmv has quit [Ping timeout: 265 seconds]
<_death>
it only has to exist when the form is evaluated.. it may be declared inline later on so you get a warning
<jmercouris>
_death: what does the line: it may be
<jmercouris>
declared inline later on so you get a warning mean?
<jmercouris>
can you please rephrase
<jmercouris>
I can't declare a struct twice with the same name, Lisp will complain
<jmercouris>
(declare (inline 'make-xyz))?
<_death>
it means the compiler may signal a warning if it already compiled references to a function that's now declaimed inline
<_death>
you don't need to define the structure twice
<jmercouris>
a way to suppress this warning?
<_death>
first, see if you get one
<jmercouris>
OK
jonatack_ has quit [Ping timeout: 250 seconds]
Jachy has quit [Quit: Idle for 30+ days]
<jmercouris>
it did not complain
<jmercouris>
interesting
<jmercouris>
I set it as the initform, and it is not executed until the object is instantiated
<jmercouris>
so, does the compiler not go through and say "hey, this function does not exist!"?
<jmercouris>
I know in defuns it does not traverse inside and do that
jprajzne has quit [Remote host closed the connection]
<beach>
What?
<_death>
the constructor defined by defstruct is like any other function
didi has left #lisp ["O bella ciao bella ciao bella ciao, ciao, ciao."]
<jmercouris>
I'm sorry, I'm a bit in my head and not explaining very whell
<jmercouris>
s/whell/well
<jmercouris>
Let me start over
<jmercouris>
I have a defclass with some slots, one of them has an initform with the value (list (make-xyz ...))
<jmercouris>
I'm asking, why is the compiler not complaining about make-xyz not existing?
<_death>
in Lisp, you can reference names to functions that are not yet defined.. as long as you don't try to evaluate the form, no error should occur
<jmercouris>
OK, so I had misunderstood
<jmercouris>
I assumed it only cared whether it was top level
<jmercouris>
ah, jeez, now I feel a bit silly
<jmercouris>
that makes a ton of sense, and explains a lot of things
<beach>
You might get a warning though, depending on the implementation. But if your function is defined in the image that you are compiling from, the compiler will take that definition as proof that the function does exist.
<beach>
jmercouris: In your case, you will get a style warning from SBCL if you compile a file with your DEFCLASS form in it from a fresh Common Lisp image.
<_death>
there's also a notinline declaration.. it will force the compiler not to inline and likely not to give inline warnings ;)
<jmercouris>
I interestingly enough did not see a warning
<jmercouris>
no idea why, I thought I would
<beach>
jmercouris: "fresh Common Lisp image"?
Steinberg2010 has joined #lisp
<jmercouris>
Yeah, i restarted slime and everything
<jmercouris>
and then only loaded my system
<jmercouris>
did a ,load-system
jonatack has joined #lisp
<beach>
jmercouris: That may not compile it if it was already compiled.
<jmercouris>
OK, fair enough, I will have to rethink it should I want the name
<Bike>
as it says, it's for debugging only
<jmercouris>
Yeah
revtintin has joined #lisp
hlavaty has quit [Remote host closed the connection]
wheelsucker49 has joined #lisp
PuercoPop has quit [Quit: WeeChat 1.9.1]
narimiran has quit [Quit: leaving]
karlosz has joined #lisp
choegusung has joined #lisp
choegusung has left #lisp [#lisp]
<jcowan>
beach: what is so great about 1-? It saves one space character and should produce exactly the same result when compiled, I would hope.
EvW has quit [Ping timeout: 260 seconds]
<jackdaniel>
a stylistic rule is to use the most specific operator when applicable
<jackdaniel>
IMO it is easier for human brain (common lisp programmer will scan 1- like other known operators, while for (- …) it will need to parse also the argument in question
<jcowan>
Well, for me (1- x) looks too infix, as if it were (- 1 x)
<Bike>
i always see (1- x) as (- 1 x), very sad
omtrent has quit [Quit: WeeChat 2.7.1]
<_death>
practice more lisp :)
<jcowan>
2MWBAST
cyberoctopi has joined #lisp
ravndal has joined #lisp
<_death>
or defun +-1 ...
<_death>
and this is not so far from (+ -1 ...)
gko has quit [Ping timeout: 258 seconds]
<jcowan>
_death: That's a potential number and so unavailable
<_death>
jcowan: is it?
<jcowan>
I think so. It begins with a sign, doesn't end with a sign, and contains a digit.
Kundry_Wag has quit [Remote host closed the connection]
<jcowan>
sbcl treats it as a symbol and so does clisp; I haven't tried any others
<Bike>
eclector also treats it as a symbol.
dale has joined #lisp
<jcowan>
Huh, and here I thought eclector would be quite clear about potential numbers, at least in strict mode.
<Bike>
i'm not sure i quite understand how this works. does an implementation have to signal an error here or is treating it as a symbol okay?
<_death>
I see, but that a conforming implementation may treat it differently does not prohibits its use
<_death>
*prohibit
<jcowan>
They are reserved tokens like a:::b
shangul has quit [Ping timeout: 260 seconds]
<jcowan>
I would signal a condition and allow restarting with a replacement value
<jcowan>
that way eclector-using systems can do what they want
<Bike>
i see, based on 2.3.5 the consequences are unspecified. i think.
EvW1 has joined #lisp
<jcowan>
However, an implementation that defines some kind of potential number needs to be told about it, not just to have it stuffed under the rug as just another symbol.
<jcowan>
so a general-purpose reader should not silently treat it as a symbol.
<jackdaniel>
it is nice when unspecified behavior is signalled with all (if feasible) sensible behaviors proposed in form of restarts
<jackdaniel>
s/in form/in a form/
<Bike>
yes, i just wanted to be clear it was okay at all
* jcowan
nods
efm has joined #lisp
msk has joined #lisp
<jcowan>
a:::b is technically not a reserved token, but the consequences are likewise unspecified
<beach>
jcowan: It's a very general rule in programming, namely, use the most specific construct that will accomplish the task. By doing it this way, you allow for the person reading your code to understand the intention much earlier. Of course (1- x) and (- x 1) is not much different, but if x spans several lines, it is.
<beach>
... er, what jackdaniel said. Sorry
<jcowan>
Fair point in general, although any editor with the brains to do paren matching will make that easy
msk_ has quit [Ping timeout: 256 seconds]
zaquest has quit [Ping timeout: 265 seconds]
<jcowan>
Also, compactness brings obscurity: cdaddr is probably best expanded to (cdr (car (cddr ...
<_death>
potential numbers seem theoretical to me at this point, but good to know
<jcowan>
or use some better tools
<beach>
jcowan: It is not about compactness. That's one aspect, but not all of it.
<beach>
Certainly not the most important one.
<jcowan>
IIUC then it is an argument against sequence fns when you don't actually need the polymorphism of the arguments?
<beach>
Any rule can be abused if you put your mind to it.
<beach>
But yes, the sequence functions are best used when the exact representation of the sequence is not known.
* jackdaniel
misses a loop operator for iterating over an arbitrary sequence
<beach>
Anyway, I'm off to spend time with my (admittedly small) family.
<jcowan>
jackdaniel: Extensible loop, is it?
msk has quit [Remote host closed the connection]
<jackdaniel>
in practice most (if not all) loop macros in today cl implementations *are* extensible, but these mechanisms are not documented nor compatible, so they are not usually used
msk has joined #lisp
<jackdaniel>
not to mention that these loop implementations usually predate clos
<jackdaniel>
so extensibility goes with some obscure operators in system internals
<jackdaniel>
s/system/implementation/
<jcowan>
yeag
nicktick has quit [Quit: Leaving.]
jmercouris has quit [Ping timeout: 256 seconds]
<jcowan>
er, yeah and yuck
<Bike>
the sequence extension includes a general sequence iteration path, which is nice
<Bike>
you could also put one in using an index and elt, of course
<Bike>
clasp's loop happens to have enough in common with sbcl's that i could cargo-cult the code over no problem, which is good, because i absolutely do not understand the loop code
<jcowan>
SRFI 42, which is not a Scheme standard, provides iteration over lists, simple vectors, strings, integer ranges, real ranges, character ranges, and streams, and adding your own is easy. There is also a polymorphic iterator that looks at the type it is interating over, and that's extensible too.
msk_ has joined #lisp
<Bike>
yeah, the extension defines a thing for efficient iteration over whatever you define
<Bike>
i wrote a path for iterate (which i don't usually use) to see if i could, and it turned out i could but only inefficiently since iterate doesn't allow outer multiple-value-bind bindings for reasons i'm not clear on
<jcowan>
multiple values are always a bugbear in Lisp, because people forget to allow for them.
<Bike>
well, i mean, iterate explicitly doesn't allow them
<jcowan>
(Continuations are an even worse bugbear in Scheme)
<jcowan>
Unrelated question: does anyone have use cases for m-v-call with more than one producer function? It's come up for me once or twice years ago, but I can't remember quite why any motr
<Bike>
producer function? You mean, argument form?
<_death>
jcowan: I had one.. at the time I defined (defmacro values-concat (&body forms) `(multiple-value-call #'values ,@forms)) for it
<jcowan>
s/function/form
<jcowan>
the first argument is a consumer and the rest are producers of m-vs
<Bike>
sure, right.
<jcowan>
_death: Do you remember what you used it for, though?
<_death>
jcowan: the form using it is (values-concat bloom (encode-bits-internal bloom)) .. encode-bits returns two values
<Bike>
let's do a quick grep... opticl/shapes.lisp... oh, alexandria uses it for curry
<jcowan>
I'll look at alexandria
<Bike>
only in the case of curry that can't be compiler macroed away, though. check functions.lisp
<Bike>
basically it does it instead of the obvious (apply f (append ...))
nitrix has quit [Read error: Connection reset by peer]
<jcowan>
I don't think a cons-free implementation of mv-call is possible; it has to be primitive
<jcowan>
Has anyone looked into a minimal basis set for special forms? Clearly the standard set is not minimal
<Bike>
people ask occasionally, but i don't know if the question is that interesting. there's that one paper on implementing them in terms of each other...
<_death>
jcowan: I also have an example from an older (circa 2008?) proprietary code base
<jcowan>
I think I read the HB long ago; I went through most of his
<Bike>
i like the last one in there about macrotizing FUNCTION. a bit more support and maybe you wouldn't need any special operators at all, just macroexpand (lambda lambda-list . body) into `(make-closure ',analyzed-lambda-list ',analyzed-body)
<Bike>
quote as a macro was done by oleg, i think
<jcowan>
the first one seems bogus, emulating if with get, because get cannot be implemented without if.
<Bike>
eh? who says?
<Bike>
you can do it with aref instead of you'd prefer
<Bike>
i think that's the trick, really. there's lots of stuff in the language you can't do with just the special operators anyway. the special operators aren't a minimal operator set, they're just operators that the compiler is allowed to treat more mysteriously than it can functions or macros
* jcowan
scratches head
<jcowan>
how with aref?
<_death>
I guess it uses GET to give clue.. if boolean was 0 or 1, AREF would do, but it's NIL and non-NIL
<Bike>
hmmm how'd it go again. that's one i remember from some usenet post
<Bike>
who was that colorful guy xach made an archive of posts of... naggum, right
<_death>
boolean could also be CAR/CDR
eck is now known as rina
rina is now known as rina`
<Bike>
oh, true that it's bogus in that it won't work if the condition evaluates to non-nil but non-T, though
<_death>
Bike: that's why it has not-not
<Bike>
ahh.
<jcowan>
The Scheme standard basis set at runtime is variable reference, implicit function call, literals (including quote), if, setq, lambda. This is thought to be minimal, but I know of no proof. Outside runtime are macrolet, defpackage, and include (as in C).
<jcowan>
and of course not depends on if
ggole has quit [Quit: Leaving]
<Bike>
well, if that's on the table, (defvar *aux* (vector nil (lambda (x y) (funcall x)) nil (lambda (x y) (funcall y))) (defmacro if (condition then &optional (else ''nil)) `(funcall (svref *aux* (length (string (not (not ,condition))))) ...))
<Bike>
genius, you will agree
<_death>
don't see any code-char there :/
<jcowan>
How do you implement length without if?
<_death>
string[-1] :)
<Bike>
hey, i'm writing the compiler, not the runtime
<jcowan>
Fair enough, but implementing `not` is still going to be circular.
<Bike>
i'm not sure why the vector? case is necessary, maybe scheme does vectors differently
<Bike>
in lisp this would remove any possibility of coalescing, but that's optional anyway
<Bike>
oh, well, you'd have to be careful about circular structures actually.
<jcowan>
vectors in Scheme are simple-vectors in CL
<jcowan>
strings are not vectors, therefore
rina` is now known as eck
revtintin has quit [Quit: WeeChat 1.9.1]
<Bike>
i mean, (eval #(...)) returns immediately, right? so you could just macroexpand (quote #(...)) to #(...)
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
<jcowan>
Now, yes, but that was not true in 2001; (eval #(1 2 3)) was an error
<Bike>
er, why?
jmercouris has joined #lisp
<jcowan>
Hysterical raisins, I think. Vectors weren't self-quoting in Maclisp either.
<Bike>
bizarre.
<jcowan>
Finally we moved to the same position as CL except for ()
<jcowan>
(eval ()) is still an error
<Bike>
that i can at least understand.
<jcowan>
it is assumed to be a malformed function call.
<_death>
in that same comment about the mote datatype, Steele remarks: "For example, I might extend my Common Lisp to evaluate a vector by evaluating its elements in parallel and returning the value of just one of them (implemented by choosing the value of whichever one finishes first)."
<jcowan>
he was much concerned with parallelism in those days: see the xapping example imn cltl
<Bike>
or fortress, but i guess that continues the "this might be a dumb way to denote a perfectly fine concept" concern
<_death>
yes (*Lisp...) .. but what Bike said re. fortress ;)
cyberoctopi has quit [Ping timeout: 264 seconds]
<pjb>
(eval ()) #| --> nil |# no error.
<pjb>
jcowan: () is a symbol, which is declared as a constant variable, whose value is CL:NIL when evaluating CL:NIL it's a symbol, which is declared as ac onstant variable, whose value is CL:NIL. Therefore the result is CL:NIL!
<pjb>
Basic evaluation rules of CL… Go read a tutorial!
<jcowan>
Yes, I know the paradoxes of nil, really
<jcowan>
Bike was looking at a macro written in Scheme and wondering about parts of it.
<jmercouris>
I forget the order and have to look it up, every time
<eta>
jmercouris: cadadar is amazing
<Bike>
well, good news, it's 2020 and we prefer defclass
<eta>
jmercouris: it just does it from left to right
<eta>
cadar = (car (cdr (car ...
<jmercouris>
yeah, I know
<jcowan>
When I wrote a Lisp interpreter long ago, the undefined-function-name logic checked to see if the name matched /c[ad]*r/ and emulated it on the spot
<jmercouris>
it doesn't mean I don't end up drawing little diagrams to figure out what it is doing
<jmercouris>
I can't do it in my head
<Bike>
in modern CL objects other than symbols and conses are self evaluating, so the kind of extension steele talks about there is not possible
<Bike>
that's good to know
<jcowan>
I can only in stereotyped ways, roughly /ca?d*r/
<jcowan>
Well, objects with printable representations anyway
<Bike>
no, all of them
<Bike>
"A form that is neither a symbol nor a cons is defined to be a self-evaluating object. Evaluating such an object yields the same object as a result. "
<jmercouris>
can an object return multiple values?
<_death>
Bike: but the potential number thing is still possible.. hardcoding IPs and magic numbers in code looks fun
<jmercouris>
a self-evaluation of an object
<Bike>
jmercouris: Nope
<Bike>
wouldn't be just the object, after all
<Bike>
as far as i know, printability has no impact on evaluability at all, which seems sensible to me
<jmercouris>
are you telling me that the definition of self-evaluation means only returning the identity?
<Bike>
sure. is that surprising?
<jmercouris>
sure it is
<jmercouris>
i just assumed self-evaluation meant that the object itself is a function which returns something
<jmercouris>
not necessarily itself
<jmercouris>
the fact that "fish" -> "fish" is not a given to me
<Bike>
That's an interesting assumption.
<Bike>
Sure, it's possible to imagine a world in which eval is a generic function and you can put methods on it, for example.
<Bike>
Was there some particular behavior or idea that made you consider this?
z147 has joined #lisp
<jmercouris>
no
<jmercouris>
the only idea that made me consider it is the idea that behind self-evaluation, must be evaluation
<jmercouris>
and evaluation makes no guarantees about what will be returned
<alandipert>
i understand lazy evaluation in other languages as something like Bike's idea of eval as generic,and conditional operators are specializations
<Bike>
well, i mean. eval is just a function. if eval had no behavior specified it wouldn't be a very easy to use function.
<jmercouris>
i understand lazy evaluation in other languages as stored sexp
<jcowan>
Bike: your quote says "A form" not "An object", so I think evaluating an object that is not a form is undefined behavior
<alandipert>
i think maybe our understanding is similar, to the extent that a function is a kind fo stored sexp
<jcowan>
e.g. (eval (lambda (x) (+ x 1)))
<Bike>
jcowan: there are no objects that are not forms.
<Bike>
(per glossary entry "form": "any object meant to be evaluated")
<jmercouris>
can a list of atoms be said to be an object?
<Bike>
lists are objects, yes.
<jmercouris>
is a list of atoms not a form?
<jmercouris>
yes
<jmercouris>
is there anything that is *not* evaluated?
<Bike>
sure, stuff you quote
<jcowan>
alas the definition of "evaluate" and "form" in the glossary are mutually recursive, but it definitely does not say that all objects are forms.
<_death>
with a suitable interpretation, you could say (1 2 3) is not a form
<Bike>
well, it's not a formal grammar or anything, i'm using some reading comprehension
<jmercouris>
_death: bike would tell you that is an object
<_death>
jmercouris: it is
<jmercouris>
_death: could we say '(1 2 3) is a form?
<_death>
jmercouris: (defun objectp (x) t)
<_death>
jmercouris: yes..
cage_ has quit [Quit: Leaving]
<_death>
jmercouris: the form (quote (1 2 3)) evaluates to (1 2 3)
<jmercouris>
so, all objects are forms, but not all forms are objects?
<Bike>
the issue where they changed the non-cons-symbol evaluation behavior mentions having to quote vectors
<jmercouris>
_death: I'm just trying to understand why you say (1 2 3) is not a form
<jcowan>
okay, you are right; the second definition of form is noncircular.
<jcowan>
But you'd be surprised how common circularity is in even professionally produced language dictionaries.
<_death>
jmercouris: the other way around.. all forms are objects, but not vice versa
<Bike>
i don't think i would be. CL is the language where prog2 returns the first value, after all
<_death>
jcowan: due to Agrippan trilemma
<jmercouris>
_death: so, you agree with jcowan then?
<jcowan>
jmercouris: No, a form is a symbol, compound form (non-empty list), or self-evaluating object (any object but a symbol or cons), so all forms are objects and vice versa
<jmercouris>
OK, you don't agree then
<jmercouris>
you guys are quite confusing sometimes :-D
<jcowan>
"Infinite are the arguments of mages."
<jcowan>
or
<jcowan>
"And I am right and you are right and everything is quite all right!"
<_death>
jmercouris: personally I don't mind calling (1 2 3) a form, unless the context requires the distinction
<jmercouris>
I usually refer to those things as forms
<jmercouris>
rather than objects, even though, yes, lists are objects
<jcowan>
It isn't a form in the first sense ("object meant to be evaluated") because it obviously isn't, but it is a form in the second sense.
<jcowan>
General dictionaries (not like the CL glossary) are constantly hovering between circularity and "word not in" (a word is used in a definition but not defined). The two are incompatible in principle, but you want to minimize a weighted sum of the two
ayuce has quit [Remote host closed the connection]
<jmercouris>
i wonder if you could make a dictionary starting from a single definition from which all are built
<jmercouris>
i guess that's what they tried to do with those discs on the voyager
<_death>
jcowan: nowadays you could have an infinite online dictionary ;)
<Bike>
principia mathematica, provided you have godel yelling over your shoulder
<jmercouris>
what if you have godel yodeling over your shoulde?
<jcowan>
s/yelling/yodeling
<jmercouris>
ha!
<jmercouris>
beat you
<Bike>
or various efforts in formal theorem proving
<jcowan>
But I'm moving faster than you, so only according to your clock, not mine
<Bike>
take fifty thousand pages to show that in at least some cases, a circle has an inside and an outside
<jcowan>
So a point is not a circle of radius 0
<_death>
Hilbert said we should use chairs, tables, and beermugs anyway
<jcowan>
or no, that is a line I guess, I was thinking of beermats.
vlatkoB has quit [Remote host closed the connection]
cyberoctopi has quit [Ping timeout: 260 seconds]
msk has joined #lisp
msk_ has quit [Ping timeout: 250 seconds]
random-nick has joined #lisp
karswell_ has quit [Read error: Connection reset by peer]
<_death>
jcowan: (1 2 3) is not a form in the second sense either, is it?
gareppa has joined #lisp
gareppa has quit [Remote host closed the connection]
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
orivej has joined #lisp
msk_ has joined #lisp
izh_ has joined #lisp
msk has quit [Ping timeout: 265 seconds]
cyberoctopi has joined #lisp
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
<phoe>
_death: all objects are forms, so (1 2 3) is a non-empty list
arduo has joined #lisp
<phoe>
even if it certainly isn't meant to be evaluated
dddddd has quit [Ping timeout: 260 seconds]
SGASAU has quit [Remote host closed the connection]
<_death>
phoe: where do you see that all objects are forms?
msk has joined #lisp
SGASAU has joined #lisp
msk_ has quit [Ping timeout: 240 seconds]
<phoe>
21:02 < jcowan> jmercouris: No, a form is a symbol, compound form (non-empty list), or self-evaluating object (any object but a symbol or cons), so all forms are objects and vice versa
<phoe>
oh wait...
<_death>
phoe: the premise is from the glossary, but not the conclusion
<phoe>
no, a compound form must be: "a non-empty list which is a form: a special form, a lambda form, a macro form, or a function form."
<phoe>
and (1 2 3) is neither
<_death>
right
<phoe>
so (1 2 3) is formless, as per ancient zen tradition
<jcowan>
okay, you are right, not all objects are forms
<_death>
phoe: WATER is a form, though
<Bike>
formless sounds more like heart sutra than zen to me
<jcowan>
it was the first language with countably infinitely many types
<jcowan>
s/60/68
<jcowan>
_death: but is it bohl- or buhl-?
<Bike>
apparently not, if Plankalkül had arrays of arrays of records
cartwright has joined #lisp
<jcowan>
Point. Also Cobol, now that I think of it
<_death>
jcowan: buhl- it seems
<jcowan>
so a perfect hybrid of English root pronounced Englishly and German affix pronounced Germanwise
<aeth>
Is there a CLobol Cobol-in-CL and if not, why did they miss the opportunity to use that name?
<pjb>
aeth: learn Cobol. It looks like it has more employement opportunities than CL!
cosimone has joined #lisp
nicktick has quit [Quit: Leaving.]
asarch has quit [Quit: Leaving]
adam4567 has quit [Remote host closed the connection]
<aeth>
If we're going to go down that route we might as well shut everything down except for ##javascript
cosimone has quit [Quit: Quit.]
iAmDecim has quit [Ping timeout: 264 seconds]
Codaraxis has joined #lisp
bendersteed has quit [Remote host closed the connection]
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
cosimone has joined #lisp
zaquest has joined #lisp
kpoeck has left #lisp [#lisp]
torbo has joined #lisp
kopiyka has quit [Ping timeout: 260 seconds]
adam4567 has joined #lisp
adam4567 has quit [Remote host closed the connection]
iAmDecim has joined #lisp
adam4567 has joined #lisp
<jcowan>
I don't see any CL-to-JS that's even close to complete in "language features" as opposed to "library features"
<aeth>
You can't really have something that's both efficient and a conforming CL in JS because the languages are just too different.
iAmDecim has quit [Ping timeout: 250 seconds]
* jcowan
waves webscript in aeth's general direction
<jcowan>
s/script/asm
<pjb>
aeth: webassembly.
<aeth>
jcowan: I believe the issue is the garbage collector
<aeth>
the initial wasm was more aimed at C/C++
<jasom>
wasm is a no-go for so many reasons
<jasom>
the biggest one being that you can't just dynamically generate assembly and then call it (which most traditional lisps do)
<Bike>
i think t hey still haven't implemented exceptions and it looks like they've decided to go with C++ style ones, which I can tell you from experience are an enormous pain in the ass to reconcile with lisp nonlocal control flow.
<jasom>
clisp requires a C style call-stack, which wasm doesn't ahve
<jasom>
CliCC would work, but the last free one was kind of incomplete