(for [m ...] (assoc m :artifacts (into-array Byte/TYPE (:artifacts m))))

then do whatever you want with the byte-arrays

wrap them in bytearrayinputstreams and wrap those in a zipinputstream and read the contents

https://docs.oracle.com/javase/7/docs/api/java/io/ByteArrayInputStream.html

https://docs.oracle.com/javase/7/docs/api/java/util/zip/ZipInputStream.html

wow

i sort of get streams abstractly

this will teach me a lot

if you aren't familiar with http://java.io.* that might prove to be a good thing because ZipInputStream can be a little different to work with then most kinds of inputstreams

about concrete streams

zipinputstream is actually maybe the old way to work with zipfiles, there is a newer api that gives you more of a filesystem like abstraction

when working with inputstreams, do those need to be paired with a reader? i have mostly only used slurp/spit

but i got help writing the edn i mentioned, then today i did successfully read it

input/outputstreams are for binary data

reader and writers are for character data

ahhhh ok

my big accomplishment for the day was getting, and caching as edn, my data — tomorrow I will get into streams, see how far I can get, then probably come running right back to . Thank you for the signpost!

https://github.com/clojure/tools.build/blob/master/src/main/clojure/clojure/tools/build/util/zip.clj#L85 has some unzip code to crib from

> there is a newer api that gives you more of a filesystem like abstraction @U0NCTKEV8 do you recall the name of the api?

https://docs.oracle.com/javase/7/docs/technotes/guides/io/fsp/zipfilesystemprovider.html

Because the reader does quote expansion in Clojure seems to be the answer.

backtick is a https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/LispReader.java#L95

probably because def

Creates and interns or locates a global var with the name of symbol and a
namespace of the value of the current namespace (*ns*).

It's kind of confusing. As I understand it, you are passing a symbol, but it gets also treated as a name that you can look up. See:

