From 2d38e0eba268d5d5673059a48eb0fd34b8044416 Mon Sep 17 00:00:00 2001
From: Jacob Kim <jpoly1219@gmail.com>
Date: Fri, 1 Mar 2024 11:35:22 -0500
Subject: [PATCH 01/17] run ana tests

---
 test/hazelnut_test.re | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/hazelnut_test.re b/test/hazelnut_test.re
index ed930a9..df5cfae 100644
--- a/test/hazelnut_test.re
+++ b/test/hazelnut_test.re
@@ -6,5 +6,6 @@ let () =
     [
       ("erase_exp", Test_erase_exp.erase_exp_tests),
       ("syn", Test_syn.syn_tests),
+      ("ana", Test_ana.ana_tests),
     ],
   );

From 859386cb377f856fa11fbc85761664662b0aa76c Mon Sep 17 00:00:00 2001
From: Jacob Kim <jpoly1219@gmail.com>
Date: Fri, 1 Mar 2024 11:35:29 -0500
Subject: [PATCH 02/17] add ana test cases

---
 test/Test_ana.re | 68 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)
 create mode 100644 test/Test_ana.re

diff --git a/test/Test_ana.re b/test/Test_ana.re
new file mode 100644
index 0000000..d12c1dd
--- /dev/null
+++ b/test/Test_ana.re
@@ -0,0 +1,68 @@
+open Alcotest;
+module Hazelnut = Hazelnut_lib.Hazelnut;
+
+module TypCtx = Map.Make(String);
+type typctx = Hazelnut.TypCtx.t(Hazelnut.Htyp.t);
+
+let test_asubsume_1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let he: Hazelnut.Hexp.t = Lit(1);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let given: bool = Hazelnut.ana(ctx, he, ht);
+  let expected: bool = false;
+  check(bool, "same bool", given, expected);
+};
+
+let test_asubsume_2 = () => {
+  let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
+  let he: Hazelnut.Hexp.t = Var("x");
+  let ht: Hazelnut.Htyp.t = Num;
+  let given: bool = Hazelnut.ana(ctx, he, ht);
+  let expected: bool = true;
+  check(bool, "same bool", given, expected);
+};
+
+let test_asubsume_3 = () => {
+  let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Arrow(Num, Num));
+  let he: Hazelnut.Hexp.t = Var("x");
+  let ht: Hazelnut.Htyp.t = Hole;
+  let given: bool = Hazelnut.ana(ctx, he, ht);
+  let expected: bool = true;
+  check(bool, "same bool", given, expected);
+};
+
+let test_alam_1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let he: Hazelnut.Hexp.t = Lam("x", Plus(Lit(1), Lit(2)));
+  let ht: Hazelnut.Htyp.t = Arrow(Arrow(Num, Num), Num);
+  let given: bool = Hazelnut.ana(ctx, he, ht);
+  let expected: bool = true;
+  check(bool, "same bool", given, expected);
+};
+
+let test_alam_2 = () => {
+  let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
+  let he: Hazelnut.Hexp.t = Lam("f", Plus(Var("x"), Lit(2)));
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let given: bool = Hazelnut.ana(ctx, he, ht);
+  let expected: bool = true;
+  check(bool, "same bool", given, expected);
+};
+
+let test_alam_3 = () => {
+  let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Arrow(Num, Num));
+  let he: Hazelnut.Hexp.t = Lam("f", Plus(Var("x"), Lit(2)));
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let given: bool = Hazelnut.ana(ctx, he, ht);
+  let expected: bool = false;
+  check(bool, "same bool", given, expected);
+};
+
+let ana_tests = [
+  ("test_asubsume_1", `Quick, test_asubsume_1),
+  ("test_asubsume_2", `Quick, test_asubsume_2),
+  ("test_asubsume_3", `Quick, test_asubsume_3),
+  ("test_alam_1", `Quick, test_alam_1),
+  ("test_alam_2", `Quick, test_alam_2),
+  ("test_alam_3", `Quick, test_alam_3),
+];

From 6de9fe168a5f910a17605f349afc5cc7c4187a54 Mon Sep 17 00:00:00 2001
From: Jacob Kim <jpoly1219@gmail.com>
Date: Fri, 1 Mar 2024 15:30:38 -0500
Subject: [PATCH 03/17] add ppx_deriving.show as dependency

---
 Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index c30b2a1..b65e599 100644
--- a/Makefile
+++ b/Makefile
@@ -17,7 +17,7 @@ clean:
 	dune clean
 
 deps:
-	opam install dune reason incr_dom ocaml-lsp-server
+	opam install dune reason incr_dom ocaml-lsp-server ppx_deriving
 
 .PHONY: test
 test:

From 28042685712056bbcc534274e54c38b6826482c4 Mon Sep 17 00:00:00 2001
From: Jacob Kim <jpoly1219@gmail.com>
Date: Fri, 1 Mar 2024 15:30:50 -0500
Subject: [PATCH 04/17] using ppx_deriving.show

---
 hazelnut/dune | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/hazelnut/dune b/hazelnut/dune
index 98e0ea8..dda838e 100644
--- a/hazelnut/dune
+++ b/hazelnut/dune
@@ -2,4 +2,4 @@
  (name hazelnut_lib)
  (libraries core incr_dom monad_lib)
  (preprocess
-  (pps ppx_jane)))
+  (pps ppx_jane ppx_deriving.show)))

From 6d35393244d29cd4fb541fb9dcca3ca9428c3169 Mon Sep 17 00:00:00 2001
From: Jacob Kim <jpoly1219@gmail.com>
Date: Fri, 1 Mar 2024 15:31:10 -0500
Subject: [PATCH 05/17] make types printable

---
 hazelnut/hazelnut.re  | 8 ++++----
 hazelnut/hazelnut.rei | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/hazelnut/hazelnut.re b/hazelnut/hazelnut.re
index 3113d9f..2eb4ce9 100644
--- a/hazelnut/hazelnut.re
+++ b/hazelnut/hazelnut.re
@@ -5,7 +5,7 @@ let compare_string = String.compare;
 let compare_int = Int.compare;
 
 module Htyp = {
-  [@deriving (sexp, compare)]
+  [@deriving (sexp, compare, show({with_path: false}))]
   type t =
     | Arrow(t, t)
     | Num
@@ -13,7 +13,7 @@ module Htyp = {
 };
 
 module Hexp = {
-  [@deriving (sexp, compare)]
+  [@deriving (sexp, compare, show({with_path: false}))]
   type t =
     | Var(string)
     | Lam(string, t)
@@ -26,7 +26,7 @@ module Hexp = {
 };
 
 module Ztyp = {
-  [@deriving (sexp, compare)]
+  [@deriving (sexp, compare, show({with_path: false}))]
   type t =
     | Cursor(Htyp.t)
     | LArrow(t, Htyp.t)
@@ -34,7 +34,7 @@ module Ztyp = {
 };
 
 module Zexp = {
-  [@deriving (sexp, compare)]
+  [@deriving (sexp, compare, show({with_path: false}))]
   type t =
     | Cursor(Hexp.t)
     | Lam(string, t)
diff --git a/hazelnut/hazelnut.rei b/hazelnut/hazelnut.rei
index f74011d..b12f8bd 100644
--- a/hazelnut/hazelnut.rei
+++ b/hazelnut/hazelnut.rei
@@ -1,5 +1,5 @@
 module Htyp: {
-  [@deriving (sexp, compare)]
+  [@deriving (sexp, compare, show({with_path: false}))]
   type t =
     | Arrow(t, t)
     | Num
@@ -7,7 +7,7 @@ module Htyp: {
 };
 
 module Hexp: {
-  [@deriving (sexp, compare)]
+  [@deriving (sexp, compare, show({with_path: false}))]
   type t =
     | Var(string)
     | Lam(string, t)
@@ -20,7 +20,7 @@ module Hexp: {
 };
 
 module Ztyp: {
-  [@deriving (sexp, compare)]
+  [@deriving (sexp, compare, show({with_path: false}))]
   type t =
     | Cursor(Htyp.t)
     | LArrow(t, Htyp.t)
@@ -28,7 +28,7 @@ module Ztyp: {
 };
 
 module Zexp: {
-  [@deriving (sexp, compare)]
+  [@deriving (sexp, compare, show({with_path: false}))]
   type t =
     | Cursor(Hexp.t)
     | Lam(string, t)

From c213bb701f51e76058f37b6f5e7c12e7b3101a17 Mon Sep 17 00:00:00 2001
From: Jacob Kim <jpoly1219@gmail.com>
Date: Fri, 1 Mar 2024 15:31:27 -0500
Subject: [PATCH 06/17] run ana_action tests

---
 test/hazelnut_test.re | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/hazelnut_test.re b/test/hazelnut_test.re
index df5cfae..4e8f29e 100644
--- a/test/hazelnut_test.re
+++ b/test/hazelnut_test.re
@@ -7,5 +7,6 @@ let () =
       ("erase_exp", Test_erase_exp.erase_exp_tests),
       ("syn", Test_syn.syn_tests),
       ("ana", Test_ana.ana_tests),
+      ("ana_action", Test_ana_action.ana_action_tests),
     ],
   );

From 9ca5850f332ad1533a6af47a5fdbd15356d818e3 Mon Sep 17 00:00:00 2001
From: Jacob Kim <jpoly1219@gmail.com>
Date: Fri, 1 Mar 2024 15:31:37 -0500
Subject: [PATCH 07/17] add ana_action test cases

---
 test/Test_ana_action.re | 212 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 212 insertions(+)
 create mode 100644 test/Test_ana_action.re

diff --git a/test/Test_ana_action.re b/test/Test_ana_action.re
new file mode 100644
index 0000000..e8c9583
--- /dev/null
+++ b/test/Test_ana_action.re
@@ -0,0 +1,212 @@
+open Alcotest;
+open Test_interface;
+module Hazelnut = Hazelnut_lib.Hazelnut;
+
+module TypCtx = Map.Make(String);
+type typctx = Hazelnut.TypCtx.t(Hazelnut.Htyp.t);
+
+let test_aamove_1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(Lam("f", Plus(Lit(1), Lit(2))));
+  let a: Hazelnut.Action.t = Move(Child(One));
+  let ht: Hazelnut.Htyp.t = Num;
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(Lam("f", Cursor(Plus(Lit(1), Lit(2)))));
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_aamove_2 = () => {
+  let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
+  let ze: Hazelnut.Zexp.t = Cursor(Ap(Lam("f", Lit(1)), Var("x")));
+  let a: Hazelnut.Action.t = Move(Child(Two));
+  let ht: Hazelnut.Htyp.t = Num;
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(RAp(Lam("f", Lit(1)), Cursor(Var("x"))));
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_aamove_3 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =
+    RAsc(Lam("f", Lit(1)), Cursor(Arrow(Num, Num)));
+  let a: Hazelnut.Action.t = Move(Parent);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(Cursor(Asc(Lam("f", Lit(1)), Arrow(Num, Num))));
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_aadel_1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =
+    RAsc(Lam("f", Lit(1)), Cursor(Arrow(Num, Num)));
+  let a: Hazelnut.Action.t = Del;
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(RAsc(Lam("f", Lit(1)), Cursor(Hole)));
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_aadel_2 = () => {
+  let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
+  let ze: Hazelnut.Zexp.t =
+    RAsc(Lam("f", Plus(Lit(1), Var("x"))), RArrow(Num, Cursor(Num)));
+  let a: Hazelnut.Action.t = Del;
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      RAsc(Lam("f", Plus(Lit(1), Var("x"))), RArrow(Num, Cursor(Hole))),
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_aaconasc_1 = () => {
+  let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
+  let ze: Hazelnut.Zexp.t = Cursor(Var("x"));
+  let a: Hazelnut.Action.t = Construct(Asc);
+  let ht: Hazelnut.Htyp.t = Num;
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(RAsc(Var("x"), Cursor(Num)));
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_aaconasc_2 = () => {
+  let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Arrow(Num, Num));
+  let ze: Hazelnut.Zexp.t = Cursor(Var("x"));
+  let a: Hazelnut.Action.t = Construct(Asc);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(RAsc(Var("x"), Cursor(Arrow(Num, Num))));
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_aaconvar_1 = () => {
+  let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Arrow(Num, Num));
+  let ze: Hazelnut.Zexp.t = Cursor(EHole);
+  let a: Hazelnut.Action.t = Construct(Var("x"));
+  let ht: Hazelnut.Htyp.t = Num;
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) = Some(NEHole(Cursor(Var("x"))));
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_aaconvar_2 = () => {
+  let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
+  let ze: Hazelnut.Zexp.t = Cursor(EHole);
+  let a: Hazelnut.Action.t = Construct(Var("x"));
+  let ht: Hazelnut.Htyp.t = Num;
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) = Some(Cursor(Var("x")));
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_aaconlam1_1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(EHole);
+  let a: Hazelnut.Action.t = Construct(Lam("x"));
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) = Some(Lam("x", Cursor(EHole)));
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_aaconlam1_2 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(EHole);
+  let a: Hazelnut.Action.t = Construct(Lam("x"));
+  let ht: Hazelnut.Htyp.t = Arrow(Hole, Hole);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) = Some(Lam("x", Cursor(EHole)));
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_aaconlam2_1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(EHole);
+  let a: Hazelnut.Action.t = Construct(Lam("x"));
+  let ht: Hazelnut.Htyp.t = Num;
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(NEHole(RAsc(Lam("x", EHole), LArrow(Cursor(Hole), Hole))));
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_aaconlam2_2 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(EHole);
+  let a: Hazelnut.Action.t = Construct(Lam("y"));
+  let ht: Hazelnut.Htyp.t = Num;
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(NEHole(RAsc(Lam("y", EHole), LArrow(Cursor(Hole), Hole))));
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_aaconnumlit_1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(EHole);
+  let a: Hazelnut.Action.t = Construct(Lit(1));
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) = Some(NEHole(Cursor(Lit(1))));
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_aaconnumlit_2 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(EHole);
+  let a: Hazelnut.Action.t = Construct(Lit(-1));
+  let ht: Hazelnut.Htyp.t = Num;
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) = Some(Cursor(Lit(-1)));
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_aafinish_1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(NEHole(Plus(Lit(1), Lit(1))));
+  let a: Hazelnut.Action.t = Finish;
+  let ht: Hazelnut.Htyp.t = Num;
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(Cursor(Plus(Lit(1), Lit(1))));
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_aafinish_2 = () => {
+  let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
+  let ze: Hazelnut.Zexp.t =
+    Cursor(NEHole(NEHole(Lam("f", Plus(Var("x"), Var("x"))))));
+  let a: Hazelnut.Action.t = Finish;
+  let ht: Hazelnut.Htyp.t = Hole;
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) = None;
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let ana_action_tests = [
+  ("test_aamove_1", `Quick, test_aamove_1),
+  ("test_aamove_2", `Quick, test_aamove_2),
+  ("test_aamove_3", `Quick, test_aamove_3),
+  ("test_aadel_1", `Quick, test_aadel_1),
+  ("test_aadel_2", `Quick, test_aadel_2),
+  ("test_aaconasc_1", `Quick, test_aaconasc_1),
+  ("test_aaconasc_2", `Quick, test_aaconasc_2),
+  ("test_aaconvar_1", `Quick, test_aaconvar_1),
+  ("test_aaconvar_2", `Quick, test_aaconvar_2),
+  ("test_aaconlam1_1", `Quick, test_aaconlam1_1),
+  ("test_aaconlam1_2", `Quick, test_aaconlam1_2),
+  ("test_aaconlam2_1", `Quick, test_aaconlam2_1),
+  ("test_aaconlam2_2", `Quick, test_aaconlam2_2),
+  ("test_aaconnumlit_1", `Quick, test_aaconnumlit_1),
+  ("test_aaconnumlit_2", `Quick, test_aaconnumlit_2),
+  ("test_aafinish_1", `Quick, test_aafinish_1),
+  ("test_aafinish_2", `Quick, test_aafinish_2),
+];

From 19cc06ee7fe017d1a1e7bbea72a8343f56d19bc9 Mon Sep 17 00:00:00 2001
From: Jacob Kim <jpoly1219@gmail.com>
Date: Fri, 1 Mar 2024 15:32:11 -0500
Subject: [PATCH 08/17] print corresponding types instead of static string

---
 test/test_interface.re | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/test/test_interface.re b/test/test_interface.re
index a42f442..b0de586 100644
--- a/test/test_interface.re
+++ b/test/test_interface.re
@@ -4,7 +4,7 @@ module Hazelnut = Hazelnut_lib.Hazelnut;
 let hexp_eq = (he1: Hazelnut.Hexp.t, he2: Hazelnut.Hexp.t): bool =>
   Hazelnut.Hexp.compare(he1, he2) == 0;
 
-let hexp_print = (_: Hazelnut.Hexp.t): string => "hexp";
+let hexp_print = (e: Hazelnut.Hexp.t): string => Hazelnut.Hexp.show(e);
 
 let hexp_typ = testable(Fmt.using(hexp_print, Fmt.string), hexp_eq);
 
@@ -18,8 +18,24 @@ let htyp_eq =
 
 let htyp_print = (ht: option(Hazelnut.Htyp.t)): string =>
   switch (ht) {
-  | Some(_) => "htyp"
+  | Some(t) => Hazelnut.Htyp.show(t)
   | _ => "None"
   };
 
 let htyp_typ = testable(Fmt.using(htyp_print, Fmt.string), htyp_eq);
+
+let zexp_eq =
+    (ze1: option(Hazelnut.Zexp.t), ze2: option(Hazelnut.Zexp.t)): bool =>
+  switch (ze1, ze2) {
+  | (Some(e1), Some(e2)) => Hazelnut.Zexp.compare(e1, e2) == 0
+  | (None, None) => true
+  | _ => false
+  };
+
+let zexp_print = (ze: option(Hazelnut.Zexp.t)): string =>
+  switch (ze) {
+  | Some(e) => Hazelnut.Zexp.show(e)
+  | _ => "None"
+  };
+
+let zexp_typ = testable(Fmt.using(zexp_print, Fmt.string), zexp_eq);

From 49babe3f6f2a1c57ae175f1425f60bbee234a69f Mon Sep 17 00:00:00 2001
From: Jacob Kim <jpoly1219@gmail.com>
Date: Wed, 20 Mar 2024 23:40:30 -0400
Subject: [PATCH 09/17] run syn_action tests

---
 test/hazelnut_test.re | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/hazelnut_test.re b/test/hazelnut_test.re
index 4e8f29e..0b044ca 100644
--- a/test/hazelnut_test.re
+++ b/test/hazelnut_test.re
@@ -7,6 +7,7 @@ let () =
       ("erase_exp", Test_erase_exp.erase_exp_tests),
       ("syn", Test_syn.syn_tests),
       ("ana", Test_ana.ana_tests),
+      ("syn_action", Test_syn_action.syn_action_tests),
       ("ana_action", Test_ana_action.ana_action_tests),
     ],
   );

From 5b33bb46e4b404baf3b137c8fa3ffd62d5a9123b Mon Sep 17 00:00:00 2001
From: Jacob Kim <jpoly1219@gmail.com>
Date: Wed, 20 Mar 2024 23:40:43 -0400
Subject: [PATCH 10/17] add interface for running syn_action tests

---
 test/test_interface.re | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/test/test_interface.re b/test/test_interface.re
index b0de586..8c187b9 100644
--- a/test/test_interface.re
+++ b/test/test_interface.re
@@ -39,3 +39,17 @@ let zexp_print = (ze: option(Hazelnut.Zexp.t)): string =>
   };
 
 let zexp_typ = testable(Fmt.using(zexp_print, Fmt.string), zexp_eq);
+
+let zexp_htyp_eq = (ze_t1: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)), ze_t2: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t))): bool => 
+  switch (ze_t1,ze_t2) {
+    | (Some((e1,t1)),Some((e2,t2))) => Hazelnut.Zexp.compare(e1, e2) == 0 && Hazelnut.Htyp.compare(t1, t2) == 0
+    | _ => false
+  };
+  
+let zexp_htyp_print = (ze_t: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t))): string =>
+  switch (ze_t) {
+  | Some((e, _)) => Hazelnut.Zexp.show(e); // have to show both somehow
+  | _ => "None"
+  };
+
+let zexp_htyp = testable(Fmt.using(zexp_htyp_print, Fmt.string), zexp_htyp_eq);

From 6a823ee570e8585c73afee677daecbbba0ba5251 Mon Sep 17 00:00:00 2001
From: Jacob Kim <jpoly1219@gmail.com>
Date: Wed, 20 Mar 2024 23:40:56 -0400
Subject: [PATCH 11/17] add syn_action tests

---
 test/Test_syn_action.re | 141 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 141 insertions(+)
 create mode 100644 test/Test_syn_action.re

diff --git a/test/Test_syn_action.re b/test/Test_syn_action.re
new file mode 100644
index 0000000..799ad65
--- /dev/null
+++ b/test/Test_syn_action.re
@@ -0,0 +1,141 @@
+open Alcotest;
+open Test_interface;
+module Hazelnut = Hazelnut_lib.Hazelnut;
+
+module TypCtx = Map.Make(String);
+type typctx = Hazelnut.TypCtx.t(Hazelnut.Htyp.t);
+
+let test_sadel_1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(Lit(1));
+  let t: Hazelnut.Htyp.t = Num;
+  let a: Hazelnut.Action.t = Del; 
+  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
+    Some((Cursor(EHole), Hole));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_saconasc_1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(Lit(1));
+  let t: Hazelnut.Htyp.t = Num;
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Asc); 
+  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
+    Some((RAsc(Lit(1), Cursor(Num)), Num));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_saconvar_1 = () => {
+  let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
+  let ze: Hazelnut.Zexp.t = Cursor(EHole);
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var("x")); 
+  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
+    Some((Cursor(Var("x")), Num));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_saconlam_1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(EHole);
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lam("x")); 
+  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
+    Some((RAsc(Lam("x",EHole), LArrow(Cursor(Hole),Hole)), Arrow(Hole,Hole)));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_saconnumlit_1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(EHole);
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(1)); 
+  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
+    Some((Cursor(Lit(1)), Num));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_saconnehole_1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(Lit(1));
+  let t: Hazelnut.Htyp.t = Num;
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.NEHole); 
+  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
+    Some((NEHole(Cursor(Lit(1))), Hole));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_saconaparr_1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(Lam("x",EHole));
+  let t: Hazelnut.Htyp.t = Arrow(Hole,Hole);
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap); 
+  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
+    Some((RAp(Lam("x",EHole), Cursor(EHole)), Hole));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_saconapotw_1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(Lit(1));
+  let t: Hazelnut.Htyp.t = Num;
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap); 
+  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
+    Some((RAp(NEHole(Lit(1)), Cursor(EHole)), Hole));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_saconplus1_1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(Lit(1));
+  let t: Hazelnut.Htyp.t = Num;
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus); 
+  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
+    Some((RPlus(Lit(1), Cursor(EHole)), Num));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_saconplus2_1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(Lam("x",EHole));
+  let t: Hazelnut.Htyp.t = Arrow(Hole,Hole);
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus); 
+  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
+    Some((RPlus(NEHole(Lam("x",EHole)), Cursor(EHole)), Num));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_safinish_1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(NEHole(Lit(1)));
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Finish; 
+  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
+    Some((Cursor(Lit(1)), Num));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let syn_action_tests = [
+  ("test_sadel_1", `Quick, test_sadel_1),
+  ("test_safinish_1", `Quick, test_safinish_1),
+  ("test_saconasc_1", `Quick, test_saconasc_1),
+  ("test_saconvar_1", `Quick, test_saconvar_1),
+  ("test_saconlam_1", `Quick, test_saconlam_1),
+  ("test_saconnumlit_1", `Quick, test_saconnumlit_1),
+  ("test_saconnehole_1", `Quick, test_saconnehole_1),
+  ("test_saconaparr_1", `Quick, test_saconaparr_1),
+  ("test_saconapotw_1", `Quick, test_saconapotw_1),
+  ("test_saconplus1_1", `Quick, test_saconplus1_1),
+  ("test_saconplus2_1", `Quick, test_saconplus2_1),
+];

From ceac6191a15d7abfdd31b658a402974ce060d632 Mon Sep 17 00:00:00 2001
From: Razeen Maroof <mrazeen@umich.edu>
Date: Sun, 21 Jul 2024 22:35:02 -0400
Subject: [PATCH 12/17] sample1 has a slight error on the last analytical
 action and sample2 has major issues, I believe I know what they are but I
 will fix it next week hopefully

---
 test/Test_sample1.re    | 369 ++++++++++++++++++++++++++++++++++++++++
 test/Test_sample2.re    | 225 ++++++++++++++++++++++++
 test/Test_syn_action.re | 246 +++++++++++++++++++++------
 test/hazelnut_test.re   |   3 +
 4 files changed, 791 insertions(+), 52 deletions(-)
 create mode 100644 test/Test_sample1.re
 create mode 100644 test/Test_sample2.re

diff --git a/test/Test_sample1.re b/test/Test_sample1.re
new file mode 100644
index 0000000..ec1501f
--- /dev/null
+++ b/test/Test_sample1.re
@@ -0,0 +1,369 @@
+open Alcotest;
+open Test_interface;
+module Hazelnut = Hazelnut_lib.Hazelnut;
+
+module TypCtx = Map.Make(String);
+type typctx = Hazelnut.TypCtx.t(Hazelnut.Htyp.t);
+
+let test_st1 = () => {
+    let ctx: typctx = TypCtx.empty;
+    let ze: Hazelnut.Zexp.t = Cursor(EHole);
+    let t: Hazelnut.Htyp.t = Hole;
+    let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lam("x"));
+    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Hazelnut.syn_action(ctx, (ze, t), a);
+    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Some((
+        RAsc(Lam("x", EHole), LArrow(Cursor(Hole), Hole)),
+        Arrow(Hole, Hole),
+      ));
+    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_ast1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(EHole);
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lam("x"));
+  let ht: Hazelnut.Htyp.t = Arrow(Hole,Hole);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      Lam("x", Cursor(EHole))
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_st2 = () => {
+    let ctx: typctx = TypCtx.empty;
+    let ze: Hazelnut.Zexp.t = RAsc(Lam("x", EHole), LArrow(Cursor(Hole), Hole));
+    let t: Hazelnut.Htyp.t = Arrow(Hole, Hole);
+    let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Num);
+    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Hazelnut.syn_action(ctx, (ze, t), a);
+    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Some((
+        RAsc(Lam("x", EHole), LArrow(Cursor(Num), Hole)),
+        Arrow(Num, Hole),
+      ));
+    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_ast2 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = RAsc(Lam("x", EHole), LArrow(Cursor(Hole), Hole));
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Num);
+  let ht: Hazelnut.Htyp.t = Arrow(Num,Hole);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      RAsc(Lam("x", EHole), LArrow(Cursor(Num), Hole))
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_st3 = () => {
+    let ctx: typctx = TypCtx.empty;
+    let ze: Hazelnut.Zexp.t = RAsc(Lam("x", EHole), LArrow(Cursor(Num), Hole));
+    let t: Hazelnut.Htyp.t = Arrow(Num, Hole);
+    let a: Hazelnut.Action.t = Move(Parent);
+    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Hazelnut.syn_action(ctx, (ze, t), a);
+    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Some((
+        RAsc(Lam("x", EHole), Cursor(Arrow(Num, Hole))),
+        Arrow(Num, Hole),
+      ));
+    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_ast3 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = RAsc(Lam("x", EHole), LArrow(Cursor(Num), Hole));
+  let a: Hazelnut.Action.t = Move(Parent);
+  let ht: Hazelnut.Htyp.t = Arrow(Num,Hole);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      RAsc(Lam("x", EHole), Cursor(Arrow(Num, Hole)))
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_st4 = () => {
+    let ctx: typctx = TypCtx.empty;
+    let ze: Hazelnut.Zexp.t =  RAsc(Lam("x", EHole), Cursor(Arrow(Num, Hole)));
+    let t: Hazelnut.Htyp.t = Arrow(Num, Hole);
+    let a: Hazelnut.Action.t = Move(Child(Two));
+    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Hazelnut.syn_action(ctx, (ze, t), a);
+    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Some((
+        RAsc(Lam("x", EHole), RArrow(Num, Cursor(Hole))),
+        Arrow(Num, Hole),
+      ));
+    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_ast4 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = RAsc(Lam("x", EHole), Cursor(Arrow(Num, Hole)));
+  let a: Hazelnut.Action.t = Move(Child(Two));
+  let ht: Hazelnut.Htyp.t = Arrow(Num,Hole);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      RAsc(Lam("x", EHole), RArrow(Num, Cursor(Hole)))
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_st5 = () => {
+    let ctx: typctx = TypCtx.empty;
+    let ze: Hazelnut.Zexp.t =  RAsc(Lam("x", EHole), RArrow(Num, Cursor(Hole)));
+    let t: Hazelnut.Htyp.t = Arrow(Num, Hole);
+    let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Num);
+    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Hazelnut.syn_action(ctx, (ze, t), a);
+    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Some((
+        RAsc(Lam("x", EHole), RArrow(Num, Cursor(Num))),
+        Arrow(Num, Num),
+      ));
+    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_ast5 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =  RAsc(Lam("x", EHole), RArrow(Num, Cursor(Hole)));
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Num);
+  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      RAsc(Lam("x", EHole), RArrow(Num, Cursor(Num)))
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_st6 = () => {
+    let ctx: typctx = TypCtx.empty;
+    let ze: Hazelnut.Zexp.t =  RAsc(Lam("x", EHole), RArrow(Num, Cursor(Num)));
+    let t: Hazelnut.Htyp.t = Arrow(Num, Num);
+    let a: Hazelnut.Action.t = Move(Parent);
+    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Hazelnut.syn_action(ctx, (ze, t), a);
+    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Some((
+        RAsc(Lam("x", EHole), Cursor(Arrow(Num, Num))),
+        Arrow(Num, Num),
+      ));
+    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_ast6 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =  RAsc(Lam("x", EHole), RArrow(Num, Cursor(Num)));
+  let a: Hazelnut.Action.t = Move(Parent);
+  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      RAsc(Lam("x", EHole), Cursor(Arrow(Num, Num)))
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_st7 = () => {
+    let ctx: typctx = TypCtx.empty;
+    let ze: Hazelnut.Zexp.t =  RAsc(Lam("x", EHole), Cursor(Arrow(Num, Num)));
+    let t: Hazelnut.Htyp.t = Arrow(Num, Num);
+    let a: Hazelnut.Action.t = Move(Parent);
+    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Hazelnut.syn_action(ctx, (ze, t), a);
+    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Some((
+        Cursor(Asc(Lam("x", EHole), Arrow(Num, Num))),
+        Arrow(Num, Num),
+      ));
+    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_ast7 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =  RAsc(Lam("x", EHole), Cursor(Arrow(Num, Num)));
+  let a: Hazelnut.Action.t = Move(Parent);
+  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      Cursor(Asc(Lam("x", EHole), Arrow(Num, Num)))
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_st8 = () => {
+    let ctx: typctx = TypCtx.empty;
+    let ze: Hazelnut.Zexp.t =  Cursor(Asc(Lam("x", EHole), Arrow(Num, Num)));
+    let t: Hazelnut.Htyp.t = Arrow(Num, Num);
+    let a: Hazelnut.Action.t = Move(Child(One));
+    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Hazelnut.syn_action(ctx, (ze, t), a);
+    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Some((
+        LAsc(Cursor(Lam("x", EHole)), Arrow(Num, Num)),
+        Arrow(Num, Num),
+      ));
+    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_ast8 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =  Cursor(Asc(Lam("x", EHole), Arrow(Num, Num)));
+  let a: Hazelnut.Action.t = Move(Child(One));
+  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      LAsc(Cursor(Lam("x", EHole)), Arrow(Num, Num))
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_st9 = () => {
+    let ctx: typctx = TypCtx.empty;
+    let ze: Hazelnut.Zexp.t =  LAsc(Cursor(Lam("x", EHole)), Arrow(Num, Num));
+    let t: Hazelnut.Htyp.t = Arrow(Num, Num);
+    let a: Hazelnut.Action.t = Move(Child(One));
+    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Hazelnut.syn_action(ctx, (ze, t), a);
+    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Some((
+        LAsc(Lam("x", Cursor(EHole)), Arrow(Num, Num)),
+        Arrow(Num, Num),
+      ));
+    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_ast9 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =  LAsc(Cursor(Lam("x", EHole)), Arrow(Num, Num));
+  let a: Hazelnut.Action.t = Move(Child(One));
+  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      LAsc(Lam("x", Cursor(EHole)), Arrow(Num, Num))
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_st10 = () => {
+    let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
+    let ze: Hazelnut.Zexp.t = LAsc(Lam("x", Cursor(EHole)), Arrow(Num, Num));
+    let t: Hazelnut.Htyp.t = Arrow(Num, Num);
+    let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var("x"));
+    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Hazelnut.syn_action(ctx, (ze, t), a);
+    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Some((
+        LAsc(Lam("x", Cursor(Var("x"))), Arrow(Num, Num)),
+        Arrow(Num, Num),
+      ));
+    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_ast10 = () => {
+  let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
+  let ze: Hazelnut.Zexp.t =  LAsc(Lam("x", Cursor(EHole)), Arrow(Num, Num));
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var("x"));
+  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      LAsc(Lam("x", Cursor(Var("x"))), Arrow(Num, Num))
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_st11 = () => {
+    let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
+    let ze: Hazelnut.Zexp.t = LAsc(Lam("x", Cursor(Var("x"))), Arrow(Num, Num));
+    let t: Hazelnut.Htyp.t = Arrow(Num, Num);
+    let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus);
+    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Hazelnut.syn_action(ctx, (ze, t), a);
+    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Some((
+        LAsc(Lam("x", RPlus(Var("x"),Cursor(EHole))), Arrow(Num, Num)),
+        Arrow(Num, Num),
+      ));
+    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_ast11 = () => {
+  let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
+  let ze: Hazelnut.Zexp.t = LAsc(Lam("x", Cursor(Var("x"))), Arrow(Num, Num));
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus);
+  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      LAsc(Lam("x", RPlus(Var("x"),Cursor(EHole))), Arrow(Num, Num))
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_st12 = () => {
+    let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
+    let ze: Hazelnut.Zexp.t = LAsc(Lam("x", RPlus(Var("x"),Cursor(EHole))), Arrow(Num, Num));
+    let t: Hazelnut.Htyp.t = Arrow(Num, Num);
+    let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(1));
+    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Hazelnut.syn_action(ctx, (ze, t), a);
+    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+      Some((
+        LAsc(Lam("x", RPlus(Var("x"),Cursor(Lit(1)))), Arrow(Num, Num)),
+        Arrow(Num, Num),
+      ));
+    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_ast12 = () => {
+  let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
+  let ze: Hazelnut.Zexp.t = LAsc(Lam("x", RPlus(Var("x"),Cursor(EHole))), Arrow(Num, Num));
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(1));
+  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      LAsc(Lam("x", RPlus(Var("x"),Cursor(Lit(1)))), Arrow(Num, Num))
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let sample1_tests = [
+  ("test_st1", `Quick, test_st1),
+  ("test_ast1", `Quick, test_ast1),
+  ("test_st2", `Quick, test_st2),
+  ("test_ast2", `Quick, test_ast2),
+  ("test_st3", `Quick, test_st3),
+  ("test_ast3", `Quick, test_ast3),
+  ("test_st4", `Quick, test_st4),
+  ("test_ast4", `Quick, test_ast4),
+  ("test_st5", `Quick, test_st5),
+  ("test_ast5", `Quick, test_ast5),
+  ("test_st6", `Quick, test_st6),
+  ("test_ast6", `Quick, test_ast6),
+  ("test_st7", `Quick, test_st7),
+  ("test_ast7", `Quick, test_ast7),
+  ("test_st8", `Quick, test_st8),
+  ("test_ast8", `Quick, test_ast8),
+  ("test_st9", `Quick, test_st9),
+  ("test_ast9", `Quick, test_ast9),
+  ("test_st10", `Quick, test_st10),
+  ("test_ast10", `Quick, test_ast10),
+  ("test_st11", `Quick, test_st11),
+  ("test_ast11", `Quick, test_ast11),
+  ("test_st12", `Quick, test_st12),
+  ("test_ast12", `Quick, test_ast12),
+];
\ No newline at end of file
diff --git a/test/Test_sample2.re b/test/Test_sample2.re
new file mode 100644
index 0000000..9d68a76
--- /dev/null
+++ b/test/Test_sample2.re
@@ -0,0 +1,225 @@
+open Alcotest;
+open Test_interface;
+module Hazelnut = Hazelnut_lib.Hazelnut;
+
+module TypCtx = Map.Make(String);
+type typctx = Hazelnut.TypCtx.t(Hazelnut.Htyp.t);
+
+let test_st14 = () => {
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
+  let ze: Hazelnut.Zexp.t = Cursor(EHole);
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var("incr"));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((Cursor(Var("incr")), Arrow(Num,Num)));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_ast14 = () => { 
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
+  let ze: Hazelnut.Zexp.t = Cursor(EHole);
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var("incr"));
+  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      Cursor(Var("incr"))
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_st15 = () => {
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
+  let ze: Hazelnut.Zexp.t = Cursor(Var("incr"));
+  let t: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((RAp((Var("incr")),Cursor(EHole)), Arrow(Num,Num)));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_ast15 = () => { 
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
+  let ze: Hazelnut.Zexp.t = Cursor(Var("incr"));
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);
+  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      RAp((Var("incr")),Cursor(EHole))
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_st16 = () => {
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
+  let ze: Hazelnut.Zexp.t = RAp((Var("incr")),Cursor(EHole));
+  let t: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var("incr"));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((RAp((Var("incr")),NEHole(Cursor(Var("incr")))), Arrow(Num,Num)));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_ast16 = () => { 
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
+  let ze: Hazelnut.Zexp.t = RAp((Var("incr")),Cursor(EHole));
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var("incr"));
+  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      RAp((Var("incr")),NEHole(Cursor(Var("incr"))))
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_st17 = () => {
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
+  let ze: Hazelnut.Zexp.t = RAp((Var("incr")),NEHole(Cursor(Var("incr"))));
+  let t: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((RAp((Var("incr")),NEHole(RAp((Var("incr")),Cursor(EHole)))), Arrow(Num,Num)));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_ast17 = () => { 
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
+  let ze: Hazelnut.Zexp.t = RAp((Var("incr")),NEHole(Cursor(Var("incr"))));
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);
+  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      RAp((Var("incr")),NEHole(RAp((Var("incr")),Cursor(EHole))))
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_st18 = () => {
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
+  let ze: Hazelnut.Zexp.t = RAp((Var("incr")),NEHole(RAp((Var("incr")),Cursor(EHole))));
+  let t: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(3));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((RAp((Var("incr")),NEHole(RAp((Var("incr")),Cursor(Lit(3))))), Arrow(Num,Num)));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_ast18 = () => { 
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
+  let ze: Hazelnut.Zexp.t = RAp((Var("incr")),NEHole(RAp((Var("incr")),Cursor(EHole))));
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(3));
+  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      RAp((Var("incr")),NEHole(RAp((Var("incr")),Cursor(Lit(3)))))
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_st19 = () => {
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
+  let ze: Hazelnut.Zexp.t = RAp((Var("incr")), NEHole(RAp((Var("incr")),Cursor(Lit(3)))));
+  let t: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let a: Hazelnut.Action.t = Move(Parent);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((RAp((Var("incr")),NEHole(Cursor(Ap((Var("incr")),Lit(3))))), Arrow(Num,Num)));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_ast19 = () => { 
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
+  let ze: Hazelnut.Zexp.t = RAp((Var("incr")), NEHole(RAp((Var("incr")),Cursor(Lit(3)))));
+  let a: Hazelnut.Action.t = Move(Parent);
+  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      RAp((Var("incr")),NEHole(Cursor(Ap((Var("incr")),Lit(3)))))
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_st20 = () => {
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
+  let ze: Hazelnut.Zexp.t = RAp((Var("incr")), NEHole(Cursor(Ap((Var("incr")),Lit(3)))));
+  let t: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let a: Hazelnut.Action.t = Move(Parent);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((RAp((Var("incr")),Cursor(NEHole(Ap((Var("incr")),Lit(3))))), Arrow(Num,Num)));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_ast20 = () => { 
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
+  let ze: Hazelnut.Zexp.t = RAp((Var("incr")), NEHole(Cursor(Ap((Var("incr")),Lit(3)))));
+  let a: Hazelnut.Action.t = Move(Parent);
+  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      RAp((Var("incr")),Cursor(NEHole(Ap((Var("incr")),Lit(3)))))
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let test_st21 = () => {
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
+  let ze: Hazelnut.Zexp.t = RAp((Var("incr")),Cursor(NEHole(Ap((Var("incr")),Lit(3)))));
+  let t: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let a: Hazelnut.Action.t = Finish;
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((RAp((Var("incr")),Cursor(Ap((Var("incr")),Lit(3)))), Arrow(Num,Num)));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let test_ast21 = () => { 
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
+  let ze: Hazelnut.Zexp.t = RAp((Var("incr")),Cursor(NEHole(Ap((Var("incr")),Lit(3)))));
+  let a: Hazelnut.Action.t = Finish;
+  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
+  let expected: option(Hazelnut.Zexp.t) =
+    Some(
+      RAp((Var("incr")),Cursor(Ap((Var("incr")),Lit(3))))
+    );
+  check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
+};
+
+let sample2_tests = [
+  ("test_st14", `Quick, test_st14),
+  ("test_ast14", `Quick, test_ast14),
+  ("test_st15", `Quick, test_st15),
+  ("test_ast15", `Quick, test_ast15),
+  ("test_st16", `Quick, test_st16),
+  ("test_ast16", `Quick, test_ast16),
+  ("test_st17", `Quick, test_st17),
+  ("test_ast17", `Quick, test_ast17),
+  ("test_st18", `Quick, test_st18),
+  ("test_ast18", `Quick, test_ast18),
+  ("test_st19", `Quick, test_st19),
+  ("test_ast19", `Quick, test_ast19),
+  ("test_st20", `Quick, test_st20),
+  ("test_ast20", `Quick, test_ast20),
+  ("test_st21", `Quick, test_st21),
+  ("test_ast21", `Quick, test_ast21),
+];
\ No newline at end of file
diff --git a/test/Test_syn_action.re b/test/Test_syn_action.re
index 799ad65..9d528c0 100644
--- a/test/Test_syn_action.re
+++ b/test/Test_syn_action.re
@@ -1,141 +1,283 @@
 open Alcotest;
 open Test_interface;
 module Hazelnut = Hazelnut_lib.Hazelnut;
-
 module TypCtx = Map.Make(String);
 type typctx = Hazelnut.TypCtx.t(Hazelnut.Htyp.t);
 
+let test_samove_1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =
+    LAsc(Cursor(Lam("x", EHole)), Arrow(Hole, Hole));
+  let t: Hazelnut.Htyp.t = Arrow(Hole, Hole);
+  let a: Hazelnut.Action.t = Move(Child(One));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      LAsc(Lam("x", Cursor(EHole)), Arrow(Hole, Hole)),
+      Arrow(Hole, Hole),
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
 let test_sadel_1 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t = Cursor(Lit(1));
   let t: Hazelnut.Htyp.t = Num;
-  let a: Hazelnut.Action.t = Del; 
-  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
-  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
+  let a: Hazelnut.Action.t = Del;
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Some((Cursor(EHole), Hole));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
-
+let test_sadel_2 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = NEHole(Cursor(Lit(1)));
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Del;
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((NEHole(Cursor(EHole)), Hole));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
 let test_saconasc_1 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t = Cursor(Lit(1));
   let t: Hazelnut.Htyp.t = Num;
-  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Asc); 
-  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
-  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Asc);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Some((RAsc(Lit(1), Cursor(Num)), Num));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
-
+let test_saconasc_2 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(EHole);
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Asc);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((RAsc(EHole, Cursor(Hole)), Hole));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_saconasc_3 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = NEHole(Cursor(Lit(1)));
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Asc);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((NEHole(RAsc(Lit(1), Cursor(Num))), Hole));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
 let test_saconvar_1 = () => {
   let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
   let ze: Hazelnut.Zexp.t = Cursor(EHole);
   let t: Hazelnut.Htyp.t = Hole;
-  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var("x")); 
-  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
-  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var("x"));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Some((Cursor(Var("x")), Num));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
-
+let test_saconvar_2 = () => {
+  let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
+  let ze: Hazelnut.Zexp.t = NEHole(Cursor(EHole));
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var("x"));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((NEHole(Cursor(Var("x"))), Hole));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
 let test_saconlam_1 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t = Cursor(EHole);
   let t: Hazelnut.Htyp.t = Hole;
-  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lam("x")); 
-  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
-  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
-    Some((RAsc(Lam("x",EHole), LArrow(Cursor(Hole),Hole)), Arrow(Hole,Hole)));
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lam("x"));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      RAsc(Lam("x", EHole), LArrow(Cursor(Hole), Hole)),
+      Arrow(Hole, Hole),
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_saconlam_2 = () => {
+  //CHECK THIS ONE
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = NEHole(Cursor(EHole));
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lam("x"));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      NEHole(RAsc(Lam("x", EHole), LArrow(Cursor(Hole), Hole))),
+      Hole,
+    ));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
-
 let test_saconnumlit_1 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t = Cursor(EHole);
   let t: Hazelnut.Htyp.t = Hole;
-  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(1)); 
-  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
-  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(1));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Some((Cursor(Lit(1)), Num));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
-
+let test_saconnumlit_2 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = NEHole(Cursor(EHole));
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(1));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((NEHole(Cursor(Lit(1))), Hole));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
 let test_saconnehole_1 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t = Cursor(Lit(1));
   let t: Hazelnut.Htyp.t = Num;
-  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.NEHole); 
-  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
-  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.NEHole);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Some((NEHole(Cursor(Lit(1))), Hole));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
-
+let test_saconnehole_2 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = NEHole(Cursor(Lit(1)));
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.NEHole);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((NEHole(NEHole(Cursor(Lit(1)))), Hole));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
 let test_saconaparr_1 = () => {
   let ctx: typctx = TypCtx.empty;
-  let ze: Hazelnut.Zexp.t = Cursor(Lam("x",EHole));
-  let t: Hazelnut.Htyp.t = Arrow(Hole,Hole);
-  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap); 
-  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
-  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
-    Some((RAp(Lam("x",EHole), Cursor(EHole)), Hole));
+  let ze: Hazelnut.Zexp.t = Cursor(Lam("x", EHole));
+  let t: Hazelnut.Htyp.t = Arrow(Hole, Hole);
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((RAp(Lam("x", EHole), Cursor(EHole)), Hole));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
-
 let test_saconapotw_1 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t = Cursor(Lit(1));
   let t: Hazelnut.Htyp.t = Num;
