Incrementat type checking

eyg/src/atelier/view/pallet.gleam

@@ -1,4 +1,5 @@
 // command pallet
+import gleam/io
 import gleam/dynamic
 import gleam/list
 import gleam/map
@@ -8,19 +9,22 @@ import lustre/element.{div, input, span, text, textarea}
 import lustre/event.{on_click}
 import lustre/attribute.{class, classes}
 import eyg/analysis/inference
+import eyg/incremental/cursor
+import eyg/analysis/jm/error
+import eyg/analysis/jm/type_ as t
 import atelier/app.{ClickOption, SelectNode}
-import atelier/view/typ
+import atelier/view/type_
 import atelier/inventory
 
-pub fn render(state: app.WorkSpace, inferred) {
+pub fn render(state: app.WorkSpace) {
   div(
     [class("cover bg-gray-100")],
     case state.mode {
       app.WriteLabel(value, _) -> render_label(value)
-      app.WriteTerm(value, _) -> render_variable(value, inferred, state)
+      app.WriteTerm(value, _) -> render_variable(value, state)
       app.WriteNumber(number, _) -> render_number(number)
       app.WriteText(value, _) -> render_text(value)
-      _ -> render_navigate(inferred, state)
+      _ -> render_navigate(state)
     },
   )
 }
@@ -36,39 +40,35 @@ fn render_label(value) {
   ]
 }
 
