        [:h2 "Use any function as a reactive value"]
 
        [:p [:code "reagent.core/track"] " takes a function, and
-       optional arguments for that function, and returns an
-       ”atom-like” value that can be derefed, and gives whatever is
+       optional arguments for that function, and gives a
+       derefable (i.e ”atom-like”) value, containing whatever is
        returned by that function. If the tracked function depends on a
        Reagent atom, the function is called again whenever that atom
        changes – just like a Reagent component function. If the value

  (:people @app-state))

(defn person-keys []
  (let [m @(r/track people)]
    (keys m)))

(defn person [id]
  (let [m @(r/track people)]
    (get m id)))

(defn name-comp [id]
  (let [p @(r/track person id)]

                                        :name-list])}]

       [:p "Here, the " [:code "name-list"] " component will only be
       re-rendered if the keys of the " [:code ":people"] " map
       changes. Every " [:code "name-comp"] " only renders again when
       needed, etc."]

       [:p "Use of " [:code "track"] " can improve performance in
       three ways:" ]

       [:ul
        [:li "It can be used as a cache for an expensive function,
        that is automatically updated if that function depends on Reagent
        atoms (or other tracks, cursors, etc)."]

        [:li "It can also be used to limit the number of times a
        component is re-rendered. The user of " [:code "track"] " is
        only updated when the function’s result changes. In other
        words, you can use track as a kind of generalized, read-only
        cursor."]

        [:li "Every use of " [:code "track"] " with the same arguments
        will only result in one execution of the function. E.g the two
        uses of " [:code "@(r/track people)"] " in the example above
        will only result in one call to the " [:code "people"] "
        function (both initially, and when the state atom changes)."]]

       ])]])

