X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Flambda-delta%2Fbasic_rg%2FbrgType.ml;h=8b119e5e25aa165cabc483a3ad48faf13aa11295;hb=2b1375e4b44e2ef351a6341a5bb0a4823e8daae5;hp=0afb9c70b23296968ef722dccb265483d04a89ab;hpb=2e451dca46e509fd7e7772f3d2e438c189ce10a1;p=helm.git

diff --git a/helm/software/lambda-delta/basic_rg/brgType.ml b/helm/software/lambda-delta/basic_rg/brgType.ml
index 0afb9c70b..8b119e5e2 100644
--- a/helm/software/lambda-delta/basic_rg/brgType.ml
+++ b/helm/software/lambda-delta/basic_rg/brgType.ml
@@ -56,30 +56,28 @@ let assert_convertibility err f st m u w v =
 
 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), _) -> 
+      | _, 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 st g m x =
+let rec b_type_of err f st 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)                ->
+   | B.Sort (a, h)           ->
+      let h = H.apply 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, _)) -> 
+	 | B.Abbr (B.Cast (_, w, _)) -> 
 	    f x (S.lift (succ i) (0) w)
-	 | B.Abbr _                     -> assert false
-	 | B.Void _                     -> 
+	 | 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)           ->
+      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
@@ -87,47 +85,47 @@ let rec b_type_of err f st g m x =
 	 | _, _, Y.Void                    ->
             error1 err "reference to unknown entry" m x
       end
-   | B.Bind (B.Abbr (a, v), t) ->
+   | 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) st g m t in
-      let f xv = f xv (R.push m (B.abbr a xv)) in
+      let f xv m = b_type_of err (f xv) st 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 st g m v
-   | B.Bind (B.Abst (a, u), t) ->
+      type_of err f st 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) st g m t in
-      let f xu _ = f xu (R.push m (B.abst a xu)) in
-      type_of err f st g m u
-   | B.Bind (B.Void a as b, t) ->
+      let f xu m = b_type_of err (f xu) st m t in
+      let f xu _ = f xu (R.push m a (B.abst xu)) in
+      type_of err f st 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
-      b_type_of err f st g (R.push m b) t
+      b_type_of err f st (R.push m a B.Void) t
          
-   | B.Appl (a, v, 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 st m tt vv xv
       in
-      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 xv vv = b_type_of err (f xv vv) st m t in
+      type_of err f st 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 st m xu tt xt
       in
-      let f xu _ = b_type_of err (f xu) st g m t in
-      type_of err f st g m u
+      let f xu _ = b_type_of err (f xu) st m t in
+      type_of err f st m u
 
 (* Interface functions ******************************************************)
 
-and type_of err f st g m x =
+and type_of err f st m x =
    let f t u = L.unbox level; f t u in
-   L.box level; b_type_of err f st g m x
+   L.box level; b_type_of err f st m x