As a basic outline of the technique, imagine building a library of simple functions that construct FleetDB queries (which is to say, a combinator library), and then building macros on top of those to make them a bit nicer to use. That's most of what I'd do, except that I'd probably put in two extra abstraction layers:

- A translator for optimizing queries just before they're sent to FleetDB. This may or may not turn out to be helpful, depending on whether FleetDB does its own optimization. Also, this is a bit of a computational complexity rabbit hole, and I'm not sure how I'd begin to approach it. I'd probably just make it extensible so other people could try. :)

- A macro that takes an s-expression DSL and manually walks over it and converts it into calls to the combinator library. This would allow us to use operator names like 'or and '< without redefining Arc's own 'or and '<. This is probably where I can best help you out with a code example:

  (= dsl-macs* (table))
  
  (mac dsl-mac (name parms . body)
    `(= (dsl-macs* ',name) (fn ,parms ,@body)))
  
  (def expand-dsl (expr)
    (if atom.expr
      expr
      (let (op . args) expr
        (aif dsl-macs*.op
          (apply it args)
          expr))))
  
  (mac dsl (expr)
    expand-dsl.expr)
  
  
  ; FleetDB combinator
  (def fleetdb-or args
    (cons "or" args))
  
  ; FleetDB DSL extension using that combinator
  (dsl-mac or args
    `(fleetdb-or ,@(map expand-dsl args)))

  arc> (dsl:or '("<" "foo" 1) (or '("=" "bar" "woof") '(">" "foo" 11))))
  ("or" ("<" "foo" 1) ("or" ("=" "bar" "woof") (">" "foo" 11)))