Fully add first class types. This means types as Values.

kyleect · kyleect · commit 17ec18d5ac18 · 2025-07-06T18:48:43.000-05:00
diff --git a/README.md b/README.md
@@ -39,17 +39,25 @@ See [USAGE.md](./USAGE.md) and [examples](./examples/) for usage examples.
 
 The syntax is s-expression like. There are only [builtin functions](#builtin-functions), identifiers and string literals.
 
-| Syntax      | Description                                 |
-| ----------- | ------------------------------------------- |
-| `:a`        | Reference to the variable `a`               |
-| `?b`        | Reference to the prompt `b`                 |
-| `!c`        | Reference to the secret `c`                 |
-| `id`        | Reference to the builtin `id`               |
-| `@key`      | Reference to the client context value `key` |
-| `(id :a)`   | Call to builtin `id` with arguments: `:a`   |
-| `` `foo` `` | String literal                              |
-| `true`      | Literal boolean value `true`                |
-| `false`     | Literal boolean value `false`               |
+| Syntax                             | Description                                                |
+| ---------------------------------- | ---------------------------------------------------------- |
+| `:a`                               | Reference to the variable `a`                              |
+| `?b`                               | Reference to the prompt `b`                                |
+| `!c`                               | Reference to the secret `c`                                |
+| `id`                               | Reference to the builtin `id`                              |
+| `@key`                             | Reference to the client context value `key`                |
+| `(id :a)`                          | Call to builtin `id` with arguments: `:a`                  |
+| `` `foo` ``                        | String literal                                             |
+| `true`                             | Literal boolean value `true`                               |
+| `false`                            | Literal boolean value `false`                              |
+| `String`                           | Literal type `String`                                      |
+| `Bool`                             | Literal type `Bool`                                        |
+| `Type<String>`                     | Literal type `Type` of type `String`                       |
+| `Fn() -> Bool`                     | Literal type for builtin functions (no args)               |
+| `Fn(Value) -> Bool`                | Literal type for builtin functions (1 arg)                 |
+| `Fn(Value, Bool, String) -> Value` | Literal type for builtin functions (n args)                |
+| `Fn(...String) -> String`          | Literal type for builtin functions (variadic arg)          |
+| `Fn(String, ...String) -> String`  | Literal type for builtin functions (args and variadic arg) |
 
 See [/spec](./spec/) for more syntax examples.
 
diff --git a/USAGE.md b/USAGE.md
@@ -25,6 +25,10 @@ The lexer takes an input string and returns a stream of tokens.
 | ------------ | ----------------------------- | --------------------------------------------------------------------- |
 | `LParan`     | `(`                           | Opening parantheses for a call expression                             |
 | `RParan`     | `)`                           | Closing parantheses for a call expression                             |
+| `Comma`      | `,`                           | Separator between arguments in `Fn` types                             |
+| `LAngle`     | `<`                           | Generic type delimitor                                                |
+| `RAngle`     | `>`                           | Generic type delimitor                                                |
+| `Arrow`      | `->`                          | Separator between `Fn` arg parans and return type                     |
 | `Identifier` | `[!?:]?[a-zA-Z][a-zA-Z0-9_]*` | Identifer referencing a builtin function, variable, prompt, or secret |
 | `String`     | `` `[^`]*` ``                 | A literal string of text delimited by backticks                       |
 | `True`       | `true`                        | A literal boolean value of `true`                                     |
@@ -103,9 +107,10 @@ pub struct ExprCall {
 
 #### ExprIdentifier
 
-An identifier referencing a builtin, variable, prompt, secret, or client value.
+An identifier referencing a builtin, type, variable, prompt, secret, or client value.
 
 - `builtin_name`
+- `TypeName`, `TypeName<Type>`, `Fn(Type, ...Type) -> Type`
 - `:var_name`
 - `?prompt_name`
 - `!secret_name`
@@ -120,6 +125,7 @@ pub enum IdentifierKind {
     Prompt,
     Secret,
     Client,
+    Type,
 }
 
 let ident = ExprIdentifier::new(":foo");
@@ -226,6 +232,7 @@ Valid bytecode will always begin with 4 bytes representing the current language
 | `SECRET`       |            3 | Secret (identifier prefixed with `!`)                |
 | `USER_BUILTIN` |            4 | User provided builtin function                       |
 | `CLIENT_CTX`   |            5 | Client provided value (identifier prefixed with `@`) |
+| `TYPE`         |            6 | A type stored in `ExprByteCode`                      |
 
 ### Compile Time Environment
 
@@ -267,6 +274,35 @@ pub struct FnArg {
 
 See: [builtins.rs](./src/builtins.rs), [types.rs](./src/types.rs), [value.rs](./src/value.rs)
 
+### ExprByteCode
+
+The result of an expression compilation is `ExprByteCode`.
+
+```rust
+pub struct ExprByteCode {
+    version: [u8; 4],
+    codes: Vec<u8>,
+    strings: Vec<String>,
+    types: Vec<Type>,
+}
+```
+
+#### Version
+
+The version of the compiler encoded as bytes.
+
+#### Codes
+
+The actual bytecode values.
+
+#### Strings
+
+An indexed list of strings encountered during compilation. These string indexes are referenced by the `opcode::CONSTANT` opcode.
+
+#### Type
+
+An indexed list of types encountered during compilation. These type indexes are referenced by the `opcode::GET` opcode and `lookup::TYPE` lookup.
+
 ### Usage
 
 ```rust
