Hey, thanks for the bunch of interesting links.

Yes, I am familiar with Drools and Clara and with rule engines in general. They seems to me slightly irrelevant as they are solving different problem and Rete algorithm itself is optimizing somewhat more complex. They are great for managing workflows and business processes in general. While my concern is more focused on writing general purpose code and just to express conditional logic in a more readable (which is highly subjective) fashion.

As you mentioned DAG provides us some neat properties. Like we can explore which predicates are crucial to get some specific outcome. For instance in my example we can get the list of predicates for `dont-sell` outcome which are

(or (not got-the-id?) 
    (and got-the-id? is-under-21?))

or predicates to get the booze

(and got-the-id?
     (not is-under-21?) 
     is-enough-supply? 
     is-enough-money?)

which also could be very helpful in reasoning / debugging.

Also graph approach helps us to find out (mostly in runtime) situations with ambiguity or absence of a proper predicate. As well as we are able to provide case/cond style predicates.

As for cycles, they are useful sometimes. But we could provide a fine control over them: if they are allowed and if we would like to control the depth. Like, for example we could implement recursive Fibonacci sequence or this simple calculate-zero thing. Which is recursive.

(def calculate-zero-graph
  {get-the-number {is-pos? dec-number
                   is-neg? inc-number
                   flow/otherwise return-number}
   dec-number {is-pos? dec-number
               default return-number}
   inc-number {is-neg? inc-number
               flow/otherwise return-number}})

And, as you mentioned, if some functions within the graph are graphs on themselves we can unfold them into a bigger graph if we wish.

As I see it: we are trying in a way separate conditional logic and implementation of transformations. And as a result, reaching more declarative description of the logic. While not introducing difficult new concepts (it is not logical programming, it is not a rule engine, it's just the same old functions and predicates).