https://www.youtube.com/watch?v=3HxVMGaiZbc

I think that's the one

Thank you, @UK0810AQ2! I’ve been searching for an hour 😅 Very much appreciate it!

Glad I could help 🙂 Clojurians slack, faster than any search 😉

By sheer luck, I also watched this talk and recognized it immediately from your description

Indeed! I didn’t want to burden others with doing my Googling, but it sure was fast! Haha.

So this was a single youtube search and was the first search result

My search foo is weak, apparently 😅

I swear I have a superpower when it comes to search engines, I manage to always phrase the search just right

david nolen clojurescript mobile

I think it actually did show up in some of my search results, but the content I was looking for was not recognizable until further into the talk, and the title and description of the video did not give me enough hints. And I didn’t recall which persons gave the talk. I was searching for things like “react native clojure mobile app car” etc.

well, if you remember who gave the talk and which talk it was then it's almost cheating 🙃

The lesson of the day for myself: “Don’t persist with “stubborn dumb-mode searching.” Ask the community first.

I bet this will happen to me at least one time, just like when you remember a song as being awesome, send it to someone only to realize it sort of sucks now, but with a conference talk

And the Clojurians community is exceptionally good there

Yeah! It’s like that. When you remember the melody of a song or a fragment of the lyrics but can’t find the music. There’s a song that I’ve had stuck on my mind for nearly two years now. I’ve searched and searched and asked others about it. The fragment of the lyrics is “ooh, calypso, tell me to go…” (that’s all I remember)—And it’s a hoarse and raspy male voice, sort of new-age post-rock-ish music. I only find some songs by John Denver and Mamie Van Doren, but that’s not it. Search engines are not great at searching contents of video and audio yet.

By the way, here is https://youtu.be/3HxVMGaiZbc?t=1094 (it starts at 18:15). It’s where @U050B88UR talks about https://storybook.js.org: > “Conceptually, what it [Storybook] lets you do, is it lets you build your components in total isolation from your application.” He also mentions an analogous tool called “defparts” or “devparse” or something like that. I can’t make out exactly what David is saying due to insufficient audio quality in the recording. I’m interested in learning more about that concept because I work with customer experience designers and user experience designers who are not very technical. It would be fantastic if they could create the user interface elements in pure data structures or maybe a domain-specific language.

> He also mentions an analogous tool called “defparts” or “devparse” or something like that. I can’t make out exactly what David is saying due to insufficient audio quality in the recording. Pretty sure David is referring to “devcards”: https://github.com/bhauman/devcards

And then there is this 🙂 https://twitter.com/bhauman/status/1032329502603530242?lang=en

Thank you, @U01SX4U5LUA and @U031CHTGX1T! Now I have some reading to do. The idea of completely separating the “visual and layout stuff” from the presentation logic and back-end intrigues me, especially if it allows non-technical designers to work on the visual components intuitively, where the artifacts they produced can be versioned alongside any coupled code. Ideally, the visual designers would be able to work in drag-and-drop tools without needing to touch anything resembling code.

Hm?

