Hi, I’m often want to add an optional values to a hash-map only if its not nil: (conj {:a 1} (when (:x m) {:x (:x m)})) Is there a more elegant way do do this?

How do I put the Authorization header in an clj-http post request?

fetch('', {
  method: 'GET',
  headers: {
    'Authorization' : `Bearer ${API_KEY}`
  }
})

(post “https://api.bannerbear.com/v2/images” {???})

I’m sending this request:

(post "" {:headers {"Authorization" "Bearer DT56EIQ3irkCLvAAYTzGfgtt"}                            :form-params {:template "j14WwV5VkY4Da7XrBx"                                              :modifications                                                           [                                                            {                                      :name "text_container_0"                              :text "You can change this text"                                                    :color nil                                               :background nil                                                             }                                                            {                                              :name "circle_1"                                                    :color nil                                                             }                                                            {                                         :name "star_rating_2"                                                              :rating 70                                                          }                                                ]                                                            :webhook_url nil                                                           :transparent false                                                            :metadata nil                                          }})

I'm working on performance optimizations to use unboxed arithmetic by using primitive type hints. I'm not getting the speed improvement I was hoping for. In inspecting the java code that is translated by Clojure, it seems the efficient version of the function isn't being called. Here's an example

(defn my-add
  [^double a ^double b]
  (+ 1.0 a b))

(decompile (defn my-add
             [^double a ^double b]
             (+ 1.0 a b)))
=>
// Decompiling class: user$my_add
import clojure.lang.*;

public final class user$my_add extends AFunction implements DDO
{
    public static Object invokeStatic(final double a, final double y) {
        return Numbers.add(1.0 + a, y);
    }
    
    @Override
    public Object invoke(final Object o, final Object o2) {
        return invokeStatic(RT.doubleCast(o), RT.doubleCast(o2));
    }
    
    @Override
    public final Object invokePrim(final double a, final double n) {
        return invokeStatic(a, n);
    }
}

(decompile (my-add 2.0 3.0))

// Decompiling class: cjd__init
import clojure.lang.*;
public class cjd__init
{
    public static final Var const__0;
    public static final Object const__1;
    public static final Object const__2;
    public static void load() {
        ((IFn)cjd__init.const__0.getRawRoot()).invoke(cjd__init.const__1, cjd__init.const__2); <-- Notice here we are calling invoke not invokeStatic
    }
    public static void __init0() {
        const__0 = RT.var("user", "my-add");
        const__1 = 2.0;
        const__2 = 3.0;
    }
    static {
        __init0();
        Compiler.pushNSandLoader(RT.classForName("cjd__init").getClassLoader());
        try {
            load();
            Var.popThreadBindings();
        }
        finally {
            Var.popThreadBindings();
        }
    }
}

@hiredman oh! Looks like this indeed calls invokeStatic

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

public final class user$fn__7239 extends AFunction
{
    public static final Var const__0;
    
    public static Object invokeStatic() {
        return ((DDO)user$fn__7239.const__0.getRawRoot()).invokePrim(2.0, 3.0);
    }
    
    @Override
    public Object invoke() {
        return invokeStatic();
    }
    
    static {
        const__0 = RT.var("user", "my-add");
    }
}

@alexmiller Looking at the byte code. Indeed it calls invoke.Prim . Thanks

(ns scratch.primitive)

(defn my-add
  [^double a ^double b]
  (+ 1.0 a b))

(defn test-fn []
  (my-add 2.0 3.0))

Byte Code
public final class scratch.primitive$test_fn extends clojure.lang.AFunction {
  public static final clojure.lang.Var const__0;
    descriptor: Lclojure/lang/Var;

  public scratch.primitive$test_fn();
    descriptor: ()V
    Code:
       0: aload_0
       1: invokespecial #9                  // Method clojure/lang/AFunction."<init>":()V
       4: return
    LineNumberTable:
      line 7: 0

  public static java.lang.Object invokeStatic();
    descriptor: ()Ljava/lang/Object;
    Code:
       0: getstatic     #15                 // Field const__0:Lclojure/lang/Var;
       3: invokevirtual #20                 // Method clojure/lang/Var.getRawRoot:()Ljava/lang/Object;
       6: checkcast     #22                 // class clojure/lang/IFn$DDO
       9: ldc2_w        #23                 // double 2.0d
      12: ldc2_w        #25                 // double 3.0d
      15: invokeinterface #30,  5           // InterfaceMethod clojure/lang/IFn$DDO.invokePrim:(DD)Ljava/lang/Object;
      20: areturn
    LineNumberTable:
      line 7: 0
      line 8: 15

  public java.lang.Object invoke();
    descriptor: ()Ljava/lang/Object;
    Code:
       0: invokestatic  #33                 // Method invokeStatic:()Ljava/lang/Object;
       3: areturn
    LineNumberTable:
      line 7: 0

  public static {};
    descriptor: ()V
    Code:
       0: ldc           #36                 // String scratch.primitive
       2: ldc           #38                 // String my-add
       4: invokestatic  #44                 // Method clojure/lang/RT.var:(Ljava/lang/String;Ljava/lang/String;)Lclojure/lang/Var;
       7: checkcast     #17                 // class clojure/lang/Var
      10: putstatic     #15                 // Field const__0:Lclojure/lang/Var;
      13: return
    LineNumberTable:
      line 7: 0
}

I remember Clojure usage stats being bandied about every now and then. anyone know where I can find those?