Clojurians Log v2

That's an interesting way of getting around it, feels slightly hacky but understandable due to the nature of EDN literals

Going a step further for programmer safety I guess it should be possible to detect when "undefined behavior" like that is happening (same memory var being used in separate branches of a map/set literal, excluding &) and flag it as an error

the example above might be contrived but I imagine it could happen with a big record-like map pattern and everything appearing to work fine until the 9th key is introduced

sounds good, I'll create a GH issue to track it :)

actually it's still a little confusing - here's a simpler case where memory vars currently fall apart:

(m/rewrite [:a [1 2 3] :b [4 5]]
  [!k [!n ...] ...]
  [!k [!n ...] ...])
;; => [:a [1 2 3 4 5]]

how would I use the hypothetical &scope construct to retain the nesting associations and rewrite back to the same data on the RHS?

They don’t fall apart, you just need more of them 🙂

(m/rewrite [:a [1 2 3] :b [4 5]]
  [!k [!x ..!n] ..!m]
  [!k [!x ..!n] ..!m])
;; => [:a [1 2 3] :b [4 5]]

My plan was to let you be able to just do ..! without naming them and make it all work out. I had an implementation, but never finished it and got it in.

ahh, more undocumented syntax 😮

I’m shocked that didn’t get documented. My bad. I will start writing the documentation right this moment.

And I will throw in some & documentation.

Thanks!

Not comprehensive, but hopefully it is a start. https://github.com/noprompt/meander/pull/98

I do apologize of the lack of documentation on things like this. I need to sit down and write a comprehensive tutorial. But there is honestly just a lot. It is hard to remember what got documented and what didn’t. It is also just hard to document. It is more like learning a language than learning a library. Libraries are typically not too hard to document, but libraries require a different approach. I also need to finish my in browser meander evaluator so we can have an interactive cookbook that anyone can contribute to.

I apologize as well. I’m almost always busy with work, family, or something due to this project and documentation frequently slips my mind or doesn’t get priority.

I will also admit that it often takes me a bit of time to write articles because I have to focus really hard to organize my thoughts into words.

I really appreciate all the lively, thoughtful discussion from everyone. 🙂

Thank you!

OMG I’m such an idiot… the “lost information” is completely solved by the ..!n

That is the associative information

I can easily reconstruct it from that

That was the motivation for it. 🙃 I just forgot to mention it. 😂

Ok so good news and bad news, the good news is I have coded a way to construct the “inferred associativity of nested repeats” or whatever you want to call them, the bad news is now I’m going to start wanting to use these in substitutions. Here is my code:

(defn kvseq
  "Recursively convert a map to key/value pairs."
  [m]
  (for [[k v] m]
    [k (cond-> v (map? v) (kvseq))]))

(kvseq
 {1 {:en "one", :de "eins", :fr "un"}
  2 {:en "two", :de "zwei", :fr "deux" :es "dos"}
  3 {:en "three", :de "drei", :fr "trois"}
  5 {:fr "cinq"}})
#_#_=>
 ([1 ([:en "one"] [:de "eins"] [:fr "un"])]
  [2 ([:en "two"] [:de "zwei"] [:fr "deux"] [:es "dos"])]
  [3 ([:en "three"] [:de "drei"] [:fr "trois"])]
  [5 ([:fr "cinq"])])

(defn associations*
  "Not intended to be called directly, prefer using associations.
  Takes a sequence of outer rows"
  [result outer-rows inner-rows partitions]
  (if (seq outer-rows)
    (let [[outer-row & os] outer-rows
          [n & ns] partitions
          [inner-chunk is] (split-at n inner-rows)
          rows (for [inner-row inner-chunk]
                 (into outer-row inner-row))]
      (recur (concat result rows) os is ns))
    result))

(defn transpose
  "Given a sequence of columns, returns a sequence of rows, or vice versa."
  [seq-of-seqs]
  (apply map vector seq-of-seqs))

(defn seqable-of-seqables?
  [x]
  (and (seqable? x)
       (every? seqable? x)))

