Factory Failsafe

Factor's error system has three pieces: throw to signal an error, recover to handle one, and ERROR: to define your own kind of error.

throw

throw (in kernel) raises an error. The argument can be any value — a string, a number, or a tuple — and it becomes the error you can later inspect:

! DOCTEST: SKIP
"file not found" throw

throw does not return; the rest of the current word is skipped.

recover

recover (in continuations) is Factor's try/catch. It takes a try quotation and a recovery quotation:

recover ( try recovery -- )

If try finishes without throwing, recovery is ignored. If try throws, the error is pushed onto the stack and recovery is run:

[ "boom" throw ] [ drop "caught" ] recover .
! => "caught"

[ "ok" ] [ drop "never runs" ] recover .
! => "ok"

when from kernel is the natural companion: it runs a quotation only when the top of stack is truthy:

: check-positive ( n -- )
    0 < [ "negative!" throw ] when ;

ERROR:

ERROR: defines a tuple class and a word that constructs a fresh instance and throws it:

! DOCTEST: SKIP
ERROR: not-found path ;

"/missing" not-found
! throws T{ not-found { path "/missing" } }

A no-slot error is just ERROR: name ; — calling name throws an empty instance. Tuples defined with ERROR: carry a class predicate name? you can use to test whether a caught error was of that type.

Reading slots back out

A caught error is just a tuple, so each ERROR: slot comes with the same auto-generated slot>> reader as any other tuple.

! DOCTEST: SKIP
{
    T{ not-found { path "/a" } }
    T{ not-found { path "/b" } }
}
[ path>> ] map .   ! => { "/a" "/b" }