Maybe a stupid beginners question. What is the clojure way to make a comment in a code which explains the challenges I have made. I like to store the solved 4clojure challenges in a file

I could do :

; comment  (defn ..... ) 

(defn ...  "comment"  ) 

(defn func-name
  "This is the docstring"
  [the arguments]
  (the function body))

that is one of the options , @seancorfield

So that one is more the clojure way ?

Since the docstring can span multiple lines you can write an essay there 🙂

There are several ways to provide actual comments in code tho'

;; this is a full line comment
(some code) ; this is an end of line comment
(comment 'and (this is any) :code you "want" as a comment)

(I think that last one will work -- I mostly use it to provide code examples in a comment so the contents are always valid Clojure code in my files)

oke, I use now this :

(defn notthing-but-the-truth
  "This is a clojure form. Enter a value which will make the form evaluate to true.
  Don't over think it! If you are confused, see the getting started page. Hint: true is equal to true."
  (= true true)
  )  

You're missing the argument vector.

I only have to think about when there are more "tests" with the same solution

maybe use them as real tests

@seancorfield is this good clojure :

defn list-conj-1
  "When operating on a list, the conj function will return a new list with one or more items \"added\" to the front."
  []
  (do (= '(1 2 3 4) (conj '(2 3 4) 1))
      (= '(1 2 3 4) (conj '(3 4) 2 1))
      )) 

The issue with ☝️ is that the first check on equality of the list with the result of conj is discarded by the second.

In other words, you don't know the result of the first test of equality and you only return the result of the last one

If you want both to be true is there a logical operator you can use that checks both things are true?

@agile_geek so I can better use and because both have to be true

👍

Changed it

now I also store my solutions to 4clojure on github 🙂

This is a sample from Clojure for the brave and true book,

(defn my-reduce
  ([f initial coll]
   (loop [result initial remaining coll]
     (if(empty? remaining)
      result
      (recur (f result (first remaining)) (rest remaining)))))
  ([f [head & tail]]
    (my-reduce f head tail)))

can someone explain the behaviour of recur here please?

(recur (f result (first remaining)) (rest remaining)))))

is it calling the loop or function?

Also what is the point of using

f

f

recur essentially invokes the next highest target with the given arguments. In this case, it will be the loop form, with (f result (first remaining)) in the result binding and (rest remaining) in the remaining binding.

f is called with result (first remaining) in this evaluation

Thanks @donaldball

Pretty sure valid recur targets are just loop and fns fwiw

👍

can i overload a function based on different keys in a map?

e.g. 
(defn myfun 
   [param1 {:keys [key1 key2 key3]}] 
     (....body 1) 
   [param1 {:keys [key1 key2]}] 
     (…body2) 

I don't think so

ah thanks .....

you could use core.match inside of it though

(some nil? [key1 key2 key3])

(defn myfun
  [param1 {:keys [key1 key2 key3] :as param2}]
  (if (contains? param2 :key2)
    (body1)
    (body2)))

https://github.com/clojure/core.match/wiki/Advanced-usage

@kyle_schmidt Problem with checking for nil? is that there's a difference between: {:a 10 :is-foo? nil} and {:a 10}

@dominicm Is there a problem doing this:

(let [{:keys [a is-foo?]} {:a 10 :is-foo? nil}]
        (some nil? [a is-foo?]))

Only if the absense of is-foo? might have a different meaning to nil.

yes ive come across core match seems like the way to go

thanks

Because this gives the same result:

(let [{:keys [a is-foo?]} {:a 10}]
        (some nil? [a is-foo?]))

@kyle_schmidt Yep, sometimes the fact that those input maps are different is important.

Lack of a key != key-value is nil

@kyle_schmidt Also, I think you want every? not some there.

@dominicm do you usually check the values that you parse from a map? Is it idiomatic to do so or do you operate assuming the keys are there? Or does it depend?

@gregnwosu I probably wouldn't throw core.match at this problem. Options: 1. defmulti with (comp set keys) as dispatcher function. 2. Destruct and use a sentinel at :or: {:keys [a] :or {a ::sentinel}}

@rauh thanks, can you provide me with a brief snippet so I can grok it

(fn [{:keys [a] :or {a ::sentinel}}]
   (if (= a ::sentinal)
     (a-was-not-provided)
     (a-was-provided)))

@rauh isn't contains? just the same as using sentinel?

Yeah, it's a matter of taste.

@kyle_schmidt Most of the time, if I can possibly be given nil, I handle it using when for example. But mostly, it depends as you say.

@rauh I would, personally, consider contains? more idiomatic. Why do you prefer sentinel?

Well I'd probably use some name that indicates what this options does, so kind of more self-documenting code

@rauh Not sure I understand. Could you expand on that?

i prefer match , its seems clearer i hate having if statements in code

How can I rewrite this solution to a 4clojure challenge better :

(defn double-down
  "Write a function which doubles a number"
  []
  (and (= ((fn [x] ( * x 2)) 2) 4)
       (= ((fn [x] ( * x 2)) 3) 6)
       (= ((fn [x] ( * x 2)) 11) 22)
       (= ((fn [x] ( * x 2)) 7) 14)))  

it looks very clumpsy to me

Which challenge? Looks kinda odd to me?

This one : http://www.4clojure.com/problem/15

I try to store my solutions so I can look it back

but this does not seem to be a good solution

or can I better make the function and use that one for all the fn cases seperate

so something like this :

(defn dounble-down 
  [x] 
  (* 2 x ))


(fn[x] (double-down x ) 4)    

I mean (fn[x] (double-down 2) 4)

Just to be clear, your solution is (fn [x] ( * x 2)) right?

right

and that have to be "inserted" into the 4 cases so there all be true

Alternatives I can think of: #(* % 2) and (partial * 2)

But I think your answer is very good.

maybe a idea to make the functions and let the cases be test-cases to the function

Or do you mean for testing the cases during development?

also

this challenges I have solved but there are a lot more

just bind it in a let

Oh, is this about the whole function instead of just the solution to 4clojure?

@dpsutton : how to do mean that. I cannot see the whole picture

@dominicm ultimate , its storing my solutions to 4clojure challenges

(let [foo (fn [x] (* x 2))]
    (and (= (foo 2) 4)
            (= (foo 3) 6)))

@dpsutton that is a nice solution. I have to type in the solution one time

@roelofw you probably want to store it some other place than 4clojure itself but if you are you logged into 4clojure you can click the solutions button and the answer you've provided is displayed as the first result

@dhruv1 are you using a particular React wrapper? (Reagent, Om, Rum, ...)

I am not.

i will move onto using warppers once I understand how to get started without the wrappers

@dhruv1 well, you can use JS interop directly

so i would have to do something like js/React.createClass app-bar ...

i.e (js/React.createClass #js {:render (fn [] (this-as this ...))})

ah okay.

thank you!

My advice: use interop as long as necessary to get it, then have a look at sablono: https://github.com/r0man/sablono