Hello guys. I just recently started to use clojurewerkz.machine-head.client and I was wondering how can I connect to aws with this cool library. How can I manage connecting the ssl certificates? Can you give me any starting points? Much appreciated 🙂

Random thing I discovered today: associative destructuring works on just about any type but throws an exception with integers (`java.lang.Long`). Anyone here have any insight on why this might be?:

(let [{:keys [a] :as b} {:a 2}] [a b])
;; [2 {:a 2}]
(let [{:keys [a] :as b} "bob"] [a b])
;; [nil "bob"]
(let [{:keys [a] :as b} []] [a b])
;; [nil []]
(let [{:keys [a] :as b} \x] [a b])
;; [nil \x]
(let [{:keys [a] :as b} 1] [a b])
;; Syntax error (UnsupportedOperationException) compiling at (REPL:1:1).
;; Can't type hint a primitive local
;; user=> 

I think you're well into "don't do that"

That error message is bad. Don't think I've ever accidentally tried to destructure a number like that.

@alexmiller haha, I guess so. I'm destructuring the return value of next.jdbc/execute! so I guess I'm being too paranoid: the return value of that function should never be an int anyway actually that's not quite correct, but I digress... the "don't do that" advice is well taken

Can eventually grep it myself, but anyone knows how :post is implemented? I would imagine that if a :post is present, the defn inner body is rewritten so that its return value passes by the :post predicates before the defn returns e.g. (defn foo [x] {:post [x]} 42) -> (defn foo [x] (let [ret-val 42] (assert ret-val) ret-val)) ;; demonstrates a 'rewrite-based' implementation

I'm looking at the source right now and I think its implemented right here

post (:post conds)                       
                       body (if post
                              `((let [~'% ~(if (< 1 (count body)) 
                                            `(do ~@body) 
                                            (first body))]
                                 ~@(map (fn* [c] `(assert ~c)) post)
                                 ~'%))
                              body)
                       body (if pre
                              (concat (map (fn* [c] `(assert ~c)) pre) 
                                      body)
                              body)

specifically

body (if post
                              `((let [~'% ~(if (< 1 (count body)) 
                                            `(do ~@body) 
                                            (first body))]
                                 ~@(map (fn* [c] `(assert ~c)) post)
                                 ~'%))
                              body)

and indeed it looks like what you say

although I wanna double check to be absolutely sure

that's right