Certified Programming with Dependent Types: src/Subset.v comparison

comparison src/Subset.v @ 471:51a8472aca68

Batch of changes based on proofreader feedback

author	Adam Chlipala <adam@chlipala.net>
date	Mon, 08 Oct 2012 16:04:49 -0400
parents	b36876d4611e
children	d9e1fb184672

comparison

equal deleted inserted replaced

-:0df6dde807ab
+:51a8472aca68
 The term [zgtz pf] fails to type-check.  Somehow the type checker has failed to take into account information that follows from which [match] branch that term appears in.  The problem is that, by default, [match] does not let us use such implied information.  To get refined typing, we must always rely on [match] annotations, either written explicitly or inferred.
 In this case, we must use a [return] annotation to declare the relationship between the _value_ of the [match] discriminee and the _type_ of the result.  There is no annotation that lets us declare a relationship between the discriminee and the type of a variable that is already in scope; hence, we delay the binding of [pf], so that we can use the [return] annotation to express the needed relationship.
-We are lucky that Coq's heuristics infer the [return] clause (specifically, [return n > 0 -> nat]) for us in this case. *)
+We are lucky that Coq's heuristics infer the [return] clause (specifically, [return n > 0 -> nat]) for us in the definition of [pred_strong1], leading to the following elaborated code: *)
 Definition pred_strong1' (n : nat) : n > 0 -> nat :=
 match n return n > 0 -> nat with
 | O => fun pf : 0 > 0 => match zgtz pf with end
 | S n' => fun _ => n'
 | O -> assert false (* absurd case *)
 | S n' -> n'
 </pre># *)
 (** The proof argument has disappeared!  We get exactly the OCaml code we would have written manually.  This is our first demonstration of the main technically interesting feature of Coq program extraction: proofs are erased systematically.
+%\medskip%
 We can reimplement our dependently typed [pred] based on%\index{subset types}% _subset types_, defined in the standard library with the type family %\index{Gallina terms!sig}%[sig]. *)
 (* begin hide *)
 (* begin thide *)
 (** %\vspace{-.15in}% [[
 Inductive sumbool (A : Prop) (B : Prop) : Set :=
 left : A -> {A} + {B} | right : B -> {A} + {B}
 ]]
-We can define some notations to make working with [sumbool] more convenient. *)
+Here, the constructors of [sumbool] have types written in terms of a registered notation for [sumbool], such that the result type of each constructor desugars to [sumbool A B].  We can define some notations of our own to make working with [sumbool] more convenient. *)
 Notation "'Yes'" := (left _ _).
 Notation "'No'" := (right _ _).
 Notation "'Reduce' x" := (if x then Yes else No) (at level 50).
 (** As with our other maximally expressive [pred] function, we arrive at quite simple output values, thanks to notations. *)
 (** * Monadic Notations *)
-(** We can treat [maybe] like a monad%~\cite{Monads}\index{monad}\index{failure monad}%, in the same way that the Haskell <<Maybe>> type is interpreted as a failure monad.  Our [maybe] has the wrong type to be a literal monad, but a "bind"-like notation will still be helpful. *)
+(** We can treat [maybe] like a monad%~\cite{Monads}\index{monad}\index{failure monad}%, in the same way that the Haskell <<Maybe>> type is interpreted as a failure monad.  Our [maybe] has the wrong type to be a literal monad, but a "bind"-like notation will still be helpful.  %Note that the notation definition uses an ASCII \texttt{<-}, while later code uses (in this rendering) a nicer left arrow $\leftarrow$.% *)
 Notation "x <- e1 ; e2" := (match e1 with
 | Unknown => ??
 | Found x _ => e2
 end)
 m2 <- pred_strong7 n2;
 [|(m1, m2)|]); tauto.
 Defined.
 (* end thide *)
-(** We can build a [sumor] version of the "bind" notation and use it to write a similarly straightforward version of this function.  %The operator rendered here as $\longleftarrow$ is noted in the source as a less-than character followed by two hyphens.% *)
+(** We can build a [sumor] version of the "bind" notation and use it to write a similarly straightforward version of this function.  %Again, the notation definition exposes the ASCII syntax with an operator \texttt{<-{}-}, while the later code uses a nicer long left arrow $\longleftarrow$.% *)
 Notation "x <-- e1 ; e2" := (match e1 with
 | inright _ => !!
 | inleft (exist x _) => e2
 end)
 eq_type_dec t1 TBool;;;
 eq_type_dec t2 TBool;;;
 [||TBool||]
 end); clear F; crush' tt hasType; eauto.
-(** We clear [F], the local name for the recursive function, to avoid strange proofs that refer to recursive calls that we never make.  The [crush] variant %\index{tactics!crush'}%[crush'] helps us by performing automatic inversion on instances of the predicates specified in its second argument.  Once we throw in [eauto] to apply [hasType_det] for us, we have discharged all the subgoals. *)
+(** We clear [F], the local name for the recursive function, to avoid strange proofs that refer to recursive calls that we never make.  Such a step is usually warranted when defining a recursive function with [refine].  The [crush] variant %\index{tactics!crush'}%[crush'] helps us by performing automatic inversion on instances of the predicates specified in its second argument.  Once we throw in [eauto] to apply [hasType_det] for us, we have discharged all the subgoals. *)
 (* end thide *)
 Defined.

Mercurial > cpdt > repo

comparison src/Subset.v @ 471:51a8472aca68