what error do you get? I remember trying to do something similar and it was not possible to use and like that because it's a macro

maybe the (fn ..) syntax will work

no, error on the 4clojure site only a message that I fail the tests

yep, this is working

(fn test [ key map] 
  (and (contains? map key) (nil? (get map key)))) 

yeah actually i think i was wrong

you just mixed the order of the arguments

in you first definiton

this works

(true?  (#(and (contains? %2 %1) (nil? (get %2 %1))) :a {:a nil :b 2}))

oops

You can use find too

i also found that

#(nil? (get %2 %1 "nope")) works but it's not really obvious what one should use in the default case

yep, i agree. the challenge is not clear about it

I think the challenge is clear, and using a default value for the get i think makes sense, you just have to put something that is not nil as the default, but i'm not sure what would be the best option

oke

How about : #(nil? (get %2 %1 :else))

nope, it fails the first case

(= (__ 0 [:a :b :c]) {:a 0 :b 0 :c 0})

I think "standard library" is the content of clojure.core namespace. Everything else is a non-standard. And yes to your second question in case of leiningen

As for the second point, yes, but it’s helpful to note that there are two intentions here: expressing what you intend to use (a concrete version of a library), and where you intend to use it (in this or that ns). You express the first intention to your deps management tool (project.clj for lein, deps.edn for clj, etc), and express the second in the namespace itself.

Looks good to me. An alternative would be

(fn [default ks] 
  (zipmap ks (repeat default)))

Good warnings on names. Although, the shorter the function, the less likely such shadowing of names is to cause problems, and that is a nice short function.

thanks both

so ks is a better name for a collection

or maybe col ?

Most commonly you will see xs (as in "a collection of x's") to refer to a generic collection of things.

oke, i know that one from my haskell days

there is xs also often used

(client/get ""
            {:query-params {:key "14OGzuak" 
                            :format "json"
                            :type "schilderij"
                            :toppieces "True"}})

vrey quick answer

I can use the same trick here

(str "" object-number "/tiles?key=14OGzuak&format=json")

where the objectnumber is a variable from a loop

yes

oke, how do I handle the objectnumber as variable then ?

(for [on ons] (use on))

that not what I mean

Have you seen the examples in the docs? https://github.com/dakrone/clj-http#get

(client/get
 (str "" object-number "/tiles")
 {:query-params ...})

so something like this :

(client/get ""
            {:query-params {:key "14OGzuak"
                            :format "json"
                            :object-number :object-number"}})

Is object-number part of the query string?

yep, is it a variable part

Seen my answer there yes?

@UCCHXTXV4 yep

Noting: query-params it's what's after the "?" bit.

so I can just use it as a variable

the url path you concatenate, yes

https://github.com/metosin/reitit can do "reverse routing": template + path params = http path

(def router (r/router ["/api"
                       ["/foo" ::foo]
                       ["/bar/:id" ::bar]]))

(:path (r/match-by-name router ::foo)) ;; /api/foo
(:path (r/match-by-name router ::bar {:id 1})) ;; /api/bar/1

oke, I did not learn reitit

Just compujure and ring so far

1st fn, 1st contains call: (contains? "xx" "xx") => contains? not supported on type: java.lang.String

I think it will clarify if you unpack the expression. What is #(contains? % "xx") being applied to in the first case?

i am passing set in place of %

Understandable you would think that, but it is not the case here. Check out the docs for https://clojuredocs.org/clojure.core/some

I am trying to do same as

(some #(= 5 %) [6 7 8 9 10])

which is mentioned in document

or, is it just taking first element from set?

(some pred coll)

Returns the first logical true value of (pred x) for any x in coll,
else nil. 

yeah...

(some #(= % "xx") #{"xx" "yy" "jj"}) worked

can we use = in comparing string in clojure?

does it check string content ? or reference?

maybe https://clojuredocs.org/clojure.string/includes_q is what you want?

include does not suit my requitement

want to check exact string

= then

> can we use = in comparing string in clojure? I think in general, yeah you're pretty safe doing that

does it check the string content?

yes

(defn =
  "Equality. Returns true if x equals y, false if not. Same as
  Java x.equals(y) except it also works for nil, and compares
  numbers and collections in a type-independent manner.  Clojure's immutable data
  structures define equals() (and thus =) as a value, not an identity,
  comparison."

yeah this is i got from core code

thanks

https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#equals(java.lang.Object)

Kinda! @seancorfield I understood that relation between f, val and coll. But i cannot understand how can that be useful in our day by day. Which problem does adding " { } " (just like in the pic i sent initially) as a initial value solves or facilitate our life? e.g

(reduce + [1 2 3])
=> 6 ; Great, we added all the values together

(reduce + {} [1 2 3]) ; ??? "{ }" helps nothing here
Execution error (ClassCastException)...

If so, why did the exercise added { } inside that maximum and minimum function? Just for the result be in a map? The book used "accumulator" to define that { }. So, we are taking our values from the coll [5 23 5004 845 22] and putting it inside the "acumulator"? (or "{}"/initial value)

Sorry for the dumb question @seancorfield , have been thinking for hours about this initial value but still didn't found the answer. Thanks for the support!

user=> (reduce + [1 2 3])
6
user=> (reduce + 0 [1 2 3])
6
user=> (reduce + 13 [1 2 3])
19

Hmmmm, just like partial?

No.

Compare these:

user=> (reduce conj [] [1 2 3 4])
[1 2 3 4]
user=> (reduce conj {} [1 2 3 4])
Execution error (IllegalArgumentException) at user/eval173 (REPL:1).
Don't know how to create ISeq from: java.lang.Long
user=> (reduce conj #{} [1 2 3 4])
#{1 4 3 2}
user=> (reduce conj [] {:a 1, :b 2, :c 3})
[[:a 1] [:b 2] [:c 3]]
user=> (reduce conj {} {:a 1, :b 2, :c 3})
{:a 1, :b 2, :c 3}
user=> (reduce conj #{} {:a 1, :b 2, :c 3})
#{[:c 3] [:b 2] [:a 1]}

But, why does the values here go "back" to the initial value if we are not using conj?

(reduce (fn [{:keys [minimum maximum]} new-number]
          {:minimum (if (and minimum (> new-number minimum))
                      minimum
                      new-number)
           :maximum (if (and maximum (< new-number maximum))
                      maximum
                      new-number)})
        {}   ;; <---- The new argument!
        [5 23 5004 845 22])
{:minimum 5, :maximum 5004} 

In (reduce + {} [1 2 3]) the first step is (+ {} 1) which is not legal.

In (reduce + 13 [1 2 3]) the first step is (+ 13 1) => 14. The next step is (+ 14 2) => 16. The final step is (+ 16 3) => 19.

In your min max example, the first step is to call that function with {} and 5 -- and the function destructures {} against {:keys [minimum maximum]} so both minimum and maximum are bound to nil.

And the if conditions check for nil: (and minimum (> new-number minimum)) will guard the comparison for non-`nil` values.

So it produces {:minimum 5, :maximum 5}

The next step is to call that function with {:minimum 5, :maximum 5} and 23

So now we get {:minimum 5, :maximum 23} and go round again with 5004 and so on.

Does that help?

(reduce + [1 2 3]) is the same as (reduce + 1 [2 3]) so it does (+ 1 2) and then (+ 3 3)

But (reduce + []) is going to call (+) -- with no arguments -- which produces 0

And (reduce + [1]) is just going to return 1 without calling +.

You can see that + is not called, in this example (reduce + [:not-a-number]) which produces :not-a-number (if it tried to call + on it, you'd get an exception).

THANK YOU @seancorfield!!!! Finaaaally ive understand that!

Cool. This higher-order stuff can be a bit bewildering at first because it's not how folks program in traditional languages.

In Clojure, using sequence and collection functions is far more common than writing loops, for example.

Rich Hickey has said several times that the IReduce form of reduce (without the initial value) was a bad idea and he wishes he'd only created the IReduceInit form -- with three arguments: the reducing function, the initial value, and the sequence.

When I added "reducible queries" to clojure.java.jdbc, I implemented both forms and it was a mistake. When I implemented next.jdbc, I very deliberately omitted the IReduce form.

Yeah, thats make sense about the Ireduce problem.

Thank you @seancorfield!!!! Now i understand this example. I appreciate your patience and attention

Couldn’t the CLJS be compiled to an npm module & required by the JS? I’ve never done it, but these docs look promising: https://shadow-cljs.github.io/docs/UsersGuide.html#target-npm-module

Oh, that does look like it might help @sebastian_cheung build stuff with cljs and integrate it into an existing React JS app?

Yes, afaik

Hmm, that repo is where I end up if I follow links for Om Next so I guess both versions of Om have gone away. Can't say I liked it, compared to Reagent -- at least when we looked at apps built with both Om and Reagent back in 2013/2014 🙂

I've been trying to escape the tyranny of the browser. I was able to get Fulcro to work on desktop. re-frame has implicit dependencies on react. I think that may be the case with reagent as well.

re-frame can be used server-side in Clojure -- it's kind of weird but it's possible...

I meant for building desktop apps.

With... Electron or something similar?

my side project is trying 🤞 to clojurize UI development: https://github.com/phronmophobic/membrane

most of the cool UI development is happening in cljs with react in mind

but where possible, I've tried to use existing UI state libraries without react

@smith.adriane @seancorfield @sebastian_cheung it's 💯 possible to use components defined using helix in a ReactJS app. care has to be taken to accept props in a way that is ergonomic for the consumer, though. E.g. you probably won't want to expect that someone using your components are passing in ClojureScript maps, vectors, sets etc.

it's also possible to do this with Fulcro, it requires more steps and care though

personally, I would not try and develop a bunch of components in CLJS that are then used in a React app, as the tradeoffs are not worth it. ClojureScript is a good application language. You'll find that when creating libraries that are then used in JS, those libraries are harder to build, to use, and will have worse performance than a JS lib

I have had great success going the other direction, building components in JS that I then use in CLJS. Helix had that in mind when it was built, and allows you to use ReactJS components basically the same as if you defined them using Helix

Thanks for the follow-up @lilactown -- that sort of confirms the impression that I'd gotten about cljs vs JS (use cljs for the app, JS for interop/components as needed) but interesting to hear that you can write components in cljs and use them from JS/React.js but it has caveats...

The tradeoffs are very similar to Clojure vs Java. I would not build a library in Clojure that is consumed in a Java app unless I had some very specific and important reason to

https://www.learnreframe.com/ Seems nice

Ah, sorry, missed that question. Yes, that's probably the one I would have recommended. There's also this one https://purelyfunctional.tv/courses/understanding-re-frame/ (and, yes, you need to pay for these).

oke, I think i try the free course first. Find 200 till 1000 euro very much for a hobby

https://clojuredocs.org/clojure.walk/keywordize-keys

Just pass the right options to json/parse-string

This is data.json right? It's right there in the README @U0EGWJE3E: https://github.com/clojure/data.json#converting-keyvalue-types

nope, this is cheshire

Then read Cheshire's docs -- that readme also covers this.

think I gave up on clojure

(json/parse-string (client/get
                           (str "" object-number "/tiles")
                           {:query-params {:key "14OGzuak"
                                           :format "json"}}))))
error: 

; Execution error (ClassCastException) at cheshire.core/parse-string (core.clj:207).
; class clojure.lang.PersistentHashMap cannot be cast to class java.lang.String (clojure.lang.PersistentHashMap is in unnamed module of loader 'app'; java.lang.String is in module java.base of loader 'bootstrap')

https://github.com/dakrone/cheshire#decoding

@U0EGWJE3E look at what client/get returns -- try it in the REPL.

It is not a string. It's a hash map.

chips, I see it

parse-string expects a string and you're handing it a hash map.

never code just before goto sleep

You need to learn to take more careful steps and try things out in the REPL.

oke

do you like this code :

(ns paintings.core
  (:require [cheshire.core :as json]
            [clj-http.client :as client]
            [clojure.walk :as walk]))


(defn image-url-size [image]
  (let [data (select-keys image [:width :height])
        url (get-in image [:tiles 0 :url])]
    (assoc data :url url)))

(defn assoc-image [object-number]
  (->> (client/get (str "" object-number "/tiles")
                           {:query-params {:key "14OGzuak"
                                           :format "json"}})
       (:body)
       (json/parse-string)
       (walk/keywordize-keys)
       (:levels)
       (sort-by :name)
       (last)
       (image-url-size)
       (merge {:object-number object-number})))

(time (->>(client/get ""
                                          {:query-params {:key "14OGzuak"
                                                          :format "json"
                                                          :type "schilderij"
                                                          :toppieces "True"}})
           (:body)
           (json/parse-string)
           (walk/keywordize-keys)
           (:artObjects)
           (map :objectNumber)
           (map assoc-image)))

Like I just said, you don't need keywordize-keys. Just tell Cheshire to return keywords.

yep but then I think I cannot use ->> but then I have to use ->

Be careful about using time around a map expression because map is lazy.

You can use -> for most of the pipeline and then switch to ->> for the final steps.

can I ? never seen that

But it's considered poor style to mix threading types -- because it indicates you are changing from "object/thing/collection" functions to sequence functions.

Can I what?

I learned I have to use a function to use -> in a ->> pipeline

(-> (client/get ..) :body (json/parse-string true) :artObjects (->> (map :objectNumber) (map assoc-image)))

okek but that is a poort style

so better not use it

Poor style because you're trying to do too much in a single pipeline. Refactor it into small functions to transform the data.

And don't forget about my comment about time and map.

I do

I will remember that the outcome is not the real time

time will just tell you how long it took to construct the initial lazy seq, not how long it actually takes to do the transformation work.

oke

then I will delete it

Compare (time (mapv inc (range 1000))) and (time (map inc (range 1000)))

I was hoping it would say how long it all took

(time (doall (map ..))) if you must use map. Or use an eager process like mapv.

the map is much faster then the mapv one

In this? "Compare (time (mapv inc (range 1000))) and (time (map inc (range 1000)))" -- no, that's exactly the point I was making: time of map doesn't time the work.

oke

I see a big difference

that is all I mean

Right, because (time (map inc (range 1000))) is not timing how long it takes to map inc over that range.

It's just timing how long it takes to create an (unrealized) lazy sequence object -- it isn't doing any work.

im now trying to figure out why this is not working

(->> (client/get ""
                       {:query-params {:key "14OGzuak"
                                       :format "json"
                                       :type "schilderij"
                                       :toppieces "True"}})
           :body 
           (json/parse-string true) 
           :artObjects 
           (->> (map :objectNumber) 
                (map assoc-image)))

(time (doall (map inc (range 1000)))) will force realization of the mapping.

oke

You're using ->> at the beginning, not ->

It should be (-> (client/get ..) ... (->> (map ..) (map ..)))

time for me to sleep

but the code is working

Now you've fixed it 🙂 Do you understand what you did wrong?

yep

again I want to fast

very bad old habit

but this is better style

(defn take-data[image-data]
  (->> image-data
      (map :objectNumber)
      (map assoc-image)))

(-> (client/get ""
                       {:query-params {:key "14OGzuak"
                                       :format "json"
                                       :type "schilderij"
                                       :toppieces "True"}})
           :body 
           (json/parse-string true) 
           :artObjects
           (take-data))

Better, yes.

oke, tomorrow I try to rewrite this part

(defn assoc-image [object-number]
  (->> (client/get (str "" object-number "/tiles")
                   {:query-params {:key "14OGzuak"
                                   :format "json"}})
       (:body)
       (json/parse-string true)
       (:levels)
       (sort-by :name)
       (last)
       (image-url-size)
       (merge {:object-number object-number})))

the same way

That's wrong.

???

I know that it's wrong

You're using ->> again and you need ->, and then switch to ->> later in the pipeline

that what I rewrite it as you learn me afew moments ago

Oh, you mean you need to rewrite it "the same way" as you rewrote the other code?

Sorry, it's hard to understand what you're asking at times.

that is what I try to say that I will try to make that work tommorow

sorry, english is not my mother languages and I was years and years ago very bad in languages

at school

NP. I get it now. Good luck tomorrow -- once you've had some sleep!

And remember: take small steps and try each piece out in the REPL.

yep, could not let it wait till tomorrow

what do you think

(ns paintings.core
  (:require [cheshire.core :as json]
            [clj-http.client :as client]
            [clojure.walk :as walk]))


(defn image-url-size [image]
  (let [data (select-keys image [:width :height])
        url (get-in image [:tiles 0 :url])]
    (assoc data :url url)))

(defn take-image-data[image-data object-number]
  (->> image-data
       (sort-by :name)
       (last)
       (image-url-size)
       (merge {:object-number object-number})))

(defn assoc-image [object-number]
  (-> (client/get (str "" object-number "/tiles")
                   {:query-params {:key "14OGzuak"
                                   :format "json"}})
       (:body)
       (json/parse-string true)
       (:levels)
       (take-image-data object-number)))

(defn take-data [api-data]
  (->> api-data
       (map :objectNumber)
       (map assoc-image)))

(-> (client/get ""
                {:query-params {:key "14OGzuak"
                                :format "json"
                                :type "schilderij"
                                :toppieces "True"}})
    :body
    (json/parse-string true)
    :artObjects
    (take-data))

Nice breakdown! Yay!

oke, then now study ring and computure to make the back-end

and then decide what to use for the front-end