access

A common lisp library to unify access to common dictionary-like data-structures (by AccelerationNet)

Access Alternatives

Similar projects and alternatives to access

NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a better access alternative or higher similarity.

access reviews and mentions

Posts with mentions or reviews of access. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2023-02-20.
  • Cleaning libraries.
    1 project | /r/Common_Lisp | 27 Feb 2023
    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.
    4 projects | /r/Common_Lisp | 20 Feb 2023
  • From Common Lisp to Julia
    6 projects | news.ycombinator.com | 8 Nov 2022
    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
    2 projects | /r/lisp | 1 Jun 2022
    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
    4 projects | /r/Common_Lisp | 15 Jan 2022
    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
  • A note from our sponsor - SaaSHub
    www.saashub.com | 26 Apr 2024
    SaaSHub helps you find the best software and product alternatives Learn more →

Stats

Basic access repo stats
5
79
0.0
over 1 year ago

AccelerationNet/access is an open source project licensed under GNU General Public License v3.0 or later which is an OSI approved license.

The primary programming language of access is Common Lisp.

Popular Comparisons


Sponsored
SaaSHub - Software Alternatives and Reviews
SaaSHub helps you find the best software and product alternatives
www.saashub.com