hey guys, somebody using emacs on debian?

i am

i am facing an issue with emacs on debian can you join #emacs for further detail please

then i will fully describe the issue

When is it preferred to write a function with no argument over a def? For example, on Lacinia’s example, https://lacinia.readthedocs.io/en/latest/tutorial/init-schema.html#id5, the resolver-map is a function. Will it be fine if I use def here?

(defn resolver-map
  []
  {:query/game-by-id (fn [context args value]
                       nil)})

@dawranliou With a def, the body is evaluated at compile time, i.e., whenever the namespace is loaded. With a defn , the "body" is evaluated at compile time but it produces a function and the function's body is only executed when you call it at runtime. Does that help?

How do tagged literals work?

You mean like creating a custom tagged literal, or just tagged literals in general?

in general

And also how to create custom ones.

I was trying to understand how integrant does what it does, with its ig/ref

Looks like ref is a function that returns a record

(defn ref
  "Create a reference to a top-level key in a config map."
  [key]
  {:pre [(valid-config-key? key)]}
  (->Ref key))

Is ig/ref run at read time then?

In general the basic idea of tagged literals is to give the Clojure reader a way to recognize and evaluate custom data types. When the reader sees #inst, for instance, it knows the next thing it sees should be a string with a formatted timestamp that it knows how to parse.

That I get, tagged literals are what make EDN extensible.

But I was wondering when this parsing happens.

At read time.

Got it.

Thanks!

:thumbsup:

Hey, I’m having a slight brain derp. Is there an inverse operation to apply? Say I have a function that takes 2 arguments, and I have a vector of 2 elements, and I want to pass those as arg1 and arg2.

(Without destructuring the vector)

That is what apply does.

:woman-facepalming: I did have a brain derp. Thanks!

Happens to the best of us 🙂

then… to collect a lot of arguments into one, would you (comp f vector)? or is there a more idiomatic way?

I think it would be more common to see (defn foo [& args] ...)

Probably just write as a vector literal

or a vector literal.

(f [a b c]) instead of ((comp f vector) a b c)

(defn foo [& args] (prn args))
#'cljs.user/foo
dev:cljs.user=> (foo 1 2 3)
(1 2 3)
nil

(I don’t have the actual values, this is theoretical exploration of tools for composing functions. TLDR: use base language capabilities 🙂 )

Thanks!

If you use & args you’ll get a seq not a vector, but it’s easy to convert.

is seq -> vec conversion O(n)?

yes

how about vec -> seq?

O(1)