diff --git a/spec/invalid/not_type_id.expr.interpreted b/spec/invalid/not_type_id.expr.interpreted
@@ -3,7 +3,7 @@
         RuntimeError(
             TypeMismatch {
                 expected: Bool,
-                actual: Type<Fn(Value) -> Value>,
+                actual: Fn(Value) -> Value,
             },
         ),
         0..0,
diff --git a/spec/valid/type_literal_bool.expr b/spec/valid/type_literal_bool.expr
@@ -0,0 +1 @@
+Bool
diff --git a/spec/valid/type_literal_bool.expr.disassembled b/spec/valid/type_literal_bool.expr.disassembled
@@ -0,0 +1,3 @@
+VERSION 0700
+----
+0000 GET TYPE            0 == 'Bool'
diff --git a/spec/valid/type_literal_bool.expr.interpreted b/spec/valid/type_literal_bool.expr.interpreted
@@ -0,0 +1 @@
+Type<Bool>
diff --git a/spec/valid/type_literal_fn_no_args.expr b/spec/valid/type_literal_fn_no_args.expr
@@ -0,0 +1 @@
+Fn() -> Value
diff --git a/spec/valid/type_literal_fn_no_args.expr.interpreted b/spec/valid/type_literal_fn_no_args.expr.interpreted
@@ -0,0 +1 @@
+Type<Fn() -> Value>
diff --git a/spec/valid/type_literal_string.expr b/spec/valid/type_literal_string.expr
@@ -0,0 +1 @@
+String
diff --git a/spec/valid/type_literal_string.expr.disassembled b/spec/valid/type_literal_string.expr.disassembled
@@ -0,0 +1,3 @@
+VERSION 0700
+----
+0000 GET TYPE            0 == 'String'
diff --git a/spec/valid/type_literal_string.expr.interpreted b/spec/valid/type_literal_string.expr.interpreted
@@ -0,0 +1 @@
+Type<String>
diff --git a/spec/valid/type_literal_type_bool.expr b/spec/valid/type_literal_type_bool.expr
@@ -0,0 +1 @@
+Type<Bool>
diff --git a/spec/valid/type_literal_type_bool.expr.disassembled b/spec/valid/type_literal_type_bool.expr.disassembled
@@ -0,0 +1,3 @@
+VERSION 0700
+----
+0000 GET TYPE            0 == 'Bool'
diff --git a/spec/valid/type_literal_type_bool.expr.interpreted b/spec/valid/type_literal_type_bool.expr.interpreted
@@ -0,0 +1 @@
+Type<Bool>
diff --git a/src/ast.rs b/src/ast.rs
@@ -85,7 +85,15 @@ impl ExprIdentifier {
             "!" => IdentifierKind::Secret,
             ":" => IdentifierKind::Var,
             "@" => IdentifierKind::Client,
-            _ => IdentifierKind::Builtin,
+            _ => {
+                let prefix_char: char = identifier_prefix.chars().nth(0).unwrap();
+
+                if prefix_char.is_uppercase() {
+                    IdentifierKind::Type
+                } else {
+                    IdentifierKind::Builtin
+                }
+            }
         }
     }
 
