brg: change in the representation of binders

[helm.git] / helm / software / lambda-delta / basic_rg / brgType.ml

diff --git a/helm/software/lambda-delta/basic_rg/brgType.ml b/helm/software/lambda-delta/basic_rg/brgType.ml
index 0afb9c70b23296968ef722dccb265483d04a89ab..79949a3a745753596a391a32f05f5c07f7ebde4e 100644 (file)
--- a/helm/software/lambda-delta/basic_rg/brgType.ml
+++ b/helm/software/lambda-delta/basic_rg/brgType.ml
@@ -56,8 +56,8 @@ 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 (**)
@@ -65,21 +65,19 @@ let assert_applicability err f st m u w v =
 let rec b_type_of err f st g m x =
    log1 "Now checking" m x;
    match x with
-   | B.Sort (a, h)             ->
+   | 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.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,38 +85,38 @@ 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 = 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) ->
+   | 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
+      let f xu _ = f xu (R.push m a (B.abst xu)) in
       type_of err f st g m u
-   | B.Bind (B.Void a as b, t) ->
+   | 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 g (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)          ->
+   | 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