triffid has quit [Remote host closed the connection]
triffid has joined #commonlisp
Gleefre has quit [Remote host closed the connection]
mgl has quit [Ping timeout: 264 seconds]
decweb has quit [Ping timeout: 255 seconds]
rendar has quit [Ping timeout: 260 seconds]
rgherdt has quit [Quit: Leaving]
zetef has joined #commonlisp
habamax has joined #commonlisp
donleo has quit [Ping timeout: 255 seconds]
dnhester26 has quit [Remote host closed the connection]
ym has quit [Ping timeout: 256 seconds]
jmiven has quit [Quit: reboot]
jmiven has joined #commonlisp
<Pixel_Outlaw>
cl-clippy ;P
yitzi has joined #commonlisp
<Pixel_Outlaw>
"I see you were trying to remember the syntax for LOOP, would you like me to help you with that?"
<Pixel_Outlaw>
Heh, last time I checked I think a few implementations just kind of cheated off each other with LOOP's implementation.
<Pixel_Outlaw>
Or maybe it was FORMAT
<random-nick>
it's both
<random-nick>
also the case for the pretty printer
dra has joined #commonlisp
Devon has quit [Read error: Connection reset by peer]
Devon has joined #commonlisp
dra has quit [Remote host closed the connection]
pfdietz has joined #commonlisp
Lycurgus has joined #commonlisp
JuanDaugherty has joined #commonlisp
habamax has quit [Ping timeout: 264 seconds]
decweb has joined #commonlisp
notzmv has joined #commonlisp
JuanDaugherty has quit [Quit: JuanDaugherty]
habamax has joined #commonlisp
habamax has quit [Remote host closed the connection]
<yitzi>
They didn't "cheat" off each other. Most inherited the implementation of subsystem from whatever Lisp they are descended from, or chose to rewrite that sub-system.
zetef_ has joined #commonlisp
zetef_ has quit [Remote host closed the connection]
zetef has quit [Ping timeout: 255 seconds]
random-nick has quit [Ping timeout: 252 seconds]
yitzi has quit [Remote host closed the connection]
zlqrvx has joined #commonlisp
zlqrvx has quit [Client Quit]
zlqrvx has joined #commonlisp
zlqrvx has quit [Client Quit]
decweb has quit [Ping timeout: 260 seconds]
zlqrvx has joined #commonlisp
zlqrvx has quit [Quit: %quit%]
decweb has joined #commonlisp
bilegeek has joined #commonlisp
tyson2 has joined #commonlisp
avocadoist has joined #commonlisp
mariari has quit [Quit: WeeChat 4.1.1]
edr has quit [Quit: Leaving]
avocadoist has quit [Ping timeout: 256 seconds]
mariari has joined #commonlisp
semz has quit [Quit: ZNC 1.8.2+deb2build5 - https://znc.in]
semz has joined #commonlisp
amb007 has quit [Remote host closed the connection]
amb007 has joined #commonlisp
arpunk has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
szkl has quit [Quit: Connection closed for inactivity]
azimut has quit [Remote host closed the connection]
lucasta has quit [Quit: Leaving]
azimut has joined #commonlisp
igemnace has joined #commonlisp
decweb has joined #commonlisp
decweb has quit [Ping timeout: 256 seconds]
habamax has joined #commonlisp
mathrick has quit [Ping timeout: 256 seconds]
rtypo has joined #commonlisp
mathrick has joined #commonlisp
bike has quit [Ping timeout: 240 seconds]
bike has joined #commonlisp
kenran has joined #commonlisp
habamax has quit [Quit: ERC 5.5.0.29.1 (IRC client for GNU Emacs 29.1.90)]
King_julian has joined #commonlisp
dcb has quit [Quit: MSN Messenger 4.1.1]
<ecraven>
is `haulong' just a phonetic spelling of `how-long', or is there a story behind the name?
<beach>
I think it is just a phonetic spelling. There were more of those in MacLisp, like (from memory) `hipart'.
igemnace has quit [Remote host closed the connection]
rgherdt has joined #commonlisp
<beach>
Oh, `haipart', not `hipart'.
<ecraven>
hehe, thanks! I need to read the pitmanual
<beach>
`baklist' I think is another.
King_julian has quit [Ping timeout: 264 seconds]
<beach>
`baktrace'
Pixel_Outlaw has quit [Quit: Leaving]
<ecraven>
interestingly, `bactrace' is an alias for `backtrace' in CC (the CADR debugger)
<beach>
I see.
<ecraven>
ah, it's actually a typo in the documentation, the alias is `baktrace'
<ecraven>
so that's where that came from ;)
<ecraven>
hehe, looking at the implementation, `baktrace' is the command, and `backtrace' is the alias :D
<beach>
I used Multics Maclisp a little at the time. It was pretty fast, but very primitive compared to Common Lisp.
<beach>
Multics Emacs was written in Multics Maclisp.
tibfulv has quit [Remote host closed the connection]
tibfulv has joined #commonlisp
pfdietz has quit [Quit: Client closed]
jonatack has quit [Read error: Connection reset by peer]
jonatack has joined #commonlisp
danza has joined #commonlisp
pve has joined #commonlisp
azimut has quit [Ping timeout: 240 seconds]
<beach>
Speaking of which, they made what I consider a pretty dumb design decision with Multics Emacs. Realizing that characters needed to be inserted and deleted in arbitrary places in a line, they added a new Multics instruction to move all the characters following an insertion or a deletion.
<beach>
So if you had a buffer with very long lines, like if you load some binary file. Editing a line was extremely slow. Plus, it must have been difficult to add a new instruction.
<beach>
I still don't understand why they didn't use some (perhaps simple) data structure for a line, like a gap buffer.
<beach>
So the design of Cluffer is the result of more than 50 years of thinking about how to represent editor buffers. :)
traidare has joined #commonlisp
bilegeek has quit [Ping timeout: 268 seconds]
rendar has joined #commonlisp
<hayley>
Such an instruction would never fly now. Oh wait, REP MOVSB does a fast memory copy on x86.
<hayley>
Well, it'd never fly on a RISC instruction set. Oh wait, ARM now has CPYP/CPYM/CPYE for copying memory too.
<beach>
Heh! ARM is not really RISC though.
<hayley>
Yes, David Patterson didn't design ARM, so it is just a sparkling load-store architecture.
Cymew has joined #commonlisp
danza has quit [Ping timeout: 252 seconds]
<moon-child>
it's 2023; risc is a meaningless designator
<hayley>
No, RISC means that David Patterson designed it. For example, doing tag checks and write barriers in hardware is RISC because David Patterson designed that.
shka has joined #commonlisp
King_julian has joined #commonlisp
danse-nr3 has joined #commonlisp
<moon-child>
brb getting intel to hire david patterson to add some more extensions to x86
<hayley>
Surely RV64GCZtso gets pretty close to the x86 experience.
mulk has joined #commonlisp
cstml has joined #commonlisp
Inline has quit [Quit: Leaving]
Inline has joined #commonlisp
bilegeek has joined #commonlisp
amb007 has quit [Ping timeout: 260 seconds]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
_cymew_ has joined #commonlisp
amb007 has joined #commonlisp
Guest86 has joined #commonlisp
anticrisis has quit [Read error: Connection reset by peer]
danse-nr3 has quit [Remote host closed the connection]
danse-nr3 has joined #commonlisp
<White_Flame>
hayley: including instruction encode/decode complexity?
cstml has quit [Ping timeout: 252 seconds]
cstml has joined #commonlisp
King_julian has quit [Ping timeout: 256 seconds]
<hayley>
White_Flame: If you make moon-child happy by using instruction fusion, why not!
cstml has quit [Ping timeout: 260 seconds]
King_julian has joined #commonlisp
santiagopim has quit [Remote host closed the connection]
<Shinmera>
Like, there are repl tools, they just usually aren't as useful or fast as M-. ing around the source.
<Guest6>
Shinmera i see thanks
<Guest6>
Shinmera actually, how do i browse the code from my emacs/repl once i have installed the package with ql ?
<Guest6>
i did a quickload, but how do i explore the code from emacs?
<Guest6>
seems like the apporach you are suggesting
<Shinmera>
What I usually do is start typing (neo4j: and then M-. on the partial name.
<Shinmera>
or whatever the package name is
<Shinmera>
quicklisp should have printed the package name at least
Guest93 has joined #commonlisp
<Guest93>
Hello, anyone knows if it sometimes happen that Quicklisp is down?
<Shinmera>
if it's down then AWS is having issues.
<Guest93>
Must be a system/SBCL issue, since I can curl the files in the client-info.sexp file
zetef has joined #commonlisp
<Guest6>
Shinmera i am on evil-mode do you know what is the equivalent of M-. ing ?
<Guest6>
oh it is the same
<Guest6>
sorry
rogersm has joined #commonlisp
<Guest6>
ok now that i am on the export, how can i jump to the function?
<Guest6>
like if i see the function -#set-node-properties and i try to M- . ing it doesn't work
cstml has joined #commonlisp
<Guest93>
So, both ECL and SBCL fail to fetch the quicklisp install files, but curl manages... what the? Is it maybe a MacOS bug? Anyone else using macports on Sonoma?
traidare has quit [Ping timeout: 268 seconds]
<Shinmera>
Guest6: I just start opening files at that point.
<Shinmera>
or complete a name I'm interested in at the repl and M-. again.
yitzi has joined #commonlisp
<Guest6>
Shinmera i am using evil mode and that M-. does not work
<Guest6>
i have to load the code
<Guest6>
how do i do that ?
danse-nr3 has quit [Read error: Connection reset by peer]
danse-nr3 has joined #commonlisp
danse-nr3 has quit [Ping timeout: 268 seconds]
cstml has quit [Ping timeout: 268 seconds]
danse-nr3 has joined #commonlisp
danse-nr3 has quit [Remote host closed the connection]
danse-nr3 has joined #commonlisp
donleo has joined #commonlisp
dim has joined #commonlisp
zetef has quit [Ping timeout: 255 seconds]
pfdietz has quit [Quit: Client closed]
King_julian has quit [Ping timeout: 255 seconds]
yitzi has quit [Remote host closed the connection]
traidare has joined #commonlisp
Guest93 has quit [Quit: Client closed]
pfdietz has joined #commonlisp
avocadoist has joined #commonlisp
zetef has joined #commonlisp
tyson2 has joined #commonlisp
chomwitt has joined #commonlisp
habamax has joined #commonlisp
Gleefre has joined #commonlisp
random-nick has joined #commonlisp
rogersm has quit [Remote host closed the connection]
rogersm has joined #commonlisp
rogersm has quit [Remote host closed the connection]
waleee has joined #commonlisp
ym has joined #commonlisp
yitzi has joined #commonlisp
zetef has quit [Remote host closed the connection]
zetef has joined #commonlisp
danse-nr3 has quit [Ping timeout: 255 seconds]
rogersm has joined #commonlisp
zetef has quit [Ping timeout: 256 seconds]
rogersm has quit [Remote host closed the connection]
rogersm has joined #commonlisp
<Guest6>
does common lisp have something in its standard library to load json ?
<ixelp>
YASON - A JSON encoder/decoder for Common Lisp
<pfdietz>
also cl-json and jsown. The last is noted for its speed.
<pfdietz>
Available through quicklisp.
rogersm has quit [Quit: Leaving...]
<random-nick>
no, the standard predates javascript, let alone JSON
<random-nick>
and one could argue that CL doesn't have a standard library because the standard doesn't make a distinction between "language" parts and "library" parts
<younder>
The 'standard' is from 1994. There are a lot of things you will want to complement CL with.clparalell for threading, alexandia contains common functions that didn't make it into the standard. CFFI for a portable C interface etc.
<pfdietz>
Standard in this case could mean "de facto standard", the extension library that a community has mostly settled on.
danse-nr3 has joined #commonlisp
<beach>
I would argue that Python doesn't have a standard library because it doesn't have a standard.
danse-nr3 has quit [Remote host closed the connection]
danse-nr3 has joined #commonlisp
<aeth>
CL's standard predates XML, let alone JSON or YAML. If it supported anything, it would have been SGML or perhaps some of the various text-based configuration formats used by DOS and UNIX.
<aeth>
But "batteries included" wasn't a thing yet and Python has backed away from that in recent years because the included batteries tend to be worse and more out of date than third party libraries
<aeth>
There's no de facto standard JSON library because there are a lot of ways to map CL to JSON (and most of the libraries do it improperly imo)
decweb has joined #commonlisp
<beach>
aeth: Why is that? I mean, how hard can it be?
<bike>
careful, that's a question that leads to making your own json library.
jon_atack has joined #commonlisp
<beach>
Me? I don't think so.
<bike>
there are various ambiguities, like json has separate false and empty list types. none of it is very severe but that just means you get some bikeshedding
<aeth>
beach: About the JSON libraries? The biggest problem is NIL, and the ability to make that represent {} (if empty plist/alist), [] (if empty list), false (if boolean), or null (if you simply go off of the name NIL without understanding its role in the language, which... some JSON libraries do!)
jonatack has quit [Read error: Connection reset by peer]
<younder>
Yason leaves it to you. That's why I like it
<ixelp>
GitHub - yitzchak/shasht: Common Lisp JSON reading and writing for the Kzinti.
<beach>
aeth: So just map everything to an instance of a standard class.
<pfdietz>
I've mostly used these libraries for reading json, not producing it. The ambiguity doesn't arise as much then.
<bike>
and some things are non obvious, e.g. json does not specify (somewhat to my surprise) what a number means. like, there's no defined distinction between floats and integers, for example, you can write them out the same
<bike>
(probably because everything's a double in javascript)
<younder>
I like JSON represented as a nested plist with vectors. Needs some tooling to make CL support that, but no biggie.
<aeth>
pfdietz: yes, most issues exist if it doesn't roundtrip
<aeth>
nil<->false and :null<->null (or similar for the latter) is probably how you round trip most easily
<aeth>
[] being vectors makes the most sense, too, because now you only have nil-as-false and nil-as-empty-plist (if you use plists for {}) ambiguity
bollu has joined #commonlisp
<beach>
aeth: I am beginning to see why you think they are all doing it wrong. But I suspect the analysis is not right.
<bike>
beach: using standard classes for {} is also a little weird since javascript uses a prototype-based OOP system. cl-json has a mode where it deserializes {} to instances, but they're custom "fluid objects" to match how JS works.
<beach>
I see.
<aeth>
beach: to be fair, this is "they are all doing it wrong" applied as of maybe 2015 or 2016 but since then there has probably been another 5 new JSON libraries
<aeth>
and some have taken these concerns into account
<bike>
(it's pretty cool in concept, i think, and seeing another use of MOP is always interesting, but i've never really had to use it)
<aeth>
but, yes, {} is the other thing that doesn't cleanly map to a CL concept (NIL is just simpler)
<aeth>
I think the closest thing to JSON {} would be a string-keyed hash table that kept its order? As opposed to the unordered hash table in CL.
<aeth>
Numbers are tricky, too, yes, because they're vaguely JS in that there's no float/integer distinction, but the JSON could be generated by and for languages that do have such a distinction
<younder>
plist keeps the order
<bike>
it's also "pretty cool" that the JSON RFC doesn't define any limits for number size or precision, but awkwardly suggests not exceeding doubles
<aeth>
younder: plist keeps the order, but it's not an object (though the simplest thing to do would be to add a CONS in front and the most correct thing to do would probably be to put it in a class) and perhaps more importantly, a plist isn't O(1) but O(n)
<aeth>
and JSON {}s could in theory be very long assuming hash-table-like behavior
<beach>
aeth: In what way is a plist not an object?
<aeth>
beach: a plist is not a type, I mean. It's just a CONS
<beach>
aeth: Perhaps you mean that a plist is not an instance of an abstract data type?
<aeth>
s/just a CONS/just a CONS-or-NIL/
<younder>
Again most JSON files i use the list of atributes is short, less that 10 so that is not usually a problem
azimut has joined #commonlisp
<aeth>
a problem is that JSON is used for everything, even where it's not very suitable
<younder>
same as XML, yes
<yitzi>
plists are convient, but a bad idea in JSON in my opinion. Keywords aren'
<yitzi>
t garbage collected.
<yitzi>
Which is probably discussed in Sabra's reviews.
<gilberth>
Just soft-intern the keywords. Use (or (find-symbol key :keyword) (make-symbol key)) and be set.
<aeth>
if you implemented JSON's {} as an extensible-sequence, treated []s as simple-vectors, repesented null with :null, round-tripped the booleans nil/t (now that you're not using lists), and had a special reader macro for JSON's strings that turned into regular strings, then you'd basically integrate JSON into CL (and have written the 20th or so JSON library)... except numbers.
<aeth>
Then everyone else's JSON library that bikesheds things differently could be reimplemented on top of that ;-p
<yitzi>
JSON's objects more closely match hash tables anyways.
<gilberth>
Reasoning is as follows: It mostly matters being interned, when you actually have some :FOO somewhere in your code. And when it's in your code, you get that keyword. If not, you don't mind in the first place.
<aeth>
younder: right, they're ordered string-keyed hash tables, which would make them behave like a hash-table in some contexts but also be perfectly suitable for a new sequence type exposed via trivial-extensible-sequences
<yitzi>
Unless you are reading a network protocol and you have no control over the key values.
<gilberth>
This is what I do. And I prefer plists. For one thing, I am round-trip safe. For the other I can use destructuring-bind. And having interned keys also conses less.
<gilberth>
yitzi: Yes, but then you won't mention it with GETF or something. You get uninterned symbols with unknown keys. As good as strings.
<yitzi>
What do you mean "won't mention it"?
<gilberth>
When you don't know the key beforehand, you won't say (GETF :FOO object) somewhere in your code.
<yitzi>
That doesn't account for serialization situations in which you have to generate an object with hundreds of new key values and you are never going to GETF or GETHASH on it. This happens in the Jupyter protocol.
<yitzi>
I acknowledge your point if reading and retreival are the primary uses, to be clear.
<gilberth>
Values? I'm talking about key names.
<yitzi>
I am as well talking about key names.
<gilberth>
And? What's the problem then? Just say MAKE-SYMBOL then. As good as a string.
<gilberth>
Anyhow, any JSON data I ever dealt with has thousands of "objects" with a small set of known keys.
<yitzi>
Calling MAKE-SYMBOL on a hundred names just so you can cast them to strings during serialization and then discard them seems a bit of a waste to me. Then again, that is just my opinion based on dealing with the applications I have to deal with.
<gilberth>
It seems more of a waste for me to cons 100,000 strings, when one single symbol would do. Also to hash a string over and over again, look at a table and do a string= again to get at some attribute, where EQ could do.
<aeth>
beach: I think the above demonstrates why there are a bunch of conflicting JSON libraries.
Guest86 has quit [Quit: Client closed]
<yitzi>
That is nothing compared to the number of testing frameworks.
<aeth>
Imo, nobody's really wrong here since e.g. yitzi generating JSON for Jupyter wants strings (no interning) and gilberth probably reading configuration files or something wants symbols (would intern anyway)
<yitzi>
And there are only 2-3 JSON libraries that actually pass the JSON test suite so there is that.
<aeth>
I wonder how much JSON in the wild fails the JSON test suite
<yitzi>
The test suite is pretty good at exposing the common failures in the wild.
<yitzi>
IMHO
<aeth>
the problem is that you have to read JSON that could be written by any library or any programming language, and write JSON that likewise could be read by anything
<aeth>
at least, if you wanted to write the sole CL JSON library
habamax has quit [Quit: ERC 5.5.0.29.1 (IRC client for GNU Emacs 29.1.90)]
<yitzi>
Well, there is a spec even if it is a terrible spec with lots of holes.
<aeth>
in practice, any JSON that cares about numbers is probably using some schema to tell you what the numbers are
<yitzi>
There is rfc8259
<gilberth>
There also is ECMA 404.
<beach>
aeth: The discussion certainly amused me.
<gilberth>
Another major difference between JSON libraries is how they represent "true", "false", and "null". Some have a choice with e.g. using NIL for "null" and "false", destroying information.
<gilberth>
And even you don't care, no internal representation suitable for writing JSON.
<aeth>
one fun thing is that JSON has no comments, so comments are potentially very large strings you're just supposed to ignore (but in practice you're going to load them for no reason in most JSON libraries)
<gilberth>
But all matter of taste as well.
arpunk has quit [Remote host closed the connection]
<gilberth>
And JSON is tiny and quick to implement. Hence, I just wrote my own. I use soft-interned keywords, plists for "objects", vectors for arrays, and :true, :false, :null. And backquote to craft JSON. I never bothered making it public proper. What's the point of the gazillionth and one implementation?
ym has quit [Ping timeout: 246 seconds]
szkl has joined #commonlisp
_whitelogger has joined #commonlisp
cage has joined #commonlisp
igemnace has joined #commonlisp
edr has joined #commonlisp
cstml has joined #commonlisp
prokhor_ has joined #commonlisp
_whitelogger has joined #commonlisp
Cymew has quit [Ping timeout: 246 seconds]
chomwitt has quit [Ping timeout: 245 seconds]
Inline has joined #commonlisp
waleee has quit [Ping timeout: 264 seconds]
igemnace has joined #commonlisp
dcb has joined #commonlisp
dcb has joined #commonlisp
<NotThatRPG>
One thing that would be nice would be to see a CL JSON implementation that's capable of dealing with JSON schemas. That would likely have the additional advantage of resolving some of the uncertainties about serializing NIL. And one could stuff additional hints for CL serializing and deserializing into the Schema.
<Demosthenex>
if only there were a data languag with strong schemas
davidt has joined #commonlisp
<aeth>
Demosthenex: well, yeah, if you have control over the data language then you can just make everyone use s-expressions
yitzi has quit [Remote host closed the connection]
Gleefre has quit [Remote host closed the connection]
<Demosthenex>
aeth: technically s-exps don't have a schema for the data. xml had all that
<Demosthenex>
but it should have been s-exps from the bottom up
<NotThatRPG>
Really, XML is just s-expressions with an excessive number of kinds of parenthesis!
enzuru has joined #commonlisp
<aeth>
almost
kenran has quit [Remote host closed the connection]
notzmv has quit [Ping timeout: 256 seconds]
<aeth>
<foo>42</foo> would be (foo () 42) and e.g. <foo awesome="true">42</foo> would be (foo (:awesome "true") 42)
zxcvz has quit [Quit: zxcvz]
<NotThatRPG>
aeth: Yes, for some reason they just insist on (foo () 42 foo) ! ;-)
<NotThatRPG>
But yes, that's the obvious interpretation.
<NotThatRPG>
My impression is that XML can actually be better at providing guidance in deserialization but, tbh, it seems like XML is one of those things where when there's a problem the solution is always more XML.
<NotThatRPG>
If one can avoid having to put programmer eyes on it, all is well, but somehow something always goes wrong, you end up needing programmer eyes on it, and it's horrible, bloated and confusing.
<NotThatRPG>
There's a whole class of technologies, which is ever-growing, which works great as long as nothing ever goes wrong. But when something DOES go wrong, one finds that no one has considered how debugging should happen.
<NotThatRPG>
IMO one should *always* assume that everything will break and ask, at design time, how debugging will happen.
* NotThatRPG
climbs down off soapbox
<aeth>
everything in XML is extra verbose, even the APIs designed in it (no matter the syntax you represent it as), see e.g. MathML
<pfdietz>
Any data can be turned into Big Data by encoding it in XML!
<aeth>
these days Big Data uses YAML, though, which is great because YAML is a language designed to be human readable at the expense of being able to write it, parse it, secure it, etc., etc.
<ixelp>
~skin/nrdl - Nestable Readable Document language - sourcehut git
<skin>
- JSON numbers are awful, but I couldn't think of a better implementation that worked well across different languages. It turns out float64's are a really good lowest common denominator; almost all languages have them.
surabax has joined #commonlisp
<skin>
- YAML is awful, but was actually really, really well designed by the original designers of XML. https://yaml.org/spec/1.2.2/
<ixelp>
YAML Ain’t Markup Language (YAML™) revision 1.2.2
<skin>
They thought way harder about it than I did.
<Demosthenex>
skin: solve the norway problem
<Demosthenex>
"human editable" with data ruining implied assumptions instead of strict checking
zxcvz has joined #commonlisp
<Demosthenex>
yaml tries to let humans be lazy and lax, but for anything more than a 5 line config file, it falls apart
<Demosthenex>
look at the disaster of ansible configs and the devops yaml craze
<skin>
But it turns out that non-ordered k/v pairs are incredibly useful. First-class support for them as a means YAML's goal of first-class support for dynamic languages is a Good Thing.
<bike>
"just write out sexps" isn't even enough for lisp's compile-file.
<bike>
or printing readably.
<skin>
THIS ^^^
<bike>
i know everyone likes to hate on xml or yaml or whatever but please consider that the problems they are maybe failing to solve may, actually, be nontrivial.
<skin>
With NRDL, I tried to stay as close to JSON as possible while still providing support for keywords and embeddable documents. This solves the Norway problem (mostly) and even the "Carpenter's square" problem.
<skin>
I made commas and colons equivalent to whitespace, like EDN did, to make things look prettier/more lisp-y, and added embeddable documents, and STOPPED, because the problem is hard.
<bike>
i am glad i googled "norway problem". hilarious
attila_lendvai has quit [Ping timeout: 256 seconds]
lispmacs[work] has joined #commonlisp
molson has quit [Remote host closed the connection]
chomwitt has joined #commonlisp
<lispmacs[work]>
hi, I wanted to do validation checks on the parameters to a function, but I was how/what exception to throw if the parameter values are out of range
<bike>
is how you signal an error (this is the lisp terminology, rather than throwing an exception)
molson has joined #commonlisp
<bike>
as for what error to signal, that depends on your application i guess. you can probably do a type-error but that's quite generic, which may or may not matter to you
<bike>
there's also check-type and assert available.
chomwitt has quit [Remote host closed the connection]
<skin>
I can post a link to the image if you can't view the twitter thing.
<skin>
(I just made up the name for it)
notzmv has joined #commonlisp
<skin>
Basically: whitespace-as-structure means that for long and complicated yaml files it is difficult to determine structure depth (how many objects nested level am I at?)
zxcvz has quit [Quit: zxcvz]
anticrisis has joined #commonlisp
<jcowan>
Sounds like a lack of tooling. It's just as easy to make a mistake with S-expressions, but we have ways to generate matching parens and to verify them. For example, using TAB (indent) and SHIFT-TAB (dedent) would make mistakes less likely, and then two commands to jump up or down to the line with the same indent level.
attila_lendvai has joined #commonlisp
mgl has quit [Ping timeout: 256 seconds]
pve has quit [Quit: leaving]
notzmv has quit [Ping timeout: 255 seconds]
contrapunctus has left #commonlisp [#commonlisp]
mgl has joined #commonlisp
tyson2 has quit [Read error: Connection reset by peer]
shka has quit [Ping timeout: 252 seconds]
zetef has quit [Remote host closed the connection]
<Shinmera>
well yes but the point of yaml expressly is to be "human readable"
<Shinmera>
if you need tools to do so, is it still really?
chomwitt has joined #commonlisp
Gleefre has quit [Remote host closed the connection]
rtypo has quit [Ping timeout: 260 seconds]
zetef has joined #commonlisp
notzmv has joined #commonlisp
notzmv has quit [Ping timeout: 252 seconds]
pfdietz has quit [Quit: Client closed]
<jcowan>
Shinmera: Programming languages are generally human readable, but most people use tools to write them and debug them.
pfdietz has joined #commonlisp
cstml has joined #commonlisp
bjorkintosh has quit [Remote host closed the connection]
bjorkintosh has joined #commonlisp
bjorkintosh has joined #commonlisp
scymtym has quit [Remote host closed the connection]
scymtym has joined #commonlisp
scymtym has quit [Remote host closed the connection]
scymtym has joined #commonlisp
szkl has quit [Quit: Connection closed for inactivity]
<surabax>
does anyone know if there is a repository for https://novaspec.org/ somewhere? is it an open-source project?
<ixelp>
Common Lisp Nova Spec
molson has quit [Remote host closed the connection]
molson has joined #commonlisp
attila_lendvai has quit [Ping timeout: 256 seconds]
akoana has quit [Quit: leaving]
mgl has quit [Ping timeout: 276 seconds]
<surabax>
gilberth: you're the author of novaspec, right?