12:19 <Putonlalla> I have a style question. Suppose I implement a procedure for a data structure, which combines its contract and eliminator. Let us call it `break-ds?`. The intent is that, given some motive `prc` and some value `obj`, the procedure `break-ds?` either returns `#f` if `obj` is not an instance of `ds`, or calls `prc` on the fields of `obj` otherwise.

12:22 <Putonlalla> The problem arises when the motive is boolean. If I want to be able to distinguish failure from a false result, I must either (1) write the contract of `break-ds?` to prohibit returning `#f`, forcing the user to sometimes box their motives, or (2) always box the result, forcing the user to always unbox successful results.

12:22 <Putonlalla> Which approach would you prefer?

12:28 <Putonlalla> Thinking outside the box (and, hence, `box`) by not writing these procedures in the first place is not possible, because they are derived from the corresponding inductive types.

14:14 <Putonlalla> As an example, for lists, these options would result in the contracts (1) `(let ((a (not/c #f))) (-> (-> a) (-> any/c list? a a) any/c (or/c #f a)))` and (2) `(let ((a any/c)) (-> (-> a) (-> any/c list? a a) any/c (or/c #f (box/c a))))`.