ClojureD talks are out! 🎉 https://www.youtube.com/playlist?list=PLaSn8eiZ631lrDFmUTBH9LFGzAxc3tvU4

Hallo everybody!

Where is the place to talk about graalvm - specifically native-image?

@deas maybe #graalvm

I was thinking how, given that (a-map :a-keyword) is same as (:a-keyword a-map) it’s weird how we picked (sub-thing big-thing) form as canonical instead of (big-thing sub-thing)

(let [m (maybe-map)] (m :foo)) => 💥 Exception

especially when you consider that map and function are synonyms

We use the sub-thing because it's usually constant.

I'd never do (k m) I'd always use (get m k) in that case. If I knew the map, not the k, I'd do ({:foo 1} k) .

good stuff

For Macros. I always hesitate to jump to them if possible. My question is, what is the opinion on resorting to a macro just to reduce boilerplate code? e.g instead of having to write the following over and over:

; try several-line-of-logic
;     catch
; log-something
; do-something-else

you're not resorting, that's what macros are for

Follow up Q: what are the things we should look out for when using macros? I read a lot about abuse of macros.

How much boilerplate would it save you? Doesn't seem like much from the example you gave

pretend that several-line-of-logic , log-something and do-something-else are 2x more each.

Another reason in favor of using a macro for something like that is if you believe you will have dozens of occurrences of it, and you believe you are likely to want to change the behavior of all of them in a consistent way, via changing the macro definition later.

Look out for using patterns that break the IDE (cursive). For it to work with Cursive, it usually needs to be similar to an existing built in form, like def, defn, let, etc

I will keep an eye out for that, isak.

Is there a straighforward way to use figwheel with phantomjs for testing

What is the idiomatic way to make into safe for both lists and vectors/sets?

(let [xs '(1 2 3 4)]
  (into (empty xs) xs)) ; => (4 3 2 1)

(let [xs [1 2 3 4]]
  (into (empty xs) xs)) ; => [1 2 3 4]

don't use empty?

I'm trying to implement a record that will have multiple fields and a context map that consumers can use as a regular map. Something like (defrecord A [private-field1 private-field2 context]) and I want all (assoc record :field val) to assoc to context field. I figured that it should be easy to do a deftype and implement IPersistentMap, but can't find a reference of all the methods required for IPersistentMap. Can someone point me into the right direction or how to implement a thing in the first paragraph with records? Thanks

you can just use the defrecord like a regular map

private fields are silly

I don't care about private fields, it is just I don't know all the fields in the record in advance

that is fine

records act like maps

so I do something like (defrecord A []) ?

user=> (defrecord A [])
user.A
user=> (assoc (->A) :x 1)
#user.A{:x 1}
user=>

ah, you mean you can't always fill in the those bits

maybe just use a map

I'll have a couple of fields that will be always present and a bunch of helper methods to modify them. I thought that I will put them in an interface and implement those using a record. I want to make sure that consumers can't mess up with those fields in any way.

I can leave them as namespaced keywords, but then it will be hard to consume these records with "filter" or any other methods, since you will always need to keep those extra fields in mind

when doing require, is there a subtractive form for :refer :all? for example '[prelude.core :refer :all-but [something-not-needed]]

:exclude , I think?

Yeah -

(require '[clojure.string :refer :all :exclude [lower-case]])
WARNING: reverse already refers to: #'clojure.core/reverse in namespace: user, being replaced by: #'clojure.string/reverse
WARNING: replace already refers to: #'clojure.core/replace in namespace: user, being replaced by: #'clojure.string/replace
=> nil
(lower-case "ABC")
Syntax error compiling at (/private/var/folders/lb/q65kb_ys1g71l4n2fj7m8jvh0000gn/T/form-init7403812543420763679.clj:1:1).
Unable to resolve symbol: lower-case in this context
(require '[clojure.string :refer :all])
=> nil
(lower-case "ABC")
=> "abc"

Is there a way to add a namespace to fields in a record?

no

you can use any key for fields, but only un-namespaced keywords for basis fields

@bear-z, I don't have a lot of experience with trying to do what you described further above, but I have to say that it seems unnatural in Clojure to use an interface to enforce an API. It seems more natural to use a regular map with namespaced fields for the required fields, and use spec to enforce the API if needed. I'm not sure what you meant about difficulties consuming the records with filtering.

(ins)user=> (defrecord Foo [a b])
user.Foo
(ins)user=> (map->Foo {:a 0 :b 1 :some.important/key "OK" [1 2 3] true})
#user.Foo{:a 0, :b 1, :some.important/key "OK", [1 2 3] true}

if you need validation, one option is to add a validator to the container holding the data

(ins)user=> (def foo 1)
#'user/foo
(ins)user=> (set-validator! #'foo number?)
nil
(ins)user=> (def foo 2)
#'user/foo
(ins)user=> foo
2
(ins)user=> (def foo :b)
Execution error (IllegalStateException) at clojure.main/main (main.java:40).
Invalid reference state
(ins)user=> foo
2

this also works on agents/refs/atoms

but importantly this isn't a property of the data object (that's immutable) but a property of the container enforcing the data objects it can contain

Thanks @noisesmith. That should work.

what is the proper way to get rid of reflection here?

(let [fs (java.nio.file.FileSystems/newFileSystem (.toPath (io/file "bb.zip")) nil)
      to-extract (.getPath fs "bb" (into-array String []))]
  (java.nio.file.Files/copy to-extract (.toPath (io/file "bb"))
                            ^"[Ljava.nio.file.CopyOption;"
                            (into-array java.nio.file.CopyOption [])))

one would think into-array with an explicit class would not need an annotation

into-array is just a function, so it isn't like the compiler determines functions return types from Class object's you pass in to the function

java interop is going to be verbose, it's java after all

so you're saying, this is the correct way to do it?

no idea, just that when trying to use java libs, it sort of removes all the beauty of the language

which for non-trivial apps, its frequent

it gets a little bit uglier than in Java itself because of the into-array stuff for passing varargs

I guess the clojure compiler doesn't support <T> type things.

generics, and they don't exist

they are a fiction of the java compiler and don't exist in the bytecode

But they don't need to do they?

since they don't exist there is no reason for clojure to support them

It's useful to express the return type of the function in terms of the arguments to the function.

you are trying to use type hints as a type system which they are not

they a means to communicate type information to the compiler, and since generics don't exist, the compiler doesn't need them

I don't need generics. I need either a into-array for all possible arrays, or a way for into array to produce compiler information based on arguments.

Maybe a macro would work.