-fn render_variable(
-  value,
-  inferred: option.Option(inference.Infered),
-  state: app.WorkSpace,
-) {
+fn render_variable(value, state: app.WorkSpace) {
   [
-    div(
-      [],
-      case inferred {
-        Some(inferred) ->
-          case inventory.variables_at(inferred.environments, state.selection) {
-            // using spaces because we are in pre tag and text based
-            // not in pre tag here
-            Ok(options) ->
-              list.map(
-                options,
-                fn(option) {
-                  let #(t, term) = option
-                  span(
-                    [
-                      class("rounded bg-blue-100 p-1"),
-                      on_click(ClickOption(term)),
-                    ],
-                    [text(t)],
-                  )
-                },
-              )
-              |> list.intersperse(text(" "))
-            Error(_) -> [text("no env")]
-          }
-        None -> []
-      },
-    ),
+    div([], []),
+    // case inferred {
+    //   Some(inferred) ->
+    //     // TODO use inferred but we dont have the whole env map.
+    //     []
+    //     // case inventory.variables_at(inferred.environments, state.selection) {
+    //     //   // using spaces because we are in pre tag and text based
+    //     //   // not in pre tag here
+    //     //   Ok(options) ->
+    //     //     list.map(
+    //     //       options,
+    //     //       fn(option) {
+    //     //         let #(t, term) = option
+    //     //         span(
+    //     //           [
+    //     //             class("rounded bg-blue-100 p-1"),
+    //     //             on_click(ClickOption(term)),
+    //     //           ],
+    //     //           [text(t)],
+    //     //         )
+    //     //       },
+    //     //     )
+    //     //     |> list.intersperse(text(" "))
+    //     //   Error(_) -> [text("no env")]
+    //     // }
+    //   None -> []
+    // },
     input([
       class("border w-full"),
       attribute.autofocus(True),
@@ -114,10 +114,11 @@ fn render_text(value) {
   ]
 }
 
-fn render_navigate(inferred, state: app.WorkSpace) {
+fn render_navigate(state: app.WorkSpace) {
+  let #(sub, _next, types) = state.inferred
   [
-    case inferred {
-      Some(inferred) -> render_errors(inferred)
+    case types {
+      Some(types) -> render_errors(types)
       None -> span([], [])
     },
     div(
@@ -126,13 +127,25 @@ fn render_navigate(inferred, state: app.WorkSpace) {
         span(
           [],
           [
-            case inferred {
-              Some(inferred) ->
+            case types {
+              Some(types) ->
                 text(string.append(
                   ":",
-                  inferred
-                  |> inference.type_of(state.selection)
-                  |> typ.render(),
+                  {
+                    let assert Ok(c) =
+                      cursor.at(state.selection, state.root, state.source)
+                    let id = cursor.inner(c)
+                    let assert Ok(type_) = map.get(types, id)
+                    case type_ {
+                      Ok(type_) -> type_.render_type(t.resolve(type_, sub))
+                      Error(#(reason, t1, t2)) ->
+                        type_.render_failure(
+                          reason,
+                          t.resolve(t1, sub),
+                          t.resolve(t2, sub),
+                        )
+                    }
+                  },
                 ))
               None -> span([], [text("type checking")])
             },
@@ -151,10 +164,10 @@ fn render_navigate(inferred, state: app.WorkSpace) {
   ]
 }
 
-fn render_errors(inferred: inference.Infered) {
+fn render_errors(types) {
   let errors =
     list.filter_map(
-      map.to_list(inferred.types),
+      map.to_list(types),
       fn(el) {
         let #(k, v) = el
         case v {
@@ -173,12 +186,22 @@ fn render_errors(inferred: inference.Infered) {
           errors,
           fn(err) {
             let #(path, reason) = err
+            // TODO real path
+            let path = []
             div(
               [classes([#("cursor-pointer", True)]), on_click(SelectNode(path))],
-              [text(typ.render_failure(reason))],
+              [text(render_failure(reason))],
             )
           },
         ),
       )
   }
 }
+
+pub fn render_failure(reason) {
+  let #(reason, _, _) = reason
+  case reason {
+    error.RecursiveType -> "recursive type"
+    _ -> "other error"
+  }
+}

eyg/src/atelier/view/root.gleam

@@ -1,13 +1,16 @@
 import gleam/io
+import gleam/option
 import lustre/element.{div}
 import lustre/attribute.{attribute, autofocus, class}
 import lustre/event.{on_keydown}
+import eyg/incremental/source
 import atelier/app
 import atelier/view/projection
 import atelier/view/pallet
 
 // maybe belongs in procejection .render
 pub fn render(state: app.WorkSpace) {
+  let assert Ok(tree) = source.to_tree(state.source, state.root)
   div(
     [
       on_keydown(app.Keypress),
@@ -19,9 +22,10 @@ pub fn render(state: app.WorkSpace) {
     ],
     [
       div([class("expand")], []),
-      projection.render(state.source, state.selection, state.inferred),
+      // pass through inferred
+      projection.render(tree, state.selection, option.None),
       div([class("expand")], []),
-      pallet.render(state, state.inferred),
+      pallet.render(state),
     ],
   )
 }

eyg/src/atelier/view/typ.gleam

@@ -6,6 +6,7 @@ import eyg/analysis/typ as t
 import eyg/analysis/unification
 import eyg/analysis/substitutions as sub
 
+// Keep for old kinded version
 // Do we have a general need for type debug functionality
 pub fn render(type_info) {
   case type_info {

eyg/src/atelier/view/type_.gleam

@@ -0,0 +1,95 @@
+// for flat types
+import gleam/int
+import gleam/list
+import gleam/string
+import eyg/analysis/jm/type_ as t
+import eyg/analysis/jm/error
+
+pub fn render_failure(reason, t1, t2) {
+  case reason {
+    error.TypeMismatch(a, b) ->
+      // need to shrink errors together
+      string.concat(["Type Missmatch: ", render_type(a), " vs ", render_type(b)])
+    error.RowMismatch(label) -> string.append("Row Missmatch: ", label)
+    error.MissingVariable(x) -> string.append("missing variable: ", x)
+    error.RecursiveType -> "Recursive type"
+    error.InvalidTail(_) -> "invalid tail"
+  }
+}
+
+pub fn render_type(typ) {
+  case typ {
+    t.Var(i) -> int.to_string(i)
+    t.Integer -> "Integer"
+    t.String -> "String"
+    t.LinkedList(el) -> string.concat(["List(", render_type(el), ")"])
+    t.Fun(from, effects, to) ->
+      string.concat([
+        "(",
+        render_type(from),
+        ") ->",
+        render_effects(effects),
+        " ",
+        render_type(to),
+      ])
+    t.Union(row) ->
+      string.concat([
+        "[",
+        string.concat(
+          render_row(row)
+          |> list.intersperse(" | "),
+        ),
+        "]",
+      ])
+    t.Record(row) ->
+      string.concat([
+        "{",
+        string.concat(
+          render_row(row)
+          |> list.intersperse(", "),
+        ),
+        "}",
+      ])
+    _ -> "invalid should not be raw type"
+  }
+}
+
+fn render_row(r) -> List(String) {
+  case r {
+    t.Empty -> []
+    t.Var(i) -> [string.append("..", int.to_string(i))]
+    t.RowExtend(label, value, tail) -> {
+      let field = string.concat([label, ": ", render_type(value)])
+      [field, ..render_row(tail)]
+    }
+    _ -> ["not a valid row"]
+  }
+}
+
+fn render_effects(effects) {
+  case effects {
+    t.Var(_) | t.Empty -> ""
+    t.EffectExtend(label, #(lift, resume), tail) ->
+      string.concat([
+        " <",
+        string.join(
+          collect_effect(tail, [render_effect(label, lift, resume)]),
+          ", ",
+        ),
+        ">",
+      ])
+    _ -> "not a valid effect"
+  }
+}
+
+fn render_effect(label, lift, resume) {
+  string.concat([label, "(", render_type(lift), ", ", render_type(resume), ")"])
+}
+
+fn collect_effect(eff, acc) {
+  case eff {
+    t.EffectExtend(label, #(lift, resume), tail) ->
+      collect_effect(tail, [render_effect(label, lift, resume), ..acc])
+    _ -> acc
+  }
+}