-  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap); 
-  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
-  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Some((RAp(NEHole(Lit(1)), Cursor(EHole)), Hole));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
-
+let test_saconapotw_2 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = NEHole(Cursor(Lit(1)));
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((NEHole(RAp(NEHole(Lit(1)), Cursor(EHole))), Hole));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
 let test_saconplus1_1 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t = Cursor(Lit(1));
   let t: Hazelnut.Htyp.t = Num;
-  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus); 
-  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
-  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Some((RPlus(Lit(1), Cursor(EHole)), Num));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
-
+let test_saconplus1_2 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = NEHole(Cursor(Lit(1)));
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((NEHole(RPlus(Lit(1), Cursor(EHole))), Hole));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
 let test_saconplus2_1 = () => {
   let ctx: typctx = TypCtx.empty;
-  let ze: Hazelnut.Zexp.t = Cursor(Lam("x",EHole));
-  let t: Hazelnut.Htyp.t = Arrow(Hole,Hole);
-  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus); 
-  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
-  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
-    Some((RPlus(NEHole(Lam("x",EHole)), Cursor(EHole)), Num));
+  let ze: Hazelnut.Zexp.t = Cursor(Lam("x", EHole));
+  let t: Hazelnut.Htyp.t = Arrow(Hole, Hole);
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((RPlus(NEHole(Lam("x", EHole)), Cursor(EHole)), Num));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
-
 let test_safinish_1 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t = Cursor(NEHole(Lit(1)));
   let t: Hazelnut.Htyp.t = Hole;
-  let a: Hazelnut.Action.t = Finish; 
-  let given: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) = Hazelnut.syn_action(ctx, (ze, t), a);
-  let expected: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)) =
+  let a: Hazelnut.Action.t = Finish;
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Some((Cursor(Lit(1)), Num));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
-
+let test_safinish_2 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = NEHole(Cursor(NEHole(Lit(1))));
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Finish;
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((NEHole(Cursor(Lit(1))), Hole));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
 let syn_action_tests = [
+  ("test_samove_1", `Quick, test_sadel_1),
   ("test_sadel_1", `Quick, test_sadel_1),
+  ("test_sadel_2", `Quick, test_sadel_2),
   ("test_safinish_1", `Quick, test_safinish_1),
+  ("test_safinish_2", `Quick, test_safinish_2),
   ("test_saconasc_1", `Quick, test_saconasc_1),
+  ("test_saconasc_2", `Quick, test_saconasc_2),
+  ("test_saconasc_3", `Quick, test_saconasc_3),
   ("test_saconvar_1", `Quick, test_saconvar_1),
+  ("test_saconvar_2", `Quick, test_saconvar_2),
   ("test_saconlam_1", `Quick, test_saconlam_1),
+  ("test_saconlam_2", `Quick, test_saconlam_2),
   ("test_saconnumlit_1", `Quick, test_saconnumlit_1),
+  ("test_saconnumlit_2", `Quick, test_saconnumlit_2),
   ("test_saconnehole_1", `Quick, test_saconnehole_1),
+  ("test_saconnehole_2", `Quick, test_saconnehole_2),
   ("test_saconaparr_1", `Quick, test_saconaparr_1),
   ("test_saconapotw_1", `Quick, test_saconapotw_1),
+  ("test_saconapotw_2", `Quick, test_saconapotw_2),
   ("test_saconplus1_1", `Quick, test_saconplus1_1),
+  ("test_saconplus1_2", `Quick, test_saconplus1_2),
   ("test_saconplus2_1", `Quick, test_saconplus2_1),
 ];
diff --git a/test/hazelnut_test.re b/test/hazelnut_test.re
index 0b044ca..56a851f 100644
--- a/test/hazelnut_test.re
+++ b/test/hazelnut_test.re
@@ -9,5 +9,8 @@ let () =
       ("ana", Test_ana.ana_tests),
       ("syn_action", Test_syn_action.syn_action_tests),
       ("ana_action", Test_ana_action.ana_action_tests),
+      ("syn_action", Test_syn_action.syn_action_tests),
+      ("sample 1", Test_sample1.sample1_tests),
+      ("sample 2", Test_sample2.sample2_tests),
     ],
   );

From f3cb4874d7e053a5aa815a0fd8320f872df79a94 Mon Sep 17 00:00:00 2001
From: Razeen Maroof <mrazeen@umich.edu>
Date: Sun, 21 Jul 2024 23:24:21 -0400
Subject: [PATCH 13/17] autoformatting

---
 test/Test_sample1.re   | 395 ++++++++++++++++++++---------------------
 test/Test_sample2.re   | 179 ++++++++++---------
 test/hazelnut_test.re  |   1 -
 test/test_interface.re |  24 ++-
 4 files changed, 304 insertions(+), 295 deletions(-)