@@ -117,6 +125,7 @@ impl ExprIdentifier {
             IdentifierKind::Prompt => &self.0[1..],
             IdentifierKind::Secret => &self.0[1..],
             IdentifierKind::Client => &self.0[1..],
+            IdentifierKind::Type => &self.0,
         }
     }
 
@@ -136,6 +145,7 @@ pub enum IdentifierKind {
     Prompt,
     Secret,
     Client,
+    Type,
 }
 
 #[derive(Debug, PartialEq)]
@@ -180,6 +190,9 @@ pub fn add_type_to_expr_parse(expr: &mut Expr) {
             IdentifierKind::Client => {
                 expr_identifier.2 = Some(Type::Value);
             }
+            IdentifierKind::Type => {
+                //
+            }
         },
         Expr::Call(expr_call) => {
             for arg in &mut expr_call.args {
@@ -238,6 +251,9 @@ pub fn add_type_to_expr(expr: &mut Expr, env: &CompileTimeEnv) {
                     expr_identifier.2 = Some(Type::String);
                 }
             }
+            IdentifierKind::Type => {
+                //
+            }
         },
         Expr::Call(expr_call) => {
             for arg in &mut expr_call.args {
diff --git a/src/compiler.rs b/src/compiler.rs
@@ -7,6 +7,7 @@ use crate::{
         CompileError::{self, WrongNumberOfArgs},
         ExprError, ExprErrorS, ExprResult,
     },
+    prelude::lookup::TYPE,
     types::Type,
 };
 
@@ -34,7 +35,8 @@ pub mod lookup {
         PROMPT,
         SECRET,
         USER_BUILTIN,
-        CLIENT_CTX
+        CLIENT_CTX,
+        TYPE
     }
 }
 
