INT32 and FLOAT32 (#226)

* Add Int32 and Float32 types

* Be explicit about i32 literals

Author: comnik

meta/src/meta/codegen_go.py

@@ -194,7 +194,9 @@ def none_generator(
         # Map terminal names to Go types for type assertion
         terminal_field_map = {
             "INT": "i64",
+            "INT32": "i32",
             "FLOAT": "f64",
+            "FLOAT32": "f32",
             "STRING": "str",
             "SYMBOL": "str",
             "DECIMAL": "decimal",
@@ -936,7 +938,9 @@ def format_literal_token_spec(self, escaped_literal: str) -> str:
         "SYMBOL": ("scanSymbol", "kindString", "str"),
         "STRING": ("scanString", "kindString", "str"),
         "INT": ("scanInt", "kindInt64", "i64"),
+        "INT32": ("scanInt32", "kindInt32", "i32"),
         "FLOAT": ("scanFloat", "kindFloat64", "f64"),
+        "FLOAT32": ("scanFloat32", "kindFloat32", "f32"),
         "UINT128": ("scanUint128", "kindUint128", "uint128"),
         "INT128": ("scanInt128", "kindInt128", "int128"),
         "DECIMAL": ("scanDecimal", "kindDecimal", "decimal"),

meta/src/meta/codegen_templates.py

@@ -43,6 +43,7 @@ class BuiltinTemplate:
     "length": BuiltinTemplate("len({0})"),
     "unwrap_option_or": BuiltinTemplate("({0} if {0} is not None else {1})"),
     "int64_to_int32": BuiltinTemplate("int({0})"),
+    "float64_to_float32": BuiltinTemplate("float({0})"),
     "to_ptr_int64": BuiltinTemplate("{0}"),  # Python doesn't need pointers
     "to_ptr_string": BuiltinTemplate("{0}"),
     "to_ptr_bool": BuiltinTemplate("{0}"),
@@ -83,7 +84,8 @@ class BuiltinTemplate:
     "dedent_io": BuiltinTemplate("None", ["self.dedent()"]),
     "try_flat_io": BuiltinTemplate("self._try_flat({0}, {1})"),
     "format_int64": BuiltinTemplate("str({0})"),
-    "format_int32": BuiltinTemplate("str({0})"),
+    "format_int32": BuiltinTemplate("(str({0}) + 'i32')"),
+    "format_float32": BuiltinTemplate("(self.format_float32_value({0}) + 'f32')"),
     "format_float64": BuiltinTemplate("str({0})"),
     "format_string": BuiltinTemplate("self.format_string_value({0})"),
     "format_symbol": BuiltinTemplate("{0}"),
@@ -95,6 +97,7 @@ class BuiltinTemplate:
     "to_string": BuiltinTemplate("str({0})"),
     # Type conversions used by pretty printer
     "int32_to_int64": BuiltinTemplate("int({0})"),
+    "float32_to_float64": BuiltinTemplate("float({0})"),
     "is_empty": BuiltinTemplate("len({0}) == 0"),
     "decode_string": BuiltinTemplate("{0}.decode('utf-8')"),
     "fragment_id_to_string": BuiltinTemplate("self.fragment_id_to_string({0})"),
@@ -137,6 +140,7 @@ class BuiltinTemplate:
     "length": BuiltinTemplate("length({0})"),
     "unwrap_option_or": BuiltinTemplate("(!isnothing({0}) ? {0} : {1})"),
     "int64_to_int32": BuiltinTemplate("Int32({0})"),
+    "float64_to_float32": BuiltinTemplate("Float32({0})"),
     "to_ptr_int64": BuiltinTemplate("{0}"),  # Julia doesn't need pointers
     "to_ptr_string": BuiltinTemplate("{0}"),
     "to_ptr_bool": BuiltinTemplate("{0}"),
@@ -173,7 +177,8 @@ class BuiltinTemplate:
     "dedent_io": BuiltinTemplate("nothing", ["dedent!(pp)"]),
     "try_flat_io": BuiltinTemplate("try_flat(pp, {0}, {1})"),
     "format_int64": BuiltinTemplate("format_int(pp, {0})"),
-    "format_int32": BuiltinTemplate("format_int(pp, Int64({0}))"),
+    "format_int32": BuiltinTemplate('(string(Int64({0})) * "i32")'),
+    "format_float32": BuiltinTemplate('(lowercase(string({0})) * "f32")'),
     "format_float64": BuiltinTemplate("format_float(pp, {0})"),
     "format_string": BuiltinTemplate("format_string(pp, {0})"),
     "format_symbol": BuiltinTemplate("{0}"),
@@ -185,6 +190,7 @@ class BuiltinTemplate:
     "to_string": BuiltinTemplate("string({0})"),
     # Type conversions used by pretty printer
     "int32_to_int64": BuiltinTemplate("Int64({0})"),
+    "float32_to_float64": BuiltinTemplate("Float64({0})"),
     "is_empty": BuiltinTemplate("isempty({0})"),
     "decode_string": BuiltinTemplate("String(copy({0}))"),
     "fragment_id_to_string": BuiltinTemplate("fragment_id_to_string(pp, {0})"),
@@ -230,6 +236,7 @@ class BuiltinTemplate:
     # unwrap_option_or is handled specially in codegen_go.py due to Go's lack of ternary
     "unwrap_option_or": BuiltinTemplate("{0}"),  # Placeholder - overridden in codegen
     "int64_to_int32": BuiltinTemplate("int32({0})"),
+    "float64_to_float32": BuiltinTemplate("float32({0})"),
     "to_ptr_int64": BuiltinTemplate("ptrInt64({0})"),
     "to_ptr_string": BuiltinTemplate("ptrString({0})"),
     "to_ptr_bool": BuiltinTemplate("ptrBool({0})"),
@@ -265,7 +272,10 @@ class BuiltinTemplate:
     "dedent_io": BuiltinTemplate("nil", ["p.dedent()"]),
     "try_flat_io": BuiltinTemplate("p.tryFlat({0}, func() {{ {1}({0}) }})"),
     "format_int64": BuiltinTemplate('fmt.Sprintf("%d", {0})'),
-    "format_int32": BuiltinTemplate('fmt.Sprintf("%d", {0})'),
+    "format_int32": BuiltinTemplate('fmt.Sprintf("%di32", {0})'),
+    "format_float32": BuiltinTemplate(
+        "fmt.Sprintf(\"%sf32\", strconv.FormatFloat(float64({0}), 'g', -1, 32))"
+    ),
     "format_float64": BuiltinTemplate("formatFloat64({0})"),
     "format_string": BuiltinTemplate("p.formatStringValue({0})"),
     "format_symbol": BuiltinTemplate("{0}"),
@@ -277,6 +287,7 @@ class BuiltinTemplate:
     "to_string": BuiltinTemplate('fmt.Sprintf("%v", {0})'),
     # Type conversions used by pretty printer
     "int32_to_int64": BuiltinTemplate("int64({0})"),
+    "float32_to_float64": BuiltinTemplate("float64({0})"),
     "is_empty": BuiltinTemplate("len({0}) == 0"),
     "decode_string": BuiltinTemplate("string({0})"),
     "fragment_id_to_string": BuiltinTemplate("p.fragmentIdToString({0})"),

meta/src/meta/extra_pretty_gen.py

@@ -46,7 +46,7 @@
     "uint32": BaseType("UInt32"),
     "uint64": BaseType("UInt64"),
     "fixed64": BaseType("UInt64"),
-    "float": BaseType("Float64"),
+    "float": BaseType("Float32"),
     "double": BaseType("Float64"),
     "bool": BaseType("Boolean"),
     "bytes": BaseType("Bytes"),
@@ -60,7 +60,7 @@
     "uint32": "format_int64",
     "uint64": "format_int64",
     "fixed64": "format_int64",
-    "float": "format_float64",
+    "float": "format_float32",
     "double": "format_float64",
     "bool": "format_bool",
     "bytes": "format_bytes",

meta/src/meta/grammar.y

@@ -37,7 +37,9 @@
 # PATTERN can be r'...' for regex or '...' for fixed string
 %token DECIMAL logic.DecimalValue r'[-]?\d+\.\d+d\d+'
 %token FLOAT Float64 r'([-]?\d+\.\d+|inf|nan)'
+%token FLOAT32 Float32 r'[-]?\d+\.\d+f32'
 %token INT Int64 r'[-]?\d+'
+%token INT32 Int32 r'[-]?\d+i32'
 %token INT128 logic.Int128Value r'[-]?\d+i128'
 %token STRING String r'"(?:[^"\\]|\\.)*"'
 %token SYMBOL String r'[a-zA-Z_][a-zA-Z0-9_./#-]*'
@@ -107,6 +109,7 @@
 %nonterm ffi logic.FFI
 %nonterm ffi_args Sequence[logic.Abstraction]
 %nonterm float_type logic.FloatType
+%nonterm float32_type logic.Float32Type
 %nonterm formula logic.Formula
 %nonterm fragment fragments.Fragment
 %nonterm fragment_id fragments.FragmentId
@@ -117,6 +120,7 @@
 %nonterm init Sequence[logic.Instruction]
 %nonterm instruction logic.Instruction
 %nonterm int_type logic.IntType
+%nonterm int32_type logic.Int32Type
 %nonterm int128_type logic.Int128Type
 %nonterm loop logic.Loop
 %nonterm lt logic.Primitive
@@ -245,6 +249,14 @@ value
       construct: $$ = logic.Value(boolean_value=$1)
       deconstruct if builtin.has_proto_field($$, 'boolean_value'):
         $1: Boolean = $$.boolean_value
+    | INT32
+      construct: $$ = logic.Value(int32_value=$1)
+      deconstruct if builtin.has_proto_field($$, 'int32_value'):
+        $1: Int32 = $$.int32_value
+    | FLOAT32
+      construct: $$ = logic.Value(float32_value=$1)
+      deconstruct if builtin.has_proto_field($$, 'float32_value'):
+        $1: Float32 = $$.float32_value
 
 date
     : "(" "date" INT INT INT ")"
@@ -435,6 +447,14 @@ type
       construct: $$ = logic.Type(boolean_type=$1)
       deconstruct if builtin.has_proto_field($$, 'boolean_type'):
         $1: logic.BooleanType = $$.boolean_type
+    | int32_type
+      construct: $$ = logic.Type(int32_type=$1)
+      deconstruct if builtin.has_proto_field($$, 'int32_type'):
+        $1: logic.Int32Type = $$.int32_type
+    | float32_type
+      construct: $$ = logic.Type(float32_type=$1)
+      deconstruct if builtin.has_proto_field($$, 'float32_type'):
+        $1: logic.Float32Type = $$.float32_type
 
 unspecified_type
     : "UNKNOWN"
@@ -479,6 +499,14 @@ decimal_type
         $3: Int64 = builtin.int32_to_int64($$.precision)
         $4: Int64 = builtin.int32_to_int64($$.scale)
 
+int32_type
+    : "INT32"
+      construct: $$ = logic.Int32Type()
+
+float32_type
+    : "FLOAT32"
+      construct: $$ = logic.Float32Type()
+
 boolean_type
     : "BOOLEAN"
       construct: $$ = logic.BooleanType()
@@ -1122,8 +1150,8 @@ export_csv_source
 
 
 def _extract_value_int32(value: Optional[logic.Value], default: int) -> Int32:
-    if value is not None and builtin.has_proto_field(builtin.unwrap_option(value), 'int_value'):
-        return builtin.int64_to_int32(builtin.unwrap_option(value).int_value)
+    if value is not None and builtin.has_proto_field(builtin.unwrap_option(value), 'int32_value'):
+        return builtin.unwrap_option(value).int32_value
     return builtin.int64_to_int32(default)
 
 
@@ -1333,7 +1361,7 @@ def construct_export_csv_config_with_source(
 
 
 def _make_value_int32(v: Int32) -> logic.Value:
-    return logic.Value(int_value=builtin.int32_to_int64(v))
+    return logic.Value(int32_value=v)
 
 
 def _make_value_int64(v: int) -> logic.Value:

meta/src/meta/pretty_gen.py

@@ -675,10 +675,14 @@ def _format_terminal(terminal: NamedTerminal, value_var: Var) -> TargetExpr:
         return Call(make_builtin("format_string"), [value_var])
     elif terminal.name in ["INT", "NUMBER"]:
         return Call(make_builtin("format_int64"), [value_var])
+    elif terminal.name == "INT32":
+        return Call(make_builtin("format_int32"), [value_var])
     elif terminal.name == "INT128":
         return Call(make_builtin("format_int128"), [value_var])
     elif terminal.name == "FLOAT":
         return Call(make_builtin("format_float64"), [value_var])
+    elif terminal.name == "FLOAT32":
+        return Call(make_builtin("format_float32"), [value_var])
     elif terminal.name == "DECIMAL":
         return Call(make_builtin("format_decimal"), [value_var])
     elif terminal.name == "BOOL":

meta/src/meta/target_builtins.py

@@ -30,6 +30,7 @@
 ANY = VarType("Any")
 INT32 = BaseType("Int32")
 INT64 = BaseType("Int64")
+FLOAT32 = BaseType("Float32")
 FLOAT64 = BaseType("Float64")
 STRING = BaseType("String")
 BOOLEAN = BaseType("Boolean")
@@ -158,6 +159,8 @@ def is_builtin(name: str) -> bool:
 # === Type conversions ===
 register_builtin("int64_to_int32", [INT64], INT32)
 register_builtin("int32_to_int64", [INT32], INT64)
+register_builtin("float64_to_float32", [FLOAT64], FLOAT32)
+register_builtin("float32_to_float64", [FLOAT32], FLOAT64)
 register_builtin("decode_string", [BYTES], STRING)
 register_builtin("to_ptr_int64", [INT64], OptionType(INT64))
 register_builtin("to_ptr_string", [STRING], OptionType(STRING))
@@ -234,6 +237,7 @@ def is_builtin(name: str) -> bool:
 # === Formatting for terminal types ===
 register_builtin("format_int64", [INT64], STRING)
 register_builtin("format_int32", [INT32], STRING)
+register_builtin("format_float32", [FLOAT32], STRING)
 register_builtin("format_float64", [FLOAT64], STRING)
 register_builtin("format_string", [STRING], STRING)
 register_builtin("format_symbol", [STRING], STRING)
@@ -329,6 +333,7 @@ def make_builtin_with_type(name: str, func_type: FunctionType) -> Builtin:
     "ANY",
     "INT64",
     "INT32",
+    "FLOAT32",
     "FLOAT64",
     "STRING",
     "BOOLEAN",

meta/src/meta/templates/parser.go.template

@@ -61,7 +61,9 @@ type tokenKind int
 const (
 	kindString tokenKind = iota
 	kindInt64
+	kindInt32
 	kindFloat64
+	kindFloat32
 	kindUint128
 	kindInt128
 	kindDecimal
@@ -72,7 +74,9 @@ type TokenValue struct {{
 	kind    tokenKind
 	str     string
 	i64     int64
+	i32     int32
 	f64     float64
+	f32     float32
 	uint128 *pb.UInt128Value
 	int128  *pb.Int128Value
 	decimal *pb.DecimalValue
@@ -82,8 +86,12 @@ func (tv TokenValue) String() string {{
 	switch tv.kind {{
 	case kindInt64:
 		return strconv.FormatInt(tv.i64, 10)
+	case kindInt32:
+		return fmt.Sprintf("%di32", tv.i32)
 	case kindFloat64:
 		return strconv.FormatFloat(tv.f64, 'g', -1, 64)
+	case kindFloat32:
+		return fmt.Sprintf("%sf32", strconv.FormatFloat(float64(tv.f32), 'g', -1, 32))
 	case kindUint128:
 		return fmt.Sprintf("0x%016x%016x", tv.uint128.High, tv.uint128.Low)
 	case kindInt128:
@@ -225,6 +233,24 @@ func scanInt(s string) int64 {{
 	return n
 }}
 
+func scanInt32(s string) int32 {{
+	numStr := s[:len(s)-3] // Remove "i32" suffix
+	n, err := strconv.ParseInt(numStr, 10, 32)
+	if err != nil {{
+		panic(ParseError{{msg: fmt.Sprintf("Invalid int32: %s", s)}})
+	}}
+	return int32(n)
+}}
+
+func scanFloat32(s string) float32 {{
+	numStr := s[:len(s)-3] // Remove "f32" suffix
+	f, err := strconv.ParseFloat(numStr, 32)
+	if err != nil {{
+		panic(ParseError{{msg: fmt.Sprintf("Invalid float32: %s", s)}})
+	}}
+	return float32(f)
+}}
+
 func scanFloat(s string) float64 {{
 	if s == "inf" {{
 		return math.Inf(1)

meta/src/meta/templates/parser.jl.template

@@ -81,6 +81,10 @@ end
 
 scan_int(n::String) = Base.parse(Int64, n)
 
+scan_int32(n::String) = Base.parse(Int32, n[1:end-3])  # Remove "i32" suffix
+
+scan_float32(f::String) = Base.parse(Float32, f[1:end-3])  # Remove "f32" suffix
+
 function scan_float(f::String)
     if f == "inf"
         return Inf
@@ -372,7 +376,7 @@ end
 # Export main parse functions and error type
 export parse, parse_transaction, parse_fragment, ParseError
 # Export scanner functions for testing
-export scan_string, scan_int, scan_float, scan_int128, scan_uint128, scan_decimal
+export scan_string, scan_int, scan_int32, scan_float, scan_float32, scan_int128, scan_uint128, scan_decimal
 # Export Lexer and provenance types for testing
 export Lexer, Location, Span
 

meta/src/meta/templates/parser.py.template

@@ -151,6 +151,21 @@ class Lexer:
             raise ParseError(f"Integer literal out of 64-bit range: {{n}}")
         return val
 
+    @staticmethod
+    def scan_int32(n: str) -> int:
+        """Parse INT32 token."""
+        n = n[:-3]  # Remove "i32" suffix
+        val = int(n)
+        if val < -(1 << 31) or val >= (1 << 31):
+            raise ParseError(f"Int32 literal out of range: {{n}}")
+        return val
+
+    @staticmethod
+    def scan_float32(f: str) -> float:
+        """Parse FLOAT32 token."""
+        f = f[:-3]  # Remove "f32" suffix
+        return float(f)
+
     @staticmethod
     def scan_float(f: str) -> float:
         """Parse FLOAT token."""

meta/src/meta/templates/pretty_printer.go.template

@@ -14,6 +14,7 @@ import (
 	"math/big"
 	"reflect"
 	"sort"
+	"strconv"
 	"strings"
 
 	pb "github.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1"