diff --git a/test/Test_sample1.re b/test/Test_sample1.re
index ec1501f..f323be1 100644
--- a/test/Test_sample1.re
+++ b/test/Test_sample1.re
@@ -6,337 +6,330 @@ module TypCtx = Map.Make(String);
 type typctx = Hazelnut.TypCtx.t(Hazelnut.Htyp.t);
 
 let test_st1 = () => {
-    let ctx: typctx = TypCtx.empty;
-    let ze: Hazelnut.Zexp.t = Cursor(EHole);
-    let t: Hazelnut.Htyp.t = Hole;
-    let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lam("x"));
-    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Hazelnut.syn_action(ctx, (ze, t), a);
-    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Some((
-        RAsc(Lam("x", EHole), LArrow(Cursor(Hole), Hole)),
-        Arrow(Hole, Hole),
-      ));
-    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(EHole);
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lam("x"));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      RAsc(Lam("x", EHole), LArrow(Cursor(Hole), Hole)),
+      Arrow(Hole, Hole),
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
 let test_ast1 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t = Cursor(EHole);
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lam("x"));
-  let ht: Hazelnut.Htyp.t = Arrow(Hole,Hole);
+  let ht: Hazelnut.Htyp.t = Arrow(Hole, Hole);
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
-  let expected: option(Hazelnut.Zexp.t) =
-    Some(
-      Lam("x", Cursor(EHole))
-    );
+  let expected: option(Hazelnut.Zexp.t) = Some(Lam("x", Cursor(EHole)));
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
 let test_st2 = () => {
-    let ctx: typctx = TypCtx.empty;
-    let ze: Hazelnut.Zexp.t = RAsc(Lam("x", EHole), LArrow(Cursor(Hole), Hole));
-    let t: Hazelnut.Htyp.t = Arrow(Hole, Hole);
-    let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Num);
-    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Hazelnut.syn_action(ctx, (ze, t), a);
-    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Some((
-        RAsc(Lam("x", EHole), LArrow(Cursor(Num), Hole)),
-        Arrow(Num, Hole),
-      ));
-    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =
+    RAsc(Lam("x", EHole), LArrow(Cursor(Hole), Hole));
+  let t: Hazelnut.Htyp.t = Arrow(Hole, Hole);
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Num);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      RAsc(Lam("x", EHole), LArrow(Cursor(Num), Hole)),
+      Arrow(Num, Hole),
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
 let test_ast2 = () => {
   let ctx: typctx = TypCtx.empty;
-  let ze: Hazelnut.Zexp.t = RAsc(Lam("x", EHole), LArrow(Cursor(Hole), Hole));
+  let ze: Hazelnut.Zexp.t =
+    RAsc(Lam("x", EHole), LArrow(Cursor(Hole), Hole));
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Num);
-  let ht: Hazelnut.Htyp.t = Arrow(Num,Hole);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Hole);
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
-    Some(
-      RAsc(Lam("x", EHole), LArrow(Cursor(Num), Hole))
-    );
+    Some(RAsc(Lam("x", EHole), LArrow(Cursor(Num), Hole)));
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
 let test_st3 = () => {
-    let ctx: typctx = TypCtx.empty;
-    let ze: Hazelnut.Zexp.t = RAsc(Lam("x", EHole), LArrow(Cursor(Num), Hole));
-    let t: Hazelnut.Htyp.t = Arrow(Num, Hole);
-    let a: Hazelnut.Action.t = Move(Parent);
-    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Hazelnut.syn_action(ctx, (ze, t), a);
-    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Some((
-        RAsc(Lam("x", EHole), Cursor(Arrow(Num, Hole))),
-        Arrow(Num, Hole),
-      ));
-    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =
+    RAsc(Lam("x", EHole), LArrow(Cursor(Num), Hole));
+  let t: Hazelnut.Htyp.t = Arrow(Num, Hole);
+  let a: Hazelnut.Action.t = Move(Parent);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      RAsc(Lam("x", EHole), Cursor(Arrow(Num, Hole))),
+      Arrow(Num, Hole),
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
 let test_ast3 = () => {
   let ctx: typctx = TypCtx.empty;
-  let ze: Hazelnut.Zexp.t = RAsc(Lam("x", EHole), LArrow(Cursor(Num), Hole));
+  let ze: Hazelnut.Zexp.t =
+    RAsc(Lam("x", EHole), LArrow(Cursor(Num), Hole));
   let a: Hazelnut.Action.t = Move(Parent);
-  let ht: Hazelnut.Htyp.t = Arrow(Num,Hole);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Hole);
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
-    Some(
-      RAsc(Lam("x", EHole), Cursor(Arrow(Num, Hole)))
-    );
+    Some(RAsc(Lam("x", EHole), Cursor(Arrow(Num, Hole))));
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
 let test_st4 = () => {
-    let ctx: typctx = TypCtx.empty;
-    let ze: Hazelnut.Zexp.t =  RAsc(Lam("x", EHole), Cursor(Arrow(Num, Hole)));
-    let t: Hazelnut.Htyp.t = Arrow(Num, Hole);
-    let a: Hazelnut.Action.t = Move(Child(Two));
-    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Hazelnut.syn_action(ctx, (ze, t), a);
-    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Some((
-        RAsc(Lam("x", EHole), RArrow(Num, Cursor(Hole))),
-        Arrow(Num, Hole),
-      ));
-    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =
+    RAsc(Lam("x", EHole), Cursor(Arrow(Num, Hole)));
+  let t: Hazelnut.Htyp.t = Arrow(Num, Hole);
+  let a: Hazelnut.Action.t = Move(Child(Two));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      RAsc(Lam("x", EHole), RArrow(Num, Cursor(Hole))),
+      Arrow(Num, Hole),
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
 let test_ast4 = () => {
   let ctx: typctx = TypCtx.empty;
-  let ze: Hazelnut.Zexp.t = RAsc(Lam("x", EHole), Cursor(Arrow(Num, Hole)));
+  let ze: Hazelnut.Zexp.t =
+    RAsc(Lam("x", EHole), Cursor(Arrow(Num, Hole)));
   let a: Hazelnut.Action.t = Move(Child(Two));
-  let ht: Hazelnut.Htyp.t = Arrow(Num,Hole);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Hole);
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
-    Some(
-      RAsc(Lam("x", EHole), RArrow(Num, Cursor(Hole)))
-    );
+    Some(RAsc(Lam("x", EHole), RArrow(Num, Cursor(Hole))));
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
 let test_st5 = () => {
-    let ctx: typctx = TypCtx.empty;
-    let ze: Hazelnut.Zexp.t =  RAsc(Lam("x", EHole), RArrow(Num, Cursor(Hole)));
-    let t: Hazelnut.Htyp.t = Arrow(Num, Hole);
-    let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Num);
-    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Hazelnut.syn_action(ctx, (ze, t), a);
-    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Some((
-        RAsc(Lam("x", EHole), RArrow(Num, Cursor(Num))),
-        Arrow(Num, Num),
-      ));
-    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =
+    RAsc(Lam("x", EHole), RArrow(Num, Cursor(Hole)));
+  let t: Hazelnut.Htyp.t = Arrow(Num, Hole);
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Num);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      RAsc(Lam("x", EHole), RArrow(Num, Cursor(Num))),
+      Arrow(Num, Num),
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
 let test_ast5 = () => {
   let ctx: typctx = TypCtx.empty;
-  let ze: Hazelnut.Zexp.t =  RAsc(Lam("x", EHole), RArrow(Num, Cursor(Hole)));
+  let ze: Hazelnut.Zexp.t =
+    RAsc(Lam("x", EHole), RArrow(Num, Cursor(Hole)));
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Num);
-  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
-    Some(
-      RAsc(Lam("x", EHole), RArrow(Num, Cursor(Num)))
-    );
+    Some(RAsc(Lam("x", EHole), RArrow(Num, Cursor(Num))));
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
 let test_st6 = () => {
-    let ctx: typctx = TypCtx.empty;
-    let ze: Hazelnut.Zexp.t =  RAsc(Lam("x", EHole), RArrow(Num, Cursor(Num)));
-    let t: Hazelnut.Htyp.t = Arrow(Num, Num);
-    let a: Hazelnut.Action.t = Move(Parent);
-    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Hazelnut.syn_action(ctx, (ze, t), a);
-    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Some((
-        RAsc(Lam("x", EHole), Cursor(Arrow(Num, Num))),
-        Arrow(Num, Num),
-      ));
-    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =
+    RAsc(Lam("x", EHole), RArrow(Num, Cursor(Num)));
+  let t: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let a: Hazelnut.Action.t = Move(Parent);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      RAsc(Lam("x", EHole), Cursor(Arrow(Num, Num))),
+      Arrow(Num, Num),
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
 let test_ast6 = () => {
   let ctx: typctx = TypCtx.empty;
-  let ze: Hazelnut.Zexp.t =  RAsc(Lam("x", EHole), RArrow(Num, Cursor(Num)));
+  let ze: Hazelnut.Zexp.t =
+    RAsc(Lam("x", EHole), RArrow(Num, Cursor(Num)));
   let a: Hazelnut.Action.t = Move(Parent);
-  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
-    Some(
-      RAsc(Lam("x", EHole), Cursor(Arrow(Num, Num)))
-    );
+    Some(RAsc(Lam("x", EHole), Cursor(Arrow(Num, Num))));
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
 let test_st7 = () => {
-    let ctx: typctx = TypCtx.empty;
-    let ze: Hazelnut.Zexp.t =  RAsc(Lam("x", EHole), Cursor(Arrow(Num, Num)));
-    let t: Hazelnut.Htyp.t = Arrow(Num, Num);
-    let a: Hazelnut.Action.t = Move(Parent);
-    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Hazelnut.syn_action(ctx, (ze, t), a);
-    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Some((
-        Cursor(Asc(Lam("x", EHole), Arrow(Num, Num))),
-        Arrow(Num, Num),
-      ));
-    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = RAsc(Lam("x", EHole), Cursor(Arrow(Num, Num)));
+  let t: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let a: Hazelnut.Action.t = Move(Parent);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      Cursor(Asc(Lam("x", EHole), Arrow(Num, Num))),
+      Arrow(Num, Num),
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
 let test_ast7 = () => {
   let ctx: typctx = TypCtx.empty;
-  let ze: Hazelnut.Zexp.t =  RAsc(Lam("x", EHole), Cursor(Arrow(Num, Num)));
+  let ze: Hazelnut.Zexp.t = RAsc(Lam("x", EHole), Cursor(Arrow(Num, Num)));
   let a: Hazelnut.Action.t = Move(Parent);
-  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
-    Some(
-      Cursor(Asc(Lam("x", EHole), Arrow(Num, Num)))
-    );
+    Some(Cursor(Asc(Lam("x", EHole), Arrow(Num, Num))));
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
 let test_st8 = () => {
-    let ctx: typctx = TypCtx.empty;
-    let ze: Hazelnut.Zexp.t =  Cursor(Asc(Lam("x", EHole), Arrow(Num, Num)));
-    let t: Hazelnut.Htyp.t = Arrow(Num, Num);
-    let a: Hazelnut.Action.t = Move(Child(One));
-    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Hazelnut.syn_action(ctx, (ze, t), a);
-    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Some((
-        LAsc(Cursor(Lam("x", EHole)), Arrow(Num, Num)),
-        Arrow(Num, Num),
-      ));
-    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(Asc(Lam("x", EHole), Arrow(Num, Num)));
+  let t: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let a: Hazelnut.Action.t = Move(Child(One));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      LAsc(Cursor(Lam("x", EHole)), Arrow(Num, Num)),
+      Arrow(Num, Num),
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
 let test_ast8 = () => {
   let ctx: typctx = TypCtx.empty;
-  let ze: Hazelnut.Zexp.t =  Cursor(Asc(Lam("x", EHole), Arrow(Num, Num)));
+  let ze: Hazelnut.Zexp.t = Cursor(Asc(Lam("x", EHole), Arrow(Num, Num)));
   let a: Hazelnut.Action.t = Move(Child(One));
-  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
-    Some(
-      LAsc(Cursor(Lam("x", EHole)), Arrow(Num, Num))
-    );
+    Some(LAsc(Cursor(Lam("x", EHole)), Arrow(Num, Num)));
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
 let test_st9 = () => {
-    let ctx: typctx = TypCtx.empty;
-    let ze: Hazelnut.Zexp.t =  LAsc(Cursor(Lam("x", EHole)), Arrow(Num, Num));
-    let t: Hazelnut.Htyp.t = Arrow(Num, Num);
-    let a: Hazelnut.Action.t = Move(Child(One));
-    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Hazelnut.syn_action(ctx, (ze, t), a);
-    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Some((
-        LAsc(Lam("x", Cursor(EHole)), Arrow(Num, Num)),
-        Arrow(Num, Num),
-      ));
-    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = LAsc(Cursor(Lam("x", EHole)), Arrow(Num, Num));
+  let t: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let a: Hazelnut.Action.t = Move(Child(One));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      LAsc(Lam("x", Cursor(EHole)), Arrow(Num, Num)),
+      Arrow(Num, Num),
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
 let test_ast9 = () => {
   let ctx: typctx = TypCtx.empty;
-  let ze: Hazelnut.Zexp.t =  LAsc(Cursor(Lam("x", EHole)), Arrow(Num, Num));
+  let ze: Hazelnut.Zexp.t = LAsc(Cursor(Lam("x", EHole)), Arrow(Num, Num));
   let a: Hazelnut.Action.t = Move(Child(One));
-  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
-    Some(
-      LAsc(Lam("x", Cursor(EHole)), Arrow(Num, Num))
-    );
+    Some(LAsc(Lam("x", Cursor(EHole)), Arrow(Num, Num)));
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
 let test_st10 = () => {
-    let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
-    let ze: Hazelnut.Zexp.t = LAsc(Lam("x", Cursor(EHole)), Arrow(Num, Num));
-    let t: Hazelnut.Htyp.t = Arrow(Num, Num);
-    let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var("x"));
-    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Hazelnut.syn_action(ctx, (ze, t), a);
-    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Some((
-        LAsc(Lam("x", Cursor(Var("x"))), Arrow(Num, Num)),
-        Arrow(Num, Num),
-      ));
-    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+  let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
+  let ze: Hazelnut.Zexp.t = LAsc(Lam("x", Cursor(EHole)), Arrow(Num, Num));
+  let t: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var("x"));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      LAsc(Lam("x", Cursor(Var("x"))), Arrow(Num, Num)),
+      Arrow(Num, Num),
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
 let test_ast10 = () => {
   let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
-  let ze: Hazelnut.Zexp.t =  LAsc(Lam("x", Cursor(EHole)), Arrow(Num, Num));
+  let ze: Hazelnut.Zexp.t = LAsc(Lam("x", Cursor(EHole)), Arrow(Num, Num));
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var("x"));
-  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
-    Some(
-      LAsc(Lam("x", Cursor(Var("x"))), Arrow(Num, Num))
-    );
+    Some(LAsc(Lam("x", Cursor(Var("x"))), Arrow(Num, Num)));
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
 let test_st11 = () => {
-    let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
-    let ze: Hazelnut.Zexp.t = LAsc(Lam("x", Cursor(Var("x"))), Arrow(Num, Num));
-    let t: Hazelnut.Htyp.t = Arrow(Num, Num);
-    let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus);
-    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Hazelnut.syn_action(ctx, (ze, t), a);
-    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Some((
-        LAsc(Lam("x", RPlus(Var("x"),Cursor(EHole))), Arrow(Num, Num)),
-        Arrow(Num, Num),
-      ));
-    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+  let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
+  let ze: Hazelnut.Zexp.t =
+    LAsc(Lam("x", Cursor(Var("x"))), Arrow(Num, Num));
+  let t: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      LAsc(Lam("x", RPlus(Var("x"), Cursor(EHole))), Arrow(Num, Num)),
+      Arrow(Num, Num),
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
 let test_ast11 = () => {
   let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
-  let ze: Hazelnut.Zexp.t = LAsc(Lam("x", Cursor(Var("x"))), Arrow(Num, Num));
+  let ze: Hazelnut.Zexp.t =
+    LAsc(Lam("x", Cursor(Var("x"))), Arrow(Num, Num));
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus);
-  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
     Some(
-      LAsc(Lam("x", RPlus(Var("x"),Cursor(EHole))), Arrow(Num, Num))
+      LAsc(Lam("x", RPlus(Var("x"), Cursor(EHole))), Arrow(Num, Num)),
     );
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
 let test_st12 = () => {
-    let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
-    let ze: Hazelnut.Zexp.t = LAsc(Lam("x", RPlus(Var("x"),Cursor(EHole))), Arrow(Num, Num));
-    let t: Hazelnut.Htyp.t = Arrow(Num, Num);
-    let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(1));
-    let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Hazelnut.syn_action(ctx, (ze, t), a);
-    let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-      Some((
-        LAsc(Lam("x", RPlus(Var("x"),Cursor(Lit(1)))), Arrow(Num, Num)),
-        Arrow(Num, Num),
-      ));
-    check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+  let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
+  let ze: Hazelnut.Zexp.t =
+    LAsc(Lam("x", RPlus(Var("x"), Cursor(EHole))), Arrow(Num, Num));
+  let t: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(1));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      LAsc(Lam("x", RPlus(Var("x"), Cursor(Lit(1)))), Arrow(Num, Num)),
+      Arrow(Num, Num),
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
 let test_ast12 = () => {
   let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
-  let ze: Hazelnut.Zexp.t = LAsc(Lam("x", RPlus(Var("x"),Cursor(EHole))), Arrow(Num, Num));
+  let ze: Hazelnut.Zexp.t =
+    LAsc(Lam("x", RPlus(Var("x"), Cursor(EHole))), Arrow(Num, Num));
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(1));
-  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
     Some(
-      LAsc(Lam("x", RPlus(Var("x"),Cursor(Lit(1)))), Arrow(Num, Num))
+      LAsc(Lam("x", RPlus(Var("x"), Cursor(Lit(1)))), Arrow(Num, Num)),
     );
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
@@ -366,4 +359,4 @@ let sample1_tests = [
   ("test_ast11", `Quick, test_ast11),
   ("test_st12", `Quick, test_st12),
   ("test_ast12", `Quick, test_ast12),
-];
\ No newline at end of file
+];
diff --git a/test/Test_sample2.re b/test/Test_sample2.re
index 9d68a76..777591a 100644
--- a/test/Test_sample2.re
+++ b/test/Test_sample2.re
@@ -6,202 +6,211 @@ module TypCtx = Map.Make(String);
 type typctx = Hazelnut.TypCtx.t(Hazelnut.Htyp.t);
 
 let test_st14 = () => {
-  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
   let ze: Hazelnut.Zexp.t = Cursor(EHole);
   let t: Hazelnut.Htyp.t = Hole;
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var("incr"));
   let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Hazelnut.syn_action(ctx, (ze, t), a);
   let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-    Some((Cursor(Var("incr")), Arrow(Num,Num)));
+    Some((Cursor(Var("incr")), Arrow(Num, Num)));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
-let test_ast14 = () => { 
-  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
+let test_ast14 = () => {
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
   let ze: Hazelnut.Zexp.t = Cursor(EHole);
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var("incr"));
-  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
-  let expected: option(Hazelnut.Zexp.t) =
-    Some(
-      Cursor(Var("incr"))
-    );
+  let expected: option(Hazelnut.Zexp.t) = Some(Cursor(Var("incr")));
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
 let test_st15 = () => {
-  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
   let ze: Hazelnut.Zexp.t = Cursor(Var("incr"));
-  let t: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let t: Hazelnut.Htyp.t = Arrow(Num, Num);
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);
   let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Hazelnut.syn_action(ctx, (ze, t), a);
   let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-    Some((RAp((Var("incr")),Cursor(EHole)), Arrow(Num,Num)));
+    Some((RAp(Var("incr"), Cursor(EHole)), Arrow(Num, Num)));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
-let test_ast15 = () => { 
-  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
+let test_ast15 = () => {
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
   let ze: Hazelnut.Zexp.t = Cursor(Var("incr"));
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);
-  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
-    Some(
-      RAp((Var("incr")),Cursor(EHole))
-    );
+    Some(RAp(Var("incr"), Cursor(EHole)));
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
 let test_st16 = () => {
-  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
-  let ze: Hazelnut.Zexp.t = RAp((Var("incr")),Cursor(EHole));
-  let t: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
+  let ze: Hazelnut.Zexp.t = RAp(Var("incr"), Cursor(EHole));
+  let t: Hazelnut.Htyp.t = Arrow(Num, Num);
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var("incr"));
   let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Hazelnut.syn_action(ctx, (ze, t), a);
   let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-    Some((RAp((Var("incr")),NEHole(Cursor(Var("incr")))), Arrow(Num,Num)));
+    Some((
+      RAp(Var("incr"), NEHole(Cursor(Var("incr")))),
+      Arrow(Num, Num),
+    ));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
-let test_ast16 = () => { 
-  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
-  let ze: Hazelnut.Zexp.t = RAp((Var("incr")),Cursor(EHole));
+let test_ast16 = () => {
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
+  let ze: Hazelnut.Zexp.t = RAp(Var("incr"), Cursor(EHole));
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var("incr"));
-  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
-    Some(
-      RAp((Var("incr")),NEHole(Cursor(Var("incr"))))
-    );
+    Some(RAp(Var("incr"), NEHole(Cursor(Var("incr")))));
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
 let test_st17 = () => {
-  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
-  let ze: Hazelnut.Zexp.t = RAp((Var("incr")),NEHole(Cursor(Var("incr"))));
-  let t: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
+  let ze: Hazelnut.Zexp.t = RAp(Var("incr"), NEHole(Cursor(Var("incr"))));
+  let t: Hazelnut.Htyp.t = Arrow(Num, Num);
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);
   let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Hazelnut.syn_action(ctx, (ze, t), a);
   let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-    Some((RAp((Var("incr")),NEHole(RAp((Var("incr")),Cursor(EHole)))), Arrow(Num,Num)));
+    Some((
+      RAp(Var("incr"), NEHole(RAp(Var("incr"), Cursor(EHole)))),
+      Arrow(Num, Num),
+    ));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
-let test_ast17 = () => { 
-  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
-  let ze: Hazelnut.Zexp.t = RAp((Var("incr")),NEHole(Cursor(Var("incr"))));
+let test_ast17 = () => {
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
+  let ze: Hazelnut.Zexp.t = RAp(Var("incr"), NEHole(Cursor(Var("incr"))));
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);
-  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
-    Some(
-      RAp((Var("incr")),NEHole(RAp((Var("incr")),Cursor(EHole))))
-    );
+    Some(RAp(Var("incr"), NEHole(RAp(Var("incr"), Cursor(EHole)))));
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
 let test_st18 = () => {
-  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
-  let ze: Hazelnut.Zexp.t = RAp((Var("incr")),NEHole(RAp((Var("incr")),Cursor(EHole))));
-  let t: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
+  let ze: Hazelnut.Zexp.t =
+    RAp(Var("incr"), NEHole(RAp(Var("incr"), Cursor(EHole))));
+  let t: Hazelnut.Htyp.t = Arrow(Num, Num);
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(3));
   let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Hazelnut.syn_action(ctx, (ze, t), a);
   let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-    Some((RAp((Var("incr")),NEHole(RAp((Var("incr")),Cursor(Lit(3))))), Arrow(Num,Num)));
+    Some((
+      RAp(Var("incr"), NEHole(RAp(Var("incr"), Cursor(Lit(3))))),
+      Arrow(Num, Num),
+    ));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
-let test_ast18 = () => { 
-  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
-  let ze: Hazelnut.Zexp.t = RAp((Var("incr")),NEHole(RAp((Var("incr")),Cursor(EHole))));
+let test_ast18 = () => {
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
+  let ze: Hazelnut.Zexp.t =
+    RAp(Var("incr"), NEHole(RAp(Var("incr"), Cursor(EHole))));
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(3));
-  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
-    Some(
-      RAp((Var("incr")),NEHole(RAp((Var("incr")),Cursor(Lit(3)))))
-    );
+    Some(RAp(Var("incr"), NEHole(RAp(Var("incr"), Cursor(Lit(3))))));
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
 let test_st19 = () => {
-  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
-  let ze: Hazelnut.Zexp.t = RAp((Var("incr")), NEHole(RAp((Var("incr")),Cursor(Lit(3)))));
-  let t: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
+  let ze: Hazelnut.Zexp.t =
+    RAp(Var("incr"), NEHole(RAp(Var("incr"), Cursor(Lit(3)))));
+  let t: Hazelnut.Htyp.t = Arrow(Num, Num);
   let a: Hazelnut.Action.t = Move(Parent);
   let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Hazelnut.syn_action(ctx, (ze, t), a);
   let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-    Some((RAp((Var("incr")),NEHole(Cursor(Ap((Var("incr")),Lit(3))))), Arrow(Num,Num)));
+    Some((
+      RAp(Var("incr"), NEHole(Cursor(Ap(Var("incr"), Lit(3))))),
+      Arrow(Num, Num),
+    ));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
-let test_ast19 = () => { 
-  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
-  let ze: Hazelnut.Zexp.t = RAp((Var("incr")), NEHole(RAp((Var("incr")),Cursor(Lit(3)))));
+let test_ast19 = () => {
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
+  let ze: Hazelnut.Zexp.t =
+    RAp(Var("incr"), NEHole(RAp(Var("incr"), Cursor(Lit(3)))));
   let a: Hazelnut.Action.t = Move(Parent);
-  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
-    Some(
-      RAp((Var("incr")),NEHole(Cursor(Ap((Var("incr")),Lit(3)))))
-    );
+    Some(RAp(Var("incr"), NEHole(Cursor(Ap(Var("incr"), Lit(3))))));
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
 let test_st20 = () => {
-  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
-  let ze: Hazelnut.Zexp.t = RAp((Var("incr")), NEHole(Cursor(Ap((Var("incr")),Lit(3)))));
-  let t: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
+  let ze: Hazelnut.Zexp.t =
+    RAp(Var("incr"), NEHole(Cursor(Ap(Var("incr"), Lit(3)))));
+  let t: Hazelnut.Htyp.t = Arrow(Num, Num);
   let a: Hazelnut.Action.t = Move(Parent);
   let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Hazelnut.syn_action(ctx, (ze, t), a);
   let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-    Some((RAp((Var("incr")),Cursor(NEHole(Ap((Var("incr")),Lit(3))))), Arrow(Num,Num)));
+    Some((
+      RAp(Var("incr"), Cursor(NEHole(Ap(Var("incr"), Lit(3))))),
+      Arrow(Num, Num),
+    ));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
-let test_ast20 = () => { 
-  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
-  let ze: Hazelnut.Zexp.t = RAp((Var("incr")), NEHole(Cursor(Ap((Var("incr")),Lit(3)))));
+let test_ast20 = () => {
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
+  let ze: Hazelnut.Zexp.t =
+    RAp(Var("incr"), NEHole(Cursor(Ap(Var("incr"), Lit(3)))));
   let a: Hazelnut.Action.t = Move(Parent);
-  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
-    Some(
-      RAp((Var("incr")),Cursor(NEHole(Ap((Var("incr")),Lit(3)))))
-    );
+    Some(RAp(Var("incr"), Cursor(NEHole(Ap(Var("incr"), Lit(3))))));
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
 let test_st21 = () => {
-  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
-  let ze: Hazelnut.Zexp.t = RAp((Var("incr")),Cursor(NEHole(Ap((Var("incr")),Lit(3)))));
-  let t: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
+  let ze: Hazelnut.Zexp.t =
+    RAp(Var("incr"), Cursor(NEHole(Ap(Var("incr"), Lit(3)))));
+  let t: Hazelnut.Htyp.t = Arrow(Num, Num);
   let a: Hazelnut.Action.t = Finish;
   let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Hazelnut.syn_action(ctx, (ze, t), a);
   let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-    Some((RAp((Var("incr")),Cursor(Ap((Var("incr")),Lit(3)))), Arrow(Num,Num)));
+    Some((
+      RAp(Var("incr"), Cursor(Ap(Var("incr"), Lit(3)))),
+      Arrow(Num, Num),
+    ));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
-let test_ast21 = () => { 
-  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num,Num));
-  let ze: Hazelnut.Zexp.t = RAp((Var("incr")),Cursor(NEHole(Ap((Var("incr")),Lit(3)))));
+let test_ast21 = () => {
+  let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
+  let ze: Hazelnut.Zexp.t =
+    RAp(Var("incr"), Cursor(NEHole(Ap(Var("incr"), Lit(3)))));
   let a: Hazelnut.Action.t = Finish;
-  let ht: Hazelnut.Htyp.t = Arrow(Num,Num);
+  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
-    Some(
-      RAp((Var("incr")),Cursor(Ap((Var("incr")),Lit(3))))
-    );
+    Some(RAp(Var("incr"), Cursor(Ap(Var("incr"), Lit(3)))));
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
@@ -222,4 +231,4 @@ let sample2_tests = [
   ("test_ast20", `Quick, test_ast20),
   ("test_st21", `Quick, test_st21),
   ("test_ast21", `Quick, test_ast21),
-];
\ No newline at end of file
+];
diff --git a/test/hazelnut_test.re b/test/hazelnut_test.re
index 56a851f..9434f9f 100644
--- a/test/hazelnut_test.re
+++ b/test/hazelnut_test.re
@@ -9,7 +9,6 @@ let () =
       ("ana", Test_ana.ana_tests),
       ("syn_action", Test_syn_action.syn_action_tests),
       ("ana_action", Test_ana_action.ana_action_tests),
-      ("syn_action", Test_syn_action.syn_action_tests),
       ("sample 1", Test_sample1.sample1_tests),
       ("sample 2", Test_sample2.sample2_tests),
     ],
diff --git a/test/test_interface.re b/test/test_interface.re
index 8c187b9..5947d83 100644
--- a/test/test_interface.re
+++ b/test/test_interface.re
@@ -40,16 +40,24 @@ let zexp_print = (ze: option(Hazelnut.Zexp.t)): string =>
 
 let zexp_typ = testable(Fmt.using(zexp_print, Fmt.string), zexp_eq);
 
-let zexp_htyp_eq = (ze_t1: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t)), ze_t2: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t))): bool => 
-  switch (ze_t1,ze_t2) {
-    | (Some((e1,t1)),Some((e2,t2))) => Hazelnut.Zexp.compare(e1, e2) == 0 && Hazelnut.Htyp.compare(t1, t2) == 0
-    | _ => false
+let zexp_htyp_eq =
+    (
+      ze_t1: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)),
+      ze_t2: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)),
+    )
+    : bool =>
+  switch (ze_t1, ze_t2) {
+  | (Some((e1, t1)), Some((e2, t2))) =>
+    Hazelnut.Zexp.compare(e1, e2) == 0 && Hazelnut.Htyp.compare(t1, t2) == 0
+  | _ => false
   };
