from Hacker News

A Common Lisp jq replacement

by tmtvl on 5/2/25, 12:15 PM with 57 comments

  • by ilyash on 5/3/25, 4:58 AM

    Opinion. Likely controversial. The fact that we need jq highlights that we are missing this functionality in shells. I argue that these days (nested) structured data is as basic requirement as having scalars, arrays and associative arrays (which bash has). It hurts my eyes seeing five line of assignment to variables where each one runs jq to extract that particular field from a data structure.

    More at "jq is a symptom" - https://ilya-sher.org/2018/09/10/jq-is-a-symptom/

    Related and might be interesting - "JSON tools for command line" - https://ilya-sher.org/2018/04/10/list-of-json-tools-for-comm...

  • by behnamoh on 5/2/25, 2:39 PM

    How is

        $ echo "$json" | cljq '(? $ "root" * 1)'
    more intuitive than the good ol' jq

        $ echo "$json" | jq '.root | map(.[1])'
    Really, people should know by now that jq does point-free programming.

  • by cube2222 on 5/2/25, 2:05 PM

    The sentiment resonates with me.

    Had similar thoughts a couple years ago, and wrote jql[0] as a jq alternative with a lispy syntax (custom, not Common Lisp), and I’ve been using it for command-line JSON processing ever since!

    [0]: https://github.com/cube2222/jql

  • by forty on 5/2/25, 4:36 PM

    > I seriously dislike jq's convoluted, impossible-to-remember ad hoc DSL that instantly joined heaps of misery like CMake and gnuplot in my heart.

    I like jq and gnuplot quite well. Makes me want to try CMake out ;)

  • by account-5 on 5/2/25, 3:26 PM

    I learned the basics of jq and quite liked it, but since I discovered Nushell it has replaced nearly all my data processing I do at the cli. It really is good technology.

  • by gray_-_wolf on 5/2/25, 1:51 PM

    One huge advantage of JQ is that it often is installed. I have jq in our Jenkins image, but I do not have this tool. The syntax is bit arcane, but once you invest bit of time into learning it, it starts to make sense (to a degree). It is a reasonable language for a stream processing.

  • by diggan on 5/2/25, 1:29 PM

    On a similar note: https://github.com/borkdude/jet

    Can convert between JSON<>EDN<>YAML<>Transit easily, plus includes a nifty little query language that is basically Clojure, so data transformations/extraction ends up really simple and concise.

    I've always liked jq for simple things, but since I never sat down to actually work through the syntax, harder things tend to be too complicated to figure out quickly. Usually end up using Jet instead as if you already know Clojure, you already know the query language Jet uses.

  • by selkin on 5/2/25, 5:17 PM

    I am old enough to remember when creating a new DSL for every task was in vogue. What used to be an issue with that approach, which I've seen hinted to in another comment here, is that I can only become proficient in so many programming languages. Achieving proficiency requires a lot of practice, so using that specific DSL needs to have a high value to justify the time investment in practicing.

    This issue is almost negated today: I find myself no longer writing jq queries, or regular expressions (both I am quite proficient in,) but having AI write those for me. This is exactly where the so-called "vibe coding" shines, and why I no longer care about tool specific DSLs.

  • by vindarel on 5/2/25, 2:46 PM

    Similar, in CL too:

    * [lqn](https://github.com/inconvergent/lqn) - query language and terminal utility for querying and transforming Lisp, JSON and other text files.

    (by this person doing nice generative art: https://inconvergent.net/)

  • by rafram on 5/2/25, 3:00 PM

    The `?` query operator is just a different, equally inscrutable DSL...

  • by pama on 5/2/25, 1:31 PM

  • by ruuda on 5/3/25, 11:27 AM

    If like me you can do basic queries in jq, but as soon as it gets slightly more complex (e.g. filter objects where some nested property that may not exist has a particular value), you wish you could do it with familiar Python/Rust/Javascript-like expressions and map/filter, try https://rcl-lang.org/#intuitive-json-queries.

  • by adamgordonbell on 5/2/25, 5:37 PM

    If you go through and learn some basic examples, JQ is a lot more understandable than seeing golfed examples in the wild might led you to believe. I wrote a tutorial once.

    But it does also seem like a place where LLMs are handy. Why learn jq or regex or AWK, if you use them infrequently, when you can just ask an llm?

    Edit: tutorial: https://earthly.dev/blog/jq-select/

  • by aidenn0 on 5/2/25, 3:07 PM

    I'm guessing there's supposed to be something other than an empty black box after "already an improvement, in my eyes:"? I'm just seeing a black box (on firefox).

    [edit]

    Removing "Unifont" from the font-family list fixes the problem, so I must have an issue with my unifont install?

  • by precompute on 5/2/25, 1:05 PM

    Whoa, love the website!

  • by peterohler on 5/3/25, 12:23 PM

    I'm clearly biased but oj which uses JSONPath is my preferred JSON manipulator. It can be installed with brew. It may not be for everyone but some of you might like it.

  • by pletnes on 5/2/25, 2:39 PM

    Pyjq is the python package for jq, in case you want to use jq as a library. The article claims that this doesn’t exist.