I'm looking at packaging Clojure for Guix - can anyone tell me where the source for the bin/clojure shell script lives? I can't see it in the main clojure git repo.

https://github.com/clojure/brew-install/tree/1.9.0/src/main/resources

Now that clojure is on java 1.8 might IFn start to extend from builtin java function interfaces beyond Callable and Runnable?

Thanks @alexmiller. Do you know if there's a script that merges the built clojure/clojure with clojure/brew-install to make something like what's found at https://download.clojure.org/install/clojure-tools-1.9.0.X.tar.gz?

That repo is where the build happens

The build basically runs script/package.sh

Great, thanks @alexmiller

Is anyone working on a TUI REPL thing like REBL that uses Datifiable/Navigable? Something like datawalk?

I haven’t see anything like that yet

I have a question about datafy. I expected to be able to implement the protocol via metadata, but I can’t seem to get it cooperate:

user=> (def x ^{:clojure.datafy/datafy (constantly [3 4 5])} [1 2 3])
#'user/x
user=> (meta x)
#:clojure.datafy{:datafy #object[clojure.core$constantly$fn__5657 0x49c6c24f "clojure.core$constantly$fn__5657@49c6c24f"]}
user=> (d/datafy x)
[1 2 3]
user=> (def x ^{:clojure.datafy/datafy #(str "foo")} [1 2 3])
#'user/x
user=> (d/datafy x)
[1 2 3]

needs to be a symbol not a keyword

{`d/datafy (..)}

same behavior 😕

user=> (def x ^{`d/datafy #(str "foo")} [1 2 3])
#'user/x
user=> (d/datafy x)
[1 2 3]

this is with latest RC5

with-meta, not ^{}

that shouldn't make a difference @ghadi

Oh whoops - it’s the wrong symbol

Should be clojure.core.protocols/data fly

yep that's it

🙂 that worked!

mystery solved

Gah, phones. Data fly is up for the taking as a library name

haha

user=> (def x (with-meta [1 2 3] {`clojure.core.protocols/datafy (fn [_] 1)}))
#'user/x
user=> (d/datafy x)
1

FWIW the literal metadata syntax was perfectly fine

Yeah

for collection literals it's (mostly) equivalent to using with-meta

^

got it. thank you both for the help!

I got confused because it seems to be implemented differently in CLJS

in CLJS:

(def y (with-meta [1 2 3] {:clojure.datafy/datafy (fn [_] 1)}))

(d/datafy y)
;; => 1

wtf

datafy is not even a protocol in cljs

it is

oh wait

no no it isn't

it’s in master branch

that's matching the old initial implementation that clojure had

@lilactown no, the protocol function in cljs is cljs.core/-datafy

not clojure.datafy/datafy

but that keyword thing is how it was implemented in clojure too, before metadata protocol extension got introduced

I expect that to change in cljs too

ah I thought you were saying that Datafiable didn’t exist 😛

ahhhh I see

the thing is, in that example you're not making use of the protocol at all

@mfikes I assume you're aware of the new impl in clojure?

(also, why does cljs not have a clojure.core.protocols namespace? that seems like an odd diversion from clojure)

there’s an issue it looks like: https://dev.clojure.org/jira/browse/CLJS-2999

Yeah, the datafy port was done a while back, so Clojure could have moved a bit from it since.

hello, can i use a transient hash-map as an atom,and many threads change it ? with persistent hash-map it works,with transient it doesn't . its my code bug or its transients?

transients supposed to be used from only 1 thread?

atoms need immutable data, since swap! needs to be pure

er, I mean swap! needs a pure f.

atoms will transparently retry on collisions from thread, and if you store mutable data in them, you will get a bad state

@takis_ what problem are you trying to solve by putting transient data in an atom?

i thought that persistent data -structures would be slower for large data

takis_: While this is true, going mutable is tricky. I would not recommend doing so until you have evidence you need to.

its a 2D vector,and many threads add lines to it

I would strongly recommend building it and measuring, your intuition is almost certainly wrong

The Clojure core devs have put a lot of effort into making the persistent data as fast as possible.

do you know if its possible to define in Clojure a synchronized method?like in Java a method that max 1 thread can use

if you need a mutable multithreaded map juc's concurrenthashmap is right there

Yeah, there’s locking

takis_: Short answer is yes. The long answer is, "wait a minute, ..."

(doc locking)
-------------------------
clojure.core/locking
([x & body])
Macro
  Executes exprs in an implicit do, while holding the monitor of x.
  Will release the monitor of x in all circumstances.

Atoms are designed to use STM and be, usually, faster than locking. locking is mostly for interop with Java, and it is used infrequently.

i know that you can lock an object,but when i tried it was slow

ok thank you alot for your time,i am new actually

but clojure very nice

locking is always going to slow down multithreaded programs

(locking in general, including java's synchronized)

takis_: it sounds like you want something like Clojure's reducers, maybe? https://clojure.org/reference/reducers

maybe alot to read and many to try thank you all 🙂

How can I refer to components of my project.clj from within my program? In particular, I need to get the :version from project.clj

What would be the clojure equivalent to this python snippet?

import os
path = "~/Downloads"

{
    z[0].replace(path, '')[1:]: z[1]
        for z in os.walk(".") if z[0].replace(path, '') and not z[2]
}

I’m working on this too. Seems like we would have to start with file-seq

What does os.walk do?

What does the output look like?

It’s building a dictionary of folders mapped to a list of empty children. os.walk returns a tree of files

https://docs.python.org/3/library/os.html#os.walk

you could construct the equivalent tree by splitting the paths of items from file-seq and using those paths with assoc-in or update-in

user=> (pprint (file-seq (java.io.File. ".")))
(#object[java.io.File 0xdbd8e44 "."]
 #object[java.io.File 0x7ac0e420 "./foo"]
 #object[java.io.File 0x78383390 "./foo/bar"]
 #object[java.io.File 0xdb57326 "./foo/bar/baz"]
 #object[java.io.File 0x34a875b3 "./Investor Type no PII.csv"]
 #object[java.io.File 0x4748a0f9 "./Untitled spreadsheet - Sheet1.csv"])

if you map str on the files, you just get the path strings

@jayzawrotny

user=> (pprint (reduce (fn [t p] (assoc-in t p {})) {} (map #(clojure.string/split (str %) #"/") (file-seq (java.io.File. ".")))))
{"."
 {"foo" {"bar" {"baz" {}}},
  "Investor Type no PII.csv" {},
  "Untitled spreadsheet - Sheet1.csv" {}}}
nil

Pretty close, I can work with that. Here’s the test file structure and the actual output:

## File Tree

# (root)
#  |- a (dir)
#  |  |- b (dir)
#  |  |  |- (empty)
#  |- c (dir)
#  |  |- d (dir)
#  |  |  |- (empty)
#  |- e (dir)
#  |  |- f.txt
#

## Output

# {'/a': ['b'],
#  '/a/b': [],
#  '/c': ['d'],
#  '/c/d': []}

oh also my snippet above doesn't differentiate files from directories

(require '[clojure.pprint]
         '[clojure.string :as string])

(defn directory?
  [file]
  (.isDirectory file))

(defn directory-with-no-files?
  [file]
  (and (directory? file)
       (empty? (->> file
                    (.listFiles)
                    (filter #(.isFile %))))))

(defn relative-name
  [path dir]
  (let [dir-path (str dir)]
    (string/replace dir-path (re-pattern path) "")))

(defn pair-files
  [path dir]
  [(relative-name path dir)
   (->> dir
        (.listFiles)
        (filter directory?)
        (map #(.getName %)))])

(defn find-empty-dirs
  [path]
  (->> path
       ()
       (file-seq)
       (drop 1)
       (filter directory-with-no-files?)
       (sort)
       (map #(pair-files path %))
       (into {})
       (clojure.pprint/pprint)))

(find-empty-dirs "/Users/jay/Projects/map-comp/test/")

Is what I got so far

so really what you want isn't a tree, but sort of a weird adjacency-list

where every item also includes all parents

(in its key)

Oh, sorry that wasn’t clear.

Sounds like (file-seq) will do the hard part, the rest seems like string manipulation

(let [root ( "/Users/jay/Downloads/test/resources/")]
  (transduce
   (comp (remove #{root})
         (keep
          (fn [^java.io.File file]
            (when (.isDirectory file)
              (let [path (.getPath file)
                    ;; Split path into two parts at the last /
                    [parent _] (string/split path #"(?=/[^/]+$)" 2)]
                [parent path])))))
   (fn
     ([m] m)
     ([m [parent child]]
      (-> m
          ;; Update the parent entry to add the child.
          (update parent (fnil conj []) child)
          ;; Create an entry for the child if it doesn't exist.
          (update child (fnil identity [])))))
   {}
   (file-seq root)))

@jayzawrotny ☝️ here’s an equivalent to your previous post without extra calls to .listFiles and .isDirectory.

I think you just beat me, I was pretty close too

{"/a" ("b"), "/a/b" (), "/c" ("d"), "/c/d" (), "/e" ()}

I just ⛳ updated that code to just use keep instead.

You could use reduce and do all the logic in one reduction function if you want. But, with respect to your desired output, these are the parts.

(I think.)

You could use this script to test against the expected output

mkdir -p a/b
mkdir -p c/d
mkdir e
touch e/f.txt

That’s exactly what I did.

Ah ok, I misunderstood

I just replace my path with yours so you could copy and paste it. 🙂