OK, probably a deep dark corner of Clojure functionality I haven't seen before, but can anyone explain what ('subset? ...) is doing in this line of code within the Clojure tests? https://github.com/clojure/clojure/blob/master/test/clojure/test_clojure/rt.clj#L97

map look up

looking up the symbol 'subset in the map returned by ns-publics

I just figured that out from REPL experimentation, which I probably should have done before asking. I knew that worked with a keyword as the first value in the form, but don't think I've ever used it with a symbol as the first value in the form.

@andy.fingerhut clojure.lang.Symbol implements clojure.lang.IFn just like clojure.lang.Keyword, and seems to implement it in basically the same way, invoking RT.get on the argument passing itself as the lookup key

I will most likely forget this, and not miss the knowledge because I wouldn't want to see this in my code 🙂

yeah it's a bit niche isn't it

I've only ever written Clojure as a hobby, but a lot of hours have gone by without me seeing this in people's code.

would be interesting to mine crossclj for the most rarely used features. I don't think I've ever seen :strs or :syms destructuring in the wild, for instance

now I'm kind of sad that there's no clojure.lang.String that also implements IFn. Then we'd have three types you can both destructure and use to look themselves up.

@hagmonk We have :strs destructuring in our production code... 🙂

secretly I think I have this in my code too ...

but it's not "in the wild" so I think I escape on a technicality. ag reveals I actually have used it twice in just this one project I checked 😳

