Is there a way to read in a csv and assign the headers or first row to create a map with the headers as keys?

@jdwoodsy1 in the README file of https://github.com/clojure/data.csv has a section about "parsing into maps"

@iagwanderson Thanks.

I have a list of functions (f g h) and values (1 2 3) and I want to get a sequence of values of evaluating the function to the argument of the same index, as in: ((f 1) (g 2) (h 3)) I thought this would work: (map #(%1 %2) '(str inc) [1 2]) but it does not. I ended up doing this: (map #(eval (list %1 %2)) '(str inc) [1 2]) ("1" 3) This seems overly verbose, and that I am missing something simple. Is there a more idiomatic way to do this?

(map #(% %2) [str #(* % 2)] [1 2])
=> ("1" 4)

user=> (map (fn [f arg] (f arg)) [inc dec +] [1 2 3])
(2 1 3)

#() syntax is nice in the majority of cases when it works, but sometimes just using (fn [ ...] ...) can make it easier to figure out how to make it work correctly.

Thanks both. One of the things I tried that I didn't post and didn't work was using a list of symbols for the functions rather than a vector of function (symbols?):

(map (fn [f arg] (f arg)) '(inc dec +) [1 2 3])

(nil nil nil)

converting to a vector gives me nils as well: (map (fn [f arg] (f arg)) (vec '(inc dec +)) [1 2 3]) (nil nil nil)

So I think my question refines down to "what is the difference between a vector of functions and list of quoted symbols in this case?"

Resolution of the symbol to the actual value.

I'd like someone to confirm though ahaha

@matthew.pettis

user=> (map (fn [f arg] ((resolve f) arg)) '(inc dec +) [1 3 5])
(2 2 5)

nice, I was trying to avoid the evalbit

Thank you @seancorfield --- I haven't seen resolve...

'inc is the symbol named inc. inc (no quote) will be evaluated by Clojure -- resolved to the symbol's current bound value. In this case clojure.core/inc is bound to a function (value) that increments its argument.

That makes the #() formulation work too: (map #((resolve %1) %2) '(inc dec +) [1 2 3]) (2 1 3)

Yes, #() is just shorthand for (fn [,,,] ,,,)

Back to '(x y z) vs [x y z] -- the former is a quoted list so it is not evaluated; the latter is a vector of values so the symbols are looked up (resolved). '[x y z] is also quoted and not evaluated.

I'm not into macros yet, but I have a question for this specific problem, would be easier to handle this list of symbols inside a macro? even avoiding the resolve call?

(list x y z) would evaluate the elements, resolving the symbols to their bound values.

@iagwanderson macros just rewrite code to code - they don't evaluate anything (they are executed at "read" time, before code is compiled and then executed).

yeah, I changed my eval for resolve and it looks like the same as the map version

(defmacro custom-map [fs args]
  (list 'map '(fn [v arg] ((resolve v) arg)) fs args))

You don't need a macro for that.

The first rule of macro club is: don't use macros.

😃

For completion, that also explains why I was getting nil values out. I was evaluating things like ('inc 2) which yields nil. I don't understand why having a "symbol named 'inc'" in the function postion in a list passed to the evaluator returns nil though...

Because it looks itself up in its argument, as if it were (get 2 'inc) which returns nil.

user=> ('inc {'inc 1 'dec 2})
1

user=> ('inc 2 :not-found)
:not-found

user=> (get 2 'inc :not-found)
:not-found

Keywords and symbols look themselves up in their argument, in the same way that maps and sets look their argument up inside themselves. It makes working with associative data structures very easy.

So, to state in my own words: inc is the name of the symbol 'inc. In the sexp type into the repl (inc 2) In the repl, you use the name, inc. The name will resolve to the symbol 'inc.

-----------------
| name | symbol |
-----------------
|  inc | 'inc   |
-----------------

------------------------------
|            var              |
------------------------------
| symbol |        val         |
------------------------------
|  'inc  | #'clojure.core/inc |
------------------------------

When reading the text of the expression in the REPL, the Clojure reader gets a symbol, and a number, which you can check yourself like this:

user=> (def tmp (read-string "(inc 2)"))
#'user/tmp
user=> (map class tmp)
(clojure.lang.Symbol java.lang.Long)

A bit confused... from above, if inc is the name, how does the reader get the symbol 'inc? Assuming I am interpreting that correctly. I assume if inc is the name, there has to be some lookup path from name -> symbol -> var value...

Doing eval on a symbol looks up a table of names in the current namespace (or in the namespace that is the prefix in the symbol, e.g. foo.bar/inc), e.g.:

user=> (eval 'inc)
#object[clojure.core$inc 0x426b6a74 "clojure.core$inc@426b6a74"]
user=> (class (eval 'inc))
clojure.core$inc
user=> (instance? clojure.lang.IFn (eval 'inc))
true

When Clojure is given a list in parentheses to evaluate, without a leading ' , and the first element does not name a macro, it evals all elements of the list, including the first, then invokes the function that is the value of the first expression.

I'm getting closer. One thing that seems odd is that the following is equivalent then:

sess3=> (eval 'inc)
#object[clojure.core$inc 0x7fbdb403 "clojure.core$inc@7fbdb403"]
sess3=> (eval inc)
#object[clojure.core$inc 0x7fbdb403 "clojure.core$inc@7fbdb403"]

functions (like most things) evaluate to themselves so the second eval returns the same thing

quote means "read, but don't evaluate"

so 'inc is read (as a symbol), the end

inc is read as a symbol, then evaluated. in general, everything in Clojure evaluates to itself, with the with the two main exceptions: symbols and lists

symbols, evaluate to what they refer to in the scope of the current namespace

(lists evaluate args, then invoke the first element)

and now you know 90% of the Clojure evaluation model

(macros being the next 9%)

Thanks! In a side channel, I'm working through the concept of a symbol vs. the name of the symbol, which I keep tripping on...

(is that the last 1%?)

symbols are names the way I think about it

(the last 1% is all the other special cases which we won't talk about :)

fair 🙂

I'm curious about best practices around calling APIs with Clojure. The code looks nice and elegant when just making the http request, but I'm not sure where to put the "parse the resulting json" code and the "http error handling" stuff.

https://clojure.org/guides/learn/syntax#_evaluation might be helpful

I'll go back and re-read, but I read through "Joy of Clojure", and I don't have it here in front of me, but I recall the mention of names of symbols as distinct from the symbols, and I think the material difference was that you could associate metadata with one but not the other. I don't recall which one...

you can associate metadata with symbols

if I have a vector of maps like: [{:firstname "test", :lastname "test"} {:firstname "test1", :lastname "test2"}] how can I get a new vector of maps with only the firstname in map ?

(mapv #(select-keys % [:firstname]) data)

Or do you mean (mapv :firstname data) to get just a vector of first names?

thanks @seancorfield, this was just what I was looking for,. Just switching to clojure and had been figuring out this for a while now 🙂

Hi, using the carmine library for redis I wanted to scan and match some keys and found out I need to use the accumulator to get the whole output, seems like it's already implemented in carmine, but I don't know how to use it: https://github.com/ptaoussanis/carmine/blob/master/src/taoensso/carmine.clj#L750 In particular I don't understand what rf refers to, can anybody help?

rf usually refers to a reduction function. So a function that takes the accumulated value, and the current, and produces a new accumulated value

So I need to provide my own function? I thought carmine would take care of that and I just give it my scan function, I'm a bit lost right now 😅

hi people I am live streaming my work. I am not advanced clojurescript guy but might be usefull for newbies

https://www.twitch.tv/elixirBeam

any opinions on the pros/cons of something like this let-map macro? https://gtrak.wordpress.com/2012/06/11/separation-of-concerns-or-let-map-birth-of-a-clojure-macro/

imo, the code before the macro was easier to read

maybe working more on the signature of some-magic-parsing-fn function would have been more profitable than correcting the results, not sure

my general suggestion would be - don't be too quick to dismiss obviousness :)

my initial feeling was let-map feels like something out of the CL world

but that's more about the interface of the macro - overloading (let [x y]) without having a body using the bindings. If there was a map literal declaration that let me access previous values, I'd probably use it here.

Is there a way to access the forms in a clojure.lang.ReaderConditional? So in the result of something like (read-string {:read-cond :preserve} "#?(:cljs (+ 1 2) :clj (+ 2 3)))")

@finn.volkel you can call :form on it

I’m trying to wrap my mind around transducers — what’s the difference between sequence and eduction? Reading the source code didn’t help that much 😕

@teslanick common: they are both contexts where a transducer can be applied. Both presume that the source collection is at least iterable different: sequence caches realization of the xf+collection, eduction does not

(defn less-promises-eduction [xform coll]
  (reify clojure.lang.IReduceInit
   (reduce [_ f init]
     ;; NB (completing f) isolates completion of inner rf from outer rf
     (transduce xform (completing f) init coll))))

one could imagine a variant of eduction that didn't require anything of the underlying collection except that it is reducible

(AKA dropping the iterable requirement)

which would differentiate sequence and eduction even more

I feel like you’re skipping over a lot of intermediate context 😉

but caching is the big difference

What do you mean by caching here?

when you realize a seq, it only happens once

when you realize an eduction, it happens every time

it being side-effects + the xforms

Aha! That is an important difference

I’m trying to get a handle on transducers by reimplementing them in a more familiar environment (JS) using a relatively familiar-to-me primitive (generators). Thus far it is going adequately well. The explainer on the Clojure website is kinda hard to grok in theory, but messing around in the repl makes it somewhat more obvious what’s going on, poking at a reimplementation makes it easier to see the holes in my understanding

I want to create a plot with a value distribution as follows: From week 0 to week 18, distribute the necessary goal weight for each week to hit a certain end goal by week 18. This is going to be used for a fun graph and bet with a coworker who is also trying to loose some weight. Basically I want to have weigh-ins every week and a small penalty if you're above the goal weight for that week

This function gets me pretty close:

(defn weigh-in [starting-weight]
  (->> (range weeks-remaining)
       (map #(hash-map :week % :goal-weight (- starting-weight (* 0.8 %))))))

Bah of course it's 1st grade math problem when I type it out 😄

Nevermind...

is there any easy way to parse/read keywords in a namespace? So I can iterate over them? Otherwise I need to copy every used keyword in that file/namespace and put in a list manually, which I don't want to do

I cannot find any vars in my namespace even though they are there. I have stuff like

(def main-workflow-file (atom []))

(def five 5)

how are you loading your namespace?