Well, here's the idea, which I've sketched up as a blob of untested and sorta-idealistic Arc. I'm using dynamic variables to simulate a "fail" parameter, but it's not quite as simple as it might sound. Until now, I didn't know it was possible; in fact, the strategy I'm using wouldn't cooperate with similar parameter-simulating frameworks. There are two tricks:

Since the surrounding language is full of fail-unaware "muggle" functions, I have to set up those variables inside the function implementation (for when a failure parameter isn't provided), as well as sometimes outside the function whenever the fail parameter is supposed to be passed.

If we stopped there, then if we failcalled a muggle function, any failure-aware functions it called would think we were failcalling them. To avoid that, we use our second trick: In 'failcall, we test the function to see whether it's fail-aware first, and if it's not, we don't set up the dynamic parameters. The catch is that it may not be easy to "test the function" this way; it depends on whether the underlying language supports 'defcall or weak sets. Here, I'll pretend the language has weak set support. (Using this framework probably invalidates 'defcall anyway, since ideally, you'd be able to 'defcall something so that it was fail-aware. That said, this weak set approach may work quite well with a 'defcall that coerces to 'fn.... Wow, unexpected 'coerce niftiness.)

There's one other thing to note: In my Penknife draft, [failfn fail [a b c] ...] and [failfn* fail [a b c] rest ...] are the most basic kinds of function syntax, but one of these "fail" parameters isn't actually the fail parameter the function was called with; instead, it's an escape continuation that calls the given fail parameter instead of continuing with the function. In my experience with Lathe's rulebooks, this continuation-handling is less efficient than explicit branching in each rule, but I'm glad to sacrifice a little efficiency here. :)

Okay, here's the code. (Remember, it's untested!) Insert your own varieties of dynamic parameters and weak sets:

  ; This branches to a different strategy when a continuation is called.
  ; Note that it's a pretty significant performance bottleneck.
  (def fn-onpoint (alternate body)
    (let (called result)
           (catch:list nil (body:fn args (throw:list t args)))
      (if called
        result
        (apply alternate result))))
  
  (mac onpoint (point alternate . body)
    `(fn-onpoint ,alternate (fn (,point) ,main)))
  
  
  (defdynamic fail* nil)
  (defdynamic failcalling* nil)
  (= fail-awares* (make-weak-set))
  
  (def failcall (func fail . args)
    (if (mem fail fail-awares*)
      (onpoint throw fail
        (w/dynamic (failcalling* t fail* throw)
          (apply func args)))))
  
  (def failable-wrapper (inner-func)
    (ret result (afn args
                  (if failcalling*
                    (w/dynamic (failcalling* nil)
                      (apply inner-func args))
                    ; The default failure is 'err.
                    (apply failcall self err args)))
      (push result fail-awares*)))
  
  
  ; Make partial functions using this.
  ; TODO: Make number-of-argument errors into failures.
  (mac failfn (fail parms . body)
    (w/uniq g-return
      `(failable-wrapper:fn ,parms
         ; We wrap the failures up in a value that should be easy to
         ; pretty-print (whenever we get around to writing such a
         ; pretty-printer).
         (onpoint ,fail [fail*:annotate 'function-failure
                          (list '(failfn ,fail ,parms ,@body) ,_)]
           ; The value of 'fail* shouldn't be used after this point,
           ; but we don't enforce that.
           ,@body))))
  
  ; This is an exception. I don't think it can be implemented without
  ; using 'failable-wrapper directly.
  (= fail-aware-apply (failable-wrapper:fn (func . args)
                        (apply apply func args)))
  
  
  (def fn-ifsuccess (func args then else)
    (failcall else (failfn fail ()
                     (then:apply failcall func fail args))))
  
  ; TODO: See if ssyntax should be supported.
  (mac ifsuccess (success failure (func . args) then . elses)
    `(fn-ifsuccess ,func (list ,@args) (fn (,success) ,then)
                                       (fn (,failure) (if ,@elses))
  
  (def failcall-cases (cases fail wrap-details collected-details . args)
    (ifdecap (case . rest) cases
      (ifsuccess success failure (fail-aware-apply case args)
        success
        (apply failcall-cases
          rest fail (cons failure collected-details) args))
      (fail wrap-details.collect-details)))
  
  
  ; Without further ado, here's one way to explicitly set up a generic
  ; function.
  
  (= fact-cases* nil)
  (= fact (failfn fail args
            (apply failcall-cases fact-cases*
              ; We wrap the failures up in a value that should be easy
              ; to pretty-print (whenever we get around to writing such
              ; a pretty-printer).
              [annotate 'rulebook-failure (list 'fact _)]
              fail nil args)))
  
  (push (failable-wrapper:failfn fail (n)
          (* n (fact:- n 1)))
        fact-cases*)
  
  (push (failable-wrapper:failfn fail (n)
          (unless (is n 0)
            (fail "The number wasn't 0."))
          1)
        fact-cases*)