@UK0810AQ2 nearly all clojure functions operating on sequences are lazy

@UH16CGZC2 There are plenty of opportunities to go through the transducing arity if all you're using is the core library

Can you show us non lazy solution?

The solution I provided is non lazy

oh i see it now, thank you, i'll look closer

🙂 How to spot it: mapcat doesn't take m as an argument

Also, the inner map doesn't take vs as an argument, i.e. it returns a transducer, which is one of the two arguments to the eduction constructor

right, i understand transducers concept, just never seen them in that context of laziness, thank you

In which context do you usually see them, then?

composable, decoupling transformations

I could use filter with (= (namespace key) “key_name”), but wonder if there is more succinct way of doing it.

dev=> (def m {:user/id 1 :user/name "abc" :test/id 2 :test/name "def"})
#'dev/m
dev=> (map #(into {} %) (vals (group-by (comp namespace key) m)))
(#:user{:id 1, :name "abc"} #:test{:id 2, :name "def"})

But I would ask “Why do you need/want this?”

(i.e., what situation are you in that you’re getting a map with mixed namespace qualifiers where you need to treat those qualifiers as structural information rather than global identity?)

Thanks for answering! This happened when joining two tables, and using a portion of data from one table to make a token.

I’d probably just use select-keys to pull out the specific fields I wanted, to make the selection explicit.

Thanks, that can also work.

Can't answer the question but can explain why it works that way, if it's useful. The ^:dynamic metadata is only taken into account when the def form is parsed. It's not read from the var. Instead (.isDynamic v) is called.

So in the above case, (.isDynamic #'*foo*) will return false.

right

And there's still a way to make it work dynamically:

user=> (.setDynamic #'*foo*)
#'user/*foo*
user=> (binding [*foo* 2])
nil

makes sense. no non-interop way of doing it I'm afraid?

Couldn't find it.

might wanna ask in #reagent if you don’t get any answers in here

How do you launch boot ? Not sure if the command exists on Mac, but does which boot output the right path to the new binary?

I created a shell script that points it to java -jar /path/to/boot.jar

actually, I will compile it again now and check

which boot returns ~/.bin/boot, which is where I placed my shell script

#!/bin/bash
export JAVA_HOME="${JAVA_HOME:-/opt/homebrew/opt/openjdk}"
declare -a "options=($BOOT_JVM_OPTIONS)"
exec "${JAVA_HOME}/bin/java" "${options[@]}" -Dboot.app.path="${HOME}/.bin/boot" -jar "${HOME}/Applications/boot/bin/boot.jar" "$@"

If you're absolutely sure that that jar at "${HOME}/Applications/boot/bin/boot.jar" is the one you compiled and that it doesn't have that error detection code, then it's very strange. Maybe removing ~/.bin/boot can help, no clue. There are also #boot-dev and #boot - maybe someone there knows.

yes, I am very sure that that is where the boot.jar is generated, and the ~/.bin/boot was also created by me (it's a folder in my PATH); thanks, I will ask there

if it’s sorted, last?

I was under the impression that that walks the entire sequence of pairs, so has O(n) performance

No, last is implemented on the sequence abstraction, which means it always iterates the full list.

peek for sorted maps is the goal here

oh my apologies, you said map

you can use rsubseq or subseq @U017QJZ9M7W if you are testing the key

“sorted map”, ie, sorted-map

rseq returns a reversed sequence in constant time

so (comp first rseq) would get the last item in constant time.

For any reversible data structure.

You can test for this with reversible?, but sorted maps qualify.

excellent, thank you!

I run Clojure with Java 16, no issues observed at all.

what support is needed?

I'm not sure yet, especially since as far as I know the api is far from stabilized. It might be that it just ends up being some stdlib stuff that clojure will support out the gate. My (very incomplete and possibly incorrect) understanding however is that we'll need some way to declare foreign functions, and that it would be out-of-band from normal execution.

seems like all the jeps for it have been released as of Java 16?

Oh, I guess I'm out of date then.

I guess I need to go look into the jeps

I'm not tracking this at all and have no idea what the gaps are between Java and Clojure. if you're interested in it, it would be great to discover that and write it up on http://ask.clojure.org if there is some gap to close

I'll start doing some research and see if there's anything that needs to be added.

there's no support necessary AFAICT

just a library you can use

looks like there are Java 17-EA builds with everything at https://jdk.java.net/panama/

That's really cool if it's just a library.

yeah - no support needed, but there might be reasons to want maybe support for deftype metadata to make a primitive class

so like

(deftype ^{:primitive true} Thing [a b])

the actual bytecode for calling a method on a primitive class should be the same as usual

beyond that there might be things like type hints being able to distinguish between stuff like Instant.ref and Instant.val

wait i am thinking of valhalla, ignore me

https://github.com/clj-python/libpython-clj <- whatever this project ends up doing with regards to panama is likely to be the way to go

https://techascent.com/blog/next-gen-native.html

keep in mind that the JVM doesn't generally break things intentionally, so anything a "dusty old jar" does is likely to remain working in the future

cond->

(cond-> x condition (expr-that-uses-x ...))

I’ve used cond-> when I have multiple expressions, but it feels weird to use it for a single expression?

why would it be weird?

it becomes a judgement call

I’ve used it for single expressions as well and to me it just makes sense

I've called this when-pred

(defn when-pred
  [test? f]
  (fn apply-when-matches
    [x]
    (if (test? x)
      (f x)
      x)))

It definitely makes sense, and I've used it for single expressions too, but when I ask myself what reads easier, I revert back to if every time 😅

also - depending on context, this can easily become a multimethod

Like this?

name is a built-in Clojure function, that may be giving you problems, try naming your argument filename or something.

Yeah, I really don't get it.

$   (defn id-extension [filename]
#_=>     (->
#_=>      (str/split filename #"teste")
#_=>      (first)
#_=>      (second)))
#_=> 
#'user/id-extension

$ ls |> (first) |> (map #(str/split % #"teste")) |> (first) |> (second)
"1.txt"

$ ls |> (id-extension)
Execution error (ClassCastException) at user/eval6839$id-extension (REPL:0).
class clojure.lang.Cons cannot be cast to class java.lang.CharSequence (clojure.lang.Cons is in unnamed modu
le of loader 'app'; java.lang.CharSequence is in module java.base of loader 'bootstrap')

Hmm, what’s the code that’s calling id-extension now?

You might want to try working with these functions in a regular REPL first to make sure you understand how map works (and perhaps ask in #beginners where folks have opted-in to helping folks with stuff like this).

The thing to bear in mind about closh is that |> always sends a sequence of lines, so ls |> (first) |> (map ..) sends a sequence containing only one element into the map function. That’s the difference from Clojure.

Your id-extension function expects a string but ls |> (id-extension) sends it a sequence of strings.

$ ls |> (identity)
("bin" "deps.edn" "scratch.clj" "script.clj" "src" "wheel")
$ ls |> (first)
"bin"
$ ls |> (first) |> (identity)
["bin"]

Ok, I see. Considering that, It worked

(defn split-teste [filename]
  (->
    (str/split filename #"teste")
    (second)))

$  ls |> (map split-teste)
("1.txt" "2.txt" "3.txt")

I will head to the #beginners . Thank you.

Also, reducing the quantities of maps, just like @U06CM8C3V said helped closing-in the solution