Type bind! and import! so a missing bang on them is reported

Both are interpreter forms that exist for their effect, but neither carried a
type declaration. `metta check` decides an operator is an action by reading the
unit return type `(->)` off its signature, so with no signature to read it could
not see either of them: a top-level `(bind! &s (new-space))` or
`(import! &self lib)` written without its leading `!` was stored as data, the
token stayed unbound and the module never loaded, and nothing said so. The first
symptom was a later match quietly finding nothing.

Declaring the types they already have fixes it, and the declarations are exact:
the token and the module name are Atom-typed because neither is reduced, while
bind!'s value is %Undefined% because it is, as in (bind! &s (new-space)). The
full suite passes unchanged, which is the check that the argument evaluation
these declarations imply is the evaluation that was already happening.

Author: MesTTo

packages/core/src/diagnose.test.ts

@@ -214,6 +214,15 @@ describe("analyzeSource — top-level actions the interpreter never runs", () =>
     expect(actionsOf("(likes Sam pizza)")).toEqual([]);
   });
 
+  it("flags a bare bind! or import!, which bind nothing and load nothing", () => {
+    // Both are interpreter forms that exist for their effect. Until they carried a unit return type this
+    // check could not see them, so a missing `!` left the token unbound or the module unloaded in silence.
+    expect(actionsOf("(bind! &s (new-space))")).toHaveLength(1);
+    expect(actionsOf("(import! &self lib)")).toHaveLength(1);
+    expect(actionsOf("!(bind! &s (new-space))")).toEqual([]);
+    expect(actionsOf("!(import! &self lib)")).toEqual([]);
+  });
+
   it("defers to the arity error when the call matches no declared overload", () => {
     expect(analyzeSource("(assertEqual 1)", cfg).map((d) => d.code)).toEqual(["arity-mismatch"]);
   });

packages/core/src/stdlib.ts

@@ -119,6 +119,14 @@ export const STDLIB_SRC = `
   (= (log! $level $payload)
      (if (log-enabled? $level) (println! (Log $level $payload)) ()))
 
+  ; bind! and import! are interpreter forms that exist for their effect, but neither carried a type, so a
+  ; top-level one written without its bang was stored as data and nothing reported it: the token was never
+  ; bound, the module never loaded, and the first symptom was a later match failing. Declaring the unit
+  ; return type is what lets the checker see them. The token and the module name are Atom-typed because
+  ; neither is reduced; bind!'s value is %Undefined% because it is, as in (bind! &s (new-space)).
+  (: bind! (-> Atom %Undefined% (->)))
+  (: import! (-> Atom Atom (->)))
+
   ; Partial application is ordinary PeTTa behavior. A known under-applied head becomes
   ; (partial head args); applying that closure rebuilds the fuller call and evaluates it.
   (: partial (-> Atom Expression Atom))