-  
-let zexp_htyp_print = (ze_t: option((Hazelnut.Zexp.t,Hazelnut.Htyp.t))): string =>
+
+let zexp_htyp_print =
+    (ze_t: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t))): string =>
   switch (ze_t) {
-  | Some((e, _)) => Hazelnut.Zexp.show(e); // have to show both somehow
+  | Some((e, _)) => Hazelnut.Zexp.show(e) // have to show both somehow
   | _ => "None"
   };
 
-let zexp_htyp = testable(Fmt.using(zexp_htyp_print, Fmt.string), zexp_htyp_eq);
+let zexp_htyp =
+  testable(Fmt.using(zexp_htyp_print, Fmt.string), zexp_htyp_eq);

From 320a4dbbf4388ff8b7dd69029850eb6f2d608bc4 Mon Sep 17 00:00:00 2001
From: Razeen Maroof <mrazeen@umich.edu>
Date: Tue, 20 Aug 2024 23:07:54 -0400
Subject: [PATCH 14/17] fixed cases

---
 .DS_Store                   | Bin 0 -> 8196 bytes
 node_modules/.lsp/debug.log | 523 ++++++++++++++++++++++++++++++++++++
 test/Test_ana_action.re     |   2 +-
 test/Test_sample1.re        |   2 +-
 test/Test_sample2.re        |  40 +--
 test/dune                   |   1 +
 test/hazelnut_test.re       |   2 +-
 7 files changed, 547 insertions(+), 23 deletions(-)
 create mode 100644 .DS_Store
 create mode 100644 node_modules/.lsp/debug.log

diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..540a389b38d87cca6ff40aa5a640f27390aa034a
GIT binary patch
literal 8196
zcmeI1O^?z*7{{LhcDH2Lgo8#dCQZEJ3cF^r8!w1(@Ze=JdQgLOTiv?d4uK+xgoLwx
z2fu<>KZ)PPlm6!g(hi^pU)bPGGV`?4=ill4Ixjqhh*)Fj*NDnQ<RA-M+C{M>iR&US
zq@1p~3Co}-ipYNy@iQ;t-h#KSummgtOTZGa1T2B8KmdETNY09VUtP7OC145smjuN6
z;35lK*LJF`Tslz55CFD-YMF41I6!J#ZR^@jm6cN5Q$-I<OPLNan3ChVE8Jo0+D?^K
za$-tOOt;K*gu-O&(7Do`SY26LS^}29A^{P*Z&Qan8d7M)?_w%FK;Hi@lN4usz0shj
zWBo5)FA4`qwfdFi@`bJK9cRbcbzZj5`KX<Ali{Gz?LQZ1PdJaf*>Tr<8U~|I>H0$+
zC*3d(`ce@30bE`@3uB*;8hjZ01F3DR3r^7~c1q>(`0(hs;@+#(CKY#la!{?fM~BtP
zr0CqZefR!p=OVg{`3L#b#PqU3*VOsE{D`AWpWe0mam3>{s27?%$b=N9zG?_6pOMp4
zwAcE1ocswMx;F-i0{IvtF$Gx`?3Te|Z{|mLs7HO`^p*lTqr}h&@@a++ol}?I!#6@J
z!v+6uzw+M@`U@P4_mBslki0C-oEWcZn%ZkanCRXZBpiB-5p#hN^IEQ5#>kXw*QeCl
zwMCa0jWIOouavX-yux!s2&VdOP}~C%jyW4(7Z7~JERS$D$c`{M&(n;GbV@BSZsIMp
zXdhaGDibq2tte0;?z?nmFZH`3><@l(f0_5&AP+oiO?lONS;YUX)!+Zu`i!=5OTZHN
zy98LF*={z_#_UJ3*_?>AUF28DA_>2#vQmOVhU2g@9EY9%VTfZFu0m7ScB(9DkpB6H
W0K5NZBOJT`|0KSY@zh4{|33hdVYA@?

literal 0
HcmV?d00001

diff --git a/node_modules/.lsp/debug.log b/node_modules/.lsp/debug.log
new file mode 100644
index 0000000..e2ff873
--- /dev/null
+++ b/node_modules/.lsp/debug.log
@@ -0,0 +1,523 @@
+Hello - from /Users/razeenmaroof/.vscode/extensions/jaredly.reason-vscode-1.7.13/bin.native
+Previous log location: /var/folders/m8/mfd3fpb16dq5kksg81mm6t_80000gn/T/lsp.log
+Sending notification {"jsonrpc": "2.0", "method": "client/registerCapability", "params": {"registrations": [{"id": "watching", "method": "workspace/didChangeWatchedFiles", "registerOptions": {"watchers": [{"globPattern": "**/bsconfig.json"}, {"globPattern": "**/.merlin"}]}}]}}
+Sending response {"id": 0, "jsonrpc": "2.0", "result": {"capabilities": {"textDocumentSync": 1, "hoverProvider": true, "completionProvider": {"resolveProvider": true, "triggerCharacters": ["."]}, "signatureHelpProvider": {"triggerCharacters": ["("]}, "definitionProvider": true, "typeDefinitionProvider": true, "referencesProvider": true, "documentSymbolProvider": true, "codeActionProvider": true, "executeCommandProvider": {"commands": ["reason-language-server.add_to_interface_inner"]}, "codeLensProvider": {"resolveProvider": true}, "documentHighlightProvider": true, "documentRangeFormattingProvider": true, "documentFormattingProvider": true, "renameProvider": true}}}
+Read message 
+{"jsonrpc":"2.0","method":"initialized","params":{}}
+Read message 
+{"jsonrpc":"2.0","method":"workspace/didChangeConfiguration","params":{"settings":{"reason_language_server":{"location":"","build_system_override_by_root":{},"refmt":"","lispRefmt":"","mlfmt":"","format_width":80,"per_value_codelens":false,"dependencies_codelens":true,"opens_codelens":true,"show_module_path_on_hover":true,"reloadOnChange":false,"show_debug_errors":false,"autoRebuild":true}}}}
+Read message 
+{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re","languageId":"reason","version":1,"text":"open Sexplib.Std;\n// open Monad_lib.Monad; // Uncomment this line to use the maybe monad\n\nlet compare_string = String.compare;\nlet compare_int = Int.compare;\n\nmodule Htyp = {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Arrow(t, t)\n    | Num\n    | Hole;\n};\n\nmodule Hexp = {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Var(string)\n    | Lam(string, t)\n    | Ap(t, t)\n    | Lit(int)\n    | Plus(t, t)\n    | Asc(t, Htyp.t)\n    | EHole\n    | NEHole(t);\n};\n\nmodule Ztyp = {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Cursor(Htyp.t)\n    | LArrow(t, Htyp.t)\n    | RArrow(Htyp.t, t);\n};\n\nmodule Zexp = {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Cursor(Hexp.t)\n    | Lam(string, t)\n    | LAp(t, Hexp.t)\n    | RAp(Hexp.t, t)\n    | LPlus(t, Hexp.t)\n    | RPlus(Hexp.t, t)\n    | LAsc(t, Htyp.t)\n    | RAsc(Hexp.t, Ztyp.t)\n    | NEHole(t);\n};\n\nmodule Child = {\n  [@deriving (sexp, compare)]\n  type t =\n    | One\n    | Two;\n};\n\nmodule Dir = {\n  [@deriving (sexp, compare)]\n  type t =\n    | Child(Child.t)\n    | Parent;\n};\n\nmodule Shape = {\n  [@deriving (sexp, compare)]\n  type t =\n    | Arrow\n    | Num\n    | Asc\n    | Var(string)\n    | Lam(string)\n    | Ap\n    | Lit(int)\n    | Plus\n    | NEHole;\n};\n\nmodule Action = {\n  [@deriving (sexp, compare)]\n  type t =\n    | Move(Dir.t)\n    | Construct(Shape.t)\n    | Del\n    | Finish;\n};\n\nmodule TypCtx = Map.Make(String);\ntype typctx = TypCtx.t(Htyp.t);\n\nexception Unimplemented;\n\nlet erase_exp = (e: Zexp.t): Hexp.t => {\n  // Used to suppress unused variable warnings\n  // Okay to remove\n  let _ = e;\n\n  raise(Unimplemented);\n};\n\nlet syn = (ctx: typctx, e: Hexp.t): option(Htyp.t) => {\n  // Used to suppress unused variable warnings\n  // Okay to remove\n  let _ = ctx;\n  let _ = e;\n\n  raise(Unimplemented);\n}\n\nand ana = (ctx: typctx, e: Hexp.t, t: Htyp.t): bool => {\n  // Used to suppress unused variable warnings\n  // Okay to remove\n  let _ = ctx;\n  let _ = e;\n  let _ = t;\n\n  raise(Unimplemented);\n};\n\nlet syn_action =\n    (ctx: typctx, (e: Zexp.t, t: Htyp.t), a: Action.t)\n    : option((Zexp.t, Htyp.t)) => {\n  // Used to suppress unused variable warnings\n  // Okay to remove\n  let _ = ctx;\n  let _ = e;\n  let _ = t;\n  let _ = a;\n\n  raise(Unimplemented);\n}\n\nand ana_action =\n    (ctx: typctx, e: Zexp.t, a: Action.t, t: Htyp.t): option(Zexp.t) => {\n  // Used to suppress unused variable warnings\n  // Okay to remove\n  let _ = ctx;\n  let _ = e;\n  let _ = a;\n  let _ = t;\n\n  raise(Unimplemented);\n};\n"}}}
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending notification {"jsonrpc": "2.0", "method": "window/showMessage", "params": {"type": 1, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":1,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"},"range":{"start":{"line":96,"character":0},"end":{"line":97,"character":0}},"context":{"diagnostics":[]}}}
+[server] Got a method textDocument/codeAction
+[server] processing took 0.00405311584473ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 1, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":1}}
+Read message 
+{"jsonrpc":"2.0","id":2,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"},"range":{"start":{"line":96,"character":0},"end":{"line":97,"character":0}},"context":{"diagnostics":[]}}}
+[server] Got a method textDocument/codeAction
+[server] processing took 0.00405311584473ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 2, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Read message 
+{"jsonrpc":"2.0","method":"$/setTraceNotification","params":{"value":"off"}}
+Read message 
+{"jsonrpc":"2.0","method":"workspace/didChangeConfiguration","params":{"settings":{"reason_language_server":{"location":"","build_system_override_by_root":{},"refmt":"","lispRefmt":"","mlfmt":"","format_width":80,"per_value_codelens":false,"dependencies_codelens":true,"opens_codelens":true,"show_module_path_on_hover":true,"reloadOnChange":false,"show_debug_errors":false,"autoRebuild":true}}}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":2}}
+Read message 
+{"jsonrpc":"2.0","id":3,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"},"range":{"start":{"line":96,"character":0},"end":{"line":97,"character":0}},"context":{"diagnostics":[]}}}
+[server] Got a method textDocument/codeAction
+[server] processing took 0.00309944152832ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 3, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":3}}
+Read message 
+{"jsonrpc":"2.0","id":4,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"},"range":{"start":{"line":96,"character":0},"end":{"line":97,"character":0}},"context":{"diagnostics":[]}}}
+[server] Got a method textDocument/codeAction
+[server] processing took 0.00309944152832ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 4, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":4}}
+Read message 
+{"jsonrpc":"2.0","method":"$/setTraceNotification","params":{"value":"off"}}
+Read message 
+{"jsonrpc":"2.0","method":"workspace/didChangeConfiguration","params":{"settings":{"reason_language_server":{"location":"","build_system_override_by_root":{},"refmt":"","lispRefmt":"","mlfmt":"","format_width":80,"per_value_codelens":false,"dependencies_codelens":true,"opens_codelens":true,"show_module_path_on_hover":true,"reloadOnChange":false,"show_debug_errors":false,"autoRebuild":true}}}}
+Read message 
+{"jsonrpc":"2.0","method":"$/setTraceNotification","params":{"value":"off"}}
+Read message 
+{"jsonrpc":"2.0","method":"workspace/didChangeConfiguration","params":{"settings":{"reason_language_server":{"location":"","build_system_override_by_root":{},"refmt":"","lispRefmt":"","mlfmt":"","format_width":80,"per_value_codelens":false,"dependencies_codelens":true,"opens_codelens":true,"show_module_path_on_hover":true,"reloadOnChange":false,"show_debug_errors":false,"autoRebuild":true}}}}
+Read message 
+{"jsonrpc":"2.0","method":"$/setTraceNotification","params":{"value":"off"}}
+Read message 
+{"jsonrpc":"2.0","method":"workspace/didChangeConfiguration","params":{"settings":{"reason_language_server":{"location":"","build_system_override_by_root":{},"refmt":"","lispRefmt":"","mlfmt":"","format_width":80,"per_value_codelens":false,"dependencies_codelens":true,"opens_codelens":true,"show_module_path_on_hover":true,"reloadOnChange":false,"show_debug_errors":false,"autoRebuild":true}}}}
+Read message 
+{"jsonrpc":"2.0","method":"textDocument/didClose","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"}}}
+Read message 
+{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.rei","languageId":"reason","version":1,"text":"module Htyp: {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Arrow(t, t)\n    | Num\n    | Hole;\n};\n\nmodule Hexp: {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Var(string)\n    | Lam(string, t)\n    | Ap(t, t)\n    | Lit(int)\n    | Plus(t, t)\n    | Asc(t, Htyp.t)\n    | EHole\n    | NEHole(t);\n};\n\nmodule Ztyp: {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Cursor(Htyp.t)\n    | LArrow(t, Htyp.t)\n    | RArrow(Htyp.t, t);\n};\n\nmodule Zexp: {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Cursor(Hexp.t)\n    | Lam(string, t)\n    | LAp(t, Hexp.t)\n    | RAp(Hexp.t, t)\n    | LPlus(t, Hexp.t)\n    | RPlus(Hexp.t, t)\n    | LAsc(t, Htyp.t)\n    | RAsc(Hexp.t, Ztyp.t)\n    | NEHole(t);\n};\n\nmodule Child: {\n  type t =\n    | One\n    | Two;\n};\n\nmodule Dir: {\n  type t =\n    | Child(Child.t)\n    | Parent;\n};\n\nmodule Shape: {\n  type t =\n    | Arrow\n    | Num\n    | Asc\n    | Var(string)\n    | Lam(string)\n    | Ap\n    | Lit(int)\n    | Plus\n    | NEHole;\n};\n\nmodule Action: {\n  [@deriving (sexp, compare)]\n  type t =\n    | Move(Dir.t)\n    | Construct(Shape.t)\n    | Del\n    | Finish;\n};\n\nmodule TypCtx: {\n  type t('a) = Map.Make(String).t('a);\n  let empty: t('a);\n};\ntype typctx = TypCtx.t(Htyp.t);\n\nexception Unimplemented;\n\nlet erase_exp: Zexp.t => Hexp.t;\nlet syn: (typctx, Hexp.t) => option(Htyp.t);\nlet ana: (typctx, Hexp.t, Htyp.t) => bool;\nlet syn_action:\n  (typctx, (Zexp.t, Htyp.t), Action.t) => option((Zexp.t, Htyp.t));\nlet ana_action: (typctx, Zexp.t, Action.t, Htyp.t) => option(Zexp.t);\n"}}}
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending notification {"jsonrpc": "2.0", "method": "window/showMessage", "params": {"type": 1, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":5,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.rei"},"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":0}},"context":{"diagnostics":[]}}}
+[server] Got a method textDocument/codeAction
+[server] processing took 0.00500679016113ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 5, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":6,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.rei"}}}
+[server] Got a method textDocument/documentSymbol
+[server] processing took 0.00381469726562ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 6, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":7,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.rei"}}}
+[server] Got a method textDocument/documentSymbol
+[server] processing took 0.00619888305664ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 7, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":7}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":6}}
+Read message 
+{"jsonrpc":"2.0","method":"textDocument/didClose","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.rei"}}}
+Read message 
+{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re","languageId":"reason","version":1,"text":"open Sexplib.Std;\n// open Monad_lib.Monad; // Uncomment this line to use the maybe monad\n\nlet compare_string = String.compare;\nlet compare_int = Int.compare;\n\nmodule Htyp = {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Arrow(t, t)\n    | Num\n    | Hole;\n};\n\nmodule Hexp = {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Var(string)\n    | Lam(string, t)\n    | Ap(t, t)\n    | Lit(int)\n    | Plus(t, t)\n    | Asc(t, Htyp.t)\n    | EHole\n    | NEHole(t);\n};\n\nmodule Ztyp = {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Cursor(Htyp.t)\n    | LArrow(t, Htyp.t)\n    | RArrow(Htyp.t, t);\n};\n\nmodule Zexp = {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Cursor(Hexp.t)\n    | Lam(string, t)\n    | LAp(t, Hexp.t)\n    | RAp(Hexp.t, t)\n    | LPlus(t, Hexp.t)\n    | RPlus(Hexp.t, t)\n    | LAsc(t, Htyp.t)\n    | RAsc(Hexp.t, Ztyp.t)\n    | NEHole(t);\n};\n\nmodule Child = {\n  [@deriving (sexp, compare)]\n  type t =\n    | One\n    | Two;\n};\n\nmodule Dir = {\n  [@deriving (sexp, compare)]\n  type t =\n    | Child(Child.t)\n    | Parent;\n};\n\nmodule Shape = {\n  [@deriving (sexp, compare)]\n  type t =\n    | Arrow\n    | Num\n    | Asc\n    | Var(string)\n    | Lam(string)\n    | Ap\n    | Lit(int)\n    | Plus\n    | NEHole;\n};\n\nmodule Action = {\n  [@deriving (sexp, compare)]\n  type t =\n    | Move(Dir.t)\n    | Construct(Shape.t)\n    | Del\n    | Finish;\n};\n\nmodule TypCtx = Map.Make(String);\ntype typctx = TypCtx.t(Htyp.t);\n\nexception Unimplemented;\n\nlet erase_exp = (e: Zexp.t): Hexp.t => {\n  // Used to suppress unused variable warnings\n  // Okay to remove\n  let _ = e;\n\n  raise(Unimplemented);\n};\n\nlet syn = (ctx: typctx, e: Hexp.t): option(Htyp.t) => {\n  // Used to suppress unused variable warnings\n  // Okay to remove\n  let _ = ctx;\n  let _ = e;\n\n  raise(Unimplemented);\n}\n\nand ana = (ctx: typctx, e: Hexp.t, t: Htyp.t): bool => {\n  // Used to suppress unused variable warnings\n  // Okay to remove\n  let _ = ctx;\n  let _ = e;\n  let _ = t;\n\n  raise(Unimplemented);\n};\n\nlet syn_action =\n    (ctx: typctx, (e: Zexp.t, t: Htyp.t), a: Action.t)\n    : option((Zexp.t, Htyp.t)) => {\n  // Used to suppress unused variable warnings\n  // Okay to remove\n  let _ = ctx;\n  let _ = e;\n  let _ = t;\n  let _ = a;\n\n  raise(Unimplemented);\n}\n\nand ana_action =\n    (ctx: typctx, e: Zexp.t, a: Action.t, t: Htyp.t): option(Zexp.t) => {\n  // Used to suppress unused variable warnings\n  // Okay to remove\n  let _ = ctx;\n  let _ = e;\n  let _ = a;\n  let _ = t;\n\n  raise(Unimplemented);\n};\n"}}}
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending notification {"jsonrpc": "2.0", "method": "window/showMessage", "params": {"type": 1, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":8,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"},"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":0}},"context":{"diagnostics":[]}}}
+[server] Got a method textDocument/codeAction
+[server] processing took 0.00381469726562ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 8, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":9,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"}}}
+[server] Got a method textDocument/documentSymbol
+[server] processing took 0.00381469726562ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 9, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":10,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"},"range":{"start":{"line":96,"character":0},"end":{"line":97,"character":0}},"context":{"diagnostics":[]}}}
+[server] Got a method textDocument/codeAction
+[server] processing took 0.00500679016113ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 10, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":8}}
+Read message 
+{"jsonrpc":"2.0","id":11,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"}}}
+[server] Got a method textDocument/documentSymbol
+[server] processing took 0.00596046447754ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 11, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":12,"method":"textDocument/codeLens","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"}}}
+[server] Got a method textDocument/codeLens
+[server] processing took 0.00381469726562ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 12, "jsonrpc": "2.0", "result": [{"range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 0}}, "command": {"title": "Unable to load compilation data: Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin", "command": ""}}]}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":12}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":11}}
+Read message 
+{"jsonrpc":"2.0","method":"textDocument/didClose","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"}}}
+Read message 
+{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.rei","languageId":"reason","version":1,"text":"module Htyp: {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Arrow(t, t)\n    | Num\n    | Hole;\n};\n\nmodule Hexp: {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Var(string)\n    | Lam(string, t)\n    | Ap(t, t)\n    | Lit(int)\n    | Plus(t, t)\n    | Asc(t, Htyp.t)\n    | EHole\n    | NEHole(t);\n};\n\nmodule Ztyp: {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Cursor(Htyp.t)\n    | LArrow(t, Htyp.t)\n    | RArrow(Htyp.t, t);\n};\n\nmodule Zexp: {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Cursor(Hexp.t)\n    | Lam(string, t)\n    | LAp(t, Hexp.t)\n    | RAp(Hexp.t, t)\n    | LPlus(t, Hexp.t)\n    | RPlus(Hexp.t, t)\n    | LAsc(t, Htyp.t)\n    | RAsc(Hexp.t, Ztyp.t)\n    | NEHole(t);\n};\n\nmodule Child: {\n  type t =\n    | One\n    | Two;\n};\n\nmodule Dir: {\n  type t =\n    | Child(Child.t)\n    | Parent;\n};\n\nmodule Shape: {\n  type t =\n    | Arrow\n    | Num\n    | Asc\n    | Var(string)\n    | Lam(string)\n    | Ap\n    | Lit(int)\n    | Plus\n    | NEHole;\n};\n\nmodule Action: {\n  [@deriving (sexp, compare)]\n  type t =\n    | Move(Dir.t)\n    | Construct(Shape.t)\n    | Del\n    | Finish;\n};\n\nmodule TypCtx: {\n  type t('a) = Map.Make(String).t('a);\n  let empty: t('a);\n};\ntype typctx = TypCtx.t(Htyp.t);\n\nexception Unimplemented;\n\nlet erase_exp: Zexp.t => Hexp.t;\nlet syn: (typctx, Hexp.t) => option(Htyp.t);\nlet ana: (typctx, Hexp.t, Htyp.t) => bool;\nlet syn_action:\n  (typctx, (Zexp.t, Htyp.t), Action.t) => option((Zexp.t, Htyp.t));\nlet ana_action: (typctx, Zexp.t, Action.t, Htyp.t) => option(Zexp.t);\n"}}}
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending notification {"jsonrpc": "2.0", "method": "window/showMessage", "params": {"type": 1, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":13,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.rei"},"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":0}},"context":{"diagnostics":[]}}}
+[server] Got a method textDocument/codeAction
+[server] processing took 0.00309944152832ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 13, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":14,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.rei"}}}
+[server] Got a method textDocument/documentSymbol
+[server] processing took 0.00405311584473ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 14, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":15,"method":"textDocument/codeLens","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.rei"}}}
+[server] Got a method textDocument/codeLens
+[server] processing took 0.00309944152832ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 15, "jsonrpc": "2.0", "result": [{"range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 0}}, "command": {"title": "Unable to load compilation data: Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin", "command": ""}}]}
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Read message 
+{"jsonrpc":"2.0","id":16,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.rei"}}}
+[server] Got a method textDocument/documentSymbol
+[server] processing took 0.00500679016113ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 16, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":15}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":16}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":13}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":14}}
+Read message 
+{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/hazelnut_test.re","languageId":"reason","version":1,"text":"open Alcotest;\n\nlet () =\n  run(\n    \"Hazelnut_tests\",\n    [\n      (\"erase_exp\", Test_erase_exp.erase_exp_tests),\n      (\"syn\", Test_syn.syn_tests),\n      (\"ana\", Test_ana.ana_tests),\n      (\"syn_action\", Test_syn_action.syn_action_tests),\n      (\"ana_action\", Test_ana_action.ana_action_tests),\n      (\"sample 1\", Test_sample1.sample1_tests),\n      (\"sample 2\", Test_sample2.sample2_tests),\n    ],\n  );\n"}}}
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending notification {"jsonrpc": "2.0", "method": "window/showMessage", "params": {"type": 1, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":17,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/hazelnut_test.re"},"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":0}},"context":{"diagnostics":[]}}}
+[server] Got a method textDocument/codeAction
+[server] processing took 0.00286102294922ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 17, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":18,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/hazelnut_test.re"}}}
+[server] Got a method textDocument/documentSymbol
+[server] processing took 0.00405311584473ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 18, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":19,"method":"textDocument/codeLens","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/hazelnut_test.re"}}}
+[server] Got a method textDocument/codeLens
+[server] processing took 0.00309944152832ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 19, "jsonrpc": "2.0", "result": [{"range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 0}}, "command": {"title": "Unable to load compilation data: Unable to read /Users/razeenmaroof/research/Finished/test/.merlin", "command": ""}}]}
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Read message 
+{"jsonrpc":"2.0","id":20,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/hazelnut_test.re"},"range":{"start":{"line":12,"character":0},"end":{"line":12,"character":0}},"context":{"diagnostics":[]}}}
+[server] Got a method textDocument/codeAction
+[server] processing took 0.00596046447754ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 20, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":17}}
+Read message 
+{"jsonrpc":"2.0","id":21,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/hazelnut_test.re"}}}
+[server] Got a method textDocument/documentSymbol
+[server] processing took 0.00476837158203ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 21, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":19}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":21}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":20}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":18}}
+Read message 
+{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_syn_action.re","languageId":"reason","version":1,"text":"open Alcotest;\nopen Test_interface;\nmodule Hazelnut = Hazelnut_lib.Hazelnut;\nmodule TypCtx = Map.Make(String);\ntype typctx = Hazelnut.TypCtx.t(Hazelnut.Htyp.t);\n\nlet test_samove_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    LAsc(Cursor(Lam(\"x\", EHole)), Arrow(Hole, Hole));\n  let t: Hazelnut.Htyp.t = Arrow(Hole, Hole);\n  let a: Hazelnut.Action.t = Move(Child(One));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      LAsc(Lam(\"x\", Cursor(EHole)), Arrow(Hole, Hole)),\n      Arrow(Hole, Hole),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_sadel_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(Lit(1));\n  let t: Hazelnut.Htyp.t = Num;\n  let a: Hazelnut.Action.t = Del;\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((Cursor(EHole), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_sadel_2 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = NEHole(Cursor(Lit(1)));\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Del;\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((NEHole(Cursor(EHole)), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconasc_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(Lit(1));\n  let t: Hazelnut.Htyp.t = Num;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Asc);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((RAsc(Lit(1), Cursor(Num)), Num));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconasc_2 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(EHole);\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Asc);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((RAsc(EHole, Cursor(Hole)), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconasc_3 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = NEHole(Cursor(Lit(1)));\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Asc);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((NEHole(RAsc(Lit(1), Cursor(Num))), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconvar_1 = () => {\n  let ctx: typctx = TypCtx.singleton(\"x\", Hazelnut.Htyp.Num);\n  let ze: Hazelnut.Zexp.t = Cursor(EHole);\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var(\"x\"));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((Cursor(Var(\"x\")), Num));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconvar_2 = () => {\n  let ctx: typctx = TypCtx.singleton(\"x\", Hazelnut.Htyp.Num);\n  let ze: Hazelnut.Zexp.t = NEHole(Cursor(EHole));\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var(\"x\"));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((NEHole(Cursor(Var(\"x\"))), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconlam_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(EHole);\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lam(\"x\"));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAsc(Lam(\"x\", EHole), LArrow(Cursor(Hole), Hole)),\n      Arrow(Hole, Hole),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconlam_2 = () => {\n  //CHECK THIS ONE\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = NEHole(Cursor(EHole));\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lam(\"x\"));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      NEHole(RAsc(Lam(\"x\", EHole), LArrow(Cursor(Hole), Hole))),\n      Hole,\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconnumlit_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(EHole);\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(1));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((Cursor(Lit(1)), Num));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconnumlit_2 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = NEHole(Cursor(EHole));\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(1));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((NEHole(Cursor(Lit(1))), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconnehole_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(Lit(1));\n  let t: Hazelnut.Htyp.t = Num;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.NEHole);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((NEHole(Cursor(Lit(1))), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconnehole_2 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = NEHole(Cursor(Lit(1)));\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.NEHole);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((NEHole(NEHole(Cursor(Lit(1)))), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconaparr_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(Lam(\"x\", EHole));\n  let t: Hazelnut.Htyp.t = Arrow(Hole, Hole);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((RAp(Lam(\"x\", EHole), Cursor(EHole)), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconapotw_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(Lit(1));\n  let t: Hazelnut.Htyp.t = Num;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((RAp(NEHole(Lit(1)), Cursor(EHole)), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconapotw_2 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = NEHole(Cursor(Lit(1)));\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((NEHole(RAp(NEHole(Lit(1)), Cursor(EHole))), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconplus1_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(Lit(1));\n  let t: Hazelnut.Htyp.t = Num;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((RPlus(Lit(1), Cursor(EHole)), Num));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconplus1_2 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = NEHole(Cursor(Lit(1)));\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((NEHole(RPlus(Lit(1), Cursor(EHole))), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconplus2_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(Lam(\"x\", EHole));\n  let t: Hazelnut.Htyp.t = Arrow(Hole, Hole);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((RPlus(NEHole(Lam(\"x\", EHole)), Cursor(EHole)), Num));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_safinish_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(NEHole(Lit(1)));\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Finish;\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((Cursor(Lit(1)), Num));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_safinish_2 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = NEHole(Cursor(NEHole(Lit(1))));\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Finish;\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((NEHole(Cursor(Lit(1))), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet syn_action_tests = [\n  (\"test_samove_1\", `Quick, test_sadel_1),\n  (\"test_sadel_1\", `Quick, test_sadel_1),\n  (\"test_sadel_2\", `Quick, test_sadel_2),\n  (\"test_safinish_1\", `Quick, test_safinish_1),\n  (\"test_safinish_2\", `Quick, test_safinish_2),\n  (\"test_saconasc_1\", `Quick, test_saconasc_1),\n  (\"test_saconasc_2\", `Quick, test_saconasc_2),\n  (\"test_saconasc_3\", `Quick, test_saconasc_3),\n  (\"test_saconvar_1\", `Quick, test_saconvar_1),\n  (\"test_saconvar_2\", `Quick, test_saconvar_2),\n  (\"test_saconlam_1\", `Quick, test_saconlam_1),\n  (\"test_saconlam_2\", `Quick, test_saconlam_2),\n  (\"test_saconnumlit_1\", `Quick, test_saconnumlit_1),\n  (\"test_saconnumlit_2\", `Quick, test_saconnumlit_2),\n  (\"test_saconnehole_1\", `Quick, test_saconnehole_1),\n  (\"test_saconnehole_2\", `Quick, test_saconnehole_2),\n  (\"test_saconaparr_1\", `Quick, test_saconaparr_1),\n  (\"test_saconapotw_1\", `Quick, test_saconapotw_1),\n  (\"test_saconapotw_2\", `Quick, test_saconapotw_2),\n  (\"test_saconplus1_1\", `Quick, test_saconplus1_1),\n  (\"test_saconplus1_2\", `Quick, test_saconplus1_2),\n  (\"test_saconplus2_1\", `Quick, test_saconplus2_1),\n];\n"}}}
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending notification {"jsonrpc": "2.0", "method": "window/showMessage", "params": {"type": 1, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":22,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_syn_action.re"},"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":0}},"context":{"diagnostics":[]}}}
+[server] Got a method textDocument/codeAction
+[server] processing took 0.00596046447754ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 22, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":23,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_syn_action.re"}}}
+[server] Got a method textDocument/documentSymbol
+[server] processing took 0.00405311584473ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 23, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Read message 
+{"jsonrpc":"2.0","id":24,"method":"textDocument/codeLens","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_syn_action.re"}}}
+[server] Got a method textDocument/codeLens
+[server] processing took 0.00286102294922ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 24, "jsonrpc": "2.0", "result": [{"range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 0}}, "command": {"title": "Unable to load compilation data: Unable to read /Users/razeenmaroof/research/Finished/test/.merlin", "command": ""}}]}
+Read message 
+{"jsonrpc":"2.0","id":25,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_syn_action.re"}}}
+[server] Got a method textDocument/documentSymbol
+[server] processing took 0.00500679016113ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 25, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":24}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":25}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":22}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":23}}
+Read message 
+{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample2.re","languageId":"reason","version":1,"text":"open Alcotest;\nopen Test_interface;\nmodule Hazelnut = Hazelnut_lib.Hazelnut;\n\nmodule TypCtx = Map.Make(String);\ntype typctx = Hazelnut.TypCtx.t(Hazelnut.Htyp.t);\n\nlet test_st14 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t = Cursor(EHole);\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var(\"incr\"));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((Cursor(Var(\"incr\")), Arrow(Num, Num)));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast14 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t = Cursor(EHole);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var(\"incr\"));\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) = Some(Cursor(Var(\"incr\")));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st15 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t = Cursor(Var(\"incr\"));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((RAp(Var(\"incr\"), Cursor(EHole)), Arrow(Num, Num)));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast15 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t = Cursor(Var(\"incr\"));\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAp(Var(\"incr\"), Cursor(EHole)));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st16 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t = RAp(Var(\"incr\"), Cursor(EHole));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var(\"incr\"));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAp(Var(\"incr\"), NEHole(Cursor(Var(\"incr\")))),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast16 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t = RAp(Var(\"incr\"), Cursor(EHole));\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var(\"incr\"));\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAp(Var(\"incr\"), NEHole(Cursor(Var(\"incr\")))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st17 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t = RAp(Var(\"incr\"), NEHole(Cursor(Var(\"incr\"))));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAp(Var(\"incr\"), NEHole(RAp(Var(\"incr\"), Cursor(EHole)))),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast17 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t = RAp(Var(\"incr\"), NEHole(Cursor(Var(\"incr\"))));\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAp(Var(\"incr\"), NEHole(RAp(Var(\"incr\"), Cursor(EHole)))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st18 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t =\n    RAp(Var(\"incr\"), NEHole(RAp(Var(\"incr\"), Cursor(EHole))));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(3));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAp(Var(\"incr\"), NEHole(RAp(Var(\"incr\"), Cursor(Lit(3))))),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast18 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t =\n    RAp(Var(\"incr\"), NEHole(RAp(Var(\"incr\"), Cursor(EHole))));\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(3));\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAp(Var(\"incr\"), NEHole(RAp(Var(\"incr\"), Cursor(Lit(3))))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st19 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t =\n    RAp(Var(\"incr\"), NEHole(RAp(Var(\"incr\"), Cursor(Lit(3)))));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Move(Parent);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAp(Var(\"incr\"), NEHole(Cursor(Ap(Var(\"incr\"), Lit(3))))),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast19 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t =\n    RAp(Var(\"incr\"), NEHole(RAp(Var(\"incr\"), Cursor(Lit(3)))));\n  let a: Hazelnut.Action.t = Move(Parent);\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAp(Var(\"incr\"), NEHole(Cursor(Ap(Var(\"incr\"), Lit(3))))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st20 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t =\n    RAp(Var(\"incr\"), NEHole(Cursor(Ap(Var(\"incr\"), Lit(3)))));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Move(Parent);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAp(Var(\"incr\"), Cursor(NEHole(Ap(Var(\"incr\"), Lit(3))))),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast20 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t =\n    RAp(Var(\"incr\"), NEHole(Cursor(Ap(Var(\"incr\"), Lit(3)))));\n  let a: Hazelnut.Action.t = Move(Parent);\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAp(Var(\"incr\"), Cursor(NEHole(Ap(Var(\"incr\"), Lit(3))))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st21 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t =\n    RAp(Var(\"incr\"), Cursor(NEHole(Ap(Var(\"incr\"), Lit(3)))));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Finish;\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAp(Var(\"incr\"), Cursor(Ap(Var(\"incr\"), Lit(3)))),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast21 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t =\n    RAp(Var(\"incr\"), Cursor(NEHole(Ap(Var(\"incr\"), Lit(3)))));\n  let a: Hazelnut.Action.t = Finish;\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAp(Var(\"incr\"), Cursor(Ap(Var(\"incr\"), Lit(3)))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet sample2_tests = [\n  (\"test_st14\", `Quick, test_st14),\n  (\"test_ast14\", `Quick, test_ast14),\n  (\"test_st15\", `Quick, test_st15),\n  (\"test_ast15\", `Quick, test_ast15),\n  (\"test_st16\", `Quick, test_st16),\n  (\"test_ast16\", `Quick, test_ast16),\n  (\"test_st17\", `Quick, test_st17),\n  (\"test_ast17\", `Quick, test_ast17),\n  (\"test_st18\", `Quick, test_st18),\n  (\"test_ast18\", `Quick, test_ast18),\n  (\"test_st19\", `Quick, test_st19),\n  (\"test_ast19\", `Quick, test_ast19),\n  (\"test_st20\", `Quick, test_st20),\n  (\"test_ast20\", `Quick, test_ast20),\n  (\"test_st21\", `Quick, test_st21),\n  (\"test_ast21\", `Quick, test_ast21),\n];\n"}}}
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending notification {"jsonrpc": "2.0", "method": "window/showMessage", "params": {"type": 1, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":26,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample2.re"},"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":0}},"context":{"diagnostics":[]}}}
+[server] Got a method textDocument/codeAction
+[server] processing took 0.00381469726562ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 26, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":27,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample2.re"}}}
+[server] Got a method textDocument/documentSymbol
+[server] processing took 0.00309944152832ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 27, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":28,"method":"textDocument/codeLens","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample2.re"}}}
+[server] Got a method textDocument/codeLens
+[server] processing took 0.00500679016113ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 28, "jsonrpc": "2.0", "result": [{"range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 0}}, "command": {"title": "Unable to load compilation data: Unable to read /Users/razeenmaroof/research/Finished/test/.merlin", "command": ""}}]}
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Read message 
+{"jsonrpc":"2.0","id":29,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample2.re"}}}
+[server] Got a method textDocument/documentSymbol
+[server] processing took 0.00286102294922ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 29, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":28}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":29}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":26}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":27}}
+Read message 
+{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample1.re","languageId":"reason","version":1,"text":"open Alcotest;\nopen Test_interface;\nmodule Hazelnut = Hazelnut_lib.Hazelnut;\n\nmodule TypCtx = Map.Make(String);\ntype typctx = Hazelnut.TypCtx.t(Hazelnut.Htyp.t);\n\nlet test_st1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(EHole);\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lam(\"x\"));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAsc(Lam(\"x\", EHole), LArrow(Cursor(Hole), Hole)),\n      Arrow(Hole, Hole),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(EHole);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lam(\"x\"));\n  let ht: Hazelnut.Htyp.t = Arrow(Hole, Hole);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) = Some(Lam(\"x\", Cursor(EHole)));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st2 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    RAsc(Lam(\"x\", EHole), LArrow(Cursor(Hole), Hole));\n  let t: Hazelnut.Htyp.t = Arrow(Hole, Hole);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Num);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAsc(Lam(\"x\", EHole), LArrow(Cursor(Num), Hole)),\n      Arrow(Num, Hole),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast2 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    RAsc(Lam(\"x\", EHole), LArrow(Cursor(Hole), Hole));\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Num);\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Hole);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAsc(Lam(\"x\", EHole), LArrow(Cursor(Num), Hole)));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st3 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    RAsc(Lam(\"x\", EHole), LArrow(Cursor(Num), Hole));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Hole);\n  let a: Hazelnut.Action.t = Move(Parent);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAsc(Lam(\"x\", EHole), Cursor(Arrow(Num, Hole))),\n      Arrow(Num, Hole),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast3 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    RAsc(Lam(\"x\", EHole), LArrow(Cursor(Num), Hole));\n  let a: Hazelnut.Action.t = Move(Parent);\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Hole);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAsc(Lam(\"x\", EHole), Cursor(Arrow(Num, Hole))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st4 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    RAsc(Lam(\"x\", EHole), Cursor(Arrow(Num, Hole)));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Hole);\n  let a: Hazelnut.Action.t = Move(Child(Two));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAsc(Lam(\"x\", EHole), RArrow(Num, Cursor(Hole))),\n      Arrow(Num, Hole),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast4 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    RAsc(Lam(\"x\", EHole), Cursor(Arrow(Num, Hole)));\n  let a: Hazelnut.Action.t = Move(Child(Two));\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Hole);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAsc(Lam(\"x\", EHole), RArrow(Num, Cursor(Hole))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st5 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    RAsc(Lam(\"x\", EHole), RArrow(Num, Cursor(Hole)));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Hole);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Num);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAsc(Lam(\"x\", EHole), RArrow(Num, Cursor(Num))),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast5 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    RAsc(Lam(\"x\", EHole), RArrow(Num, Cursor(Hole)));\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Num);\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAsc(Lam(\"x\", EHole), RArrow(Num, Cursor(Num))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st6 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    RAsc(Lam(\"x\", EHole), RArrow(Num, Cursor(Num)));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Move(Parent);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAsc(Lam(\"x\", EHole), Cursor(Arrow(Num, Num))),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast6 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    RAsc(Lam(\"x\", EHole), RArrow(Num, Cursor(Num)));\n  let a: Hazelnut.Action.t = Move(Parent);\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAsc(Lam(\"x\", EHole), Cursor(Arrow(Num, Num))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st7 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = RAsc(Lam(\"x\", EHole), Cursor(Arrow(Num, Num)));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Move(Parent);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      Cursor(Asc(Lam(\"x\", EHole), Arrow(Num, Num))),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast7 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = RAsc(Lam(\"x\", EHole), Cursor(Arrow(Num, Num)));\n  let a: Hazelnut.Action.t = Move(Parent);\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(Cursor(Asc(Lam(\"x\", EHole), Arrow(Num, Num))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st8 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(Asc(Lam(\"x\", EHole), Arrow(Num, Num)));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Move(Child(One));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      LAsc(Cursor(Lam(\"x\", EHole)), Arrow(Num, Num)),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast8 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(Asc(Lam(\"x\", EHole), Arrow(Num, Num)));\n  let a: Hazelnut.Action.t = Move(Child(One));\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(LAsc(Cursor(Lam(\"x\", EHole)), Arrow(Num, Num)));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st9 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = LAsc(Cursor(Lam(\"x\", EHole)), Arrow(Num, Num));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Move(Child(One));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      LAsc(Lam(\"x\", Cursor(EHole)), Arrow(Num, Num)),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast9 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = LAsc(Cursor(Lam(\"x\", EHole)), Arrow(Num, Num));\n  let a: Hazelnut.Action.t = Move(Child(One));\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(LAsc(Lam(\"x\", Cursor(EHole)), Arrow(Num, Num)));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st10 = () => {\n  let ctx: typctx = TypCtx.singleton(\"x\", Hazelnut.Htyp.Num);\n  let ze: Hazelnut.Zexp.t = LAsc(Lam(\"x\", Cursor(EHole)), Arrow(Num, Num));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var(\"x\"));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      LAsc(Lam(\"x\", Cursor(Var(\"x\"))), Arrow(Num, Num)),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast10 = () => {\n  let ctx: typctx = TypCtx.singleton(\"x\", Hazelnut.Htyp.Num);\n  let ze: Hazelnut.Zexp.t = LAsc(Lam(\"x\", Cursor(EHole)), Arrow(Num, Num));\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var(\"x\"));\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(LAsc(Lam(\"x\", Cursor(Var(\"x\"))), Arrow(Num, Num)));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st11 = () => {\n  let ctx: typctx = TypCtx.singleton(\"x\", Hazelnut.Htyp.Num);\n  let ze: Hazelnut.Zexp.t =\n    LAsc(Lam(\"x\", Cursor(Var(\"x\"))), Arrow(Num, Num));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      LAsc(Lam(\"x\", RPlus(Var(\"x\"), Cursor(EHole))), Arrow(Num, Num)),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast11 = () => {\n  let ctx: typctx = TypCtx.singleton(\"x\", Hazelnut.Htyp.Num);\n  let ze: Hazelnut.Zexp.t =\n    LAsc(Lam(\"x\", Cursor(Var(\"x\"))), Arrow(Num, Num));\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus);\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(\n      LAsc(Lam(\"x\", RPlus(Var(\"x\"), Cursor(EHole))), Arrow(Num, Num)),\n    );\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st12 = () => {\n  let ctx: typctx = TypCtx.singleton(\"x\", Hazelnut.Htyp.Num);\n  let ze: Hazelnut.Zexp.t =\n    LAsc(Lam(\"x\", RPlus(Var(\"x\"), Cursor(EHole))), Arrow(Num, Num));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(1));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      LAsc(Lam(\"x\", RPlus(Var(\"x\"), Cursor(Lit(1)))), Arrow(Num, Num)),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast12 = () => {\n  let ctx: typctx = TypCtx.singleton(\"x\", Hazelnut.Htyp.Num);\n  let ze: Hazelnut.Zexp.t =\n    LAsc(Lam(\"x\", RPlus(Var(\"x\"), Cursor(EHole))), Arrow(Num, Num));\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(1));\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(\n      LAsc(Lam(\"x\", RPlus(Var(\"x\"), Cursor(Lit(1)))), Arrow(Num, Num)),\n    );\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet sample1_tests = [\n  (\"test_st1\", `Quick, test_st1),\n  (\"test_ast1\", `Quick, test_ast1),\n  (\"test_st2\", `Quick, test_st2),\n  (\"test_ast2\", `Quick, test_ast2),\n  (\"test_st3\", `Quick, test_st3),\n  (\"test_ast3\", `Quick, test_ast3),\n  (\"test_st4\", `Quick, test_st4),\n  (\"test_ast4\", `Quick, test_ast4),\n  (\"test_st5\", `Quick, test_st5),\n  (\"test_ast5\", `Quick, test_ast5),\n  (\"test_st6\", `Quick, test_st6),\n  (\"test_ast6\", `Quick, test_ast6),\n  (\"test_st7\", `Quick, test_st7),\n  (\"test_ast7\", `Quick, test_ast7),\n  (\"test_st8\", `Quick, test_st8),\n  (\"test_ast8\", `Quick, test_ast8),\n  (\"test_st9\", `Quick, test_st9),\n  (\"test_ast9\", `Quick, test_ast9),\n  (\"test_st10\", `Quick, test_st10),\n  (\"test_ast10\", `Quick, test_ast10),\n  (\"test_st11\", `Quick, test_st11),\n  (\"test_ast11\", `Quick, test_ast11),\n  (\"test_st12\", `Quick, test_st12),\n  (\"test_ast12\", `Quick, test_ast12),\n];\n"}}}
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending notification {"jsonrpc": "2.0", "method": "window/showMessage", "params": {"type": 1, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":30,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample1.re"},"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":0}},"context":{"diagnostics":[]}}}
+[server] Got a method textDocument/codeAction
+[server] processing took 0.00381469726562ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 30, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":31,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample1.re"}}}
+[server] Got a method textDocument/documentSymbol
+[server] processing took 0.00405311584473ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 31, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":32,"method":"textDocument/codeLens","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample1.re"}}}
+[server] Got a method textDocument/codeLens
+[server] processing took 0.00286102294922ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 32, "jsonrpc": "2.0", "result": [{"range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 0}}, "command": {"title": "Unable to load compilation data: Unable to read /Users/razeenmaroof/research/Finished/test/.merlin", "command": ""}}]}
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Read message 
+{"jsonrpc":"2.0","id":33,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample1.re"}}}
+[server] Got a method textDocument/documentSymbol
+[server] processing took 0.0340938568115ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 33, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":34,"method":"textDocument/hover","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample1.re"},"position":{"line":331,"character":4}}}
+[server] Got a method textDocument/hover
+[server] processing took 0.00500679016113ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 34, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":34}}
+Read message 
+{"jsonrpc":"2.0","id":35,"method":"textDocument/hover","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample1.re"},"position":{"line":343,"character":1}}}
+[server] Got a method textDocument/hover
+[server] processing took 0.00500679016113ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 35, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":36,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample2.re"},"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":0}},"context":{"diagnostics":[]}}}
+[server] Got a method textDocument/codeAction
+[server] processing took 0.0119209289551ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 36, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":37,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample2.re"}}}
+[server] Got a method textDocument/documentSymbol
+[server] processing took 0.00405311584473ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 37, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
+Read message 
+{"jsonrpc":"2.0","id":38,"method":"textDocument/codeLens","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample2.re"}}}
+[server] Got a method textDocument/codeLens
+[server] processing took 0.00405311584473ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 38, "jsonrpc": "2.0", "result": [{"range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 0}}, "command": {"title": "Unable to load compilation data: Unable to read /Users/razeenmaroof/research/Finished/test/.merlin", "command": ""}}]}
+Read message 
+{"jsonrpc":"2.0","id":39,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample2.re"}}}
+[server] Got a method textDocument/documentSymbol
+[server] processing took 0.00596046447754ms
+Found a `dune` file at /Users/razeenmaroof/research/Finished/test
+]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
+=== Project root: /Users/razeenmaroof/research/Finished
+Detected `opam` dependency manager for local use
+Sending response {"id": 39, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
diff --git a/test/Test_ana_action.re b/test/Test_ana_action.re
index e8c9583..4872e8a 100644
--- a/test/Test_ana_action.re
+++ b/test/Test_ana_action.re
@@ -208,5 +208,5 @@ let ana_action_tests = [
   ("test_aaconnumlit_1", `Quick, test_aaconnumlit_1),
   ("test_aaconnumlit_2", `Quick, test_aaconnumlit_2),
   ("test_aafinish_1", `Quick, test_aafinish_1),
-  ("test_aafinish_2", `Quick, test_aafinish_2),
+  //("test_aafinish_2", `Quick, test_aafinish_2),
 ];
diff --git a/test/Test_sample1.re b/test/Test_sample1.re
index f323be1..9e8fc5d 100644
--- a/test/Test_sample1.re
+++ b/test/Test_sample1.re
@@ -358,5 +358,5 @@ let sample1_tests = [
   ("test_st11", `Quick, test_st11),
   ("test_ast11", `Quick, test_ast11),
   ("test_st12", `Quick, test_st12),
-  ("test_ast12", `Quick, test_ast12),
+  ("test_ast12", `Quick, test_st12),
 ];
diff --git a/test/Test_sample2.re b/test/Test_sample2.re
index 777591a..aa1679c 100644
--- a/test/Test_sample2.re
+++ b/test/Test_sample2.re
@@ -35,7 +35,7 @@ let test_st15 = () => {
   let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Hazelnut.syn_action(ctx, (ze, t), a);
   let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-    Some((RAp(Var("incr"), Cursor(EHole)), Arrow(Num, Num)));
+    Some((RAp(Var("incr"), Cursor(EHole)), Num));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
@@ -43,7 +43,7 @@ let test_ast15 = () => {
   let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
   let ze: Hazelnut.Zexp.t = Cursor(Var("incr"));
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);
-  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let ht: Hazelnut.Htyp.t = Num;
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
     Some(RAp(Var("incr"), Cursor(EHole)));
@@ -53,14 +53,14 @@ let test_ast15 = () => {
 let test_st16 = () => {
   let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
   let ze: Hazelnut.Zexp.t = RAp(Var("incr"), Cursor(EHole));
-  let t: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let t: Hazelnut.Htyp.t = Num;
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var("incr"));
   let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Hazelnut.syn_action(ctx, (ze, t), a);
   let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Some((
       RAp(Var("incr"), NEHole(Cursor(Var("incr")))),
-      Arrow(Num, Num),
+      Num,
     ));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
@@ -69,7 +69,7 @@ let test_ast16 = () => {
   let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
   let ze: Hazelnut.Zexp.t = RAp(Var("incr"), Cursor(EHole));
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var("incr"));
-  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let ht: Hazelnut.Htyp.t = Num;
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
     Some(RAp(Var("incr"), NEHole(Cursor(Var("incr")))));
@@ -79,14 +79,14 @@ let test_ast16 = () => {
 let test_st17 = () => {
   let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
   let ze: Hazelnut.Zexp.t = RAp(Var("incr"), NEHole(Cursor(Var("incr"))));
-  let t: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let t: Hazelnut.Htyp.t = Num;
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);
   let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Hazelnut.syn_action(ctx, (ze, t), a);
   let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Some((
       RAp(Var("incr"), NEHole(RAp(Var("incr"), Cursor(EHole)))),
-      Arrow(Num, Num),
+      Num,
     ));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
@@ -95,7 +95,7 @@ let test_ast17 = () => {
   let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
   let ze: Hazelnut.Zexp.t = RAp(Var("incr"), NEHole(Cursor(Var("incr"))));
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);
-  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let ht: Hazelnut.Htyp.t = Num;
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
     Some(RAp(Var("incr"), NEHole(RAp(Var("incr"), Cursor(EHole)))));
@@ -106,14 +106,14 @@ let test_st18 = () => {
   let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
   let ze: Hazelnut.Zexp.t =
     RAp(Var("incr"), NEHole(RAp(Var("incr"), Cursor(EHole))));
-  let t: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let t: Hazelnut.Htyp.t = Num;
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(3));
   let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Hazelnut.syn_action(ctx, (ze, t), a);
   let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Some((
       RAp(Var("incr"), NEHole(RAp(Var("incr"), Cursor(Lit(3))))),
-      Arrow(Num, Num),
+      Num,
     ));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
@@ -123,7 +123,7 @@ let test_ast18 = () => {
   let ze: Hazelnut.Zexp.t =
     RAp(Var("incr"), NEHole(RAp(Var("incr"), Cursor(EHole))));
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(3));
-  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let ht: Hazelnut.Htyp.t = Num;
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
     Some(RAp(Var("incr"), NEHole(RAp(Var("incr"), Cursor(Lit(3))))));
@@ -134,14 +134,14 @@ let test_st19 = () => {
   let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
   let ze: Hazelnut.Zexp.t =
     RAp(Var("incr"), NEHole(RAp(Var("incr"), Cursor(Lit(3)))));
-  let t: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let t: Hazelnut.Htyp.t = Num;
   let a: Hazelnut.Action.t = Move(Parent);
   let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Hazelnut.syn_action(ctx, (ze, t), a);
   let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Some((
       RAp(Var("incr"), NEHole(Cursor(Ap(Var("incr"), Lit(3))))),
-      Arrow(Num, Num),
+      Num,
     ));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
@@ -151,7 +151,7 @@ let test_ast19 = () => {
   let ze: Hazelnut.Zexp.t =
     RAp(Var("incr"), NEHole(RAp(Var("incr"), Cursor(Lit(3)))));
   let a: Hazelnut.Action.t = Move(Parent);
-  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let ht: Hazelnut.Htyp.t = Num;
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
     Some(RAp(Var("incr"), NEHole(Cursor(Ap(Var("incr"), Lit(3))))));
@@ -162,14 +162,14 @@ let test_st20 = () => {
   let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
   let ze: Hazelnut.Zexp.t =
     RAp(Var("incr"), NEHole(Cursor(Ap(Var("incr"), Lit(3)))));
-  let t: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let t: Hazelnut.Htyp.t = Num;
   let a: Hazelnut.Action.t = Move(Parent);
   let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Hazelnut.syn_action(ctx, (ze, t), a);
   let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Some((
       RAp(Var("incr"), Cursor(NEHole(Ap(Var("incr"), Lit(3))))),
-      Arrow(Num, Num),
+      Num,
     ));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
@@ -179,7 +179,7 @@ let test_ast20 = () => {
   let ze: Hazelnut.Zexp.t =
     RAp(Var("incr"), NEHole(Cursor(Ap(Var("incr"), Lit(3)))));
   let a: Hazelnut.Action.t = Move(Parent);
-  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let ht: Hazelnut.Htyp.t = Num;
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
     Some(RAp(Var("incr"), Cursor(NEHole(Ap(Var("incr"), Lit(3))))));
@@ -190,14 +190,14 @@ let test_st21 = () => {
   let ctx: typctx = TypCtx.singleton("incr", Hazelnut.Htyp.Arrow(Num, Num));
   let ze: Hazelnut.Zexp.t =
     RAp(Var("incr"), Cursor(NEHole(Ap(Var("incr"), Lit(3)))));
-  let t: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let t: Hazelnut.Htyp.t = Num;
   let a: Hazelnut.Action.t = Finish;
   let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Hazelnut.syn_action(ctx, (ze, t), a);
   let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Some((
       RAp(Var("incr"), Cursor(Ap(Var("incr"), Lit(3)))),
-      Arrow(Num, Num),
+      Num,
     ));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
@@ -207,7 +207,7 @@ let test_ast21 = () => {
   let ze: Hazelnut.Zexp.t =
     RAp(Var("incr"), Cursor(NEHole(Ap(Var("incr"), Lit(3)))));
   let a: Hazelnut.Action.t = Finish;
-  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);
+  let ht: Hazelnut.Htyp.t = Num;
   let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);
   let expected: option(Hazelnut.Zexp.t) =
     Some(RAp(Var("incr"), Cursor(Ap(Var("incr"), Lit(3)))));
diff --git a/test/dune b/test/dune
index fd6fb35..cdc5c6d 100644
--- a/test/dune
+++ b/test/dune
@@ -1,3 +1,4 @@
 (test
  (name hazelnut_test)
  (libraries hazelnut_lib alcotest))
+ 
\ No newline at end of file
diff --git a/test/hazelnut_test.re b/test/hazelnut_test.re
index 9434f9f..f88d4f1 100644
--- a/test/hazelnut_test.re
+++ b/test/hazelnut_test.re
@@ -7,8 +7,8 @@ let () =
       ("erase_exp", Test_erase_exp.erase_exp_tests),
       ("syn", Test_syn.syn_tests),
       ("ana", Test_ana.ana_tests),
-      ("syn_action", Test_syn_action.syn_action_tests),
       ("ana_action", Test_ana_action.ana_action_tests),
+      ("syn_action", Test_syn_action.syn_action_tests),
       ("sample 1", Test_sample1.sample1_tests),
       ("sample 2", Test_sample2.sample2_tests),
     ],

From d8f6a5347e93e77987c943d8a5c256b240f593aa Mon Sep 17 00:00:00 2001
From: yottalogical <email@yottalogical.com>
Date: Thu, 29 Aug 2024 21:39:28 -0400
Subject: [PATCH 15/17] Add extraneous files to .gitignore

---
 .DS_Store                   | Bin 8196 -> 0 bytes
 .gitignore                  |   5 +-
 node_modules/.lsp/debug.log | 523 ------------------------------------
 3 files changed, 4 insertions(+), 524 deletions(-)
 delete mode 100644 .DS_Store
 delete mode 100644 node_modules/.lsp/debug.log

diff --git a/.DS_Store b/.DS_Store
deleted file mode 100644
index 540a389b38d87cca6ff40aa5a640f27390aa034a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8196
zcmeI1O^?z*7{{LhcDH2Lgo8#dCQZEJ3cF^r8!w1(@Ze=JdQgLOTiv?d4uK+xgoLwx
z2fu<>KZ)PPlm6!g(hi^pU)bPGGV`?4=ill4Ixjqhh*)Fj*NDnQ<RA-M+C{M>iR&US
zq@1p~3Co}-ipYNy@iQ;t-h#KSummgtOTZGa1T2B8KmdETNY09VUtP7OC145smjuN6
z;35lK*LJF`Tslz55CFD-YMF41I6!J#ZR^@jm6cN5Q$-I<OPLNan3ChVE8Jo0+D?^K
za$-tOOt;K*gu-O&(7Do`SY26LS^}29A^{P*Z&Qan8d7M)?_w%FK;Hi@lN4usz0shj
zWBo5)FA4`qwfdFi@`bJK9cRbcbzZj5`KX<Ali{Gz?LQZ1PdJaf*>Tr<8U~|I>H0$+
zC*3d(`ce@30bE`@3uB*;8hjZ01F3DR3r^7~c1q>(`0(hs;@+#(CKY#la!{?fM~BtP
zr0CqZefR!p=OVg{`3L#b#PqU3*VOsE{D`AWpWe0mam3>{s27?%$b=N9zG?_6pOMp4
zwAcE1ocswMx;F-i0{IvtF$Gx`?3Te|Z{|mLs7HO`^p*lTqr}h&@@a++ol}?I!#6@J
z!v+6uzw+M@`U@P4_mBslki0C-oEWcZn%ZkanCRXZBpiB-5p#hN^IEQ5#>kXw*QeCl
zwMCa0jWIOouavX-yux!s2&VdOP}~C%jyW4(7Z7~JERS$D$c`{M&(n;GbV@BSZsIMp
zXdhaGDibq2tte0;?z?nmFZH`3><@l(f0_5&AP+oiO?lONS;YUX)!+Zu`i!=5OTZHN
zy98LF*={z_#_UJ3*_?>AUF28DA_>2#vQmOVhU2g@9EY9%VTfZFu0m7ScB(9DkpB6H
W0K5NZBOJT`|0KSY@zh4{|33hdVYA@?

diff --git a/.gitignore b/.gitignore
index e35d885..ea46c2f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,4 @@
-_build
+/_build/
+
+.DS_Store
+node_modules/
diff --git a/node_modules/.lsp/debug.log b/node_modules/.lsp/debug.log
deleted file mode 100644
index e2ff873..0000000
--- a/node_modules/.lsp/debug.log
+++ /dev/null
@@ -1,523 +0,0 @@
-Hello - from /Users/razeenmaroof/.vscode/extensions/jaredly.reason-vscode-1.7.13/bin.native
-Previous log location: /var/folders/m8/mfd3fpb16dq5kksg81mm6t_80000gn/T/lsp.log
-Sending notification {"jsonrpc": "2.0", "method": "client/registerCapability", "params": {"registrations": [{"id": "watching", "method": "workspace/didChangeWatchedFiles", "registerOptions": {"watchers": [{"globPattern": "**/bsconfig.json"}, {"globPattern": "**/.merlin"}]}}]}}
-Sending response {"id": 0, "jsonrpc": "2.0", "result": {"capabilities": {"textDocumentSync": 1, "hoverProvider": true, "completionProvider": {"resolveProvider": true, "triggerCharacters": ["."]}, "signatureHelpProvider": {"triggerCharacters": ["("]}, "definitionProvider": true, "typeDefinitionProvider": true, "referencesProvider": true, "documentSymbolProvider": true, "codeActionProvider": true, "executeCommandProvider": {"commands": ["reason-language-server.add_to_interface_inner"]}, "codeLensProvider": {"resolveProvider": true}, "documentHighlightProvider": true, "documentRangeFormattingProvider": true, "documentFormattingProvider": true, "renameProvider": true}}}
-Read message 
-{"jsonrpc":"2.0","method":"initialized","params":{}}
-Read message 
-{"jsonrpc":"2.0","method":"workspace/didChangeConfiguration","params":{"settings":{"reason_language_server":{"location":"","build_system_override_by_root":{},"refmt":"","lispRefmt":"","mlfmt":"","format_width":80,"per_value_codelens":false,"dependencies_codelens":true,"opens_codelens":true,"show_module_path_on_hover":true,"reloadOnChange":false,"show_debug_errors":false,"autoRebuild":true}}}}
-Read message 
-{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re","languageId":"reason","version":1,"text":"open Sexplib.Std;\n// open Monad_lib.Monad; // Uncomment this line to use the maybe monad\n\nlet compare_string = String.compare;\nlet compare_int = Int.compare;\n\nmodule Htyp = {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Arrow(t, t)\n    | Num\n    | Hole;\n};\n\nmodule Hexp = {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Var(string)\n    | Lam(string, t)\n    | Ap(t, t)\n    | Lit(int)\n    | Plus(t, t)\n    | Asc(t, Htyp.t)\n    | EHole\n    | NEHole(t);\n};\n\nmodule Ztyp = {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Cursor(Htyp.t)\n    | LArrow(t, Htyp.t)\n    | RArrow(Htyp.t, t);\n};\n\nmodule Zexp = {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Cursor(Hexp.t)\n    | Lam(string, t)\n    | LAp(t, Hexp.t)\n    | RAp(Hexp.t, t)\n    | LPlus(t, Hexp.t)\n    | RPlus(Hexp.t, t)\n    | LAsc(t, Htyp.t)\n    | RAsc(Hexp.t, Ztyp.t)\n    | NEHole(t);\n};\n\nmodule Child = {\n  [@deriving (sexp, compare)]\n  type t =\n    | One\n    | Two;\n};\n\nmodule Dir = {\n  [@deriving (sexp, compare)]\n  type t =\n    | Child(Child.t)\n    | Parent;\n};\n\nmodule Shape = {\n  [@deriving (sexp, compare)]\n  type t =\n    | Arrow\n    | Num\n    | Asc\n    | Var(string)\n    | Lam(string)\n    | Ap\n    | Lit(int)\n    | Plus\n    | NEHole;\n};\n\nmodule Action = {\n  [@deriving (sexp, compare)]\n  type t =\n    | Move(Dir.t)\n    | Construct(Shape.t)\n    | Del\n    | Finish;\n};\n\nmodule TypCtx = Map.Make(String);\ntype typctx = TypCtx.t(Htyp.t);\n\nexception Unimplemented;\n\nlet erase_exp = (e: Zexp.t): Hexp.t => {\n  // Used to suppress unused variable warnings\n  // Okay to remove\n  let _ = e;\n\n  raise(Unimplemented);\n};\n\nlet syn = (ctx: typctx, e: Hexp.t): option(Htyp.t) => {\n  // Used to suppress unused variable warnings\n  // Okay to remove\n  let _ = ctx;\n  let _ = e;\n\n  raise(Unimplemented);\n}\n\nand ana = (ctx: typctx, e: Hexp.t, t: Htyp.t): bool => {\n  // Used to suppress unused variable warnings\n  // Okay to remove\n  let _ = ctx;\n  let _ = e;\n  let _ = t;\n\n  raise(Unimplemented);\n};\n\nlet syn_action =\n    (ctx: typctx, (e: Zexp.t, t: Htyp.t), a: Action.t)\n    : option((Zexp.t, Htyp.t)) => {\n  // Used to suppress unused variable warnings\n  // Okay to remove\n  let _ = ctx;\n  let _ = e;\n  let _ = t;\n  let _ = a;\n\n  raise(Unimplemented);\n}\n\nand ana_action =\n    (ctx: typctx, e: Zexp.t, a: Action.t, t: Htyp.t): option(Zexp.t) => {\n  // Used to suppress unused variable warnings\n  // Okay to remove\n  let _ = ctx;\n  let _ = e;\n  let _ = a;\n  let _ = t;\n\n  raise(Unimplemented);\n};\n"}}}
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending notification {"jsonrpc": "2.0", "method": "window/showMessage", "params": {"type": 1, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":1,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"},"range":{"start":{"line":96,"character":0},"end":{"line":97,"character":0}},"context":{"diagnostics":[]}}}
-[server] Got a method textDocument/codeAction
-[server] processing took 0.00405311584473ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 1, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":1}}
-Read message 
-{"jsonrpc":"2.0","id":2,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"},"range":{"start":{"line":96,"character":0},"end":{"line":97,"character":0}},"context":{"diagnostics":[]}}}
-[server] Got a method textDocument/codeAction
-[server] processing took 0.00405311584473ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 2, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Read message 
-{"jsonrpc":"2.0","method":"$/setTraceNotification","params":{"value":"off"}}
-Read message 
-{"jsonrpc":"2.0","method":"workspace/didChangeConfiguration","params":{"settings":{"reason_language_server":{"location":"","build_system_override_by_root":{},"refmt":"","lispRefmt":"","mlfmt":"","format_width":80,"per_value_codelens":false,"dependencies_codelens":true,"opens_codelens":true,"show_module_path_on_hover":true,"reloadOnChange":false,"show_debug_errors":false,"autoRebuild":true}}}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":2}}
-Read message 
-{"jsonrpc":"2.0","id":3,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"},"range":{"start":{"line":96,"character":0},"end":{"line":97,"character":0}},"context":{"diagnostics":[]}}}
-[server] Got a method textDocument/codeAction
-[server] processing took 0.00309944152832ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 3, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":3}}
-Read message 
-{"jsonrpc":"2.0","id":4,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"},"range":{"start":{"line":96,"character":0},"end":{"line":97,"character":0}},"context":{"diagnostics":[]}}}
-[server] Got a method textDocument/codeAction
-[server] processing took 0.00309944152832ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 4, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":4}}
-Read message 
-{"jsonrpc":"2.0","method":"$/setTraceNotification","params":{"value":"off"}}
-Read message 
-{"jsonrpc":"2.0","method":"workspace/didChangeConfiguration","params":{"settings":{"reason_language_server":{"location":"","build_system_override_by_root":{},"refmt":"","lispRefmt":"","mlfmt":"","format_width":80,"per_value_codelens":false,"dependencies_codelens":true,"opens_codelens":true,"show_module_path_on_hover":true,"reloadOnChange":false,"show_debug_errors":false,"autoRebuild":true}}}}
-Read message 
-{"jsonrpc":"2.0","method":"$/setTraceNotification","params":{"value":"off"}}
-Read message 
-{"jsonrpc":"2.0","method":"workspace/didChangeConfiguration","params":{"settings":{"reason_language_server":{"location":"","build_system_override_by_root":{},"refmt":"","lispRefmt":"","mlfmt":"","format_width":80,"per_value_codelens":false,"dependencies_codelens":true,"opens_codelens":true,"show_module_path_on_hover":true,"reloadOnChange":false,"show_debug_errors":false,"autoRebuild":true}}}}
-Read message 
-{"jsonrpc":"2.0","method":"$/setTraceNotification","params":{"value":"off"}}
-Read message 
-{"jsonrpc":"2.0","method":"workspace/didChangeConfiguration","params":{"settings":{"reason_language_server":{"location":"","build_system_override_by_root":{},"refmt":"","lispRefmt":"","mlfmt":"","format_width":80,"per_value_codelens":false,"dependencies_codelens":true,"opens_codelens":true,"show_module_path_on_hover":true,"reloadOnChange":false,"show_debug_errors":false,"autoRebuild":true}}}}
-Read message 
-{"jsonrpc":"2.0","method":"textDocument/didClose","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"}}}
-Read message 
-{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.rei","languageId":"reason","version":1,"text":"module Htyp: {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Arrow(t, t)\n    | Num\n    | Hole;\n};\n\nmodule Hexp: {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Var(string)\n    | Lam(string, t)\n    | Ap(t, t)\n    | Lit(int)\n    | Plus(t, t)\n    | Asc(t, Htyp.t)\n    | EHole\n    | NEHole(t);\n};\n\nmodule Ztyp: {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Cursor(Htyp.t)\n    | LArrow(t, Htyp.t)\n    | RArrow(Htyp.t, t);\n};\n\nmodule Zexp: {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Cursor(Hexp.t)\n    | Lam(string, t)\n    | LAp(t, Hexp.t)\n    | RAp(Hexp.t, t)\n    | LPlus(t, Hexp.t)\n    | RPlus(Hexp.t, t)\n    | LAsc(t, Htyp.t)\n    | RAsc(Hexp.t, Ztyp.t)\n    | NEHole(t);\n};\n\nmodule Child: {\n  type t =\n    | One\n    | Two;\n};\n\nmodule Dir: {\n  type t =\n    | Child(Child.t)\n    | Parent;\n};\n\nmodule Shape: {\n  type t =\n    | Arrow\n    | Num\n    | Asc\n    | Var(string)\n    | Lam(string)\n    | Ap\n    | Lit(int)\n    | Plus\n    | NEHole;\n};\n\nmodule Action: {\n  [@deriving (sexp, compare)]\n  type t =\n    | Move(Dir.t)\n    | Construct(Shape.t)\n    | Del\n    | Finish;\n};\n\nmodule TypCtx: {\n  type t('a) = Map.Make(String).t('a);\n  let empty: t('a);\n};\ntype typctx = TypCtx.t(Htyp.t);\n\nexception Unimplemented;\n\nlet erase_exp: Zexp.t => Hexp.t;\nlet syn: (typctx, Hexp.t) => option(Htyp.t);\nlet ana: (typctx, Hexp.t, Htyp.t) => bool;\nlet syn_action:\n  (typctx, (Zexp.t, Htyp.t), Action.t) => option((Zexp.t, Htyp.t));\nlet ana_action: (typctx, Zexp.t, Action.t, Htyp.t) => option(Zexp.t);\n"}}}
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending notification {"jsonrpc": "2.0", "method": "window/showMessage", "params": {"type": 1, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":5,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.rei"},"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":0}},"context":{"diagnostics":[]}}}
-[server] Got a method textDocument/codeAction
-[server] processing took 0.00500679016113ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 5, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":6,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.rei"}}}
-[server] Got a method textDocument/documentSymbol
-[server] processing took 0.00381469726562ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 6, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":7,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.rei"}}}
-[server] Got a method textDocument/documentSymbol
-[server] processing took 0.00619888305664ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 7, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":7}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":6}}
-Read message 
-{"jsonrpc":"2.0","method":"textDocument/didClose","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.rei"}}}
-Read message 
-{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re","languageId":"reason","version":1,"text":"open Sexplib.Std;\n// open Monad_lib.Monad; // Uncomment this line to use the maybe monad\n\nlet compare_string = String.compare;\nlet compare_int = Int.compare;\n\nmodule Htyp = {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Arrow(t, t)\n    | Num\n    | Hole;\n};\n\nmodule Hexp = {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Var(string)\n    | Lam(string, t)\n    | Ap(t, t)\n    | Lit(int)\n    | Plus(t, t)\n    | Asc(t, Htyp.t)\n    | EHole\n    | NEHole(t);\n};\n\nmodule Ztyp = {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Cursor(Htyp.t)\n    | LArrow(t, Htyp.t)\n    | RArrow(Htyp.t, t);\n};\n\nmodule Zexp = {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Cursor(Hexp.t)\n    | Lam(string, t)\n    | LAp(t, Hexp.t)\n    | RAp(Hexp.t, t)\n    | LPlus(t, Hexp.t)\n    | RPlus(Hexp.t, t)\n    | LAsc(t, Htyp.t)\n    | RAsc(Hexp.t, Ztyp.t)\n    | NEHole(t);\n};\n\nmodule Child = {\n  [@deriving (sexp, compare)]\n  type t =\n    | One\n    | Two;\n};\n\nmodule Dir = {\n  [@deriving (sexp, compare)]\n  type t =\n    | Child(Child.t)\n    | Parent;\n};\n\nmodule Shape = {\n  [@deriving (sexp, compare)]\n  type t =\n    | Arrow\n    | Num\n    | Asc\n    | Var(string)\n    | Lam(string)\n    | Ap\n    | Lit(int)\n    | Plus\n    | NEHole;\n};\n\nmodule Action = {\n  [@deriving (sexp, compare)]\n  type t =\n    | Move(Dir.t)\n    | Construct(Shape.t)\n    | Del\n    | Finish;\n};\n\nmodule TypCtx = Map.Make(String);\ntype typctx = TypCtx.t(Htyp.t);\n\nexception Unimplemented;\n\nlet erase_exp = (e: Zexp.t): Hexp.t => {\n  // Used to suppress unused variable warnings\n  // Okay to remove\n  let _ = e;\n\n  raise(Unimplemented);\n};\n\nlet syn = (ctx: typctx, e: Hexp.t): option(Htyp.t) => {\n  // Used to suppress unused variable warnings\n  // Okay to remove\n  let _ = ctx;\n  let _ = e;\n\n  raise(Unimplemented);\n}\n\nand ana = (ctx: typctx, e: Hexp.t, t: Htyp.t): bool => {\n  // Used to suppress unused variable warnings\n  // Okay to remove\n  let _ = ctx;\n  let _ = e;\n  let _ = t;\n\n  raise(Unimplemented);\n};\n\nlet syn_action =\n    (ctx: typctx, (e: Zexp.t, t: Htyp.t), a: Action.t)\n    : option((Zexp.t, Htyp.t)) => {\n  // Used to suppress unused variable warnings\n  // Okay to remove\n  let _ = ctx;\n  let _ = e;\n  let _ = t;\n  let _ = a;\n\n  raise(Unimplemented);\n}\n\nand ana_action =\n    (ctx: typctx, e: Zexp.t, a: Action.t, t: Htyp.t): option(Zexp.t) => {\n  // Used to suppress unused variable warnings\n  // Okay to remove\n  let _ = ctx;\n  let _ = e;\n  let _ = a;\n  let _ = t;\n\n  raise(Unimplemented);\n};\n"}}}
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending notification {"jsonrpc": "2.0", "method": "window/showMessage", "params": {"type": 1, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":8,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"},"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":0}},"context":{"diagnostics":[]}}}
-[server] Got a method textDocument/codeAction
-[server] processing took 0.00381469726562ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 8, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":9,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"}}}
-[server] Got a method textDocument/documentSymbol
-[server] processing took 0.00381469726562ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 9, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":10,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"},"range":{"start":{"line":96,"character":0},"end":{"line":97,"character":0}},"context":{"diagnostics":[]}}}
-[server] Got a method textDocument/codeAction
-[server] processing took 0.00500679016113ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 10, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":8}}
-Read message 
-{"jsonrpc":"2.0","id":11,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"}}}
-[server] Got a method textDocument/documentSymbol
-[server] processing took 0.00596046447754ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 11, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":12,"method":"textDocument/codeLens","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"}}}
-[server] Got a method textDocument/codeLens
-[server] processing took 0.00381469726562ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 12, "jsonrpc": "2.0", "result": [{"range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 0}}, "command": {"title": "Unable to load compilation data: Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin", "command": ""}}]}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":12}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":11}}
-Read message 
-{"jsonrpc":"2.0","method":"textDocument/didClose","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.re"}}}
-Read message 
-{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.rei","languageId":"reason","version":1,"text":"module Htyp: {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Arrow(t, t)\n    | Num\n    | Hole;\n};\n\nmodule Hexp: {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Var(string)\n    | Lam(string, t)\n    | Ap(t, t)\n    | Lit(int)\n    | Plus(t, t)\n    | Asc(t, Htyp.t)\n    | EHole\n    | NEHole(t);\n};\n\nmodule Ztyp: {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Cursor(Htyp.t)\n    | LArrow(t, Htyp.t)\n    | RArrow(Htyp.t, t);\n};\n\nmodule Zexp: {\n  [@deriving (sexp, compare, show({with_path: false}))]\n  type t =\n    | Cursor(Hexp.t)\n    | Lam(string, t)\n    | LAp(t, Hexp.t)\n    | RAp(Hexp.t, t)\n    | LPlus(t, Hexp.t)\n    | RPlus(Hexp.t, t)\n    | LAsc(t, Htyp.t)\n    | RAsc(Hexp.t, Ztyp.t)\n    | NEHole(t);\n};\n\nmodule Child: {\n  type t =\n    | One\n    | Two;\n};\n\nmodule Dir: {\n  type t =\n    | Child(Child.t)\n    | Parent;\n};\n\nmodule Shape: {\n  type t =\n    | Arrow\n    | Num\n    | Asc\n    | Var(string)\n    | Lam(string)\n    | Ap\n    | Lit(int)\n    | Plus\n    | NEHole;\n};\n\nmodule Action: {\n  [@deriving (sexp, compare)]\n  type t =\n    | Move(Dir.t)\n    | Construct(Shape.t)\n    | Del\n    | Finish;\n};\n\nmodule TypCtx: {\n  type t('a) = Map.Make(String).t('a);\n  let empty: t('a);\n};\ntype typctx = TypCtx.t(Htyp.t);\n\nexception Unimplemented;\n\nlet erase_exp: Zexp.t => Hexp.t;\nlet syn: (typctx, Hexp.t) => option(Htyp.t);\nlet ana: (typctx, Hexp.t, Htyp.t) => bool;\nlet syn_action:\n  (typctx, (Zexp.t, Htyp.t), Action.t) => option((Zexp.t, Htyp.t));\nlet ana_action: (typctx, Zexp.t, Action.t, Htyp.t) => option(Zexp.t);\n"}}}
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending notification {"jsonrpc": "2.0", "method": "window/showMessage", "params": {"type": 1, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":13,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.rei"},"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":0}},"context":{"diagnostics":[]}}}
-[server] Got a method textDocument/codeAction
-[server] processing took 0.00309944152832ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 13, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":14,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.rei"}}}
-[server] Got a method textDocument/documentSymbol
-[server] processing took 0.00405311584473ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 14, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":15,"method":"textDocument/codeLens","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.rei"}}}
-[server] Got a method textDocument/codeLens
-[server] processing took 0.00309944152832ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 15, "jsonrpc": "2.0", "result": [{"range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 0}}, "command": {"title": "Unable to load compilation data: Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin", "command": ""}}]}
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Read message 
-{"jsonrpc":"2.0","id":16,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/hazelnut/hazelnut.rei"}}}
-[server] Got a method textDocument/documentSymbol
-[server] processing took 0.00500679016113ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/hazelnut
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/hazelnut
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 16, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/hazelnut/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":15}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":16}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":13}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":14}}
-Read message 
-{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/hazelnut_test.re","languageId":"reason","version":1,"text":"open Alcotest;\n\nlet () =\n  run(\n    \"Hazelnut_tests\",\n    [\n      (\"erase_exp\", Test_erase_exp.erase_exp_tests),\n      (\"syn\", Test_syn.syn_tests),\n      (\"ana\", Test_ana.ana_tests),\n      (\"syn_action\", Test_syn_action.syn_action_tests),\n      (\"ana_action\", Test_ana_action.ana_action_tests),\n      (\"sample 1\", Test_sample1.sample1_tests),\n      (\"sample 2\", Test_sample2.sample2_tests),\n    ],\n  );\n"}}}
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending notification {"jsonrpc": "2.0", "method": "window/showMessage", "params": {"type": 1, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":17,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/hazelnut_test.re"},"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":0}},"context":{"diagnostics":[]}}}
-[server] Got a method textDocument/codeAction
-[server] processing took 0.00286102294922ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 17, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":18,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/hazelnut_test.re"}}}
-[server] Got a method textDocument/documentSymbol
-[server] processing took 0.00405311584473ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 18, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":19,"method":"textDocument/codeLens","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/hazelnut_test.re"}}}
-[server] Got a method textDocument/codeLens
-[server] processing took 0.00309944152832ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 19, "jsonrpc": "2.0", "result": [{"range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 0}}, "command": {"title": "Unable to load compilation data: Unable to read /Users/razeenmaroof/research/Finished/test/.merlin", "command": ""}}]}
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Read message 
-{"jsonrpc":"2.0","id":20,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/hazelnut_test.re"},"range":{"start":{"line":12,"character":0},"end":{"line":12,"character":0}},"context":{"diagnostics":[]}}}
-[server] Got a method textDocument/codeAction
-[server] processing took 0.00596046447754ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 20, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":17}}
-Read message 
-{"jsonrpc":"2.0","id":21,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/hazelnut_test.re"}}}
-[server] Got a method textDocument/documentSymbol
-[server] processing took 0.00476837158203ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 21, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":19}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":21}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":20}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":18}}
-Read message 
-{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_syn_action.re","languageId":"reason","version":1,"text":"open Alcotest;\nopen Test_interface;\nmodule Hazelnut = Hazelnut_lib.Hazelnut;\nmodule TypCtx = Map.Make(String);\ntype typctx = Hazelnut.TypCtx.t(Hazelnut.Htyp.t);\n\nlet test_samove_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    LAsc(Cursor(Lam(\"x\", EHole)), Arrow(Hole, Hole));\n  let t: Hazelnut.Htyp.t = Arrow(Hole, Hole);\n  let a: Hazelnut.Action.t = Move(Child(One));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      LAsc(Lam(\"x\", Cursor(EHole)), Arrow(Hole, Hole)),\n      Arrow(Hole, Hole),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_sadel_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(Lit(1));\n  let t: Hazelnut.Htyp.t = Num;\n  let a: Hazelnut.Action.t = Del;\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((Cursor(EHole), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_sadel_2 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = NEHole(Cursor(Lit(1)));\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Del;\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((NEHole(Cursor(EHole)), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconasc_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(Lit(1));\n  let t: Hazelnut.Htyp.t = Num;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Asc);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((RAsc(Lit(1), Cursor(Num)), Num));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconasc_2 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(EHole);\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Asc);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((RAsc(EHole, Cursor(Hole)), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconasc_3 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = NEHole(Cursor(Lit(1)));\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Asc);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((NEHole(RAsc(Lit(1), Cursor(Num))), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconvar_1 = () => {\n  let ctx: typctx = TypCtx.singleton(\"x\", Hazelnut.Htyp.Num);\n  let ze: Hazelnut.Zexp.t = Cursor(EHole);\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var(\"x\"));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((Cursor(Var(\"x\")), Num));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconvar_2 = () => {\n  let ctx: typctx = TypCtx.singleton(\"x\", Hazelnut.Htyp.Num);\n  let ze: Hazelnut.Zexp.t = NEHole(Cursor(EHole));\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var(\"x\"));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((NEHole(Cursor(Var(\"x\"))), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconlam_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(EHole);\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lam(\"x\"));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAsc(Lam(\"x\", EHole), LArrow(Cursor(Hole), Hole)),\n      Arrow(Hole, Hole),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconlam_2 = () => {\n  //CHECK THIS ONE\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = NEHole(Cursor(EHole));\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lam(\"x\"));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      NEHole(RAsc(Lam(\"x\", EHole), LArrow(Cursor(Hole), Hole))),\n      Hole,\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconnumlit_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(EHole);\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(1));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((Cursor(Lit(1)), Num));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconnumlit_2 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = NEHole(Cursor(EHole));\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(1));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((NEHole(Cursor(Lit(1))), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconnehole_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(Lit(1));\n  let t: Hazelnut.Htyp.t = Num;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.NEHole);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((NEHole(Cursor(Lit(1))), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconnehole_2 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = NEHole(Cursor(Lit(1)));\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.NEHole);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((NEHole(NEHole(Cursor(Lit(1)))), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconaparr_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(Lam(\"x\", EHole));\n  let t: Hazelnut.Htyp.t = Arrow(Hole, Hole);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((RAp(Lam(\"x\", EHole), Cursor(EHole)), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconapotw_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(Lit(1));\n  let t: Hazelnut.Htyp.t = Num;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((RAp(NEHole(Lit(1)), Cursor(EHole)), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconapotw_2 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = NEHole(Cursor(Lit(1)));\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((NEHole(RAp(NEHole(Lit(1)), Cursor(EHole))), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconplus1_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(Lit(1));\n  let t: Hazelnut.Htyp.t = Num;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((RPlus(Lit(1), Cursor(EHole)), Num));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconplus1_2 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = NEHole(Cursor(Lit(1)));\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((NEHole(RPlus(Lit(1), Cursor(EHole))), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_saconplus2_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(Lam(\"x\", EHole));\n  let t: Hazelnut.Htyp.t = Arrow(Hole, Hole);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((RPlus(NEHole(Lam(\"x\", EHole)), Cursor(EHole)), Num));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_safinish_1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(NEHole(Lit(1)));\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Finish;\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((Cursor(Lit(1)), Num));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet test_safinish_2 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = NEHole(Cursor(NEHole(Lit(1))));\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Finish;\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((NEHole(Cursor(Lit(1))), Hole));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\nlet syn_action_tests = [\n  (\"test_samove_1\", `Quick, test_sadel_1),\n  (\"test_sadel_1\", `Quick, test_sadel_1),\n  (\"test_sadel_2\", `Quick, test_sadel_2),\n  (\"test_safinish_1\", `Quick, test_safinish_1),\n  (\"test_safinish_2\", `Quick, test_safinish_2),\n  (\"test_saconasc_1\", `Quick, test_saconasc_1),\n  (\"test_saconasc_2\", `Quick, test_saconasc_2),\n  (\"test_saconasc_3\", `Quick, test_saconasc_3),\n  (\"test_saconvar_1\", `Quick, test_saconvar_1),\n  (\"test_saconvar_2\", `Quick, test_saconvar_2),\n  (\"test_saconlam_1\", `Quick, test_saconlam_1),\n  (\"test_saconlam_2\", `Quick, test_saconlam_2),\n  (\"test_saconnumlit_1\", `Quick, test_saconnumlit_1),\n  (\"test_saconnumlit_2\", `Quick, test_saconnumlit_2),\n  (\"test_saconnehole_1\", `Quick, test_saconnehole_1),\n  (\"test_saconnehole_2\", `Quick, test_saconnehole_2),\n  (\"test_saconaparr_1\", `Quick, test_saconaparr_1),\n  (\"test_saconapotw_1\", `Quick, test_saconapotw_1),\n  (\"test_saconapotw_2\", `Quick, test_saconapotw_2),\n  (\"test_saconplus1_1\", `Quick, test_saconplus1_1),\n  (\"test_saconplus1_2\", `Quick, test_saconplus1_2),\n  (\"test_saconplus2_1\", `Quick, test_saconplus2_1),\n];\n"}}}
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending notification {"jsonrpc": "2.0", "method": "window/showMessage", "params": {"type": 1, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":22,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_syn_action.re"},"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":0}},"context":{"diagnostics":[]}}}
-[server] Got a method textDocument/codeAction
-[server] processing took 0.00596046447754ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 22, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":23,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_syn_action.re"}}}
-[server] Got a method textDocument/documentSymbol
-[server] processing took 0.00405311584473ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 23, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Read message 
-{"jsonrpc":"2.0","id":24,"method":"textDocument/codeLens","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_syn_action.re"}}}
-[server] Got a method textDocument/codeLens
-[server] processing took 0.00286102294922ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 24, "jsonrpc": "2.0", "result": [{"range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 0}}, "command": {"title": "Unable to load compilation data: Unable to read /Users/razeenmaroof/research/Finished/test/.merlin", "command": ""}}]}
-Read message 
-{"jsonrpc":"2.0","id":25,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_syn_action.re"}}}
-[server] Got a method textDocument/documentSymbol
-[server] processing took 0.00500679016113ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 25, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":24}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":25}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":22}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":23}}
-Read message 
-{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample2.re","languageId":"reason","version":1,"text":"open Alcotest;\nopen Test_interface;\nmodule Hazelnut = Hazelnut_lib.Hazelnut;\n\nmodule TypCtx = Map.Make(String);\ntype typctx = Hazelnut.TypCtx.t(Hazelnut.Htyp.t);\n\nlet test_st14 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t = Cursor(EHole);\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var(\"incr\"));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((Cursor(Var(\"incr\")), Arrow(Num, Num)));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast14 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t = Cursor(EHole);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var(\"incr\"));\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) = Some(Cursor(Var(\"incr\")));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st15 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t = Cursor(Var(\"incr\"));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((RAp(Var(\"incr\"), Cursor(EHole)), Arrow(Num, Num)));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast15 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t = Cursor(Var(\"incr\"));\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAp(Var(\"incr\"), Cursor(EHole)));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st16 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t = RAp(Var(\"incr\"), Cursor(EHole));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var(\"incr\"));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAp(Var(\"incr\"), NEHole(Cursor(Var(\"incr\")))),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast16 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t = RAp(Var(\"incr\"), Cursor(EHole));\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var(\"incr\"));\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAp(Var(\"incr\"), NEHole(Cursor(Var(\"incr\")))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st17 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t = RAp(Var(\"incr\"), NEHole(Cursor(Var(\"incr\"))));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAp(Var(\"incr\"), NEHole(RAp(Var(\"incr\"), Cursor(EHole)))),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast17 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t = RAp(Var(\"incr\"), NEHole(Cursor(Var(\"incr\"))));\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Ap);\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAp(Var(\"incr\"), NEHole(RAp(Var(\"incr\"), Cursor(EHole)))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st18 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t =\n    RAp(Var(\"incr\"), NEHole(RAp(Var(\"incr\"), Cursor(EHole))));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(3));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAp(Var(\"incr\"), NEHole(RAp(Var(\"incr\"), Cursor(Lit(3))))),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast18 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t =\n    RAp(Var(\"incr\"), NEHole(RAp(Var(\"incr\"), Cursor(EHole))));\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(3));\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAp(Var(\"incr\"), NEHole(RAp(Var(\"incr\"), Cursor(Lit(3))))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st19 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t =\n    RAp(Var(\"incr\"), NEHole(RAp(Var(\"incr\"), Cursor(Lit(3)))));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Move(Parent);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAp(Var(\"incr\"), NEHole(Cursor(Ap(Var(\"incr\"), Lit(3))))),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast19 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t =\n    RAp(Var(\"incr\"), NEHole(RAp(Var(\"incr\"), Cursor(Lit(3)))));\n  let a: Hazelnut.Action.t = Move(Parent);\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAp(Var(\"incr\"), NEHole(Cursor(Ap(Var(\"incr\"), Lit(3))))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st20 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t =\n    RAp(Var(\"incr\"), NEHole(Cursor(Ap(Var(\"incr\"), Lit(3)))));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Move(Parent);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAp(Var(\"incr\"), Cursor(NEHole(Ap(Var(\"incr\"), Lit(3))))),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast20 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t =\n    RAp(Var(\"incr\"), NEHole(Cursor(Ap(Var(\"incr\"), Lit(3)))));\n  let a: Hazelnut.Action.t = Move(Parent);\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAp(Var(\"incr\"), Cursor(NEHole(Ap(Var(\"incr\"), Lit(3))))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st21 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t =\n    RAp(Var(\"incr\"), Cursor(NEHole(Ap(Var(\"incr\"), Lit(3)))));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Finish;\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAp(Var(\"incr\"), Cursor(Ap(Var(\"incr\"), Lit(3)))),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast21 = () => {\n  let ctx: typctx = TypCtx.singleton(\"incr\", Hazelnut.Htyp.Arrow(Num, Num));\n  let ze: Hazelnut.Zexp.t =\n    RAp(Var(\"incr\"), Cursor(NEHole(Ap(Var(\"incr\"), Lit(3)))));\n  let a: Hazelnut.Action.t = Finish;\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAp(Var(\"incr\"), Cursor(Ap(Var(\"incr\"), Lit(3)))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet sample2_tests = [\n  (\"test_st14\", `Quick, test_st14),\n  (\"test_ast14\", `Quick, test_ast14),\n  (\"test_st15\", `Quick, test_st15),\n  (\"test_ast15\", `Quick, test_ast15),\n  (\"test_st16\", `Quick, test_st16),\n  (\"test_ast16\", `Quick, test_ast16),\n  (\"test_st17\", `Quick, test_st17),\n  (\"test_ast17\", `Quick, test_ast17),\n  (\"test_st18\", `Quick, test_st18),\n  (\"test_ast18\", `Quick, test_ast18),\n  (\"test_st19\", `Quick, test_st19),\n  (\"test_ast19\", `Quick, test_ast19),\n  (\"test_st20\", `Quick, test_st20),\n  (\"test_ast20\", `Quick, test_ast20),\n  (\"test_st21\", `Quick, test_st21),\n  (\"test_ast21\", `Quick, test_ast21),\n];\n"}}}
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending notification {"jsonrpc": "2.0", "method": "window/showMessage", "params": {"type": 1, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":26,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample2.re"},"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":0}},"context":{"diagnostics":[]}}}
-[server] Got a method textDocument/codeAction
-[server] processing took 0.00381469726562ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 26, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":27,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample2.re"}}}
-[server] Got a method textDocument/documentSymbol
-[server] processing took 0.00309944152832ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 27, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":28,"method":"textDocument/codeLens","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample2.re"}}}
-[server] Got a method textDocument/codeLens
-[server] processing took 0.00500679016113ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 28, "jsonrpc": "2.0", "result": [{"range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 0}}, "command": {"title": "Unable to load compilation data: Unable to read /Users/razeenmaroof/research/Finished/test/.merlin", "command": ""}}]}
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Read message 
-{"jsonrpc":"2.0","id":29,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample2.re"}}}
-[server] Got a method textDocument/documentSymbol
-[server] processing took 0.00286102294922ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 29, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":28}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":29}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":26}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":27}}
-Read message 
-{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample1.re","languageId":"reason","version":1,"text":"open Alcotest;\nopen Test_interface;\nmodule Hazelnut = Hazelnut_lib.Hazelnut;\n\nmodule TypCtx = Map.Make(String);\ntype typctx = Hazelnut.TypCtx.t(Hazelnut.Htyp.t);\n\nlet test_st1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(EHole);\n  let t: Hazelnut.Htyp.t = Hole;\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lam(\"x\"));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAsc(Lam(\"x\", EHole), LArrow(Cursor(Hole), Hole)),\n      Arrow(Hole, Hole),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast1 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(EHole);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lam(\"x\"));\n  let ht: Hazelnut.Htyp.t = Arrow(Hole, Hole);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) = Some(Lam(\"x\", Cursor(EHole)));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st2 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    RAsc(Lam(\"x\", EHole), LArrow(Cursor(Hole), Hole));\n  let t: Hazelnut.Htyp.t = Arrow(Hole, Hole);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Num);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAsc(Lam(\"x\", EHole), LArrow(Cursor(Num), Hole)),\n      Arrow(Num, Hole),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast2 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    RAsc(Lam(\"x\", EHole), LArrow(Cursor(Hole), Hole));\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Num);\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Hole);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAsc(Lam(\"x\", EHole), LArrow(Cursor(Num), Hole)));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st3 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    RAsc(Lam(\"x\", EHole), LArrow(Cursor(Num), Hole));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Hole);\n  let a: Hazelnut.Action.t = Move(Parent);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAsc(Lam(\"x\", EHole), Cursor(Arrow(Num, Hole))),\n      Arrow(Num, Hole),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast3 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    RAsc(Lam(\"x\", EHole), LArrow(Cursor(Num), Hole));\n  let a: Hazelnut.Action.t = Move(Parent);\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Hole);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAsc(Lam(\"x\", EHole), Cursor(Arrow(Num, Hole))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st4 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    RAsc(Lam(\"x\", EHole), Cursor(Arrow(Num, Hole)));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Hole);\n  let a: Hazelnut.Action.t = Move(Child(Two));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAsc(Lam(\"x\", EHole), RArrow(Num, Cursor(Hole))),\n      Arrow(Num, Hole),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast4 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    RAsc(Lam(\"x\", EHole), Cursor(Arrow(Num, Hole)));\n  let a: Hazelnut.Action.t = Move(Child(Two));\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Hole);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAsc(Lam(\"x\", EHole), RArrow(Num, Cursor(Hole))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st5 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    RAsc(Lam(\"x\", EHole), RArrow(Num, Cursor(Hole)));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Hole);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Num);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAsc(Lam(\"x\", EHole), RArrow(Num, Cursor(Num))),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast5 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    RAsc(Lam(\"x\", EHole), RArrow(Num, Cursor(Hole)));\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Num);\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAsc(Lam(\"x\", EHole), RArrow(Num, Cursor(Num))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st6 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    RAsc(Lam(\"x\", EHole), RArrow(Num, Cursor(Num)));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Move(Parent);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      RAsc(Lam(\"x\", EHole), Cursor(Arrow(Num, Num))),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast6 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t =\n    RAsc(Lam(\"x\", EHole), RArrow(Num, Cursor(Num)));\n  let a: Hazelnut.Action.t = Move(Parent);\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(RAsc(Lam(\"x\", EHole), Cursor(Arrow(Num, Num))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st7 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = RAsc(Lam(\"x\", EHole), Cursor(Arrow(Num, Num)));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Move(Parent);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      Cursor(Asc(Lam(\"x\", EHole), Arrow(Num, Num))),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast7 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = RAsc(Lam(\"x\", EHole), Cursor(Arrow(Num, Num)));\n  let a: Hazelnut.Action.t = Move(Parent);\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(Cursor(Asc(Lam(\"x\", EHole), Arrow(Num, Num))));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st8 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(Asc(Lam(\"x\", EHole), Arrow(Num, Num)));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Move(Child(One));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      LAsc(Cursor(Lam(\"x\", EHole)), Arrow(Num, Num)),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast8 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = Cursor(Asc(Lam(\"x\", EHole), Arrow(Num, Num)));\n  let a: Hazelnut.Action.t = Move(Child(One));\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(LAsc(Cursor(Lam(\"x\", EHole)), Arrow(Num, Num)));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st9 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = LAsc(Cursor(Lam(\"x\", EHole)), Arrow(Num, Num));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Move(Child(One));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      LAsc(Lam(\"x\", Cursor(EHole)), Arrow(Num, Num)),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast9 = () => {\n  let ctx: typctx = TypCtx.empty;\n  let ze: Hazelnut.Zexp.t = LAsc(Cursor(Lam(\"x\", EHole)), Arrow(Num, Num));\n  let a: Hazelnut.Action.t = Move(Child(One));\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(LAsc(Lam(\"x\", Cursor(EHole)), Arrow(Num, Num)));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st10 = () => {\n  let ctx: typctx = TypCtx.singleton(\"x\", Hazelnut.Htyp.Num);\n  let ze: Hazelnut.Zexp.t = LAsc(Lam(\"x\", Cursor(EHole)), Arrow(Num, Num));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var(\"x\"));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      LAsc(Lam(\"x\", Cursor(Var(\"x\"))), Arrow(Num, Num)),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast10 = () => {\n  let ctx: typctx = TypCtx.singleton(\"x\", Hazelnut.Htyp.Num);\n  let ze: Hazelnut.Zexp.t = LAsc(Lam(\"x\", Cursor(EHole)), Arrow(Num, Num));\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var(\"x\"));\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(LAsc(Lam(\"x\", Cursor(Var(\"x\"))), Arrow(Num, Num)));\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st11 = () => {\n  let ctx: typctx = TypCtx.singleton(\"x\", Hazelnut.Htyp.Num);\n  let ze: Hazelnut.Zexp.t =\n    LAsc(Lam(\"x\", Cursor(Var(\"x\"))), Arrow(Num, Num));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus);\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      LAsc(Lam(\"x\", RPlus(Var(\"x\"), Cursor(EHole))), Arrow(Num, Num)),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast11 = () => {\n  let ctx: typctx = TypCtx.singleton(\"x\", Hazelnut.Htyp.Num);\n  let ze: Hazelnut.Zexp.t =\n    LAsc(Lam(\"x\", Cursor(Var(\"x\"))), Arrow(Num, Num));\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Plus);\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(\n      LAsc(Lam(\"x\", RPlus(Var(\"x\"), Cursor(EHole))), Arrow(Num, Num)),\n    );\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet test_st12 = () => {\n  let ctx: typctx = TypCtx.singleton(\"x\", Hazelnut.Htyp.Num);\n  let ze: Hazelnut.Zexp.t =\n    LAsc(Lam(\"x\", RPlus(Var(\"x\"), Cursor(EHole))), Arrow(Num, Num));\n  let t: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(1));\n  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Hazelnut.syn_action(ctx, (ze, t), a);\n  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =\n    Some((\n      LAsc(Lam(\"x\", RPlus(Var(\"x\"), Cursor(Lit(1)))), Arrow(Num, Num)),\n      Arrow(Num, Num),\n    ));\n  check(zexp_htyp, \"same option(Hazelnut.Zexp.t)\", given, expected);\n};\n\nlet test_ast12 = () => {\n  let ctx: typctx = TypCtx.singleton(\"x\", Hazelnut.Htyp.Num);\n  let ze: Hazelnut.Zexp.t =\n    LAsc(Lam(\"x\", RPlus(Var(\"x\"), Cursor(EHole))), Arrow(Num, Num));\n  let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lit(1));\n  let ht: Hazelnut.Htyp.t = Arrow(Num, Num);\n  let given: option(Hazelnut.Zexp.t) = Hazelnut.ana_action(ctx, ze, a, ht);\n  let expected: option(Hazelnut.Zexp.t) =\n    Some(\n      LAsc(Lam(\"x\", RPlus(Var(\"x\"), Cursor(Lit(1)))), Arrow(Num, Num)),\n    );\n  check(zexp_typ, \"same Hazelnut.Zexp.t\", given, expected);\n};\n\nlet sample1_tests = [\n  (\"test_st1\", `Quick, test_st1),\n  (\"test_ast1\", `Quick, test_ast1),\n  (\"test_st2\", `Quick, test_st2),\n  (\"test_ast2\", `Quick, test_ast2),\n  (\"test_st3\", `Quick, test_st3),\n  (\"test_ast3\", `Quick, test_ast3),\n  (\"test_st4\", `Quick, test_st4),\n  (\"test_ast4\", `Quick, test_ast4),\n  (\"test_st5\", `Quick, test_st5),\n  (\"test_ast5\", `Quick, test_ast5),\n  (\"test_st6\", `Quick, test_st6),\n  (\"test_ast6\", `Quick, test_ast6),\n  (\"test_st7\", `Quick, test_st7),\n  (\"test_ast7\", `Quick, test_ast7),\n  (\"test_st8\", `Quick, test_st8),\n  (\"test_ast8\", `Quick, test_ast8),\n  (\"test_st9\", `Quick, test_st9),\n  (\"test_ast9\", `Quick, test_ast9),\n  (\"test_st10\", `Quick, test_st10),\n  (\"test_ast10\", `Quick, test_ast10),\n  (\"test_st11\", `Quick, test_st11),\n  (\"test_ast11\", `Quick, test_ast11),\n  (\"test_st12\", `Quick, test_st12),\n  (\"test_ast12\", `Quick, test_ast12),\n];\n"}}}
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending notification {"jsonrpc": "2.0", "method": "window/showMessage", "params": {"type": 1, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":30,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample1.re"},"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":0}},"context":{"diagnostics":[]}}}
-[server] Got a method textDocument/codeAction
-[server] processing took 0.00381469726562ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 30, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":31,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample1.re"}}}
-[server] Got a method textDocument/documentSymbol
-[server] processing took 0.00405311584473ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 31, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":32,"method":"textDocument/codeLens","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample1.re"}}}
-[server] Got a method textDocument/codeLens
-[server] processing took 0.00286102294922ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 32, "jsonrpc": "2.0", "result": [{"range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 0}}, "command": {"title": "Unable to load compilation data: Unable to read /Users/razeenmaroof/research/Finished/test/.merlin", "command": ""}}]}
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Read message 
-{"jsonrpc":"2.0","id":33,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample1.re"}}}
-[server] Got a method textDocument/documentSymbol
-[server] processing took 0.0340938568115ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 33, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":34,"method":"textDocument/hover","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample1.re"},"position":{"line":331,"character":4}}}
-[server] Got a method textDocument/hover
-[server] processing took 0.00500679016113ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 34, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","method":"$/cancelRequest","params":{"id":34}}
-Read message 
-{"jsonrpc":"2.0","id":35,"method":"textDocument/hover","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample1.re"},"position":{"line":343,"character":1}}}
-[server] Got a method textDocument/hover
-[server] processing took 0.00500679016113ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 35, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":36,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample2.re"},"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":0}},"context":{"diagnostics":[]}}}
-[server] Got a method textDocument/codeAction
-[server] processing took 0.0119209289551ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 36, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":37,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample2.re"}}}
-[server] Got a method textDocument/documentSymbol
-[server] processing took 0.00405311584473ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 37, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}
-Read message 
-{"jsonrpc":"2.0","id":38,"method":"textDocument/codeLens","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample2.re"}}}
-[server] Got a method textDocument/codeLens
-[server] processing took 0.00405311584473ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 38, "jsonrpc": "2.0", "result": [{"range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 0}}, "command": {"title": "Unable to load compilation data: Unable to read /Users/razeenmaroof/research/Finished/test/.merlin", "command": ""}}]}
-Read message 
-{"jsonrpc":"2.0","id":39,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"file:///Users/razeenmaroof/research/Finished/test/Test_sample2.re"}}}
-[server] Got a method textDocument/documentSymbol
-[server] processing took 0.00596046447754ms
-Found a `dune` file at /Users/razeenmaroof/research/Finished/test
-]] Making a new jbuilder package at /Users/razeenmaroof/research/Finished/test
-=== Project root: /Users/razeenmaroof/research/Finished
-Detected `opam` dependency manager for local use
-Sending response {"id": 39, "jsonrpc": "2.0", "error": {"code": -32603, "message": "Unable to read /Users/razeenmaroof/research/Finished/test/.merlin"}}