user=> (seqable? #{})
true

That's odd, I'm getting a non-ISeqable error thrown in my code when I'm using a sorted-set. It must be some other issue.

you might be confusing ISeq and Seqable

sets are not seqs, but they can produce a seq

Possibly. I'll look at my code a bit more.

just like vectors

maybe you think about sequential?

(seqable? (sorted-set)) ;; => true
(seqable? (hash-set)) ;; => true
(sequential? (sorted-set)) ;; => false
(sequential? (hash-set)) ;; => false
(seq? (sorted-set)) ;; => false
(seq? (hash-set)) ;; => false

I found it - the ISequable error was being thrown because of an incorrect variable reference which was returning a nil rather than the sequence I thought I was using.

Sorry for the confusion.

Because of mapcat, maybe you want map instead? Your mapcat function produces maps, but mapcat will map+cat, treating the map as a sequence of items and return the concatenation of that.

(mapcat (fn [[a b]] {:a a :b b}) [[1 2] [1 2] [1 2]])
([:a 1] [:b 2] [:a 1] [:b 2] [:a 1] [:b 2])

which is “concat {:a 1 b 2} {a 1 b 2} …” so it concats the key value entries

Ah, okay. So mapcat applies the map, which produces a hashmap, but then concat calls seq on the result, which turns each hashmap into a seq of entries, and then those are concat'ed into a vector.

concated into a sequence

Right, right.. makes sense. Thank you.

My 10k foot view is that you provide transduce with some lazy sequence, the transform is a set of pure transformations on the sequence, and then the reducing function receives the result and can perform some IO. Does that sum it up well?

I think its better to think about transducers being a function that takes a reducing function and returns a new reducing function. Reducing functions do not have to be pure but can do io, etc

lazy sequence is not required and is just one collection type you can transduce over

If it's not lazy, you still get the benefit of not having to retain the entire set of transformations in memory, yeah? That's basically the point?

Even though it is tempting, I would not start with transduce to understand transducers. into for example might be simpler:

(into [] (filter even?) (range 10))
[0 2 4 6 8]

The idea behind transducers is actually that you don’t care for the sequence itself. Lazy, not lazy, async channels --- it does not matter to the transducer

@U031CHTGX1T I saw that example from the docs but I don't understand how that's supposed to make understanding it any easier. Seems like it just introduces an another abstraction layer into->transducer to explain the transducer.

https://clojure.org/reference/transducers is a good reference. As is (source transduce)

Your mileage might vary. For me, this is helpful be cause the key of a transducer is that it transforms items that “pass through it”. With transduce, you also have to worry about the f parameter 🤷

If you haven’t seen it already, go watch Rich’s talk! https://www.youtube.com/watch?v=6mTbuzafcII

I did watch that one a couple months ago. I should refresh.

Haven't seen "Inside Transducers" yet.

> I think its better to think about transducers being a function that takes a reducing function and returns a new reducing function. So transducers return a new reducing function, which is just the given reducing function with the given transforms applied to its input before it's evaluated? Sound better?

I think this is worse unfortunately. See, a transducer wraps a reducing function. If it calls the wrapped one or not is up to the transducer.

🤕

(map inc) will call the passed reducing function for every item after transforming it

yeah. look at the source of map.

([f]
    (fn [rf]
      (fn
        ([] (rf))
        ([result] (rf result))
        ([result input]
           (rf result (f input)))
        ([result input & inputs]
           (rf result (apply f input inputs))))))

(filter even?) will not call the reducing function for odd items

(remove any?) will never call its reducing function

(filter pred) will also not transform the items themselves

> I think this is worse unfortunately. See, a transducer wraps a reducing function. If it calls the wrapped one or not is up to the transducer. But doesn't this align with my description? You've provided some examples where the transducer transforms the input by excluding some of the members. So the transducer is not "deciding" whether the wrapped function is called, but it is changing the size of the the original input and what ultimately gets to the wrapped function. Is that different from how I described it as: > the given reducing function with the given transforms applied to its input before it's evaluated

The input to a reducing function is each item individually, not the whole sequence, right?

I read your definition as “Transforms values before passing them to the wrapped reducing function”. This describes the map transducer, but not filter

> The input to a reducing function is each item individually, not the whole sequence, right? Hmm :thinking_face: So the transformation receives the entire sequence and hands off individual items to the reducing function. But I guess that's not quite right either. I remember from Rich's luggage handler analogy, the input can be filtered, transformed, and rebundled. So if there's a partition step in there somewhere, the input to the reducing function could be a bundle of the individual items. It's starting to come together for me, I think..

I tried medley/dissoc-in, but I got :

Execution error (ClassCastException) at medley.core/dissoc-in (core.cljc:31).
class clojure.lang.PersistentVector$ChunkedSeq cannot be cast to class clojure.lang.IPersistentMap (clojure.lang.PersistentVector$ChunkedSeq and clojure.lang.IPersistentMap are in unnamed module of loader 'app')

Seqs are not associative

So you cannot dissoc from them, nested or otherwise

You can remove from them, though!

(remove #{"A"} (list 1 "A" "B" "C" "A"))
;; => (1 "B" "C")

Maybe

(defn dissoc-in-val
  [m path value]
  (let [map-value (get-in m path)]
    (if (coll? map-value)
      (let [without-value (remove #{value} map-value)]
        (if (empty? without-value)
          (medley/dissoc-in m path)
          (assoc-in m path without-value)))
      (medley/dissoc-in m path))))

i'm not sure what OO Language you are referring to

>>> def a():
...     print("...")
...
>>> a()
...
>>> b = a()
...
>>> b
>>> print(b)
None
>>> type(b)
<class 'NoneType'>
>>>

for dynamic languages "no return is implicitly null return" is pretty common

similar yes - in lisps (clojure included) the last form evaluation result is implicitly the return value of the function being called if that evals to nil, that's like 'false' or 'undefined' in most other langs, although clojure has false and nil (moved from non-thread to thread, my bad)

I think the last time I saw something like that was with Objective-C

The answer here is “no”. Some languages have “void” as a return type for a side-effecting operation. That's not possible in Clojure, so you get the result of the last statements. io operations like println will return nil which may be where this question came from? But that can't be relied on. There are also legitimate reasons to return nil: it can be returned from a function that would typically return something else, and can indicate a missing value, an empty structure, a falsey value, and so on