X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Flambda-delta%2Fbasic_rg%2FbrgType.ml;h=728e3ff416e75c0e2322b65c65b11fa1a2cc4a24;hb=f2771b346a41445df23adb6acccd7ee6b1578666;hp=a35a9c32afe3ca657bd381a1586c359cc3d5f40b;hpb=cd798346d31b14b8947e5801b87dc4f363607862;p=helm.git

diff --git a/helm/software/lambda-delta/basic_rg/brgType.ml b/helm/software/lambda-delta/basic_rg/brgType.ml
index a35a9c32a..728e3ff41 100644
--- a/helm/software/lambda-delta/basic_rg/brgType.ml
+++ b/helm/software/lambda-delta/basic_rg/brgType.ml
@@ -50,86 +50,82 @@ let message3 m t1 t2 ?mu t3 =
 let error3 err m t1 t2 ?mu t3 =
    err (message3 m t1 t2 ?mu t3)
 
-let assert_convertibility err f ~si m u w v =
-   let err _ = error3 err m v w u in
-   R.are_convertible err f ~si m u m w 
+let assert_convertibility err f st m u w v =
+   if R.are_convertible st m u m w then f () else
+   error3 err m v w u
 
-let assert_applicability err f ~si m u w v =
-   let f mu = function
-      | B.Sort _                  -> error1 err "not a function type" m u
-      | B.Bind (B.Abst (_, u), _) -> 
-         let err _ = error3 err m v w ~mu u in 
-         R.are_convertible err f ~si mu u m w
-      | _                         -> assert false
-   in
-   R.xwhd f m u 
+let assert_applicability err f st m u w v =
+   match R.xwhd st m u with 
+      | _, B.Sort _                 -> error1 err "not a function type" m u
+      | mu, B.Bind (_, B.Abst u, _) -> 
+         if R.are_convertible st mu u m w then f () else
+	 error3 err m v w ~mu u
+      | _                         -> assert false (**)
 
-let rec b_type_of err f ~si g m x =
+let rec b_type_of err f st g m x =
    log1 "Now checking" m x;
    match x with
-   | B.Sort (a, h)             ->
-      let f h = f x (B.Sort (a, h)) in H.apply f g h
-   | B.LRef (_, i)             ->
-      let f = function
-         | B.Abst (_, w)                ->
-	    S.lift (f x) (succ i) (0) w
-	 | B.Abbr (_, B.Cast (_, w, _)) -> 
-	    S.lift (f x) (succ i) (0) w
-	 | B.Abbr _                     -> assert false
-	 | B.Void _                     -> 
+   | B.Sort (a, h)           ->
+      let h = H.apply g h in f x (B.Sort (a, h)) 
+   | B.LRef (_, i)           ->
+      begin match R.get m i with
+         | B.Abst w                  ->
+	    f x (S.lift (succ i) (0) w)
+	 | B.Abbr (B.Cast (_, w, _)) -> 
+	    f x (S.lift (succ i) (0) w)
+	 | B.Abbr _                  -> assert false
+	 | B.Void                    -> 
 	    error1 err "reference to excluded variable" m x
-      in
-      let err _ = error1 err "reference to unknown variable" m x in
-      R.get err f m i
-   | B.GRef (_, uri)           ->
-      let f = function
+      end
+   | B.GRef (_, uri)         ->
+      begin match E.get_entity uri with
          | _, _, Y.Abst w                  -> f x w
 	 | _, _, Y.Abbr (B.Cast (_, w, _)) -> f x w
 	 | _, _, Y.Abbr _                  -> assert false
-      in
-      let err _ = error1 err "reference to unknown entry" m x in
-      E.get_entity err f uri   
-   | B.Bind (B.Abbr (a, v), t) ->
+	 | _, _, Y.Void                    ->
+            error1 err "reference to unknown entry" m x
+      end
+   | B.Bind (a, B.Abbr v, t) ->
       let f xv xt tt =
          f (A.sh2 v xv t xt x (B.bind_abbr a)) (B.bind_abbr a xv tt)
       in
-      let f xv m = b_type_of err (f xv) ~si g m t in
-      let f xv = R.push (f xv) m (B.abbr a xv) in
+      let f xv m = b_type_of err (f xv) st g m t in
+      let f xv = f xv (R.push m a (B.abbr xv)) in
       let f xv vv = match xv with 
 	 | B.Cast _ -> f xv
          | _        -> f (B.Cast ([], vv, xv))
       in
-      type_of err f ~si g m v
-   | B.Bind (B.Abst (a, u), t) ->
+      type_of err f st g m v
+   | B.Bind (a, B.Abst u, t) ->
       let f xu xt tt =
 	 f (A.sh2 u xu t xt x (B.bind_abst a)) (B.bind_abst a xu tt)
       in
-      let f xu m = b_type_of err (f xu) ~si g m t in
-      let f xu _ = R.push (f xu) m (B.abst a xu) in
-      type_of err f ~si g m u
-   | B.Bind (B.Void a as b, t) ->
+      let f xu m = b_type_of err (f xu) st g m t in
+      let f xu _ = f xu (R.push m a (B.abst xu)) in
+      type_of err f st g m u
+   | B.Bind (a, B.Void, t)   ->
       let f xt tt = 
-         f (A.sh1 t xt x (B.bind b)) (B.bind b tt)
+         f (A.sh1 t xt x (B.bind_void a)) (B.bind_void a tt)
       in
-      let f m = b_type_of err f ~si g m t in
-      R.push f m b   
-   | B.Appl (a, v, t)          ->
+      b_type_of err f st g (R.push m a B.Void) t
+         
+   | B.Appl (a, v, t)        ->
       let f xv vv xt tt = 
          let f _ = f (A.sh2 v xv t xt x (B.appl a)) (B.appl a xv tt) in
-         assert_applicability err f ~si m tt vv xv
+         assert_applicability err f st m tt vv xv
       in
-      let f xv vv = b_type_of err (f xv vv) ~si g m t in
-      type_of err f ~si g m v
-   | B.Cast (a, u, t)          ->
+      let f xv vv = b_type_of err (f xv vv) st g m t in
+      type_of err f st g m v
+   | B.Cast (a, u, t)        ->
       let f xu xt tt =  
 	 let f _ = f (A.sh2 u xu t xt x (B.cast a)) xu in
-         assert_convertibility err f ~si m xu tt xt
+         assert_convertibility err f st m xu tt xt
       in
-      let f xu _ = b_type_of err (f xu) ~si g m t in
-      type_of err f ~si g m u
+      let f xu _ = b_type_of err (f xu) st g m t in
+      type_of err f st g m u
 
 (* Interface functions ******************************************************)
 
-and type_of err f ?(si=false) g m x =
+and type_of err f st g m x =
    let f t u = L.unbox level; f t u in
-   L.box level; b_type_of err f ~si g m x
+   L.box level; b_type_of err f st g m x