Is this lisp written in lisp?

Yes :)

☯️

Write a custom comparator?

(sort-by (juxt :a :b) [{:a 3 :b 1}
                       {:a 1 :b 1}
                       {:a 1 :b 2}])

=> ({:a 1, :b 1} {:a 1, :b 2} {:a 3, :b 1})

Juxt allocates a tuple for the result

yeah was wondering how convoluted the comparator would look like. I haven't dived into it but perhaps the more criteria you add, the more convoluted it would become

You could write a function which takes a hierarchy of predicates a d returns a comparator, or something similar

you can also just construct a vector instead of a string [0 entry] [1 entry] [2 lib-name] etc as long as your algorithm ensures an entry and lib-name are never compared against one another

my custom comparators often end up creating vectors for the comparison (not free, but cheaper than those strings allocation wise)

this is clojure, every function call represents multiple allocations

> this is clojure, every function call represents multiple allocations I wouldn't have imagined that. Even invoking an empty or near-empty defn (`(defn foo [] 42)`) represents an alloc?

the arg list is an alloc, for example (perhaps there's an optimization if the list is empty)

remember that the jvm doesn't store any data structures on the stack, if it's not an immediate primitive, it's a heap allocation

I'd have to go read code to get the specifics, but even for just entering the scope of the function, I'd assume there's an alloc or two...

unless foo is a local that was captured (in which case we need to analyze the parent that captured it...) even just calling foo will cause a var lookup from the ns at the very least, and I don't think that's garbage free in clojure

Great insights thanks!

to get the real details, check out the stack traces you see with simple function calls, and ideally find a good disassembler (|'ve been meaning to check what the state of the art is these days... no.disassemble was nice but inconvenient)

(ins)user=> (decompile (fn [] (foo)))

// Decompiling class: user$fn_line_1__212
import clojure.lang.*;

public final class user$fn_line_1__212 extends AFunction
{
    public static final Var const__0;
    
    public static Object invokeStatic() {
        return ((IFn)user$fn_line_1__212.const__0.getRawRoot()).invoke();
    }
    
    @Override
    public Object invoke() {
        return invokeStatic();
    }
    
    static {
        const__0 = RT.var("user", "foo");
    }
}

nil

that's using https://github.com/clojure-goes-fast/clj-java-decompiler

so the allocation and var lookup is being done statically - better perf wise than I first imagined

(fn [a b c] ,,,) is compiled to a method invoke(Object a, Object b, Object c) (fn [& args]) will alloc an ArraySeq and call a different method

the var lookup via .getRawRoot depends on direct linking, which is off by default

What an interesting thread. Thanks for that @U051SS2EU !