(defn associations
  "Takes sequences of outer values to be associated with sequences of inner values as rows by partitions.
  Rows are vectors of associated values.
  Given outer sequences ([1 2]),
  inner sequences ([:one :un :two :deux]),
  and partitions [2 2]
  Produces ([:one 1] [:un 1] [:two 2] [:deux 2])
  Suitable for converting memory variable notation into row notation.
  [!xs [!ys ..!ns] ...]
  (associations [!xs] [!ys] !ns)
  Can take layers of inners and partitions.
  [!xs [!ys [!zs ..!ms] ..!ns] ...]
  (associations [!xs] [!ys] !ns [!zs] !ms)
  => ([x y z] [x y z] [x y z] ...)
  By aligning inner and outer values, we define their relationship.
  This is often useful for deriving other logically consistent nested forms,
  For example {!xs... {!ys... !vs...}} -> rows -> {!ys... {!xs... !vs...}}
  Note that in this case, !ys and !vs are at the same level:
  (associations [!xs] [!ys !vs] !ns)
  => ([x y v] [x y v] [x y v] ...)"
  [outers & inner-partitions]
  {:pre [(even? (count inner-partitions))
         (seqable-of-seqables? outers)]}
  (loop [rows (transpose outers)
         ips inner-partitions]
    (if ips
      (let [[is ps & m] ips]
        (assert (seqable-of-seqables? is))
        (assert (= (count ps) (count rows)))
        (assert (seqable? ps))
        (assert (every? int? ps))
        (let [inner-rows (transpose is)]
          (assert (= (reduce + ps) (count inner-rows)))
          (recur (associations* () rows inner-rows ps)
                 m)))
      rows)))

(associations [[1 2]] [[:one :un :two :deux]] [2 2])
#_#_=> ([1 :one] [1 :un] [2 :two] [2 :deux])

(associations [[1 2]]
              [[:one :un :two :deux]] [2 2]
              [["ae1" "be1" "af1" "bf1" "ae2" "be2" "af2" "bf2"]] [2 2 2 2])
#_#_=>
    ([1 :one "ae1"]
     [1 :one "be1"]
     [1 :un "af1"]
     [1 :un "bf1"]
     [2 :two "ae2"]
     [2 :two "be2"]
     [2 :deux "af2"]
     [2 :deux "bf2"])

(def data {:en {1 "one", 2 "two", 3 "three"},
           :de {1 "eins", 2 "zwei", 3 "drei"},
           :fr {1 "un", 2 "deux", 3 "trois", 5 "cinq"},
           :es {4 "cuatro"}})

(m/match (kvseq data)
         ([!lang ([!num !word] ..!n)] ...)
         (associations [!lang] [!num !word] !n))
#_#_=>
    ([:en 1 "one"]
     [:en 2 "two"]
     [:en 3 "three"]
     [:de 1 "eins"]
     [:de 2 "zwei"]
     [:de 3 "drei"]
     [:fr 1 "un"]
     [:fr 2 "deux"]
     [:fr 3 "trois"]
     [:fr 5 "cinq"]
     [:es 4 "cuatro"])

(defn nest-by [order rows]
  (reduce
   (fn [acc ordered-row]
     (assoc-in acc (butlast ordered-row) (last ordered-row)))
   {}
   (for [row rows]
     (mapv row order))))

(nest-by [1 0 2]
         [[:en 1 "one"]
          [:en 2 "two"]
          [:en 3 "three"]
          [:de 1 "eins"]
          [:de 2 "zwei"]
          [:de 3 "drei"]
          [:fr 1 "un"]
          [:fr 2 "deux"]
          [:fr 3 "trois"]
          [:fr 5 "cinq"]
          [:es 4 "cuatro"]])
#_#_=>
    {1 {:en "one", :de "eins", :fr "un"},
     2 {:en "two", :de "zwei", :fr "deux"},
     3 {:en "three", :de "drei", :fr "trois"},
     5 {:fr "cinq"},
     4 {:es "cuatro"}}

(def data {:en {1 "one", 2 "two", 3 "three"},
           :de {1 "eins", 2 "zwei", 3 "drei"},
           :fr {1 "un", 2 "deux", 3 "trois", 5 "cinq"},
           :es {4 "cuatro"}})

(m/match (kvseq data)
         ([!lang ([!num !word] ..!n)] ...)
         (->> (associations [!lang] [!num !word] !n)
              (nest-by [1 0 2])))
=>
{1 {:en "one", :de "eins", :fr "un"},
 2 {:en "two", :de "zwei", :fr "deux"},
 3 {:en "three", :de "drei", :fr "trois"},
 5 {:fr "cinq"},
 4 {:es "cuatro"}}

:party-corgi:

Main things this proves to me: 1. Memory variables can capture the implied associativity of nested repeats (or whatever it’s called). 2. I think the concept of rows helps as an intermediary substrate when transforming between different orders of nesting 3. Creating a new nesting for maps is just assoc-in choosing the path and value from the rows in a different order 4. This is a general approach that works for arbitrary nestings of arbitrary participation (not just maps)

But the main drawback is of course that I had to write a lot of non-meander helper code. I think it is worth a quick review of why I needed them: