jzon
access
jzon | access | |
---|---|---|
8 | 5 | |
137 | 82 | |
- | - | |
7.2 | 0.0 | |
about 1 month ago | 2 months ago | |
Common Lisp | Common Lisp | |
MIT License | GNU General Public License v3.0 or later |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
jzon
-
Common Lisp JSON parser?
jzon https://github.com/Zulu-Inuoe/jzon/ is the newest and probably the most complete, the most robust and the most accurate. It explains everything in its readme. I have settled on Shasht so far.
-
How to create a post body for dexador
I think the consensus now for JSON libraries (it's a meme that there are way too many CL JSON libraries) is to use jzon (https://github.com/Zulu-Inuoe/jzon). It's the best one I've found.
-
SBCL Help wanted: capturing big stdout (100M) and json parsing
I use JZON for SAX-style parsing; it works very well. If you can arrange to read your input as a stream, you shouldn't have memory problem with the reading/parsing part of your project.
- JZON hits 1.0 and is at last on the latest QL release: a correct and safe JSON parser, packed with features, and also FASTER than the latest JSON library advertised here.
- What was your favorite Common Lisp release (implementation, library, tool, ...) in 2021?
- jzon - a correct and safe JSON parser.
access
-
Cleaning libraries.
I like https://github.com/AccelerationNet/access
- JZON hits 1.0 and is at last on the latest QL release: a correct and safe JSON parser, packed with features, and also FASTER than the latest JSON library advertised here.
-
From Common Lisp to Julia
I agree you can make arguments, I like your explanation for the final form further downthread. For the second form, another choice could be (.x foo) or (. foo x). Or if you're trying to write something like System.out.println("x"), Clojure's .. shows it could be written as (.. System out (println "x")). Or, if you're using CL, you can use the access library (https://github.com/AccelerationNet/access) and write things like #Dfoo.bar.bast or (with-dot () (do-thing whatever.thing another.thing)).
In trying to further steelman a case where random Lisp syntax can be more difficult to read than, say, equivalent Python, two other areas come to mind. First is the inside-outness order of operations thing, it trips people up sometimes. Like the famous "REPL" (with a bad printer) is just (loop (print (eval (read)))), but in English we want to see that as LPER. Solutions include things like the arrow macro (Clojure did good work on showcasing it and other simple macros that can resolve this issue in many places) and if you write/pull one into CL REPL becomes (-> (read) (eval) (print) (loop)), how nice to read. But even the ancient let/let* forms allow you to express a more linear version of something, and you can avoid some instances of the problem with just general programming taste on expression complexity (an issue with all languages -- https://grugbrain.dev/#grug-on-expression-complexity ).
The second area is on functions that have multiple exit points. A lot of Lispers seem to just not like return-from, and will convert things into cond expressions or similar or just say no to early-exits. The solution here I think comes from both ends, the first is a broader cultural norm spreading in other languages against functions with multiple return statements and getting used to code written that way, the other is to just not get so upset about return-from and use it when it makes the code nicer to read.
-
Document Store/DB Implemented in Common Lisp
thanks. Do you know how your cl-getx differs from access? https://github.com/AccelerationNet/access It is a universal accessor with the option of nested look ups.
-
Modern sequence abstractions
ps: related: how to access an element in all the lisp sequences, generically? I like access for that: https://github.com/AccelerationNet/access (and generic-cl
What are some alternatives?
clog - CLOG - The Common Lisp Omnificent GUI
trivia - Pattern Matcher Compatible with Optima
jingo - This package provides the ability to encode golang structs to a buffer as JSON very quickly.
clerk - ⚡️ Moldable Live Programming for Clojure
kandria - A post-apocalyptic actionRPG. Now on Steam!
lem - Common Lisp editor/IDE with high expansibility
jsondiff - Compute the diff between two JSON documents as a series of RFC6902 (JSON Patch) operations
clingon - Command-line options parser system for Common Lisp
jonathan - JSON encoder and decoder.
emerald - Simple JSON serializer/deserializer for Dart (only JIT, not Flutter).
json-streams - Common Lisp library for reading and writing JSON.
cl-json-pointer - JSON Pointer processor for Common Lisp