Spec question: If I have a function that takes a destructured map, what's the best way to spec that function, so that the values of the keys in my map are also specced? The best I've got right now is (s/keys :req-un [::a ::b ::c]) given (defn foo [{:keys [a b c]})

But, I'd kind of want the names of the keys for my function to not match the spec name of their value. And I'd rather define the spec for them inline. Any easy way to do that?

Would be nice to have something like (s/map :req [:a int? :b string? :c ::other-spec]) for this scenario

Is there a way to make this point free #(assoc %2 :id %1)

lol, I don't think it'd be shorter in any point free style

I get that. This was a just a challenge based on a discussion we are having internally at my company.

maybe something involving merge, apply, and reverse, and rotating

(apply assoc (reverse (interpose :id %)))

(->> args (interpose :id) reverse (apply assoc)) 🙂

That's not point-free...

What is point-free? I thought it merely meant "don't use variable names, and chain together functions"

But args and % are variables.

right, so we need to get rid of the "args" field

the line before that was me working out intermediate steps

we need to removeargs from (->> args (interpose :id) reverse (apply assoc)) and then we're good

Here's a point-free version: (comp (partial apply assoc) reverse (partial interpose :id) vector)

boot.user=> ( (comp (partial apply assoc) reverse (partial interpose :id) vector) 123 {} )
{:id 123}

@stuartrexking ^ does that answer the challenge?

@seancorfield Sure does! Thanks!

The page on transients says that: > In Clojure 1.6 and earlier, transients would detect any (read or write) use from a thread other than the one that created them and throw an exception. That check was removed in 1.7 to allow for more flexible use in frameworks like core.async go blocks that enforce the single-threaded constraint via other means. Emphasis mine. But under summary it still says: > Thread isolation - enforced I tried the following in 1.8:

(dotimes [_ 5]
  (def tv (let [tv (transient [])]
          (future (Thread/sleep (rand-int 3))
                  (conj! tv 1))
          (future (Thread/sleep (rand-int 3))
                  (conj! tv 2))
          tv))
  (Thread/sleep 3)
  (println (persistent! tv)))
;; =>
;; [2 1]
;; [2 1]
;; [2 1]
;; [2 1]
;; [1 2]

[just guessing] perhaps it means that with respect to a transient, conj! pop! push! are all atomic -- i.e. if you run them from different threads, its as if they're beintg run from the same thread in some order - they won't 'trample' on each other due to race conditions

also, the above example confuses me, as I thought you were supposed to look at the return value of conj! ... instead of printing the 'original transient'

I'm looking for a clojure DSL that lets me output C code. Is https://github.com/aaronc/c-in-clj (5 years since last commit?) the best we've got ? Pre-emptive: why not just use C?: C's macro system is lacking. I want to use the full power of Clojure amcros for my macro system.

Not that I know of, it’s not really a easy thing to pull off since C lacks almost everything Clojure would need

But writing a AST to C layer wouldn’t be that hard. I know of several projects that do that

Carp? It transpiles to c so I guess it would fit

Not sure how mature it is tho

@tbaldridge: I'm not trying to do Clojure -> C . I'm trying to do "Clojure data representing a program -> C".

I have some code which deals with nothing but tensors of floats -- no other data structure, no gc-ing, nothing else and I want to represent this code as 'clojure data', and then generate C from it (which will let me hit both WebAssembly and Cuda afterwards)

if I'm dealing with a java class that extends a HashMap, is there an easy way to cast a map into it?

public class RowData extends HashMap<String, Object> {
}

would love to do (cast RowData (java.util.HashMap. {:a 1})) but that raises a ClassCastException

I'm playing with function specs and I wondered if one could use it to emulate type checking, during compile time, something like this:

(s/fdef divide
        :args (s/cat :x integer? :y integer?)
        :ret number?)

(defn divide [x y] (/ x y))

;; should throw when compiled?
(defmacro divide-by-foo []
  (eval `(divide 6 :foo)))

hi guys

why this work in second case and not work in the first

?

@fbielejec you need to have instrumentation enabled to have it throw

@fbielejec something like https://github.com/jeaye/orchestra

@fbielejec by default, clojure spec doesn't circumvent evaluation to perform spec analysis, you need to tell it to check your specs

so just (:require [clojure.spec.test.alpha :as st]) and (st/instrument 'divide) ?

you'll have to read over the docs, and mess around with it

think it's after you define your specs, but before you evaluate your function that you want spec analysis for

hmm

your defmacro is never going to throw a spec error until it's been evaluated

note that instrumentation was turned on after the specs have been introduced and evaluated

I could have put it at line 7 or 9

the divide-by-foo case should probably fail, none of this has been tested

this is my problem - I don't understand why at compile-time the macro doesn't become (eval (/ 6 :foo)), which should still throw. The divide-by-foo will fail for sure (with an exception or spec validation error depending on whether instrumentation is turned on), like you say.

if i want to display some quick charts from the repl, is incanter the best option?

i just want to quickly visualize some line charts, no fancy processing is needed

Does either "lein repl" or "boot repl" have a web interface? I want something like "boot web-repl" or "lein web-repl" to 1. open up a webserver on port 8081 2. I can go to <localhost://8081> and interact with the repl 3. have certain forms of output render nicely into HTML tables / SVG diagrams / ...

@qqq gorilla repl can do that

http://gorilla-repl.org/start.html

is there a tool for formatting end files?

https://github.com/weavejester/cljfmt

.. why did I not just try running cljfmt on it earlier. I keep running it on my .clj files

thanks 🙂

Hi, I am transducing over a lazy sequence that reads from a file (hurray). However I am having some trouble figuring efficient ways to debug or any plausible way to debug at all. Maybe you can comment? Here's code:

(ns cleanser.dictionary-test
  (:require
     [clojure.pprint :refer [pprint]]
     [puget.printer :refer [cprint]]
     [clojure.inspector :as inspect :refer [inspect-tree]]
     [cleanser.dictionary-search :refer :all]
     [ :as io]
     [clojure.set :refer :all]
     [clojure.math.combinatorics :refer [cartesian-product]]
     [clojure.test :refer :all]
     [ :as io]
     [clojure.string :refer [split]]))

(defn text-file-reader [filepath reader]
   " return a lazy sequence for streaming through the file contents "
   (with-open
      [file-reader (reader filepath)]
      (line-seq file-reader)))


(deftest names-dictionary
  (let
    [text (slurp "resources/names/hebrew-wikipedia-content.txt")

     names-dump-filter  (remove #(re-matches #"# < > \[ \] \{ \} / @ \*" %)) 
     names-dump-breaker (mapcat #(split % #"\|"))                            

     names
       (sequence
         (comp names-dump-breaker names-dump-filter)
         (text-file-reader "resources/names/user-names-unique.txt" ))

     dictionary (build-dictionary names)]

     (println (search text dictionary))
     (println (type names) ; a lazy stream
     (println names))))   ; java.io.IOException: Stream closed

@matan you could use trace to monitor the input/output of your transducer functions https://github.com/clojure/tools.trace

actually, I am not very sure how I'd trace very elegantly in transducing code like above

@matan I though it would be easy with trace, but it doesn't work as expected in my case

instead, you could define your own transducer for logging purpose

(defn xflog []
      (fn [rf]    
       (fn       
       ([] (rf))                          
       ([res] (rf result))                
       ([res input] (println input) (rf res input)))))

(sequence (comp (xflog) (filter odd?) (map inc)) (range 5))

it works as expected, but you could extend it to include a tag (e.g. "before filter odd?")

@matan Or use the debug atom trick. Something like

(defonce a (atom []))

(def dbg-xf (map (fn [x] (swap! a conj x) x)))

(comment
  ;; The atom now contains every value that passed through dbg-xf
  @a
  )

Or just (def logging-xf (map (fn [x] (prn x) x)))

@matan you can also just use a plain old debugger like the one available in Cursive. You can also use scope-capture as a more powerful version of the debug atom trick, which also supports a form of breakpoint (disclaimer: I'm the author!): https://github.com/vvvvalvalval/scope-capture

scope-capture is great

I’m using it a lot nowadays

I have a system.edn file that needs a database url that I don't want to check in to source control. How can I introduce a variable into an edn data structure?

@captaingrover there are a bunch of config libs for Clojure, here’s some examples:

https://github.com/tolitius/cprop

https://github.com/juxt/aero

https://github.com/levand/immuconf

they all manage secrets, different environments etc

@schmee those all look like good options. thanks!

cprop is nice!

@schmee I've always used environment variables. That way I can have an .env.example file people can copy and modify to their likings and not check it in

the environment-variable approach is also great when paired with direnv https://direnv.net/

I’m using jvisualvm to successfully profile my app, locally, on macOS 10.12. It works correctly through several jvm reboots, and jvisualvm suddenly fails to connect with “Failed to create JMX connection to target application.” I wasn’t explicitly creating JMX connections beforehand. Rebooting my mac fixes it, but is there any way to solve it without rebooting?

are you using the same version of the jvm each time?

https://bugs.openjdk.java.net/browse/JDK-8023786

I should be. I’m just in the same terminal window and lein repling each time

once it’s hosed, restarting both my clojure jvm and the visualvm process doesn’t fix it

and then after rebooting my mac, it works until I reboot my clojure app ~5 times

is visualvm forking something off that’s sticking around?

That’s super spooky

could be, but I’m not finding anything obvious

there are no java processes running

what version of the jvm?

something about port acquisition logic?

$ java -version
java version "1.8.0_144"
Java(TM) SE Runtime Environment (build 1.8.0_144-b01)
Java HotSpot(TM) 64-Bit Server VM (build 25.144-b01, mixed mode)

I feel like this code can be much shorter: I'm trying to tokenize a string via . a list of regexps:

(defn- token-len [t]
  (count (:str t)))

(defn lex [pats s] 
  "lex :: obj.pats -> string -> [obj.token]"
  (let [regexps (mapv pat->regexp pats)] 
    (loop [tokens [] 
           s      s] 
      (if (empty? s)
        tokens 
        (let [token (first (keep #(regexp-match % s) regexps))] 
          (assert token (str "failed to tokenize substring: " s))
          (assert (> (token-len token) 0)
                  (str "empty token: " token " s: " s))
          (recur (conj tokens token)
                 (subs s (token-len token)))))))) 

https://clojuredocs.org/clojure.core/subs <-- does clojure not offer an O(1) time substring ?

No. Clojure doesn’t have a string type and just uses Java’s strings. If Java’s strings don’t have it Clojure doesn’t have it.

you’d think with immutable String you could make an immutable CharSequence that used an indexed range of a string - except of course unicode we can’t have it because unicode

since you can’t guarantee that the index of a string by character starts at any given byte

(without an O(n) scan that is)

ztellman has a new immutable strings implementation in his bifrucan library that gives you log(n) substringing I think

cool

the problem with java's strings is the lack of a tree structure, so you can can't just hold a reference to the parts you need, your substring ends up holding a reference to the whole string

which was causing enough of a memory issue that they switched from what you propose (substring returning a special string that refers to the other string with offsets) to substring returning a copy

seems like a case of "people cut self with scissors; let's ban all scissors"

I don't see an argument against .substring-ref and .substring-copy

but you could make a CharSequence that is cheap to construct from a String and uses a simple tree of some sort - and if code breaks when you use CharSequence instead of String the code is bad

instead of just deciding upfront that all has to be copies

https://dev.clojure.org/jira/browse/CLJ-112 I opened this issue in assembla before clojure was on jira (after asking rich about it on irc)