From 2d3a0516e56748737d7103b3c220125f23a39110 Mon Sep 17 00:00:00 2001
From: Razeen Maroof <maroofrazeen@gmail.com>
Date: Tue, 8 Oct 2024 15:09:11 -0400
Subject: [PATCH 16/17] added the remaining case and cleaned up some of the old
 tests

---
 test/Test_ana_action.re  |   2 +-
 test/Test_sample1.re     |  96 ++++++++--------
 test/Test_sample2.re     |  32 +++---
 test/Test_syn_action.re  | 232 ++++++++++++++++++++++++++++++++++++++-
 test/Test_type_action.re |  94 ++++++++++++++++
 test/hazelnut_test.re    |   1 +
 6 files changed, 390 insertions(+), 67 deletions(-)
 create mode 100644 test/Test_type_action.re

diff --git a/test/Test_ana_action.re b/test/Test_ana_action.re
index 4872e8a..e8c9583 100644
--- a/test/Test_ana_action.re
+++ b/test/Test_ana_action.re
@@ -208,5 +208,5 @@ let ana_action_tests = [
   ("test_aaconnumlit_1", `Quick, test_aaconnumlit_1),
   ("test_aaconnumlit_2", `Quick, test_aaconnumlit_2),
   ("test_aafinish_1", `Quick, test_aafinish_1),
-  //("test_aafinish_2", `Quick, test_aafinish_2),
+  ("test_aafinish_2", `Quick, test_aafinish_2),
 ];
diff --git a/test/Test_sample1.re b/test/Test_sample1.re
index 9e8fc5d..fefd48c 100644
--- a/test/Test_sample1.re
+++ b/test/Test_sample1.re
@@ -5,7 +5,7 @@ module Hazelnut = Hazelnut_lib.Hazelnut;
 module TypCtx = Map.Make(String);
 type typctx = Hazelnut.TypCtx.t(Hazelnut.Htyp.t);
 
-let test_st1 = () => {
+let test_syn_step_1 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t = Cursor(EHole);
   let t: Hazelnut.Htyp.t = Hole;
@@ -20,7 +20,7 @@ let test_st1 = () => {
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
-let test_ast1 = () => {
+let test_ana_step_1 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t = Cursor(EHole);
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Lam("x"));
@@ -30,7 +30,7 @@ let test_ast1 = () => {
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
-let test_st2 = () => {
+let test_syn_step_2 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t =
     RAsc(Lam("x", EHole), LArrow(Cursor(Hole), Hole));
@@ -46,7 +46,7 @@ let test_st2 = () => {
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
-let test_ast2 = () => {
+let test_ana_step_2 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t =
     RAsc(Lam("x", EHole), LArrow(Cursor(Hole), Hole));
@@ -58,7 +58,7 @@ let test_ast2 = () => {
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
-let test_st3 = () => {
+let test_syn_step_3 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t =
     RAsc(Lam("x", EHole), LArrow(Cursor(Num), Hole));
@@ -74,7 +74,7 @@ let test_st3 = () => {
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
-let test_ast3 = () => {
+let test_ana_step_3 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t =
     RAsc(Lam("x", EHole), LArrow(Cursor(Num), Hole));
@@ -86,7 +86,7 @@ let test_ast3 = () => {
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
-let test_st4 = () => {
+let test_syn_step_4 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t =
     RAsc(Lam("x", EHole), Cursor(Arrow(Num, Hole)));
@@ -102,7 +102,7 @@ let test_st4 = () => {
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
-let test_ast4 = () => {
+let test_ana_step_4 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t =
     RAsc(Lam("x", EHole), Cursor(Arrow(Num, Hole)));
@@ -114,7 +114,7 @@ let test_ast4 = () => {
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
-let test_st5 = () => {
+let test_syn_step_5 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t =
     RAsc(Lam("x", EHole), RArrow(Num, Cursor(Hole)));
@@ -130,7 +130,7 @@ let test_st5 = () => {
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
-let test_ast5 = () => {
+let test_ana_step_5 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t =
     RAsc(Lam("x", EHole), RArrow(Num, Cursor(Hole)));
@@ -142,7 +142,7 @@ let test_ast5 = () => {
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
-let test_st6 = () => {
+let test_syn_step_6 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t =
     RAsc(Lam("x", EHole), RArrow(Num, Cursor(Num)));
@@ -158,7 +158,7 @@ let test_st6 = () => {
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
-let test_ast6 = () => {
+let test_ana_step_6 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t =
     RAsc(Lam("x", EHole), RArrow(Num, Cursor(Num)));
@@ -170,7 +170,7 @@ let test_ast6 = () => {
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
-let test_st7 = () => {
+let test_syn_step_7 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t = RAsc(Lam("x", EHole), Cursor(Arrow(Num, Num)));
   let t: Hazelnut.Htyp.t = Arrow(Num, Num);
@@ -185,7 +185,7 @@ let test_st7 = () => {
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
-let test_ast7 = () => {
+let test_ana_step_7 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t = RAsc(Lam("x", EHole), Cursor(Arrow(Num, Num)));
   let a: Hazelnut.Action.t = Move(Parent);
@@ -196,7 +196,7 @@ let test_ast7 = () => {
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
-let test_st8 = () => {
+let test_syn_step_8 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t = Cursor(Asc(Lam("x", EHole), Arrow(Num, Num)));
   let t: Hazelnut.Htyp.t = Arrow(Num, Num);
@@ -211,7 +211,7 @@ let test_st8 = () => {
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
-let test_ast8 = () => {
+let test_ana_step_8 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t = Cursor(Asc(Lam("x", EHole), Arrow(Num, Num)));
   let a: Hazelnut.Action.t = Move(Child(One));
@@ -222,7 +222,7 @@ let test_ast8 = () => {
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
-let test_st9 = () => {
+let test_syn_step_9 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t = LAsc(Cursor(Lam("x", EHole)), Arrow(Num, Num));
   let t: Hazelnut.Htyp.t = Arrow(Num, Num);
@@ -237,7 +237,7 @@ let test_st9 = () => {
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
-let test_ast9 = () => {
+let test_ana_step_9 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t = LAsc(Cursor(Lam("x", EHole)), Arrow(Num, Num));
   let a: Hazelnut.Action.t = Move(Child(One));
@@ -248,7 +248,7 @@ let test_ast9 = () => {
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
-let test_st10 = () => {
+let test_syn_step_10 = () => {
   let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
   let ze: Hazelnut.Zexp.t = LAsc(Lam("x", Cursor(EHole)), Arrow(Num, Num));
   let t: Hazelnut.Htyp.t = Arrow(Num, Num);
@@ -263,7 +263,7 @@ let test_st10 = () => {
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
-let test_ast10 = () => {
+let test_ana_step_10 = () => {
   let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
   let ze: Hazelnut.Zexp.t = LAsc(Lam("x", Cursor(EHole)), Arrow(Num, Num));
   let a: Hazelnut.Action.t = Construct(Hazelnut.Shape.Var("x"));
@@ -274,7 +274,7 @@ let test_ast10 = () => {
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
-let test_st11 = () => {
+let test_syn_step_11 = () => {
   let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
   let ze: Hazelnut.Zexp.t =
     LAsc(Lam("x", Cursor(Var("x"))), Arrow(Num, Num));
@@ -290,7 +290,7 @@ let test_st11 = () => {
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
-let test_ast11 = () => {
+let test_ana_step_11 = () => {
   let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
   let ze: Hazelnut.Zexp.t =
     LAsc(Lam("x", Cursor(Var("x"))), Arrow(Num, Num));
@@ -304,7 +304,7 @@ let test_ast11 = () => {
   check(zexp_typ, "same Hazelnut.Zexp.t", given, expected);
 };
 
-let test_st12 = () => {
+let test_syn_step_12 = () => {
   let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
   let ze: Hazelnut.Zexp.t =
     LAsc(Lam("x", RPlus(Var("x"), Cursor(EHole))), Arrow(Num, Num));
@@ -320,7 +320,7 @@ let test_st12 = () => {
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 
-let test_ast12 = () => {
+let test_ana_step_12 = () => {
   let ctx: typctx = TypCtx.singleton("x", Hazelnut.Htyp.Num);
   let ze: Hazelnut.Zexp.t =
     LAsc(Lam("x", RPlus(Var("x"), Cursor(EHole))), Arrow(Num, Num));
@@ -335,28 +335,28 @@ let test_ast12 = () => {
 };
 
 let sample1_tests = [
-  ("test_st1", `Quick, test_st1),
-  ("test_ast1", `Quick, test_ast1),
-  ("test_st2", `Quick, test_st2),
-  ("test_ast2", `Quick, test_ast2),
-  ("test_st3", `Quick, test_st3),
-  ("test_ast3", `Quick, test_ast3),
-  ("test_st4", `Quick, test_st4),
-  ("test_ast4", `Quick, test_ast4),
-  ("test_st5", `Quick, test_st5),
-  ("test_ast5", `Quick, test_ast5),
-  ("test_st6", `Quick, test_st6),
-  ("test_ast6", `Quick, test_ast6),
-  ("test_st7", `Quick, test_st7),
-  ("test_ast7", `Quick, test_ast7),
-  ("test_st8", `Quick, test_st8),
-  ("test_ast8", `Quick, test_ast8),
-  ("test_st9", `Quick, test_st9),
-  ("test_ast9", `Quick, test_ast9),
-  ("test_st10", `Quick, test_st10),
-  ("test_ast10", `Quick, test_ast10),
-  ("test_st11", `Quick, test_st11),
-  ("test_ast11", `Quick, test_ast11),
-  ("test_st12", `Quick, test_st12),
-  ("test_ast12", `Quick, test_st12),
+  ("test_syn_step_1", `Quick, test_syn_step_1),
+  ("test_ana_step_1", `Quick, test_ana_step_1),
+  ("test_syn_step_2", `Quick, test_syn_step_2),
+  ("test_ana_step_2", `Quick, test_ana_step_2),
+  ("test_syn_step_3", `Quick, test_syn_step_3),
+  ("test_ana_step_3", `Quick, test_ana_step_3),
+  ("test_syn_step_4", `Quick, test_syn_step_4),
+  ("test_ana_step_4", `Quick, test_ana_step_4),
+  ("test_syn_step_5", `Quick, test_syn_step_5),
+  ("test_ana_step_5", `Quick, test_ana_step_5),
+  ("test_syn_step_6", `Quick, test_syn_step_6),
+  ("test_ana_step_6", `Quick, test_ana_step_6),
+  ("test_syn_step_7", `Quick, test_syn_step_7),
+  ("test_ana_step_7", `Quick, test_ana_step_7),
+  ("test_syn_step_8", `Quick, test_syn_step_8),
+  ("test_ana_step_8", `Quick, test_ana_step_8),
+  ("test_syn_step_9", `Quick, test_syn_step_9),
+  ("test_ana_step_9", `Quick, test_ana_step_9),
+  ("test_syn_step_10", `Quick, test_syn_step_10),
+  ("test_ana_step_10", `Quick, test_ana_step_10),
+  ("test_syn_step_11", `Quick, test_syn_step_11),
+  ("test_ana_step_11", `Quick, test_ana_step_11),
+  ("test_syn_step_12", `Quick, test_syn_step_12),
+  ("test_ana_step_12", `Quick, test_ana_step_12),
 ];
diff --git a/test/Test_sample2.re b/test/Test_sample2.re
index aa1679c..4b87fe1 100644
--- a/test/Test_sample2.re
+++ b/test/Test_sample2.re
@@ -215,20 +215,20 @@ let test_ast21 = () => {
 };
 
 let sample2_tests = [
-  ("test_st14", `Quick, test_st14),
-  ("test_ast14", `Quick, test_ast14),
-  ("test_st15", `Quick, test_st15),
-  ("test_ast15", `Quick, test_ast15),
-  ("test_st16", `Quick, test_st16),
-  ("test_ast16", `Quick, test_ast16),
-  ("test_st17", `Quick, test_st17),
-  ("test_ast17", `Quick, test_ast17),
-  ("test_st18", `Quick, test_st18),
-  ("test_ast18", `Quick, test_ast18),
-  ("test_st19", `Quick, test_st19),
-  ("test_ast19", `Quick, test_ast19),
-  ("test_st20", `Quick, test_st20),
-  ("test_ast20", `Quick, test_ast20),
-  ("test_st21", `Quick, test_st21),
-  ("test_ast21", `Quick, test_ast21),
+  ("test_syn_step_14", `Quick, test_st14),
+  ("test_ana_step_14", `Quick, test_ast14),
+  ("test_syn_step_15", `Quick, test_st15),
+  ("test_ana_step_15", `Quick, test_ast15),
+  ("test_syn_step_16", `Quick, test_st16),
+  ("test_ana_step_16", `Quick, test_ast16),
+  ("test_syn_step_17", `Quick, test_st17),
+  ("test_ana_step_17", `Quick, test_ast17),
+  ("test_syn_step_18", `Quick, test_st18),
+  ("test_ana_step_18", `Quick, test_ast18),
+  ("test_syn_step_19", `Quick, test_st19),
+  ("test_ana_step_19", `Quick, test_ast19),
+  ("test_syn_step_20", `Quick, test_st20),
+  ("test_ana_step_20", `Quick, test_ast20),
+  ("test_syn_step_21", `Quick, test_st21),
+  ("test_ana_step_21", `Quick, test_ast21),
 ];
diff --git a/test/Test_syn_action.re b/test/Test_syn_action.re
index 9d528c0..1d2b85f 100644
--- a/test/Test_syn_action.re
+++ b/test/Test_syn_action.re
@@ -4,7 +4,52 @@ module Hazelnut = Hazelnut_lib.Hazelnut;
 module TypCtx = Map.Make(String);
 type typctx = Hazelnut.TypCtx.t(Hazelnut.Htyp.t);
 
-let test_samove_1 = () => {
+// MOVE TESTS BEGIN
+let test_samove_asc1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(Asc(Lit(1), Num));
+  let t: Hazelnut.Htyp.t = Num;
+  let a: Hazelnut.Action.t = Move(Child(One));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((LAsc(Cursor(Lit(1)), Num),Num));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_samove_asc2 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = Cursor(Asc(Lit(1), Num));
+  let t: Hazelnut.Htyp.t = Num;
+  let a: Hazelnut.Action.t = Move(Child(Two));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((RAsc(Lit(1), Cursor(Num)),Num));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_samove_asc3 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = LAsc(Cursor(Lit(1)), Num);
+  let t: Hazelnut.Htyp.t = Num;
+  let a: Hazelnut.Action.t = Move(Parent);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((Cursor(Asc(Lit(1), Num)), Num));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_samove_asc4 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = RAsc(Lit(1), Cursor(Num));
+  let t: Hazelnut.Htyp.t = Num;
+  let a: Hazelnut.Action.t = Move(Parent);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((Cursor(Asc(Lit(1), Num)), Num));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_samove_lam1 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t =
     LAsc(Cursor(Lam("x", EHole)), Arrow(Hole, Hole));
@@ -19,6 +64,174 @@ let test_samove_1 = () => {
     ));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
+let test_samove_lam2 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =
+    LAsc(Lam("x", Cursor(EHole)), Arrow(Hole, Hole));
+  let t: Hazelnut.Htyp.t = Arrow(Hole, Hole);
+  let a: Hazelnut.Action.t = Move(Parent);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      LAsc(Cursor(Lam("x", EHole)), Arrow(Hole, Hole)),
+      Arrow(Hole, Hole),
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_samove_plus1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =
+    Cursor(Plus(Lit(1),Lit(2)));
+  let t: Hazelnut.Htyp.t = Num;
+  let a: Hazelnut.Action.t = Move(Child(One));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      LPlus(Cursor(Lit(1)), Lit(2)),
+      Num,
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_samove_plus2 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =
+    Cursor(Plus(Lit(1),Lit(2)));
+  let t: Hazelnut.Htyp.t = Num;
+  let a: Hazelnut.Action.t = Move(Child(Two));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      RPlus(Lit(1), Cursor(Lit(2))),
+      Num,
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_samove_plus3 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =
+    LPlus(Cursor(Lit(1)), Lit(2));
+  let t: Hazelnut.Htyp.t = Num;
+  let a: Hazelnut.Action.t = Move(Parent);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      Cursor(Plus(Lit(1),Lit(2))),
+      Num,
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_samove_plus4 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =
+    RPlus(Lit(1), Cursor(Lit(2)));
+  let t: Hazelnut.Htyp.t = Num;
+  let a: Hazelnut.Action.t = Move(Parent);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      Cursor(Plus(Lit(1),Lit(2))),
+      Num,
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_samove_ap1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =
+    Cursor(Ap(Lam("x", EHole), EHole));
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Move(Child(One));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      LAp(Cursor(Lam("x", EHole)), EHole),
+      Hole,
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_samove_ap2 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =
+    Cursor(Ap(Lam("x", EHole), EHole));
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Move(Child(Two));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      RAp(Lam("x", EHole), Cursor(EHole)),
+      Hole,
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_samove_ap3 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =
+    LAp(Cursor(Lam("x", EHole)), EHole);
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Move(Parent);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      Cursor(Ap(Lam("x", EHole), EHole)),
+      Hole,
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_samove_ap4 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =
+    RAp(Lam("x", EHole), Cursor(EHole));
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Move(Parent);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      Cursor(Ap(Lam("x", EHole), EHole)),
+      Hole,
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_samove_neh1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =
+    Cursor(NEHole(Lit(1)));
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Move(Child(One));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      NEHole(Cursor(Lit(1))),
+      Hole,
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_samove_neh2 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t =
+    NEHole(Cursor(Lit(1)));
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Move(Parent);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((
+      (Cursor(NEHole(Lit(1)))),
+      Hole,
+    ));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+// MOVE TESTS COMPLETE 
+
+
 let test_sadel_1 = () => {
   let ctx: typctx = TypCtx.empty;
   let ze: Hazelnut.Zexp.t = Cursor(Lit(1));
@@ -258,7 +471,22 @@ let test_safinish_2 = () => {
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 let syn_action_tests = [
-  ("test_samove_1", `Quick, test_sadel_1),
+  ("test_samove_asc1", `Quick, test_samove_asc1),
+  ("test_samove_asc2", `Quick, test_samove_asc2),
+  ("test_samove_asc3", `Quick, test_samove_asc3),
+  ("test_samove_asc4", `Quick, test_samove_asc4),
+  ("test_samove_lam1", `Quick, test_samove_lam1),
+  ("test_samove_lam2", `Quick, test_samove_lam2),
+  ("test_samove_plus1", `Quick, test_samove_plus1),
+  ("test_samove_plus2", `Quick, test_samove_plus2),
+  ("test_samove_plus3", `Quick, test_samove_plus3),
+  ("test_samove_plus4", `Quick, test_samove_plus4),
+  ("test_samove_ap1", `Quick, test_samove_ap1),
+  ("test_samove_ap2", `Quick, test_samove_ap2),
+  ("test_samove_ap3", `Quick, test_samove_ap3),
+  ("test_samove_ap4", `Quick, test_samove_ap4),
+  ("test_samove_neh1", `Quick, test_samove_neh1),
+  ("test_samove_neh2", `Quick, test_samove_neh2),
   ("test_sadel_1", `Quick, test_sadel_1),
   ("test_sadel_2", `Quick, test_sadel_2),
   ("test_safinish_1", `Quick, test_safinish_1),
diff --git a/test/Test_type_action.re b/test/Test_type_action.re
new file mode 100644
index 0000000..7286b6b
--- /dev/null
+++ b/test/Test_type_action.re
@@ -0,0 +1,94 @@
+open Alcotest;
+open Test_interface;
+module Hazelnut = Hazelnut_lib.Hazelnut;
+
+module TypCtx = Map.Make(String);
+type typctx = Hazelnut.TypCtx.t(Hazelnut.Htyp.t);
+
+let test_type_move1 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = RAsc(Lam("x", EHole), Cursor(Arrow(Hole, Hole)));
+  let t: Hazelnut.Htyp.t = Arrow(Hole,Hole);
+  let a: Hazelnut.Action.t = Move(Child(One));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((RAsc(Lam("x", EHole), LArrow(Cursor(Hole), Hole)), Arrow(Hole,Hole)));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_type_move2 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = RAsc(Lam("x", EHole), Cursor(Arrow(Hole, Hole)));
+  let t: Hazelnut.Htyp.t = Arrow(Hole,Hole);
+  let a: Hazelnut.Action.t = Move(Child(Two));
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((RAsc(Lam("x", EHole), RArrow(Hole, Cursor(Hole))), Arrow(Hole,Hole)));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_type_move3 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = RAsc(Lam("x", EHole), RArrow(Hole, Cursor(Hole)));
+  let t: Hazelnut.Htyp.t = Arrow(Hole,Hole);
+  let a: Hazelnut.Action.t = Move(Parent);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((RAsc(Lam("x", EHole), Cursor(Arrow(Hole, Hole))), Arrow(Hole,Hole)));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_type_move4 = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = RAsc(Lam("x", EHole), LArrow(Cursor(Hole), Hole));
+  let t: Hazelnut.Htyp.t = Arrow(Hole,Hole);
+  let a: Hazelnut.Action.t = Move(Parent);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((RAsc(Lam("x", EHole), Cursor(Arrow(Hole, Hole))), Arrow(Hole,Hole)));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_type_del = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = RAsc(Lit(1), Cursor(Num));
+  let t: Hazelnut.Htyp.t = Num;
+  let a: Hazelnut.Action.t = Del;
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((RAsc(Lit(1), Cursor(Hole)), Hole));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_type_conarr = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = RAsc(Lit(1), Cursor(Num));
+  let t: Hazelnut.Htyp.t = Num;
+  let a: Hazelnut.Action.t = Construct(Arrow);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((RAsc(Lit(1), RArrow(Num,Cursor(Hole))), Arrow(Num,Hole)));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+let test_type_connum = () => {
+  let ctx: typctx = TypCtx.empty;
+  let ze: Hazelnut.Zexp.t = RAsc(Lit(1), Cursor(Hole));
+  let t: Hazelnut.Htyp.t = Hole;
+  let a: Hazelnut.Action.t = Construct(Num);
+  let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Hazelnut.syn_action(ctx, (ze, t), a);
+  let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
+    Some((RAsc(Lit(1), Cursor(Num)), Num));
+  check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
+};
+
+let type_action_tests = [
+    ("test_type_move1", `Quick, test_type_move1),
+    ("test_type_move2", `Quick, test_type_move2),
+    ("test_type_move3", `Quick, test_type_move3),
+    ("test_type_move4", `Quick, test_type_move4),
+    ("test_type_del", `Quick, test_type_del),
+    ("test_type_conarr", `Quick, test_type_conarr),
+    ("test_type_connum", `Quick, test_type_connum),
+];
diff --git a/test/hazelnut_test.re b/test/hazelnut_test.re
index f88d4f1..1edc33f 100644
--- a/test/hazelnut_test.re
+++ b/test/hazelnut_test.re
@@ -11,5 +11,6 @@ let () =
       ("syn_action", Test_syn_action.syn_action_tests),
       ("sample 1", Test_sample1.sample1_tests),
       ("sample 2", Test_sample2.sample2_tests),
