is there a way to make cursive repl use the user namespace by default instead of my-app.core?

Is there something like elixirs Enum.take/2

elixir 
iex> Enum.take([1, 2, 3], 2)
[1, 2]

Take

thanks

😁

Interesting that Elixir's argument order is coll, n as opposed to n, coll which feels like it reads better to me: "take n elements of coll"...

i think because of pipe operator they choosed coll first so it can be coll |> Enum.take(2) |> other_func()

That works like ->?

Whereas Clojure has (->> coll (take 2)) -- and distinguishes between sequence functions (sequence last) and collection functions (type-preserving, collection first)

For example (subvec [1 2 3] 0 2)

yes it's similiar to -> gets previous functions result as first argument

and (conj [1 2] 3), (conj #{1 2} 3)

Whereas (cons 1 [1 2]) -- calls seq on the argument and also returns a sequence.

@juan.ignacio848 what is that app in you phone that has cljs repl

Replete I think?

(Replete is what I use on my phone to try stuff out)

Yes, replete

thanks 🙂

It's available for Android and iOS

i like it thank you for teaching me this @seancorfield

When folks are learning Clojure, they often wonder why some functions seem to take the "collection" first and others take it last -- but it is pretty consistent once you understand the difference between collection (has a type: vector, list, set, hash map, queue, etc) and a sequence (an abstraction that provides elements in order -- sequentially -- even for collections that have no specified order such as sets and hash maps).

(and the various "sequence functions" can accept a collection because they call seq on it first -- which means they can accept anything that is seqable?, which includes things like strings etc)

https://clojure.org/guides/faq#arg_order

Hey strangers! 👋 I’m pretty new to Clojure and have been having a hard time finding a readable and/or idiomatic way to create a nested map from two ranges. You can map or for or merge or reduce. Any suggestions? The most readable so far has been:

(def rows 2)
(def cols 3)
(def val "")

(apply merge-with merge
  (for [row (range rows)
         col (range cols)]
    {row {col val}}))

(defn value-for-row
  [cols]
  (->> cols
       range
       (map #(hash-map % value))
       (into {})))

(->> rows
     range
     (map #(hash-map % (value-for-row cols)))
     (into {}))

given the way the rows are constructed, you can just use into {} instead of apply merge-with merge

also I would replace #(hash-map % value) with (fn [x] {x value})

but in this context youo can use [x value] as well (and I'd argue that's more direct / idiomatic as entries in a map are special two-element vectors)

I do like pairs for indices, but you lose certain kinds of queries unless you use a sorted map

(def rows 2)
(def cols 3)
(def val "")


((apply comp
        (for [row (range rows)
              col (range cols)]
          #(assoc-in % [row col] val)))
 {})

that's reduce through squinted eyes there

and i would never have thought of that

oh yeah, for sure I would write the reduce version without thinking about it, and have over and over again. I was reaching for something novel, and it superficially is, but I wish I had some cool way to get rid of that for

not readable at all:

(def rows 2)
(def cols 3)
(def val "")

((->> (range (* rows cols))
      (map (juxt #(mod % rows) #(mod % cols)))
      (map (fn [entry] #(assoc-in % entry val)))
      (apply comp))
 {})

That’s art

Someone knows how to remove theses warnings from react?

Warning: componentWillMount has been renamed, and is not recommended for use. See  for details.

i suppose they appeared when i upgrade react package version

@papachan are you using reagent?