feat(v3): totalize Int division with Result carrier

.github/workflows/ci.yml

@@ -81,7 +81,6 @@ jobs:
             ~/.cargo/registry/index/
             ~/.cargo/registry/cache/
             ~/.cargo/git/db/
-            target/
           key: cargo-${{ runner.os }}-${{ hashFiles('**/Cargo.lock') }}-${{ hashFiles('src/v2/stage0/src/**') }}
           restore-keys: |
             cargo-${{ runner.os }}-${{ hashFiles('**/Cargo.lock') }}-

dsl/std/algebra.dag

@@ -86,6 +86,8 @@
 
 module std.algebra
 
+import std.error_primitives { DivError, Result }
+
 // =========================================================================
 // Unary structures (single operation)
 // =========================================================================
@@ -179,7 +181,7 @@ type OrderedRing<T> {
   zero: T
   negate: fn(T) -> T
   mul: fn(T, T) -> T
-  div: fn(T, T) -> T
+  div: fn(T, T) -> Result<T, DivError>
   one: T
   compare: fn(T, T) -> Ordering
   quotient: fn(T, T) -> T

dsl/std/error_primitives.dag

@@ -0,0 +1,18 @@
+// std/error_primitives.dag — minimal error carriers with **no** dependency on
+// `Int` / `String` / other `std.types` surface, so this module can load in the
+// v3 std bootstrap seed *before* `algebra.dag` (which needs `Result` / `DivError`
+// for `OrderedRing.div`).
+
+module std.error_primitives
+
+// 🟡 STRUCTURAL-CARRIER: algebraic Result sum for fallible std operations
+// (e.g. `OrderedRing.div` totality). It is substrate-owned until target
+// realizations can consume this declaration directly instead of filtering it
+// from emitted std surfaces and reintroducing per-target carriers.
+type Result<ok, err> = Ok { value: ok } | Err { value: err }
+
+// 🟡 STRUCTURAL-CARRIER: signed integer division (`Int / Int`) failure modes
+// (C-8): zero divisor vs MIN / -1 signed overflow. The target preludes mirror
+// this declaration until `std.error_primitives` is emitted through the normal
+// filtered-type path.
+type DivError = DivideByZero | Overflow

src/v2/02_parse.dag

@@ -1278,6 +1278,7 @@ fn parse_type_after_kw(tokens: List<Token>, ctx: ParseContext, start_span: Sourc
   let type_params = type_params_result.params
   let tokens = skip_newlines(tokens: type_params_result.tokens)
   let ctx = type_params_result.ctx
+  let tokens = type_body_tokens_after_modifiers(tokens: tokens)
 
   // Record type: type Name { fields }
   match eat(tokens: tokens, expected: ExpectLBrace) {

src/v2/03_resolve.dag

@@ -347,7 +347,7 @@ fn topological_sort(modules: List<Node>, source_indices: Map<String, NewlineInde
     modules |> flat_map(m =>
       let m_name = authored_name_at(source_indices: source_indices, node: m)
       let imports_std_types = module_imports(n: m) |> any(imp => authored_name_at(source_indices: source_indices, node: imp) == "std.types")
-      if m_name != "std.types" && m_name != "std.algebra" && imports_std_types == false {
+      if m_name != "std.types" && m_name != "std.algebra" && m_name != "std.error_primitives" && imports_std_types == false {
         [DepEdge { from_module: "std.types", to_module: m_name }]
       } else {
         []
@@ -368,7 +368,7 @@ fn topological_sort(modules: List<Node>, source_indices: Map<String, NewlineInde
   let in_degree_map = modules |> fold(init: empty_map(), f: (acc, m) =>
     let m_name = authored_name_at(source_indices: source_indices, node: m)
     let imports_std_types = module_imports(n: m) |> any(imp => authored_name_at(source_indices: source_indices, node: imp) == "std.types")
-    let implicit_std_types_in_degree = if has_std_types && m_name != "std.types" && m_name != "std.algebra" && imports_std_types == false { 1 } else { 0 }
+    let implicit_std_types_in_degree = if has_std_types && m_name != "std.types" && m_name != "std.algebra" && m_name != "std.error_primitives" && imports_std_types == false { 1 } else { 0 }
     map_insert(acc, m_name, module_imports(n: m) |> count + implicit_std_types_in_degree)
   )
 

src/v2/05_emit_rust.dag

@@ -666,11 +666,11 @@ fn emit_module_full(typed_module: TypedModule, registry: Map<String, ItemInfo>,
   )
   let svc_imports_str = if extern_svc_imports |> count == 0 { "" }
     else { concat("\n", extern_svc_imports |> join(separator: "\n")) }
-  // RC1: For enums defined in this module, add `use EnumName::*;` so
+  // RC1: For enums defined in this module, add `use self::EnumName::*;` so
   // variant names are in scope without qualification.
   let local_enum_uses = typed_module.items
     |> filter(item => is_type_def_item(item: item) && is_coproduct_type(n: item))
-    |> map(item => concat("use ", authored_name(env: scope.type_env, node: item), "::*;"))
+    |> map(item => concat("use self::", authored_name(env: scope.type_env, node: item), "::*;"))
   let local_uses_str = if local_enum_uses |> count == 0 { "" }
     else { concat("\n", local_enum_uses |> join(separator: "\n")) }
   // Wire contract: find the module's wire_contract data item (if any)
@@ -682,9 +682,12 @@ fn emit_module_full(typed_module: TypedModule, registry: Map<String, ItemInfo>,
   let raw_filename = module_to_filename(name: authored_name(env: scope.type_env, node: m))
   // Avoid collision with the CLI entry point (src/main.rs)
   let filename = if raw_filename == "main" { "main_mod" } else { raw_filename }
+  let module_attrs = if authored_name(env: scope.type_env, node: m) == "std.error_primitives" {
+    "#![allow(non_camel_case_types)]\n\n"
+  } else { "" }
   let content = concat("// Generated by v2 compiler -- do not edit.\n",
     "// Source module: ", authored_name(env: scope.type_env, node: m), "\n\n",
-    prelude, imports_section, svc_imports_str, local_uses_str, "\n\n",
+    module_attrs, prelude, imports_section, svc_imports_str, local_uses_str, "\n\n",
     items_str, "\n")
   TextFile { path: concat(rust_source_root(), filename, rust_source_ext()), content: content }
 }

src/v2/compiler_tests_rust.dag

@@ -213,6 +213,7 @@ fn ct_gist_sources() -> String {
     "            \"dsl/extdeps/github/github.dag\",\n",
     "            \"dsl/gunbc/auth/credentials.dag\",\n",
     "            \"dsl/gunbc/tools/gist.dag\",\n",
+    "            \"dsl/std/error_primitives.dag\",\n",
     "            \"dsl/std/algebra.dag\",\n",
     "            \"dsl/std/encoding.dag\",\n",
     "            \"dsl/std/errors.dag\",\n",

src/v2/stage0/src/compiler_tests.rs

@@ -188,6 +188,7 @@ mod compiler_tests {
             "dsl/extdeps/github/github.dag",
             "dsl/gunbc/auth/credentials.dag",
             "dsl/gunbc/tools/gist.dag",
+            "dsl/std/error_primitives.dag",
             "dsl/std/algebra.dag",
             "dsl/std/encoding.dag",
             "dsl/std/errors.dag",

src/v2/stage0/src/extdeps_languages_python_types.rs

@@ -1,13 +1,13 @@
 // Generated by v2 compiler -- do not edit.
 // Source module: extdeps.languages.python.types
 
+use self::PythonTypeKind::*;
 pub use crate::std_coercion::{CallableRepr, CastSyntax, InhabitantDecl, TypeCheckpoint};
 use crate::v2_rt;
 use crate::NonEmptyBTreeSet;
 use crate::NonEmptyVec;
 use std::collections::HashMap;
 use std::rc::Rc;
-use PythonTypeKind::*;
 
 pub fn python_type_checkpoints() -> Rc<Vec<Rc<TypeCheckpoint>>> {
     thread_local! {

src/v2/stage0/src/extdeps_languages_rust_types.rs

@@ -1,14 +1,14 @@
 // Generated by v2 compiler -- do not edit.
 // Source module: extdeps.languages.rust.types
 
+use self::OwnershipKind::*;
+use self::SmartPointerKind::*;
 pub use crate::std_coercion::{CallableRepr, CastRule, CastSyntax, InhabitantDecl, TypeCheckpoint};
 use crate::v2_rt;
 use crate::NonEmptyBTreeSet;
 use crate::NonEmptyVec;
 use std::collections::HashMap;
 use std::rc::Rc;
-use OwnershipKind::*;
-use SmartPointerKind::*;
 
 pub fn rust_type_checkpoints() -> Rc<Vec<Rc<TypeCheckpoint>>> {
     thread_local! {

src/v2/stage0/src/lib.rs

@@ -30,6 +30,7 @@ pub mod std_algebra;
 pub mod std_coercion;
 pub mod std_computation;
 pub mod std_effects;
+pub mod std_error_primitives;
 pub mod std_graph;
 pub mod std_http_path;
 pub mod std_induction;

src/v2/stage0/src/std_algebra.rs

@@ -1,17 +1,20 @@
 // Generated by v2 compiler -- do not edit.
 // Source module: std.algebra
 
+use self::AlgebraProfile::*;
+use self::AlgebraTypeTemplate::*;
+use self::CollectionSizeEffect::*;
+use self::ContainerSource::*;
+use self::CostShape::*;
+use self::Ordering::*;
+use crate::std_error_primitives::DivError::*;
+use crate::std_error_primitives::Result::*;
+pub use crate::std_error_primitives::{DivError, Result};
 use crate::v2_rt;
 use crate::NonEmptyBTreeSet;
 use crate::NonEmptyVec;
 use std::collections::HashMap;
 use std::rc::Rc;
-use AlgebraProfile::*;
-use AlgebraTypeTemplate::*;
-use CollectionSizeEffect::*;
-use ContainerSource::*;
-use CostShape::*;
-use Ordering::*;
 
 #[derive(Clone)]
 pub struct Magma<T> {
@@ -73,7 +76,7 @@ pub struct OrderedRing<T> {
     pub zero: Box<T>,
     pub negate: Rc<dyn Fn(T) -> T>,
     pub mul: Rc<dyn Fn(T, T) -> T>,
-    pub div: Rc<dyn Fn(T, T) -> T>,
+    pub div: Rc<dyn Fn(T, T) -> Rc<Result<T, DivError>>>,
     pub one: Box<T>,
     pub compare: Rc<dyn Fn(T, T) -> Ordering>,
     pub quotient: Rc<dyn Fn(T, T) -> T>,

src/v2/stage0/src/std_computation.rs

@@ -1,6 +1,11 @@
 // Generated by v2 compiler -- do not edit.
 // Source module: std.computation
 
+use self::CallPattern::*;
+use self::IterationDimension::*;
+use self::IterationPrimitive::*;
+use self::ShrinkFactor::*;
+use self::SizeBound::*;
 use crate::std_algebra::AlgebraProfile::{
     ApproximateFieldProfile, BooleanAlgebraCollectionProfile, BooleanAlgebraProfile,
     FreeMonoidCollectionProfile, FreeMonoidScalarProfile, OrderedRingProfile,
@@ -19,11 +24,6 @@ use crate::NonEmptyBTreeSet;
 use crate::NonEmptyVec;
 use std::collections::HashMap;
 use std::rc::Rc;
-use CallPattern::*;
-use IterationDimension::*;
-use IterationPrimitive::*;
-use ShrinkFactor::*;
-use SizeBound::*;
 
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 #[serde(tag = "_variant")]

src/v2/stage0/src/std_effects.rs

@@ -1,6 +1,11 @@
 // Generated by v2 compiler -- do not edit.
 // Source module: std.effects
 
+use self::DeriveOpEffectResult::*;
+use self::EffectShape::*;
+use self::IdempotencyEvidence::*;
+use self::KeySource::*;
+use self::ModifierAgreement::*;
 use crate::std_http_path::PathTemplateParseResult::{MalformedPathTemplate, ParsedPathTemplate};
 pub use crate::std_http_path::{
     has_path_params, last_path_param, parse_path_template, PathTemplate, PathTemplateParseResult,
@@ -12,11 +17,6 @@ use crate::NonEmptyBTreeSet;
 use crate::NonEmptyVec;
 use std::collections::HashMap;
 use std::rc::Rc;
-use DeriveOpEffectResult::*;
-use EffectShape::*;
-use IdempotencyEvidence::*;
-use KeySource::*;
-use ModifierAgreement::*;
 
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 #[serde(tag = "_variant")]

src/v2/stage0/src/std_error_primitives.rs

@@ -0,0 +1,26 @@
+// Generated by v2 compiler -- do not edit.
+// Source module: std.error_primitives
+
+#![allow(non_camel_case_types)]
+
+use self::DivError::*;
+use self::Result::*;
+use crate::v2_rt;
+use crate::NonEmptyBTreeSet;
+use crate::NonEmptyVec;
+use std::collections::HashMap;
+use std::rc::Rc;
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[serde(tag = "_variant")]
+pub enum Result<ok, err> {
+    Ok { value: Box<ok> },
+    Err { value: Box<err> },
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
+#[serde(tag = "_variant")]
+pub enum DivError {
+    DivideByZero,
+    Overflow,
+}

src/v2/stage0/src/std_http_path.rs

@@ -1,14 +1,14 @@
 // Generated by v2 compiler -- do not edit.
 // Source module: std.http_path
 
+use self::PathSegmentTokensResult::*;
+use self::PathTemplateParseResult::*;
+use self::UrlPathToken::*;
 use crate::v2_rt;
 use crate::NonEmptyBTreeSet;
 use crate::NonEmptyVec;
 use std::collections::HashMap;
 use std::rc::Rc;
-use PathSegmentTokensResult::*;
-use PathTemplateParseResult::*;
-use UrlPathToken::*;
 
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 #[serde(tag = "_variant")]

src/v2/stage0/src/std_induction.rs

@@ -1,6 +1,11 @@
 // Generated by v2 compiler -- do not edit.
 // Source module: std.induction
 
+use self::AtomicCost::*;
+use self::CostBound::*;
+use self::PolynomialExponent::*;
+use self::RecursionShape::*;
+use self::SubValueRelation::*;
 use crate::std_computation::CallPattern::{
     ArithmeticDivideCall, ArithmeticSubtractCall, ChildAccessorCall, FoldBodyCall, SameArgumentCall,
 };
@@ -25,11 +30,6 @@ use crate::NonEmptyBTreeSet;
 use crate::NonEmptyVec;
 use std::collections::HashMap;
 use std::rc::Rc;
-use AtomicCost::*;
-use CostBound::*;
-use PolynomialExponent::*;
-use RecursionShape::*;
-use SubValueRelation::*;
 
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 #[serde(tag = "_variant")]

src/v2/stage0/src/std_syntax.rs

@@ -1,16 +1,16 @@
 // Generated by v2 compiler -- do not edit.
 // Source module: std.syntax
 
+use self::AlgebraFieldKind::*;
+use self::BinOp::*;
+use self::BodyKind::*;
+use self::ItemFormKind::*;
+use self::LiteralValue::*;
 use crate::v2_rt;
 use crate::NonEmptyBTreeSet;
 use crate::NonEmptyVec;
 use std::collections::HashMap;
 use std::rc::Rc;
-use AlgebraFieldKind::*;
-use BinOp::*;
-use BodyKind::*;
-use ItemFormKind::*;
-use LiteralValue::*;
 
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 #[serde(tag = "_variant")]

src/v2/stage0/src/std_termination.rs

@@ -1,18 +1,18 @@
 // Generated by v2 compiler -- do not edit.
 // Source module: std.termination
 
+use self::DescentEvidence::*;
+use self::DescentSource::*;
+use self::PositiveDescentAmount::*;
+use self::ProportionalDivisor::*;
+use self::RankingDimension::*;
 pub use crate::std_algebra::Ordering;
 use crate::std_algebra::Ordering::*;
 use crate::v2_rt;
 use crate::NonEmptyBTreeSet;
 use crate::NonEmptyVec;
 use std::collections::HashMap;
 use std::rc::Rc;
-use DescentEvidence::*;
-use DescentSource::*;
-use PositiveDescentAmount::*;
-use ProportionalDivisor::*;
-use RankingDimension::*;
 
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 #[serde(tag = "_variant")]

src/v2/stage0/src/std_types.rs

@@ -1,6 +1,22 @@
 // Generated by v2 compiler -- do not edit.
 // Source module: std.types
 
+use self::AbiEnv::*;
+use self::Arch::*;
+use self::AuthScheme::*;
+use self::Bool::*;
+use self::CodegenBackend::*;
+use self::CredentialFlow::*;
+use self::DocSourceKind::*;
+use self::EntryKind::*;
+use self::ExecutionEnv::*;
+use self::FermiDepth::*;
+use self::HttpMethod::*;
+use self::Os::*;
+use self::Platform::*;
+use self::SymlinkTarget::*;
+use self::TopologyNodeKind::*;
+use self::Vendor::*;
 pub use crate::std_algebra::{
     algebra_type_param_names, kernel_algebra_profile, BooleanAlgebra, FreeMonoid, PartialFunction,
 };
@@ -9,22 +25,6 @@ use crate::NonEmptyBTreeSet;
 use crate::NonEmptyVec;
 use std::collections::HashMap;
 use std::rc::Rc;
-use AbiEnv::*;
-use Arch::*;
-use AuthScheme::*;
-use Bool::*;
-use CodegenBackend::*;
-use CredentialFlow::*;
-use DocSourceKind::*;
-use EntryKind::*;
-use ExecutionEnv::*;
-use FermiDepth::*;
-use HttpMethod::*;
-use Os::*;
-use Platform::*;
-use SymlinkTarget::*;
-use TopologyNodeKind::*;
-use Vendor::*;
 
 pub fn kernel_type_set() -> Rc<HashMap<String, bool>> {
     thread_local! {