Hi gang! I was having trouble earlier getting React to work in Figwheel with the new native :npm-deps options, but I got it all sorted out thanks to some help from @spinningtopsofdoom and @tiagoantao . I documented how to make it work; hopefully it will help somebody else if they run into the process is not defined error: https://ajpierce.github.io/posts/react-figwheel-npm/ Thanks for the help, everybody 🙂

hello! looking for a shove in the right direction. I am trying to do this codewars kata: Collatz Conjecture https://www.codewars.com/kata/collatz-conjecture-3n-plus-1 here is my code so far:

(ns clojure.collatz)

(defn hotpo [n]
  (loop [m n, count 0]
    (when (> m 1)
      (recur 
        (cond
           (even? m) (int (/ m 2))
           :else (int (+ (* m 3) 1)))
        (+ count 1)))))

change the when into if, and put count as the third form in the if

you return from a loop by having a form that doesn't end in a recursion

Hi, Someone share the code to use FlatList example ?

@noisesmith sorry i don't follow, what do you mean by: > put count as the third form in the if ?

(when false :hi) will return nil. but (if (> m 1) (recur for collatz) count) will return the count if the collatz procedure has finally reduced the number to 1

the when form returns nil when the predicate fails. But your predicate is "do i need to reduce some more". if not, you need to return the count

so use an if expression rather than a when

@dpsutton @noisesmith got it, thanks!

👍

so now my function looks like this:

(defn hotpo [n]
  (loop [m n, val 0]
    (if (> m 1)
      (recur 
        (cond
           (even? m) (int (/ m 2))
           :else (int (+ (* m 3) 1)))
        (+ val 1))
      val)))

@rorysmith I like to put the short option first, which in this case means flipping the sense of the boolean, so something like

So if we’re done, we return val immediately. Otherwise, the rest of the code is all talking about the “else” clause, so there’s less confusion about where the “if” ends and the “else” begins.

Hey, I have kind of a dumb question, think I'm missing something obvious. Can anyone tell me what's wrong with this?

=> (let [m {:n {}}] (update m :n merge-with + {:a 1}))
IllegalArgumentException contains? not supported on type: clojure.core$_PLUS_  clojure.lang.RT.contains (RT.java:829)

@timgilbert What you wrote: (update m :n #(merge-with % + {:a 1})) what you want: (update m :n #(merge-with + % {:a 1}))

Aha! Thanks @rauh

I am doing an exercise where I have to create a function which takes in a sequence and returns a sequence of all possible rotations.

The code works as expected but I find it messy. Is there any way to improve this ?

output is something like this

(rotations [1 2 3]) ;=> ((1 2 3) (2 3 1) (3 1 2))

Here's the exercise: http://iloveponies.github.io/120-hour-epic-sax-marathon/recursion.html#exercise-18

Is there anyway I can club that code into a single function ? I couldn't come up with a base condition for single function so I used count.

you can make it one function with multiple arities

also fyi you can replace '() with () - it’s unambiguous so the reader accepts it

of course '(()) still needs quoting

(defn rotations ([s] (rotations s (count s))) ([s count] ...)) is the general form of the multiple arity version

ah, I didn't know I could use ( ) without quoting. That's interesting!

@noisesmith I am not familiar with the concept of arities yet. I will look that up. Thanks 🙂 . I am going by the course I linked. It hasn't introduced arities yet.

it’s the same code you have already, both functions have the same name, they are distinct by argument count

and they are in the same defn body

I have no idea what arities are. I will look that up first. Thank you @noisesmith

Is it common to write recursive functions the way I wrote it in case I don't have a natural base condition or just use arities instead ?

@retrazil “arity” is a fancy word for “number of arguments”

@retrazil the common way is to use distinct arities, but the logic looks the same

Is this what you mean @noisesmith ?

I think I got you 🙂

if that runs, you got it right

haha

yes it runs lol

this is interesting

@noisesmith how can i use a function local to the function i am in? i tried using let but it seems you can't do the same thing as with defn. for example, can't i just put the first-letter and last-letter functions inside the generate-band-name function to avoid having to pass noun into them?

(defn first-letter [noun] (subs noun 0 1))

(defn last-letter [noun]
  (def length (count noun))  
  (subs noun 
    (dec length)
    length))
    
(defn generate-band-name [noun]
  (if (= (first-letter noun) (last-letter noun))
    (clojure.string/capitalize (str noun (subs noun 1)))
    (str "The " (clojure.string/capitalize noun))))

yes, you can put them in there in a let

(defn generate-band-name [noun]
  (let [first-letter (fn first-letter [] ...)
        last-letter (fn last-letter [] ...)]
    ...)

also don’t use def inside defn, that’s the primary purpose of let

and like defn, def only creates namespace level bindings, it doesn’t create locals

i see

it was the syntax that tripped me up

the name inside fn is optional, but makes stack traces more readable

ok, i was just about to ask about that 🙂

@rorysmith @noisesmith Hey you can also use letfn

(defn foo [& args]
  (letfn [(bar [x] ...)
          (baz 
            ([] ...)
            ([x y]))]
    (->> args
         bar
         (baz 1))))

yes, that’s true

oh neat!

but let is more flexible since you will usually end up wanting to bind local data too

letfn is great for when two functions each need to call the other though

eg. for trampoline

(probably no longer in #beginners territory on that note)

@rorysmith but as @noisesmith said don’t you def or defn insisde of themselves these forms are side effects (they modify the namespace) you are better of with letand letfn

got it :thumbsup:

@noisesmith I didn’t know letfn lets you use the function as if they were declared before hand. Nice.

@rorysmith Just FYI, you can call first and last directly on a string, so (first noun) and (last noun) will work. Note: last operates in linear time!

thanks, i missed that!

I believe that (get noun (dec (count noun))) would be the constant time equivalent to (last noun) -- just in case you care about performance enough (for long band names!).

(took me a while to trace through the source there but String implements CharSequence so (count noun) is (.length noun) and (get noun n) is (.charAt noun n) under the hood)

@seancorfield is there a place that can tell you the time complexity of some things oin clojure? or just knowing the source code?