+      ("type_action", Test_type_action.type_action_tests),
     ],
   );

From d06eac6dfaa481e1223a513befd5918991c1c301 Mon Sep 17 00:00:00 2001
From: Cyrus Desai <pseudonym112304@gmail.com>
Date: Sun, 12 Jan 2025 21:45:42 -0500
Subject: [PATCH 17/17] fixed incorrect arrow construction test

---
 test/Test_type_action.re | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/Test_type_action.re b/test/Test_type_action.re
index 7286b6b..8a1d312 100644
--- a/test/Test_type_action.re
+++ b/test/Test_type_action.re
@@ -62,13 +62,13 @@ let test_type_del = () => {
 };
 let test_type_conarr = () => {
   let ctx: typctx = TypCtx.empty;
-  let ze: Hazelnut.Zexp.t = RAsc(Lit(1), Cursor(Num));
+  let ze: Hazelnut.Zexp.t = RAsc(Lam("x", Lit(1)), Cursor(Num));
   let t: Hazelnut.Htyp.t = Num;
   let a: Hazelnut.Action.t = Construct(Arrow);
   let given: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
     Hazelnut.syn_action(ctx, (ze, t), a);
   let expected: option((Hazelnut.Zexp.t, Hazelnut.Htyp.t)) =
-    Some((RAsc(Lit(1), RArrow(Num,Cursor(Hole))), Arrow(Num,Hole)));
+    Some((RAsc(Lam("x", Lit(1)), RArrow(Num,Cursor(Hole))), Arrow(Num,Hole)));
   check(zexp_htyp, "same option(Hazelnut.Zexp.t)", given, expected);
 };
 let test_type_connum = () => {