Ah, don’t remember…it does seem a mistake

in fact, it just looks wrong altogether?

unless the multimethod implementation looks for it this way?

possibly, I was looking for a way to clear the state of the chart

No, I think that op is half-baked…it should be building a vector of assign ops, one per k-v pair 😕

the :assign op

(defmethod run-flat-op :assign [all-data {:keys [data]}]
  (reduce-kv
    (fn [acc path value]
      (cond
        (= :ROOT path) value
        (keyword? path) (assoc acc path value)
        (and (vector? path) (= :ROOT (first path))) (assoc-in acc (rest path) value)
        (vector? path) (assoc-in acc path value)
        :else acc))
    all-data
    data))

you’re using the flat data model?

instead of the fulcro one?

(defmethod run-fulcro-data-op! :assign [app processing-env {:keys [data]}]
  (let [session-id (senv/session-id processing-env)
        local-data (get-in @(state-atom app) (local-data-path session-id))
        aliases    (get local-data :fulcro/aliases)]
    (swap! (state-atom app)
      (fn [all-data]
        (reduce-kv
          (fn assign* [acc path value]
            (let [path (resolve-actors-in-path local-data path)]
              (cond
                (= :ROOT path) (assoc-in acc (local-data-path session-id) value)
                (and (sequential? path) (#{:fulcro/state :fulcro/state-map} (first path))) (assoc-in acc (rest path) value)
                (and (keyword? path) (contains? aliases path)) (assign* acc (get aliases path) value)
                (keyword? path) (assoc-in acc (local-data-path session-id path) value)
                (and (vector? path) (= :ROOT (first path))) (assoc-in acc (into (local-data-path session-id) (rest path)) value)
                (vector? path) (assoc-in acc (into (local-data-path session-id) path) value)
                :else acc)))
          all-data
          data)))))

oh wait…it is doing a reduce-kv over the data

I think I'm using the fulcro one then

so if I use :ROOT as path and give it my initial data as value I will have a clear state

Ah, the difference is that assign has an API like assoc, and set-map-ops has an API more like merge….but you are right that there is no need for the vector there

On your :ROOT question, yes, that sounds right

how do you deal with statechart events that require a route change in the UI? for instance I have:

(on :review :state/closed
                            (script-fn [_ {:keys [new-topic-id]}]
                                       (when new-topic-id
                                         (comp/transact! app [(mutations/route-to-topic {:subject-id new-topic-id})]))))

I personally make my own state that forces the route called rstate…didn’t I talk about this already?

yeah you did

rstate stands for routing-state?

Yes

basically

right so you call change-route! in the script-fn (which is actually what my mutation does so I could just get rid of it)

Here’s my thinking: Routing is a globally stateful thing. When you’re on a route that is a singular fact in the entire system. My statechart code relies on the UI being in a particular condition when I’m in a state, then it should be in control of that

Right, but it becomes part of the state not the transition, which is critical IMO

e.g. on-entry of the state

The only caveat is if you use allow route change on targets in DR…then you can break things because the statechart will move to the state, but the route won’t

which is why I’d suggest moving away from DR features like that (side effects on will-enter and denying routing via allow-route-change?). Move all of that logic into the chart, where it belongs and isn’t peppered all over the place 😄

When I wrote DR I was trying to meet immediate needs of users who wanted what it does. But I never much cared for the way it pushes you to program. I’m very rapidly moving towards having statecharts be the primary logic artifacts in my UI. They compose, you can invoke them, they can have parallel regions, etc.

I just haven’t refined my approach enough in real code artifacts to publish anything about it, other than the low-level lilbraries