for
access
for | access | |
---|---|---|
1 | 5 | |
39 | 82 | |
- | - | |
2.7 | 0.0 | |
10 months ago | 2 months ago | |
Common Lisp | Common Lisp | |
zlib 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.
for
-
Modern sequence abstractions
This is an extensible iteration library, that has the generic for…over: https://github.com/Shinmera/for
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?
fset - FSet, the functional collections library for Common Lisp.
trivia - Pattern Matcher Compatible with Optima
jzon - A correct and safe(er) JSON RFC 8259 reader/writer with sane defaults.
clerk - ⚡️ Moldable Live Programming for Clojure