@@ -189,10 +191,11 @@ pub struct ExprByteCode {
     version: [u8; 4],
     codes: Vec<u8>,
     strings: Vec<String>,
+    types: Vec<Type>,
 }
 
 impl ExprByteCode {
-    pub fn new(codes: Vec<u8>, strings: Vec<String>) -> Self {
+    pub fn new(codes: Vec<u8>, strings: Vec<String>, types: Vec<Type>) -> Self {
         let version_bytes = get_version_bytes();
         let version_bytes_from_codes = &codes[0..4];
 
@@ -207,6 +210,7 @@ impl ExprByteCode {
             version: version_bytes,
             codes,
             strings,
+            types,
         }
     }
 
@@ -218,9 +222,17 @@ impl ExprByteCode {
         &self.codes
     }
 
+    pub fn get_code(&self, index: usize) -> Option<&u8> {
+        self.codes.get(index)
+    }
+
     pub fn strings(&self) -> &[String] {
         &self.strings
     }
+
+    pub fn types(&self) -> &[Type] {
+        &self.types
+    }
 }
 
 pub fn get_version_bytes() -> [u8; 4] {
@@ -235,19 +247,21 @@ pub fn get_version_bytes() -> [u8; 4] {
 /// Compile an [`ast::Expr`] into [`ExprByteCode`]
 pub fn compile(expr: &mut ExprS, env: &CompileTimeEnv) -> ExprResult<ExprByteCode> {
     let mut strings: Vec<String> = vec![];
+    let mut types: Vec<Type> = vec![];
     let mut codes = vec![];
 
     codes.extend(get_version_bytes());
 
-    codes.extend(compile_expr(expr, env, &mut strings)?);
+    codes.extend(compile_expr(expr, env, &mut strings, &mut types)?);
 
-    Ok(ExprByteCode::new(codes, strings))
+    Ok(ExprByteCode::new(codes, strings, types))
 }
 
 fn compile_expr(
     (expr, span): &mut ExprS,
     env: &CompileTimeEnv,
     strings: &mut Vec<String>,
+    types: &mut Vec<Type>,
 ) -> ExprResult<Vec<u8>> {
     use opcode::*;
 
@@ -273,7 +287,7 @@ fn compile_expr(
             let identifier_name = identifier.full_name().to_string();
 
             let identifier_undefined_err = (
-                CompileError::Undefined(identifier_name).into(),
+                CompileError::Undefined(identifier_name.clone()).into(),
                 span.clone(),
             );
 
@@ -319,14 +333,30 @@ fn compile_expr(
                         None
                     }
                 }
+                IdentifierKind::Type => {
+                    let ty = Type::from(&identifier_name);
+                    if let Some(index) = types.iter().position(|x| x == &ty) {
+                        codes.push(GET);
+                        codes.push(TYPE);
+                        codes.push(index as u8);
+                    } else {
+                        types.push(ty);
+                        let index = types.len() - 1;
+                        codes.push(GET);
+                        codes.push(TYPE);
+                        codes.push(index as u8);
+                    }
+
+                    Some(())
+                }
             };
 
             if let None = result {
                 errs.push(identifier_undefined_err);
             }
         }
         Expr::Call(expr_call) => {
-            let callee_bytecode = compile_expr(&mut expr_call.callee, env, strings)?;
+            let callee_bytecode = compile_expr(&mut expr_call.callee, env, strings, types)?;
 
             if let Some(_op) = callee_bytecode.first()
                 && let Some(lookup) = callee_bytecode.get(1)
@@ -403,7 +433,7 @@ fn compile_expr(
             codes.extend(callee_bytecode);
 
             for arg in expr_call.args.iter_mut() {
-                match compile_expr(arg, env, strings) {
+                match compile_expr(arg, env, strings, types) {
                     Ok(arg_bytecode) => {
                         codes.extend(arg_bytecode);
                     }
@@ -450,7 +480,7 @@ mod compiler_tests {
         let mut codes = get_version_bytes().to_vec();
         codes.push(opcode::TRUE);
 
-        ExprByteCode::new(codes.to_vec(), vec![]);
+        ExprByteCode::new(codes.to_vec(), vec![], vec![]);
     }
 
     #[test]
@@ -459,15 +489,15 @@ mod compiler_tests {
         let mut codes: Vec<u8> = [0, 0, 0, 0].to_vec();
         codes.push(opcode::TRUE);
 
-        ExprByteCode::new(codes.to_vec(), vec![]);
+        ExprByteCode::new(codes.to_vec(), vec![], vec![]);
     }
 
     #[test]
     pub fn get_version_bytes_from_bytecode() {
         let mut codes = get_version_bytes().to_vec();
         codes.push(opcode::TRUE);
 
-        let bytecode = ExprByteCode::new(codes.to_vec(), vec![]);
+        let bytecode = ExprByteCode::new(codes.to_vec(), vec![], vec![]);
 
         assert_eq!(bytecode.version(), &get_version_bytes());
     }
diff --git a/src/disassembler.rs b/src/disassembler.rs
@@ -140,6 +140,11 @@ impl<'bytecode, 'env> Disassembler<'bytecode, 'env> {
 
                 value
             }
+            lookup::TYPE => {
+                let value = self.bytecode.types().get(constant_idx).unwrap();
+
+                &value.name()
+            }
             _ => panic!("invalid get lookup code: {}", lookup_type),
         };
 
@@ -150,6 +155,7 @@ impl<'bytecode, 'env> Disassembler<'bytecode, 'env> {
             lookup::PROMPT => "PROMPT",
             lookup::SECRET => "SECRET",
             lookup::CLIENT_CTX => "CLIENT_CTX",
+            lookup::TYPE => "TYPE",
             _ => panic!("invalid get lookup code: {}", lookup_type),
         };
 
diff --git a/src/grammar.lalrpop b/src/grammar.lalrpop
diff --git a/src/lexer.rs b/src/lexer.rs
diff --git a/src/types.rs b/src/types.rs
diff --git a/src/value.rs b/src/value.rs
diff --git a/src/vm.rs b/src/vm.rs
diff --git a/tests/integration_tests.rs b/tests/integration_tests.rs

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+VERSION 0700`
	`2`	`+----`
	`3`	`+0000 GET TYPE 0 == 'Bool'`