Clojurians Log v2

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

Watch all Rich Hickey talks.

Thanks a lot

Thanks Sean and Rakyi, I read Rich’s explanation and couldn’t quite follow the train of thought. How does “sequences being read from left and being fed from right” along with the "sequence functions like map, filter and having variadic args" influence the choice of having the sequence as the last arg?

Particularly why does “sequences being read from left and being fed from right” influence (map f sequence) , (filter pred sequence) not being (map sequence f) , (filter sequence pred). We could still chain them the same way we do it for other collections (-> sequence (map f) (filter f)) .

Oh okay maybe it is this bit "partial allows for direct parameterization as above" that majorly affected this decision. But I rarely do something like this ((partial map inc) '(1 2)). Can't think of many sequence functions that have more than one arg before the source.

I think I need some clojure regex help. I'd like to remove a pattern of characters toward the end of a string. For example "persons name ABC12345" would return "persons name". If there is a space after the in the string the pattern would not be removed. I've been experimenting with re-seq, replace and re-pattern but havent found the right regex. Also, any good articles on using boundaries in regex would be useful, as I suspect defining boundaries might help

Hi! If I want to concat 3 items: 1. A simple hash map {:url url :label "Previous"} 2. A vector of hash maps [{:url (str url item) :label (str item)}{:url (str url item) :label (str item)}...] return by a for loop 3. A simple hash map {:url url :label "Previous"} Is there a better way - more idiomatic - to do this than to surround simple maps with a vector like I do now?

(let [previous-link {:url url :label "Previous"}
      links (for [item (range 1 (inc page-number))]
              {:url (str url item) :label (str item)})
      next-link {:url url :label "Next"}]
  (concat [previous-link] links [next-link]))

(defn something [s] 
   (if-let [match (re-matches #"^(persons name) *\S+" s)]
     (second match)
     s))

(something "persons name *ABC12345") => "persons name"
(something "persons name * ABC12345") => "persons name * ABC12345"

Pretty sure it can be done more succinctly using a better capturing group and re-find

Not really better or more idiomatic than what you have here,

(flatten [previous-link links next-link])

What would've been idiomatic is to have something like

(->> some-list
     (cons el2)
     (push el3))

Perfect @kslvsunil, thanks. I prefer your flatten solution that mine. 👍

how do I do get the same result as (rest (rest something)) without looking so stupid? 😄

(nthrest something 2)

user=> (def something [1 2 3 4 5 6 7 8])
#'user/something
user=> (rest (rest something))
(3 4 5 6 7 8)
user=> (nthrest something 2)
(3 4 5 6 7 8)

This <https://clojuredocs.org/clojure.core/nthrest> talks about it more detail, in particular the difference between nthrest and drop, with drop being lazy.

Thanks <3

and another thing I've been trying to solve for a while but can't do it, is there a way to get rid of the duplication in this macro code:

(if docstring
  `(rum/defc
     ~sym
     ~docstring
     ~'< reactive
     ~@body
  `(rum/defc
     ~sym
     ~'< reactive
     ~@body))

well after spending another 30 min on this I feel stupid...

(let [definition `(rum/defc
                    ~sym
                    ~'< reactive
                    ~@body)]
  (if docstring
    (concat 
      (take 2 definition)
      [docstring]
      (drop 2 definition))
    definition))

How can I transform this structure in the flat vector of vectors, without loosing the inner vectors and the order? [[[1 2 3]][[12 13 14][10 50 60]]]

the "else" above is (identity %). My imagination fails me: how will that be different than %? Otherwise, your approach seems fine.

In a world like Common Lisp where sort is destructive we could use when sorter sort X knowing X will either get sorted or sail on untroubled as is, but not so with clojure.

(->> [[[1 2 3]] [[12 13 14] [10 50 60]]]
      flatten
      (partition-all 3))

(this would return a lazy sequence)

for variable size vectors

(defn my-flatten 
  [coll] 
  (filter (comp number? first) 
          (tree-seq (fn [[x :as c]] 
                        (and (sequential? c) 
                             ((complement number?) x))) 
                    seq
                    coll)))

;; (my-flatten [[[1 2]][[12 13 14][10 50 60 70]] [] [[[[1]]]]])
;; => ([1 2] [12 13 14] [10 50 60 70] [1])

@kslvsunil A lot of those sequence functions have transducer-producing arities: (map f), (filter pred) etc.

As you get more familiar with Clojure, this argument ordering will start to make more sense and you’ll come to understand what Rich means.

Okay Sean. But transducers were introduced much later. Will probably have to reread the motive a few times.

Those transducer arities were only possible because of the argument ordering conventions.

Yeah, very interesting. Can’t imagine transducers composing easily without this arg ordering of sequence functions. Not sure if it was extreme foresight or if we just got lucky. :)

Or more like a good design decision allowing the easy evolution and birth of transducers

The goal is to transform to a flat vector like this, [[1 2 3] [12 13 14] [10 50 60]] but it can’t be partitioned , because there be can be varied maps instead of numbers. Aren’t there simpler solutions eg with zipmap?

user=> (into [] cat [[[1 2 3]] [[12 13 14] [10 50 60]]])
[[1 2 3] [12 13 14] [10 50 60]]

doesn't work for deeply nested elements, 2 levels is the max

Yes, if the input sequence has deeper nesting, that won't work. The original question doesn't say anything about that, though.

true, it's just for me the deep nesting is in the context of flatten

also unintended behavior for vectors on the first level

(into [] cat [[3 4 5] [6 [7]]])
=> [3 4 5 6 [7]]

Whether it's unintended depends on what you need. 🙂

Hi, can someone help to transform a async/await js example into cljs? I use shadow-cljs, installed an npm package and required it in a namespace (package beckhoff-js https://www.npmjs.com/package/beckhoff-js ). The example is:

const AdsClient = require('beckhoff-js');

const options = {
  target: {
    host: "172.16.21.6",
    netID: "5.9.36.191.1.1",
    amsPort: 801
  }
};

const client = new AdsClient.default(options);
client
  .connect()
  .then(async () => {
    // Read a tag
    const bTest = await client.readTag(".bTest");
    console.log('bTest value is', bTest);
  });

(ns app
  (:require [reagent.core :as r]
            [reagent.dom :as rdom]
            ["beckhoff-js" :as adsclient]))

(comment

  (def client (adsclient/default. #js{:target #js{:host "127.0.0.1" :netID "172.26.0.1.1.1" :amsPort 851}}))

  (.connect client)) 

Does what I was looking for. There’s little documentation on the cap function. What does it do?

Actually I should have used (apply concat coll), works as well