Merge input nodes into resulted map about plumbing

[hozumi]

Thank you for explanation.

Because I currently use my fork which solved #3 , unfortunately the suggested code does not work for me in the situation described in #3 .

I think that as input nodes is also node, to include them in result map seems natural and harmless.
To make no distinction between input nodes and normal nodes has additional benefit.
A caller could intercept an intermediate node by feeding the node as input.

(def lazy-stat
  (graph/lazy-compile {:a (pl/fnk [] 1)
                       :b (pl/fnk [a] a)
                       :c (pl/fnk [b] b)}))
(:c (lazy-stat {:b 2}))
; => 2  (imaginary result)

But I don't know internal details and tradeoff, so don't be mind.
Thanks.

[w01fe]

Unless you have a strong argument for this, I don't think we'll change the default behavior. But you can easily achieve this by wrapping your compiled graph with a higher-order function:

user> (require '[plumbing.graph :as graph] '[plumbing.core :as plumbing] '[plumbing.map :as map] '[plumbing.fnk.pfnk :as pfnk])
nil
user> (defn merge-inputs [f]
  (pfnk/fn->fnk
   (fn [m] (merge m (f m)))
   [(pfnk/input-schema f)
    (merge (pfnk/output-schema f)
           (map/keep-leaves identity (pfnk/input-schema f)))]))
#'user/merge-inputs
user> (def merged-lazy-stat (merge-inputs (graph/lazy-compile {:a (plumbing/fnk [x] (+ x 1))})))
#'user/merged-lazy-stat
user> (merged-lazy-stat {:x 3})
{:a 4, :x 3}

You could even make your own compile functions that do this automatically, if that's what you want:

(def my-lazy-compile (comp merge-inputs graph/lazy-compile))

(Feel free to use this code however you wish.) Does this satisfy your need?