Coder Social home page Coder Social logo

om.core/update-state! about om HOT 4 CLOSED

omcljs avatar omcljs commented on July 17, 2024
om.core/update-state!

from om.

Comments (4)

gdeer81 avatar gdeer81 commented on July 17, 2024

Did you have something like this in mind?

first we define a function that applies a state transition function to the state

(defn apply-trans-fun
  "Applies the transition function to the state and returns the updated state"
  [state trans-fun]
  (trans-fun state))

then we reduce the state with our application function

(defn update-state!
  "Updates the state by applying all transition functions in order."
  [state trans-funs]
  (reduce apply-trans-fun state trans-funs))

This isn't analogous to set-state! so I'll study the set-state! function to see if I can come up with something better

from om.

swannodette avatar swannodette commented on July 17, 2024

om.core/update-state! is really more about being idiomatic. It's more idiomatic to take some state and do some functional operations on it and return a value over banging on it several times in succession. I was thinking about something more analogous to cljs.core/update-in

from om.

pbostrom avatar pbostrom commented on July 17, 2024

Would swap! be a better analogy? Something like

(defn swap-state!
  "Takes a pure owning component and sets the state of the component to be:
   (apply f current-state args)."
  ([owner f]
    (allow-reads
      (let [props  (.-props owner)
            state  (.-state owner)
            cursor (aget props "__om_cursor")
            path   (-path cursor)
            pstate (or (aget state "__om_pending_state")
                       (aget state "__om_state"))]
        (aset state "__om_pending_state" (f pstate))
        ;; invalidate path to component
        (if (empty? path)
          (swap! (-state cursor) clone)
          (swap! (-state cursor) update-in path clone)))))
  ([owner f x]
    (swap-state! owner #(f % x)))
  ([owner f x y]
    (swap-state! owner #(f % x y)))
  ([owner f x y & args]
    (swap-state! owner #(apply f % x y args))))

;; Usage: 
(om/swap-state! owner assoc :foo 1 :bar 2)

I tested this out, it seems to work pretty well. I suppose we might want to enforce an invariant that the new state is always a map. I'm open to any other suggestions.

from om.

swannodette avatar swannodette commented on July 17, 2024

fixed 4405497

from om.

Related Issues (20)

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.