(defn foo [x] x)
(-> #'foo meta :name) ; foo
(def bar 1)
(-> #'bar meta :name) ; bar

also def is a special form and defn is macro

(macroexpand '(def foo 42))
;; => (def foo 42)

(macroexpand '(defn bar []))
;; => (def bar (clojure.core/fn ([])))

> As I understand 'symbol' will be created after we initialize it with 'def'. But first we have to pass a 'name'. > So, for me it should be (def name doc-string? init?) not (def symbol doc-string? init?). > What do you think?

A symbol stands on its own. Yes, it's often a name for a var. You can't evaluate it until you assigned it to a var, except you quote it like 'foo Symbol and name are kind of interchangeable concepts. But be aware that a symbol is actually a thing and not just a label that is assigned to something else. You can for example use symbols in macros that get treated at a first class thing and assigned to a var or multiples later on. The confusing thing is rather why they used both name and symbol in the docs. I assume it is because we think in terms of "function names" both for fn and defn.

So it is more of a high level cultural expression there (function name).

symbol and name are not interchangeable concepts. def expect symbol and will use its name in combination with the value of *ns* to create and intern global var.

That's why I said "kind of". What I'm personally not sure about is what the "name" in fn is. It definitely doesn't assign a symbol to a var in your namespace. Maybe it's just for debugging purposes? But it's very different from def and defn

"also def is a special form and defn is macro" so what fnis also special form and use 'name'

"If a name symbol is provided, it is bound within the function definition to the function object itself, allowing for self-calling, even in anonymous functions."

> symbol and name are not interchangeable concepts. def expect symbol and will use its name in combination with the value of *ns* to create and intern global var. Symbols are definitely first class names though - just to be sure! def takes the symbol and assignes a name (the symbol) for it in your namespace. The name in fn is something entirely different it seems. Not sure what it does.

for fn name is bound to that function only and available only within its definition.

also symbol is just symbol. depending on the context it will be used differently: to intern a global var, define local binding, etc.

Huh I didn’t realize def supported a docstring!

Has that always been the case?

> Support for doc-string was added in Clojure 1.3.

https://github.com/mentat-collective/emmy/pull/110 haha I had 100s of docstrings attached via :doc… backed them all out here, this looks way better!!

I didn't know that either! Also that's a huuuge commit :)

I’m a docstring addict

because in set and hashed-map order of elements are not same

I made a simple comparison table, maybe it will be useful

Good example, thank you!

"This is because of the internal structure of the HashSet. The value is transformed in a unique hash, which allows fast access but does not keep the insertion order. If you care about the order in which the elements are added, you need to use a different data structure," from book The Clojure Workshop: Use functional programming to build data-centric applications with Clojure and ClojureScript

What the key of elements in set. In vector key is a index (position) from 0 In map - keyword, string in set? hash of element value?

sets and maps have no order, indexing in them doesn't apply

the only thing that is guaranteed is for maps, iteration order is consistent between (seq m), (keys m), (vals m), where m is a map

> What the key of elements in set. > sets and maps have no order, indexing in them doesn't apply So @U050ECB92 is being accurate, but slightly pedantic. A better term for what I think you mean by this question, that I hope @U050ECB92 will not also object to?, is "lookup value". For vectors, you can look up an element by index. For maps you can look up an element by key. For sets you can look up an element by itself, which is a constant time operation.

(:foo #{:foo :bar})
; =>
:foo

(#{:foo :bar} :foo)
; =>
:foo

> Sets support...get, the latter returning the object that is held in the set which compares equal to the key, if found:

(def s #{:a :b :c :d})
(get s :a)
-> :a

(yeah I'm being pedantic: lookup is for finding by arbitrary keys, indexing is finding by an integer in a sequential collection)

I think that distinction is fair if you consider indexing to be a specific less-arbitrary subset of lookup in general. Either way, lookup by self in a set is every bit as arbitrary as lookup by key in a map.

Awesome! It's what I want to knew. What the index/key of set. Before, I don't understand what the different between hash-map and sets as structure data. Can you show me example where you use set or hash-map in real code? For what kind of data using set ?

A few pretty good succinct examples here. Quite common to use sets as functions for existence lookups rather than something like data storage. https://blog.jdriven.com/2020/06/clojure-goodness-using-sets-as-functions/

Thank you

The usage of hash-maps, sets, lists, vectors, etc. isn't really Clojure-specific as much as it is general computer science knowledge. Barring a few tricks, the way these data structures are applied will be much the same in any programming language. Just clarifying since it might be good to look up a more general source of information too.

Two common uses for maps are domain objects and lookup tables. Typical examples in real code: • assoc used to create an "object" map with certain properties, to be passed around: https://github.com/mhuebert/maria/blob/main/shapes/src/shapes/core.cljs#L174 fn in maria.cloud • a nested lookup table https://github.com/daveliepmann/uruk/blob/master/src/uruk/core.clj#L120

I wasn't able to figure out whether defining -main fn is still a thing in Clojure (nor is it particularly clear to me how to do it).

As much as Clojure CLI is a nice system, it's bloody complex. I found Babashka a great first contact with Clojure since running it is much simpler TBH. This is my first time trying to set up a project using deps.edn and my head is spinning like mad.

-main is still a thing and if you do that, you can call it from the cli with clj -M -m my.ns

those args are passed as strings to the function and then you can do whatever you want with it

-X / -T expect to invoke a function that takes a map, and thus take k v pairs, and will edn/read each of the arguments

I see. So -M -m is really what I want then.

I was confused by both -M and -m, I thought it's one or the other.

-M is clojure.main, which takes an argument -m to pass the main class

Thanks @U064X3EF3!

Now it works.

And just to round this out: with -M you can also use -e, -i, and -r which are also options understood by clojure.main

you are treating the vector like a stack. And you can use peek and pop for quick access

or just use a list like a stack with first and rest

last is 0(n) in the size of the input; it creates a seq from the input and walks the seq to the end

butlast is also converting your vector to a seq, so conj is adding to the front

so butlast is dropping the last item in the seq, and then conj is adding at the front

If you need a stack, a list is the fastest option

Right...I see what you're saying. Ruby/JS has only one type of arrays, so I'm quite confused with all these 🙈

OK I thought I got what you guys were saying, but maybe not...my interpretation was: "use list and it all somehow work" and I realised that if list adds to the first of it, then I could just do assoc-in with index 0 which will be the last item (as in the item I added last, but actually the first one "physically"). However:

user=> (assoc-in [{:name "test"}] [0 :name] "a")
[{:name "a"}]
user=> (assoc-in '({:name "test"}) [0 :name] "a")
Execution error (ClassCastException) at user/eval3 (REPL:1).

lists are not associative

You just need cons (push), first (peek), and rest (pop)

No I get that, they behave like vectors...but these two functions works on vectors, so why not on lists?

Lists are not indexed

you have what look like logic errors in your code (using last to get the last element, but then conj'ing it back on to the front) that you may want to address before getting concerned about repetitive code

it is possible you might want something like (circular ring buffer type thing), but in that case you still don't want to be using last

@U0NCTKEV8 I'm writing a prototype of something. I'm more worried about how much code I need to write than about performance. I get your point though, but my priority is elsewhere. I do want to learn Clj properly and write proper code, but as of now "it works" is more important than anything else.

I am not just saying performance, I am saying if the intent of the code is to treat accum like a stack, then it isn't doing that correctly

it is "popping" from the end of the list, and adding the beginning, more like a queue

Anyway the right code is then:

(prn (reduce
       (fn [acc i] (cons {:name i} acc))
       '()
       ["a" "b" "c"]))

But essentially the code will be doing exactly the same as my original code in terms of code structure. It might be more correct and fast, but no chance for less code then?

you can destructure acc into the first and the rest

OK that's a fair start (let [[f & r] '(1 2 3)] [f r]) ; [1 (2 3)].

you can even abstract the whole thing out (fn [f] (fn [a b] (cons (f (first a) b) (rest a))))

use it as a transducer with transduce

presumably at some point you want to push a new element onto the stack instead of updating the top

Yes of course.

@U0NCTKEV8 Would you have an example of how to use it as a transducer? That one's a bit out of my CLJ league still 🙈 But it's something I wanted to learn, but I'm still not getting it.

(defn stack [g]
  (fn [rf]
    (completing
     (fn [accum item]
       (let [accum (g accum)]
         (cons (rf (first accum) item) (rest accum)))))))

(transduce
 (stack (fn [stack]
          (if (> (count (:path (first stack))) 2)
            (cons {:path []} stack)
            stack)))
 (completing
  (fn [a b]
    (update-in a [:path] conj b)))
 '({:path []})
 (range 10))

output of the above is

({:path [9]} {:path [6 7 8]} {:path [3 4 5]} {:path [0 1 2]})

Thank @U0NCTKEV8, I really appreciate your help.

Going to read up on transducers now, because this is over my head still 🙈

I see there's a Rich's video on them, great, I love these.

Ignoring all the above discussion about stacks and whatnot, and focusing on your original question and isolated code samples: It's not clear from the docs, but you can use update on a vector, with an index as the "key", as shown in the https://clojuredocs.org/clojure.core/update#example-58075cdce4b001179b66bdcf. This does not save you any characters, but I think it is a bit more declarative representation of what your code is doing, and feels less awkward.

(defn last-idx [v] (-> v count dec))

(let [acc [{:paths []}]]
  (update acc (last-idx acc)
          #(assoc % :name "name")))
; =>
({:paths [], :name "name"})

(let [acc [{:paths []}]]
  (update acc (last-idx acc)
          #(assoc % :paths "path")))
; =>
({:paths ["path"]})

"Is there any way I can reprovide a macro in clojurescript?" Scary. I spent a couple hours doing this today. "Trying", I should say. gave up.

"(def a-value backend/a-value)"

But for a macro...well that obviously doesn't work...

(defmacro a-macro [& args] `(backend/a-macro [email protected]))

> Did you try it? I made the same assumption and did not even try either, but one never knows. Ya...I did, works about as well as you'd expect. In racket its easy enough to do with make-rename-transformer, but alas, does not seem to be a thing here.

> I seemed to making headway, but I do an anaphoric variable injection of sth akin to JS "this" and it works great, but it got lost when I did the reprovisioning -- CLJS now complained the anaphor was undefined. I have a hunch that its due to the auto-namespace injection that clojure's quasiquote inserts. Care to share your current headway?

Let me put it back in and get a fresh fail. The headway may have been that lein test passes, but that just tests Clojure. (I have a big CLJC project, never got round to automated testing for CLJS.) brb

(defmacro c-fn-var-ex [[c] & body]
  `(fn [~c]
     (let [~'me (c-model ~c) ;; <================ me
           ~'_cell ~c
           ~'_slot-name (c-slot ~c)
           ~'_cache (c-value ~c)]
       [email protected])))

(defmacro c-fn [& body]
  `(c-fn-var (~'slot-c#) [email protected]))

(defmacro cF [& body]
  `(tiltontec.cell.core/make-c-formula
     :code '~body
     :value tiltontec.cell.base/unbound
     :rule (tiltontec.cell.core/c-fn [email protected])))

[Figwheel:WARNING] Compile Warning   src/web_mx_quickstart/core.cljs   line:64  column:45

  Use of undeclared Var web-mx-quickstart.core/me

  59                            {:default     :ignore
  60                             :on-navigate (fn [route params query]
  61                                            (when-let [mtx @md/matrix]
  62                                              ;; todo mset! me
  63                                              (mset! mtx :route route)))}))
  64       :selected-lesson (cF (let [route (mget me :route)]
                                                  ^---
  65                              (some (fn [lesson]
  66                                      (when (= route (:route lesson))
  67                                        lesson)) lessons)))
  68       :keydowner       (cF+ [:watch (fn [_ me new _ _]
  69                                       (.addEventListener js/document "keydown" new))]

OMG. I thought :refer-macros was no longer needed. The CLJS works now with:

[tiltontec.matrix.api
     :refer-macros [cF]
     :refer [mpar mget mset! mswap! mset! fasc fmu] :as mx]

IIRC, you need to use :include-macros true now.

So it would be

[tiltontec.matrix.api :refer [mpar mget ...elided... cF] :include-macros true]]

OK, :include-macros does the trick (thx!). Trying again with:

(defmacro cF [& body]
  `(tiltontec.cell.core/cF [email protected]))

Glad to hear it.

You can still avoid include-macros!!

Oh cool, how?

On my phone, searching for an example, one sec …

https://github.com/microsoft/same-ish/pull/25

If you add a :require-macros call to the cljs side of the namespace where the macro is written, no one else requiring that namespace has to do anything beyond :refer

Oh, sure.

But if you've already been given a clojurescript file which you don't want to change, it seems like include-macros is still required, ya?

Ah yes sorry I misunderstood. You are right

Rats, oh well, thanks.

Or push a PR upstream, that’s what I did here since i wanted all of those pesky include-macros calls gone from my library

One day perhaps clojurescript will never require include-macros, even for libraries that haven't added require-macros. Until then, thanks anyway. 🙂

Although I guess while I have your attention, is there any way (at runtime) to get a list of all the macros a namespace provides?

It seems like Clojure can do it.

But in clojurescript, the only thing I've found that does it is cljs.repl/dir.

Which would be fine, except it prints it to stdout.

Yeah I think all of the var info / metadata is gone at runtime

Errr...I should say in bootstrapped cljs.

In which case its not because...ya. 🙂

oddly enough though, it seems like cljs.repl/dir uses ns-publics, so not sure why usig ns-publics directly doesn't work.

(looking at https://github.com/clojure/clojurescript/blob/r1.11.60/src/main/clojure/cljs/repl.cljc )

You can call ns-publics in a macro, since that will run at compile time

On the JVM

But the macroexpansion won’t have a runtime reference to ns-publics left over

Ah, so your saying that dir works because its a defmacro, but if it was defined with defn, then it wouldn't work?

That’s right

Which I guess would explain why ClojureScript's implementation of dir doesn't have a similar dir-fn.

Hmm...strange, looks like even when I use it in a macro, I still am not getting the macros:

cljs.user=> (defmacro foo [arg] (ns-publics 'shadow.cljs.modern))
#'cljs.user/foo
cljs.user=> (foo)
{}
cljs.user=> (clojure.repl/dir shadow.cljs.modern)
defclass
js-await
js-template
nil
cljs.user=> 

(Note that even though I'm referring to shadow.cljs.modern, I'm actually not using Shadow CLJS, I'm just using that one file.)

Huh, I am not sure what is going on there!

Rats, well thanks anyway. 🙂

You know, I wonder if it has something to do with the fact that I defined it in the repl.

That sounds likely!

So I tried @U017QJZ9M7W’s trick and in a CLJ test it works fine, but in my CLJS build I get:

Could not Analyze: Library name must be specified as a symbol in :require / :require-macros; offending spec: (:require-macros [tiltontec.matrix.api]) at line 1 jar:file:/Users/kennethtilton/.m2/repository/com/tiltontec/matrix/4.3.1-SNAPSHOT/matrix-4.3.1-SNAPSHOT.jar!/tiltontec/matrix/api.cljc  jar:file:/Users/kennethtilton/.m2/repository/com/tiltontec/matrix/4.3.1-SNAPSHOT/matrix-4.3.1-SNAPSHOT.jar!/tiltontec/matrix/api.cljc   line:1  column:1

(ns tiltontec.matrix.api
  (:require
    #?(:cljs
       (:require-macros [tiltontec.matrix.api]))
  ...etc)

Move it out of the :require block

It should sit at the same level

Also side note, @U017QJZ9M7W yup, it seems to only show up in the repl. When I make a new .clj file and put the defmacro in there, it works fine.

Ah, coulda stared at that all day. Thx!

you can use http://clojure.github.io/clojure/clojure.java.shell-api.html#clojure.java.shell/sh to shell out with open

A possibility is to use the open command if you're on mac. But hopefully someone provides a more Clojure-y solution.

That obviously with the shell just as @U064X3EF3 said.

open opens file in the default app.

(clojure.java.shell/sh "open" "foo.png")

These days, unless I want a lazy sequence, I am leaning toward using transducers for most transformations that are more than a trivial map or mapv. I don't always remember but I'm getting better about it (after using Clojure for a long time before transducers existed!).

I think I have the same heuristic, transducers whenever I am doing anything I used to use ->> for with chained transformations . With many exceptions of course!!

I also try to make my “reducing” functions implement the three arities transducers need

Thanks for the insights!