Change unit conversion functions to operate on input rather than return a conversion factor

Signed-off-by: Nick Cameron <nrc@ncameron.org>

docs/kcl/consts/std-math-PI.md

@@ -18,7 +18,7 @@ std::math::PI: number = 3.14159265358979323846264338327950288_
 circumference = 70
 
 exampleSketch = startSketchOn(XZ)
- |> circle(center = [0, 0], radius = circumference/ (2 * PI))
+ |> circle(center = [0, 0], radius = circumference / (2 * PI))
 
 example = extrude(exampleSketch, length = 5)
 ```

docs/kcl/index.md

@@ -65,11 +65,15 @@ layout: manual
   * [`chamfer`](kcl/chamfer)
   * [`circleThreePoint`](kcl/circleThreePoint)
   * [`close`](kcl/close)
-  * [`cm`](kcl/cm)
   * [`extrude`](kcl/extrude)
   * [`fillet`](kcl/fillet)
   * [`floor`](kcl/floor)
-  * [`ft`](kcl/ft)
+  * [`fromCm`](kcl/fromCm)
+  * [`fromFt`](kcl/fromFt)
+  * [`fromInches`](kcl/fromInches)
+  * [`fromM`](kcl/fromM)
+  * [`fromMm`](kcl/fromMm)
+  * [`fromYd`](kcl/fromYd)
   * [`getCommonEdge`](kcl/getCommonEdge)
   * [`getNextAdjacentEdge`](kcl/getNextAdjacentEdge)
   * [`getOppositeEdge`](kcl/getOppositeEdge)
@@ -77,7 +81,6 @@ layout: manual
   * [`helix`](kcl/std-helix)
   * [`hole`](kcl/hole)
   * [`hollow`](kcl/hollow)
-  * [`inch`](kcl/inch)
   * [`lastSegX`](kcl/lastSegX)
   * [`lastSegY`](kcl/lastSegY)
   * [`legAngX`](kcl/legAngX)
@@ -89,11 +92,9 @@ layout: manual
   * [`log`](kcl/log)
   * [`log10`](kcl/log10)
   * [`log2`](kcl/log2)
-  * [`m`](kcl/m)
   * [`map`](kcl/map)
   * [`max`](kcl/max)
   * [`min`](kcl/min)
-  * [`mm`](kcl/mm)
   * [`offsetPlane`](kcl/offsetPlane)
   * [`patternCircular2d`](kcl/patternCircular2d)
   * [`patternCircular3d`](kcl/patternCircular3d)
@@ -137,7 +138,6 @@ layout: manual
   * [`translate`](kcl/translate)
   * [`xLine`](kcl/xLine)
   * [`yLine`](kcl/yLine)
-  * [`yd`](kcl/yd)
 * **std::math**
   * [`E`](kcl/consts/std-math-E)
   * [`PI`](kcl/consts/std-math-PI)

docs/kcl/std.json

@@ -79599,34 +79599,6 @@
       "exampleSketch = startSketchOn(-XZ)\n  |> startProfileAt([0, 0], %)\n  |> line(end = [10, 0])\n  |> line(end = [0, 10])\n  |> close()\n\nexample = extrude(exampleSketch, length = 10)"
     ]
   },
-  {
-    "name": "cm",
-    "summary": "Centimeters conversion factor for current projects units.",
-    "description": "No matter what units the current project uses, this function will always return the conversion factor to centimeters.\n\nFor example, if the current project uses inches, this function will return `0.393701`. If the current project uses millimeters, this function will return `10`. If the current project uses centimeters, this function will return `1`.\n\n**Caution**: This function is only intended to be used when you absolutely MUST have different units in your code than the project settings. Otherwise, it is a bad pattern to use this function.\n\nWe merely provide these functions for convenience and readability, as `10 * cm()` is more readable that your intent is \"I want 10 centimeters\" than `10 * 10`, if the project settings are in millimeters.",
-    "tags": [
-      "units"
-    ],
-    "keywordArguments": false,
-    "args": [],
-    "returnValue": {
-      "name": "",
-      "type": "number",
-      "schema": {
-        "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema",
-        "title": "double",
-        "type": "number",
-        "format": "double"
-      },
-      "required": true,
-      "includeInSnippet": true,
-      "labelRequired": true
-    },
-    "unpublished": false,
-    "deprecated": false,
-    "examples": [
-      "totalWidth = 10 * cm()"
-    ]
-  },
   {
     "name": "e",
     "summary": "Return the value of Euler’s number `e`.",
@@ -97490,14 +97462,28 @@
     ]
   },
   {
-    "name": "ft",
+    "name": "fromCm",
-    "summary": "Feet conversion factor for current projects units.",
+    "summary": "Converts a number from centimeters to the current default unit.",
-    "description": "No matter what units the current project uses, this function will always return the conversion factor to feet.\n\nFor example, if the current project uses inches, this function will return `12`. If the current project uses millimeters, this function will return `304.8`. If the current project uses feet, this function will return `1`.\n\n**Caution**: This function is only intended to be used when you absolutely MUST have different units in your code than the project settings. Otherwise, it is a bad pattern to use this function.\n\nWe merely provide these functions for convenience and readability, as `10 * ft()` is more readable that your intent is \"I want 10 feet\" than `10 * 304.8`, if the project settings are in millimeters.",
+    "description": "No matter what units the current file uses, this function will always return a number equivalent to the input in centimeters.\n\nFor example, if the current project uses inches, `fromCm` will return `0.393701`. If the current project uses millimeters, `fromCm` will return `10`. If the current project uses centimeters, `fromCm` will return `1`.\n\n**Caution**: This function is only intended to be used when you absolutely MUST have different units in your code than the project settings. Otherwise, it is a bad pattern to use this function.\n\nWe merely provide these functions for convenience and readability, as `fromCm(10)` is more readable that your intent is \"I want 10 centimeters\" than `10 * 10`, if the project settings are in millimeters.",
     "tags": [
       "units"
     ],
     "keywordArguments": false,
-    "args": [],
+    "args": [
+      {
+        "name": "input",
+        "type": "number",
+        "schema": {
+          "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema",
+          "title": "double",
+          "type": "number",
+          "format": "double"
+        },
+        "required": true,
+        "includeInSnippet": true,
+        "labelRequired": true
+      }
+    ],
     "returnValue": {
       "name": "",
       "type": "number",
@@ -97514,7 +97500,217 @@
     "unpublished": false,
     "deprecated": false,
     "examples": [
-      "totalWidth = 10 * ft()"
+      "totalWidth = fromCm(10)"
+    ]
+  },
+  {
+    "name": "fromFt",
+    "summary": "Converts a number from feet to the current default unit.",
+    "description": "No matter what units the current file uses, this function will always return a number equivalent to the input in feet.\n\nFor example, if the current project uses inches, `fromFt(1)` will return `12`. If the current project uses millimeters, `fromFt(1)` will return `304.8`. If the current project uses feet, `fromFt(1)` will return `1`.\n\n**Caution**: This function is only intended to be used when you absolutely MUST have different units in your code than the project settings. Otherwise, it is a bad pattern to use this function.\n\nWe merely provide these functions for convenience and readability, as `fromFt(10)` is more readable that your intent is \"I want 10 feet\" than `10 * 304.8`, if the project settings are in millimeters.",
+    "tags": [
+      "units"
+    ],
+    "keywordArguments": false,
+    "args": [
+      {
+        "name": "input",
+        "type": "number",
+        "schema": {
+          "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema",
+          "title": "double",
+          "type": "number",
+          "format": "double"
+        },
+        "required": true,
+        "includeInSnippet": true,
+        "labelRequired": true
+      }
+    ],
+    "returnValue": {
+      "name": "",
+      "type": "number",
+      "schema": {
+        "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema",
+        "title": "double",
+        "type": "number",
+        "format": "double"
+      },
+      "required": true,
+      "includeInSnippet": true,
+      "labelRequired": true
+    },
+    "unpublished": false,
+    "deprecated": false,
+    "examples": [
+      "totalWidth = fromFt(10)"
+    ]
+  },
+  {
+    "name": "fromInches",
+    "summary": "Converts a number from inches to the current default unit.",
+    "description": "No matter what units the current file uses, this function will always return a number equivalent to the input in inches.\n\nFor example, if the current project uses inches, `fromInches(1)` will return `1`. If the current project uses millimeters, `fromInches(1)` will return `25.4`.\n\n**Caution**: This function is only intended to be used when you absolutely MUST have different units in your code than the project settings. Otherwise, it is a bad pattern to use this function.\n\nWe merely provide these functions for convenience and readability, as `fromInches(10)` is more readable that your intent is \"I want 10 inches\" than `10 * 25.4`, if the project settings are in millimeters.",
+    "tags": [
+      "units"
+    ],
+    "keywordArguments": false,
+    "args": [
+      {
+        "name": "input",
+        "type": "number",
+        "schema": {
+          "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema",
+          "title": "double",
+          "type": "number",
+          "format": "double"
+        },
+        "required": true,
+        "includeInSnippet": true,
+        "labelRequired": true
+      }
+    ],
+    "returnValue": {
+      "name": "",
+      "type": "number",
+      "schema": {
+        "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema",
+        "title": "double",
+        "type": "number",
+        "format": "double"
+      },
+      "required": true,
+      "includeInSnippet": true,
+      "labelRequired": true
+    },
+    "unpublished": false,
+    "deprecated": false,
+    "examples": [
+      "totalWidth = fromInches(10)"
+    ]
+  },
+  {
+    "name": "fromM",
+    "summary": "Converts a number from meters to the current default unit.",
+    "description": "No matter what units the current file uses, this function will always return a number equivalent to the input in meters.\n\nFor example, if the current project uses inches, `fromM` will return `39.3701`. If the current project uses millimeters, `fromM` will return `1000`. If the current project uses meters, `fromM` will return `1`.\n\n**Caution**: This function is only intended to be used when you absolutely MUST have different units in your code than the project settings. Otherwise, it is a bad pattern to use this function.\n\nWe merely provide these functions for convenience and readability, as `fromM(10)` is more readable that your intent is \"I want 10 meters\" than `10 * 1000`, if the project settings are in millimeters.",
+    "tags": [
+      "units"
+    ],
+    "keywordArguments": false,
+    "args": [
+      {
+        "name": "input",
+        "type": "number",
+        "schema": {
+          "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema",
+          "title": "double",
+          "type": "number",
+          "format": "double"
+        },
+        "required": true,
+        "includeInSnippet": true,
+        "labelRequired": true
+      }
+    ],
+    "returnValue": {
+      "name": "",
+      "type": "number",
+      "schema": {
+        "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema",
+        "title": "double",
+        "type": "number",
+        "format": "double"
+      },
+      "required": true,
+      "includeInSnippet": true,
+      "labelRequired": true
+    },
+    "unpublished": false,
+    "deprecated": false,
+    "examples": [
+      "totalWidth = 10 * fromM(10)"
+    ]
+  },
+  {
+    "name": "fromMm",
+    "summary": "Converts a number from mm to the current default unit.",
+    "description": "No matter what units the current file uses, this function will always return a number equivalent to the input in millimeters.\n\nFor example, if the current project uses inches, `fromMm(1)` will return `1/25.4`. If the current project uses millimeters, `fromMm(1)` will return `1`.\n\n**Caution**: This function is only intended to be used when you absolutely MUST have different units in your code than the project settings. Otherwise, it is a bad pattern to use this function.\n\nWe merely provide these functions for convenience and readability, as `fromMm(10)` is more readable that your intent is \"I want 10 millimeters\" than `10 * (1/25.4)`, if the project settings are in inches.",
+    "tags": [
+      "units"
+    ],
+    "keywordArguments": false,
+    "args": [
+      {
+        "name": "input",
+        "type": "number",
+        "schema": {
+          "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema",
+          "title": "double",
+          "type": "number",
+          "format": "double"
+        },
+        "required": true,
+        "includeInSnippet": true,
+        "labelRequired": true
+      }
+    ],
+    "returnValue": {
+      "name": "",
+      "type": "number",
+      "schema": {
+        "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema",
+        "title": "double",
+        "type": "number",
+        "format": "double"
+      },
+      "required": true,
+      "includeInSnippet": true,
+      "labelRequired": true
+    },
+    "unpublished": false,
+    "deprecated": false,
+    "examples": [
+      "totalWidth = fromMm(10)"
+    ]
+  },
+  {
+    "name": "fromYd",
+    "summary": "Converts a number from yards to the current default unit.",
+    "description": "No matter what units the current file uses, this function will always return a number equivalent to the input in yards.\n\nFor example, if the current project uses inches, `fromYd` will return `36`. If the current project uses millimeters, `fromYd` will return `914.4`. If the current project uses yards, `fromYd` will return `1`.\n\n**Caution**: This function is only intended to be used when you absolutely MUST have different units in your code than the project settings. Otherwise, it is a bad pattern to use this function.\n\nWe merely provide these functions for convenience and readability, as `fromYd(10)` is more readable that your intent is \"I want 10 yards\" than `10 * 914.4`, if the project settings are in millimeters.",
+    "tags": [
+      "units"
+    ],
+    "keywordArguments": false,
+    "args": [
+      {
+        "name": "input",
+        "type": "number",
+        "schema": {
+          "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema",
+          "title": "double",
+          "type": "number",
+          "format": "double"
+        },
+        "required": true,
+        "includeInSnippet": true,
+        "labelRequired": true
+      }
+    ],
+    "returnValue": {
+      "name": "",
+      "type": "number",
+      "schema": {
+        "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema",
+        "title": "double",
+        "type": "number",
+        "format": "double"
+      },
+      "required": true,
+      "includeInSnippet": true,
+      "labelRequired": true
+    },
+    "unpublished": false,
+    "deprecated": false,
+    "examples": [
+      "totalWidth = fromYd(10)"
     ]
   },
   {
@@ -106369,34 +106565,6 @@
       "import height, buildSketch from \"common.kcl\"\n\nplane = XZ\nmargin = 2\ns1 = buildSketch(plane, [0, 0])\ns2 = buildSketch(plane, [0, height() + margin])"
     ]
   },
-  {
-    "name": "inch",
-    "summary": "Inches conversion factor for current projects units.",
-    "description": "No matter what units the current project uses, this function will always return the conversion factor to inches.\n\nFor example, if the current project uses inches, this function will return `1`. If the current project uses millimeters, this function will return `25.4`.\n\n**Caution**: This function is only intended to be used when you absolutely MUST have different units in your code than the project settings. Otherwise, it is a bad pattern to use this function.\n\nWe merely provide these functions for convenience and readability, as `10 * inch()` is more readable that your intent is \"I want 10 inches\" than `10 * 25.4`, if the project settings are in millimeters.",
-    "tags": [
-      "units"
-    ],
-    "keywordArguments": false,
-    "args": [],
-    "returnValue": {
-      "name": "",
-      "type": "number",
-      "schema": {
-        "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema",
-        "title": "double",
-        "type": "number",
-        "format": "double"
-      },
-      "required": true,
-      "includeInSnippet": true,
-      "labelRequired": true
-    },
-    "unpublished": false,
-    "deprecated": false,
-    "examples": [
-      "totalWidth = 10 * inch()"
-    ]
-  },
   {
     "name": "int",
     "summary": "Convert a number to an integer.",
@@ -134361,34 +134529,6 @@
       "exampleSketch = startSketchOn(XZ)\n  |> startProfileAt([0, 0], %)\n  |> line(end = [log2(100), 0])\n  |> line(end = [5, 8])\n  |> line(end = [-10, 0])\n  |> close()\n\nexample = extrude(exampleSketch, length = 5)"
     ]
   },
-  {
-    "name": "m",
-    "summary": "Meters conversion factor for current projects units.",
-    "description": "No matter what units the current project uses, this function will always return the conversion factor to meters.\n\nFor example, if the current project uses inches, this function will return `39.3701`. If the current project uses millimeters, this function will return `1000`. If the current project uses meters, this function will return `1`.\n\n**Caution**: This function is only intended to be used when you absolutely MUST have different units in your code than the project settings. Otherwise, it is a bad pattern to use this function.\n\nWe merely provide these functions for convenience and readability, as `10 * m()` is more readable that your intent is \"I want 10 meters\" than `10 * 1000`, if the project settings are in millimeters.",
-    "tags": [
-      "units"
-    ],
-    "keywordArguments": false,
-    "args": [],
-    "returnValue": {
-      "name": "",
-      "type": "number",
-      "schema": {
-        "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema",
-        "title": "double",
-        "type": "number",
-        "format": "double"
-      },
-      "required": true,
-      "includeInSnippet": true,
-      "labelRequired": true
-    },
-    "unpublished": false,
-    "deprecated": false,
-    "examples": [
-      "totalWidth = 10 * m()"
-    ]
-  },
   {
     "name": "map",
     "summary": "Apply a function to every element of a list.",
@@ -141853,34 +141993,6 @@
       "exampleSketch = startSketchOn(XZ)\n  |> startProfileAt([0, 0], %)\n  |> angledLine({\n       angle = 70,\n       length = min(15, 31, 4, 13, 22)\n     }, %)\n  |> line(end = [20, 0])\n  |> close()\n\nexample = extrude(exampleSketch, length = 5)"
     ]
   },
-  {
-    "name": "mm",
-    "summary": "Millimeters conversion factor for current projects units.",
-    "description": "No matter what units the current project uses, this function will always return the conversion factor to millimeters.\n\nFor example, if the current project uses inches, this function will return `(1/25.4)`. If the current project uses millimeters, this function will return `1`.\n\n**Caution**: This function is only intended to be used when you absolutely MUST have different units in your code than the project settings. Otherwise, it is a bad pattern to use this function.\n\nWe merely provide these functions for convenience and readability, as `10 * mm()` is more readable that your intent is \"I want 10 millimeters\" than `10 * (1/25.4)`, if the project settings are in inches.",
-    "tags": [
-      "units"
-    ],
-    "keywordArguments": false,
-    "args": [],
-    "returnValue": {
-      "name": "",
-      "type": "number",
-      "schema": {
-        "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema",
-        "title": "double",
-        "type": "number",
-        "format": "double"
-      },
-      "required": true,
-      "includeInSnippet": true,
-      "labelRequired": true
-    },
-    "unpublished": false,
-    "deprecated": false,
-    "examples": [
-      "totalWidth = 10 * mm()"
-    ]
-  },
   {
     "name": "offsetPlane",
     "summary": "Offset a plane by a distance along its normal.",
@@ -201564,15 +201676,6 @@
             },
             "length": {
               "description": "The length of the line.",
-              "allOf": [
-                {
-                  "$ref": "#/components/schemas/TyF64"
-                }
-              ]
-            }
-          },
-          "definitions": {
-            "TyF64": {
               "type": "number",
               "format": "double"
             }
@@ -336171,33 +336274,5 @@
     "examples": [
       "exampleSketch = startSketchOn(XZ)\n  |> startProfileAt([0, 0], %)\n  |> yLine(length = 15)\n  |> angledLine({ angle = 30, length = 15 }, %)\n  |> line(end = [8, -10])\n  |> yLine(length = -5)\n  |> close()\n\nexample = extrude(exampleSketch, length = 10)"
     ]
-  },
-  {
-    "name": "yd",
-    "summary": "Yards conversion factor for current projects units.",
-    "description": "No matter what units the current project uses, this function will always return the conversion factor to yards.\n\nFor example, if the current project uses inches, this function will return `36`. If the current project uses millimeters, this function will return `914.4`. If the current project uses yards, this function will return `1`.\n\n**Caution**: This function is only intended to be used when you absolutely MUST have different units in your code than the project settings. Otherwise, it is a bad pattern to use this function.\n\nWe merely provide these functions for convenience and readability, as `10 * yd()` is more readable that your intent is \"I want 10 yards\" than `10 * 914.4`, if the project settings are in millimeters.",
-    "tags": [
-      "units"
-    ],
-    "keywordArguments": false,
-    "args": [],
-    "returnValue": {
-      "name": "",
-      "type": "number",
-      "schema": {
-        "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema",
-        "title": "double",
-        "type": "number",
-        "format": "double"
-      },
-      "required": true,
-      "includeInSnippet": true,
-      "labelRequired": true
-    },
-    "unpublished": false,
-    "deprecated": false,
-    "examples": [
-      "totalWidth = 10 * yd()"
-    ]
   }
 ]

public/kcl-samples/car-wheel-assembly/car-wheel.kcl

@@ -32,7 +32,7 @@ lugClearance = startSketchOn(lugExtrusion, 'END')
 
 // Create the circular pattern for the lug holes
 lugHoles = startSketchOn(lugBase, 'END')
-  |> circle(center = [lugSpacing / 2, 0], radius = 16 * mm() / 2)
+  |> circle(center = [lugSpacing / 2, 0], radius = fromMm(16) / 2)
   |> patternCircular2d(
        arcDegrees = 360,
        center = [0, 0],

public/kcl-samples/car-wheel-assembly/lug-nut.kcl

@@ -11,7 +11,7 @@ customPlane = {
   plane = {
     origin = {
       x = lugSpacing / 2,
-      y = -30 * mm(),
+      y = fromMm(-30),
       z = 0
     },
     xAxis = { x = 1, y = 0, z = 0 },
@@ -26,7 +26,7 @@ fn lug(plane, length, diameter) {
     |> angledLineOfYLength({ angle = 70, length = lugHeadLength }, %)
     |> xLine(endAbsolute = lugDiameter / 2)
     |> yLine(endAbsolute = lugLength)
-    |> tangentialArc({ offset = 90, radius = 3 * mm() }, %)
+    |> tangentialArc({ offset = 90, radius = fromMm(3) }, %)
     |> xLine(endAbsolute = 0 + .001, tag = $c1)
     |> yLine(endAbsolute = lugThreadDepth)
     |> xLine(endAbsolute = lugThreadDiameter)

public/kcl-samples/car-wheel-assembly/parameters.kcl

@@ -5,8 +5,8 @@
 
 // Car wheel
 export lugCount = 5
-export lugSpacing = 114.3 * mm()
+export lugSpacing = fromMm(114.3)
-export offset = -35 * mm()
+export offset = fromMm(-35)
 export backSpacing = 6.38
 export wheelWidth = 9.5
 export wheelDiameter = 19
@@ -16,11 +16,11 @@ export spokeAngle = 0.02
 export spokeThickness = 0.95
 
 // Lug Nut
-export lugDiameter = 24 * mm()
+export lugDiameter = fromMm(24)
 export lugHeadLength = lugDiameter * .5
 export lugThreadDiameter = lugDiameter / 2 * .85
-export lugLength = 30 * mm()
+export lugLength = fromMm(30)
-export lugThreadDepth = lugLength - (12.7 * mm())
+export lugThreadDepth = lugLength - fromMm(12.7)
 
 // Car rotor
 export rotorDiameter = 12

public/kcl-samples/i-beam/main.kcl

@@ -5,7 +5,7 @@
 @settings(defaultLengthUnit = in)
 
 // Define parameters
-beamLength = 6 * ft()
+beamLength = fromFt(6)
 beamHeight = 4
 flangeWidth = 2.663
 flangeThickness = 0.293

public/kcl-samples/router-template-cross-bar/main.kcl

@@ -6,7 +6,7 @@
 
 // Define parameters
 routerDiameter = 12.7
-templateDiameter = 11 / 16 * inch()
+templateDiameter = fromInches(11 / 16)
 slateWidthHalf = 41.5 / 2
 minClampingDistance = 50 + 30
 templateThickness = 10

public/kcl-samples/router-template-slate/main.kcl

@@ -6,7 +6,7 @@
 
 // Define parameters
 routerDiameter = 12.7
-templateDiameter = 11 / 16 * inch()
+templateDiameter = fromInches(11 / 16)
 slateWidthHalf = 41.5 / 2
 minClampingDistance = 50 + 30
 templateThickness = 10

rust/kcl-lib/src/errors.rs

@@ -120,7 +120,7 @@ impl From<KclErrorWithOutputs> for KclError {
     }
 }
 
-#[derive(Error, Debug, Serialize, Deserialize, ts_rs::TS, Clone, PartialEq)]
+#[derive(Error, Debug, Serialize, ts_rs::TS, Clone, PartialEq)]
 #[error("{error}")]
 #[ts(export)]
 #[serde(rename_all = "camelCase")]

rust/kcl-lib/src/execution/cad_op.rs

@@ -3,11 +3,11 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use super::{types::NumericType, ArtifactId, KclValue};
-use crate::{docs::StdLibFn, std::get_stdlib_fn, ModuleId, SourceRange};
+use crate::{docs::StdLibFn, ModuleId, SourceRange};
 
 /// A CAD modeling operation for display in the feature tree, AKA operations
 /// timeline.
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
 #[ts(export_to = "Operation.ts")]
 #[serde(tag = "type")]
 pub enum Operation {
@@ -60,7 +60,7 @@ impl Operation {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
 #[ts(export_to = "Operation.ts")]
 #[serde(tag = "type")]
 #[expect(clippy::large_enum_variant)]
@@ -90,7 +90,7 @@ pub enum Group {
 }
 
 /// An argument to a CAD modeling operation.
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
 #[ts(export_to = "Operation.ts")]
 #[serde(rename_all = "camelCase")]
 pub struct OpArg {
@@ -110,7 +110,7 @@ impl OpArg {
 
 /// A reference to a standard library function.  This exists to implement
 /// `PartialEq` and `Eq` for `Operation`.
-#[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Serialize, ts_rs::TS, JsonSchema)]
 #[ts(export_to = "Operation.ts")]
 #[serde(rename_all = "camelCase")]
 pub struct StdLibFnRef {
@@ -156,25 +156,13 @@ where
     serializer.serialize_str(&name)
 }
 
-fn std_lib_fn_from_name<'de, D>(deserializer: D) -> Result<Box<dyn StdLibFn>, D::Error>
-where
-    D: serde::Deserializer<'de>,
-{
-    let s = String::deserialize(deserializer)?;
-    if let Some(std_lib_fn) = get_stdlib_fn(&s) {
-        Ok(std_lib_fn)
-    } else {
-        Err(serde::de::Error::custom(format!("not a KCL stdlib function: {}", s)))
-    }
-}
-
 fn is_false(b: &bool) -> bool {
     !*b
 }
 
 /// A KCL value used in Operations.  `ArtifactId`s are used to refer to the
 /// actual scene objects.  Any data not needed in the UI may be omitted.
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
 #[ts(export_to = "Operation.ts")]
 #[serde(tag = "type")]
 pub enum OpKclValue {

rust/kcl-lib/src/execution/exec_ast.rs

@@ -3,7 +3,11 @@ use std::collections::HashMap;
 use async_recursion::async_recursion;
 use indexmap::IndexMap;
 
-use super::{cad_op::Group, kcl_value::TypeDef, types::PrimitiveType};
+use super::{
+    cad_op::Group,
+    kcl_value::TypeDef,
+    types::{PrimitiveType, CHECK_NUMERIC_TYPES},
+};
 use crate::{
     engine::ExecutionKind,
     errors::{KclError, KclErrorDetails},
@@ -26,7 +30,7 @@ use crate::{
     },
     source_range::SourceRange,
     std::{
-        args::{Arg, KwArgs},
+        args::{Arg, KwArgs, TyF64},
         FunctionKind,
     },
     CompilationError,
@@ -705,14 +709,14 @@ impl ExecutorContext {
                 let result = self
                     .execute_expr(&expr.expr, exec_state, metadata, &[], statement_kind)
                     .await?;
-                coerce(&result, &expr.ty, exec_state, expr.into())?
+                apply_ascription(&result, &expr.ty, exec_state, expr.into())?
             }
         };
         Ok(item)
     }
 }
 
-fn coerce(
+fn apply_ascription(
     value: &KclValue,
     ty: &Node<Type>,
     exec_state: &mut ExecState,
@@ -721,7 +725,24 @@ fn coerce(
     let ty = RuntimeType::from_parsed(ty.inner.clone(), exec_state, value.into())
         .map_err(|e| KclError::Semantic(e.into()))?;
 
-    value.coerce(&ty, exec_state).ok_or_else(|| {
+    if let KclValue::Number {
+        ty: NumericType::Unknown,
+        value,
+        meta,
+    } = value
+    {
+        // If the number has unknown units but the user is explicitly specifying them, treat the value as having had it's units erased,
+        // rather than forcing the user to explicitly erase them.
+        KclValue::Number {
+            ty: NumericType::Any,
+            value: *value,
+            meta: meta.clone(),
+        }
+        .coerce(&ty, exec_state)
+    } else {
+        value.coerce(&ty, exec_state)
+    }
+    .map_err(|_| {
         KclError::Semantic(KclErrorDetails {
             message: format!("could not coerce {} value to type {}", value.human_friendly_type(), ty),
             source_ranges: vec![source_range],
@@ -977,69 +998,85 @@ impl Node<BinaryExpression> {
             return Ok(KclValue::Bool { value: raw_value, meta });
         }
 
-        let (left, lty) = parse_number_as_f64(&left_value, self.left.clone().into())?;
+        let left = number_as_f64(&left_value, self.left.clone().into())?;
-        let (right, rty) = parse_number_as_f64(&right_value, self.right.clone().into())?;
+        let right = number_as_f64(&right_value, self.right.clone().into())?;
 
         let value = match self.operator {
-            BinaryOperator::Add => KclValue::Number {
+            BinaryOperator::Add => {
-                value: left + right,
+                let (l, r, ty) = NumericType::combine_eq(left, right);
-                meta,
+                self.warn_on_unknown(&ty, "Adding", exec_state);
-                ty: NumericType::combine_add(lty, rty),
+                KclValue::Number { value: l + r, meta, ty }
-            },
+            }
-            BinaryOperator::Sub => KclValue::Number {
+            BinaryOperator::Sub => {
-                value: left - right,
+                let (l, r, ty) = NumericType::combine_eq(left, right);
-                meta,
+                self.warn_on_unknown(&ty, "Subtracting", exec_state);
-                ty: NumericType::combine_add(lty, rty),
+                KclValue::Number { value: l - r, meta, ty }
-            },
+            }
-            BinaryOperator::Mul => KclValue::Number {
+            BinaryOperator::Mul => {
-                value: left * right,
+                let (l, r, ty) = NumericType::combine_mul(left, right);
-                meta,
+                self.warn_on_unknown(&ty, "Multiplying", exec_state);
-                ty: NumericType::combine_mul(lty, rty),
+                KclValue::Number { value: l * r, meta, ty }
-            },
+            }
-            BinaryOperator::Div => KclValue::Number {
+            BinaryOperator::Div => {
-                value: left / right,
+                let (l, r, ty) = NumericType::combine_div(left, right);
-                meta,
+                self.warn_on_unknown(&ty, "Dividing", exec_state);
-                ty: NumericType::combine_div(lty, rty),
+                KclValue::Number { value: l / r, meta, ty }
-            },
+            }
-            BinaryOperator::Mod => KclValue::Number {
+            BinaryOperator::Mod => {
-                value: left % right,
+                let (l, r, ty) = NumericType::combine_div(left, right);
-                meta,
+                self.warn_on_unknown(&ty, "Modulo of", exec_state);
-                ty: NumericType::combine_div(lty, rty),
+                KclValue::Number { value: l % r, meta, ty }
-            },
+            }
             BinaryOperator::Pow => KclValue::Number {
-                value: left.powf(right),
+                value: left.n.powf(right.n),
                 meta,
                 ty: NumericType::Unknown,
             },
-            BinaryOperator::Neq => KclValue::Bool {
+            BinaryOperator::Neq => {
-                value: left != right,
+                let (l, r, ty) = NumericType::combine_eq(left, right);
-                meta,
+                self.warn_on_unknown(&ty, "Comparing", exec_state);
-            },
+                KclValue::Bool { value: l != r, meta }
-            BinaryOperator::Gt => KclValue::Bool {
+            }
-                value: left > right,
+            BinaryOperator::Gt => {
-                meta,
+                let (l, r, ty) = NumericType::combine_eq(left, right);
-            },
+                self.warn_on_unknown(&ty, "Comparing", exec_state);
-            BinaryOperator::Gte => KclValue::Bool {
+                KclValue::Bool { value: l > r, meta }
-                value: left >= right,
+            }
-                meta,
+            BinaryOperator::Gte => {
-            },
+                let (l, r, ty) = NumericType::combine_eq(left, right);
-            BinaryOperator::Lt => KclValue::Bool {
+                self.warn_on_unknown(&ty, "Comparing", exec_state);
-                value: left < right,
+                KclValue::Bool { value: l >= r, meta }
-                meta,
+            }
-            },
+            BinaryOperator::Lt => {
-            BinaryOperator::Lte => KclValue::Bool {
+                let (l, r, ty) = NumericType::combine_eq(left, right);
-                value: left <= right,
+                self.warn_on_unknown(&ty, "Comparing", exec_state);
-                meta,
+                KclValue::Bool { value: l < r, meta }
-            },
+            }
-            BinaryOperator::Eq => KclValue::Bool {
+            BinaryOperator::Lte => {
-                value: left == right,
+                let (l, r, ty) = NumericType::combine_eq(left, right);
-                meta,
+                self.warn_on_unknown(&ty, "Comparing", exec_state);
-            },
+                KclValue::Bool { value: l <= r, meta }
+            }
+            BinaryOperator::Eq => {
+                let (l, r, ty) = NumericType::combine_eq(left, right);
+                self.warn_on_unknown(&ty, "Comparing", exec_state);
+                KclValue::Bool { value: l == r, meta }
+            }
             BinaryOperator::And | BinaryOperator::Or => unreachable!(),
         };
 
         Ok(value)
     }
+
+    fn warn_on_unknown(&self, ty: &NumericType, verb: &str, exec_state: &mut ExecState) {
+        if *CHECK_NUMERIC_TYPES && ty == &NumericType::Unknown {
+            // TODO suggest how to fix this
+            exec_state.warn(CompilationError::err(
+                self.as_source_range(),
+                format!("{} numbers which have unknown or incompatible units.", verb),
+            ));
+        }
+    }
 }
 
 impl Node<UnaryExpression> {
@@ -1759,21 +1796,15 @@ fn article_for(s: &str) -> &'static str {
     }
 }
 
-pub fn parse_number_as_f64(v: &KclValue, source_range: SourceRange) -> Result<(f64, NumericType), KclError> {
+fn number_as_f64(v: &KclValue, source_range: SourceRange) -> Result<TyF64, KclError> {
-    if let KclValue::Number { value: n, ty, .. } = &v {
+    v.as_ty_f64().ok_or_else(|| {
-        Ok((*n, ty.clone()))
-    } else {
         let actual_type = v.human_friendly_type();
-        let article = if actual_type.starts_with(['a', 'e', 'i', 'o', 'u']) {
+        let article = article_for(actual_type);
-            "an"
+        KclError::Semantic(KclErrorDetails {
-        } else {
-            "a"
-        };
-        Err(KclError::Semantic(KclErrorDetails {
             source_ranges: vec![source_range],
             message: format!("Expected a number, but found {article} {actual_type}",),
-        }))
+        })
-    }
+    })
 }
 
 impl Node<IfExpression> {
@@ -2196,13 +2227,18 @@ impl FunctionSource {
                                             .unwrap(),
                                         exec_state,
                                     )
-                                    .ok_or_else(|| {
+                                    .map_err(|e| {
-                                        KclError::Semantic(KclErrorDetails {
+                                        let mut message = format!(
-                                            message: format!(
                                             "{label} requires a value with type `{}`, but found {}",
                                             ty.inner,
-                                                arg.value.human_friendly_type()
+                                            arg.value.human_friendly_type(),
-                                            ),
+                                        );
+                                        if let Some(ty) = e.explicit_coercion {
+                                            // TODO if we have access to the AST for the argument we could choose which example to suggest.
+                                            message = format!("{message}\n\nYou may need to add information about the type of the argument, for example:\n  using a numeric suffix: `42{ty}`\n  or using type ascription: `foo(): number({ty})`");
+                                        }
+                                        KclError::Semantic(KclErrorDetails {
+                                            message,
                                             source_ranges: vec![callsite],
                                         })
                                     })?;
@@ -2226,13 +2262,13 @@ impl FunctionSource {
                                     &RuntimeType::from_parsed(ty.inner.clone(), exec_state, arg.source_range).unwrap(),
                                     exec_state,
                                 )
-                                .ok_or_else(|| {
+                                .map_err(|_| {
                                     KclError::Semantic(KclErrorDetails {
                                         message: format!(
                                             "The input argument of {} requires a value with type `{}`, but found {}",
                                             props.name,
                                             ty.inner,
-                                            arg.value.human_friendly_type()
+                                            arg.value.human_friendly_type(),
                                         ),
                                         source_ranges: vec![callsite],
                                     })

rust/kcl-lib/src/execution/kcl_value.rs

@@ -15,7 +15,7 @@ use crate::{
     parsing::ast::types::{
         DefaultParamVal, FunctionExpression, KclNone, Literal, LiteralValue, Node, TagDeclarator, TagNode,
     },
-    std::StdFnProps,
+    std::{args::TyF64, StdFnProps},
     CompilationError, KclError, ModuleId, SourceRange,
 };
 
@@ -495,6 +495,7 @@ impl KclValue {
             None
         }
     }
+
     pub fn as_f64(&self) -> Option<f64> {
         if let KclValue::Number { value, .. } = &self {
             Some(*value)
@@ -503,6 +504,14 @@ impl KclValue {
         }
     }
 
+    pub fn as_ty_f64(&self) -> Option<TyF64> {
+        if let KclValue::Number { value, ty, .. } = &self {
+            Some(TyF64::new(*value, ty.clone()))
+        } else {
+            None
+        }
+    }
+
     pub fn as_bool(&self) -> Option<bool> {
         if let KclValue::Bool { value, meta: _ } = &self {
             Some(*value)

rust/kcl-lib/src/execution/mod.rs

@@ -1534,8 +1534,8 @@ let shape = layer() |> patternTransform(instances = 10, transform = transform)
 
     #[tokio::test(flavor = "multi_thread")]
     async fn test_unit_default() {
-        let ast = r#"const inMm = 25.4 * mm()
+        let ast = r#"const inMm = fromMm(25.4)
-const inInches = 1.0 * inch()"#;
+const inInches = fromInches(1)"#;
         let result = parse_execute(ast).await.unwrap();
         assert_eq!(
             25.4,
@@ -1554,8 +1554,8 @@ const inInches = 1.0 * inch()"#;
     #[tokio::test(flavor = "multi_thread")]
     async fn test_unit_overriden() {
         let ast = r#"@settings(defaultLengthUnit = inch)
-const inMm = 25.4 * mm()
+const inMm = fromMm(25.4)
-const inInches = 1.0 * inch()"#;
+const inInches = fromInches(1)"#;
         let result = parse_execute(ast).await.unwrap();
         assert_eq!(
             1.0,
@@ -1575,8 +1575,8 @@ const inInches = 1.0 * inch()"#;
     #[tokio::test(flavor = "multi_thread")]
     async fn test_unit_overriden_in() {
         let ast = r#"@settings(defaultLengthUnit = in)
-const inMm = 25.4 * mm()
+const inMm = fromMm(25.4)
-const inInches = 2.0 * inch()"#;
+const inInches = fromInches(2)"#;
         let result = parse_execute(ast).await.unwrap();
         assert_eq!(
             1.0,

rust/kcl-lib/src/execution/types.rs

@@ -14,10 +14,20 @@ use crate::{
         ast::types::{PrimitiveType as AstPrimitiveType, Type},
         token::NumericSuffix,
     },
-    std::args::FromKclValue,
+    std::args::{FromKclValue, TyF64},
     CompilationError, SourceRange,
 };
 
+lazy_static::lazy_static! {
+    pub(super) static ref CHECK_NUMERIC_TYPES: bool = {
+        let env_var = std::env::var("ZOO_NUM_TYS");
+        let Ok(env_var) = env_var else {
+            return false;
+        };
+        !env_var.is_empty()
+    };
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub enum RuntimeType {
     Primitive(PrimitiveType),
@@ -337,7 +347,7 @@ impl fmt::Display for PrimitiveType {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub enum NumericType {
@@ -351,6 +361,15 @@ pub enum NumericType {
     Any,
 }
 
+impl Default for NumericType {
+    fn default() -> Self {
+        NumericType::Default {
+            len: UnitLen::default(),
+            angle: UnitAngle::default(),
+        }
+    }
+}
+
 impl NumericType {
     pub fn count() -> Self {
         NumericType::Known(UnitType::Count)
@@ -361,52 +380,67 @@ impl NumericType {
     }
 
     /// Combine two types when we expect them to be equal.
-    pub fn combine_eq(self, other: &NumericType) -> NumericType {
+    pub fn combine_eq(a: TyF64, b: TyF64) -> (f64, f64, NumericType) {
-        if &self == other {
+        use NumericType::*;
-            self
+        match (a.ty, b.ty) {
-        } else {
+            (at, bt) if at == bt => (a.n, b.n, at),
-            NumericType::Unknown
+            (at, Any) => (a.n, b.n, at),
+            (Any, bt) => (a.n, b.n, bt),
+            (Default { .. }, Default { .. }) | (_, Unknown) | (Unknown, _) => (a.n, b.n, Unknown),
+
+            // Known types and compatible, but needs adjustment.
+            (t @ Known(UnitType::Length(l1)), Known(UnitType::Length(l2))) => (a.n, l2.adjust_to(b.n, l1), t),
+            (t @ Known(UnitType::Angle(a1)), Known(UnitType::Angle(a2))) => (a.n, a2.adjust_to(b.n, a1), t),
+
+            // Known but incompatible.
+            (Known(_), Known(_)) => (a.n, b.n, Unknown),
+
+            // Known and unknown => we assume the known one, possibly with adjustment
+            (Known(UnitType::Count), Default { .. }) | (Default { .. }, Known(UnitType::Count)) => {
+                (a.n, b.n, Known(UnitType::Count))
+            }
+
+            (t @ Known(UnitType::Length(l1)), Default { len: l2, .. }) => (a.n, l2.adjust_to(b.n, l1), t),
+            (Default { len: l1, .. }, t @ Known(UnitType::Length(l2))) => (l1.adjust_to(a.n, l2), b.n, t),
+
+            (t @ Known(UnitType::Angle(a1)), Default { angle: a2, .. }) => (a.n, a2.adjust_to(b.n, a1), t),
+            (Default { angle: a1, .. }, t @ Known(UnitType::Angle(a2))) => (a1.adjust_to(a.n, a2), b.n, t),
         }
     }
 
-    /// Combine n types when we expect them to be equal.
+    /// Combine two types for multiplication-like operations.
-    ///
+    pub fn combine_mul(a: TyF64, b: TyF64) -> (f64, f64, NumericType) {
-    /// Precondition: tys.len() > 0
+        use NumericType::*;
-    pub fn combine_n_eq(tys: &[NumericType]) -> NumericType {
+        match (a.ty, b.ty) {
-        let ty0 = tys[0].clone();
+            (at @ Default { .. }, bt @ Default { .. }) if at != bt => (a.n, b.n, Unknown),
-        for t in &tys[1..] {
+            (Known(UnitType::Count) | Default { .. }, bt) => (a.n, b.n, bt),
-            if t != &ty0 {
+            (at, Known(UnitType::Count) | Default { .. }) => (a.n, b.n, at),
-                return NumericType::Unknown;
+            (Any, Any) => (a.n, b.n, Any),
+            _ => (a.n, b.n, Unknown),
         }
     }
-        ty0
-    }
 
-    /// Combine two types in addition-like operations.
+    /// Combine two types for division-like operations.
-    pub fn combine_add(a: NumericType, b: NumericType) -> NumericType {
+    pub fn combine_div(a: TyF64, b: TyF64) -> (f64, f64, NumericType) {
-        if a == b {
+        use NumericType::*;
-            return a;
+        match (a.ty, b.ty) {
+            (at, bt) if at == bt => (a.n, b.n, Known(UnitType::Count)),
+            (Default { .. }, Default { .. }) => (a.n, b.n, Unknown),
+            (at, Known(UnitType::Count) | Default { .. } | Any) => (a.n, b.n, at),
+            (Known(UnitType::Length(l1)), Known(UnitType::Length(l2))) => {
+                (a.n, l2.adjust_to(b.n, l1), Known(UnitType::Count))
             }
-        NumericType::Unknown
+            (Known(UnitType::Angle(a1)), Known(UnitType::Angle(a2))) => {
+                (a.n, a2.adjust_to(b.n, a1), Known(UnitType::Count))
             }
-
+            (Default { len: l1, .. }, Known(UnitType::Length(l2))) => {
-    /// Combine two types in multiplication-like operations.
+                (l1.adjust_to(a.n, l2), b.n, Known(UnitType::Count))
-    pub fn combine_mul(a: NumericType, b: NumericType) -> NumericType {
-        if a == NumericType::count() {
-            return b;
             }
-        if b == NumericType::count() {
+            (Default { angle: a1, .. }, Known(UnitType::Angle(a2))) => {
-            return a;
+                (a1.adjust_to(a.n, a2), b.n, Known(UnitType::Count))
             }
-        NumericType::Unknown
+            _ => (a.n, b.n, Unknown),
         }
-
-    /// Combine two types in division-like operations.
-    pub fn combine_div(a: NumericType, b: NumericType) -> NumericType {
-        if b == NumericType::count() {
-            return a;
-        }
-        NumericType::Unknown
     }
 
     pub fn from_parsed(suffix: NumericSuffix, settings: &super::MetaSettings) -> Self {
@@ -431,12 +465,104 @@ impl NumericType {
         use NumericType::*;
 
         match (self, other) {
-            (Unknown, _) | (_, Unknown) => false,
-            (a, b) if a == b => true,
             (_, Any) => true,
+            (a, b) if a == b => true,
+            (Unknown, _) | (_, Unknown) => false,
             (_, _) => false,
         }
     }
+
+    fn example_ty(&self) -> Option<String> {
+        match self {
+            Self::Known(t) => Some(t.to_string()),
+            Self::Default { len, .. } => Some(len.to_string()),
+            _ => None,
+        }
+    }
+
+    fn coerce(&self, val: &KclValue) -> Result<KclValue, CoercionError> {
+        let KclValue::Number { value, ty, meta } = val else {
+            return Err(val.into());
+        };
+
+        if !*CHECK_NUMERIC_TYPES {
+            return Ok(val.clone());
+        }
+
+        if ty.subtype(self) {
+            return Ok(KclValue::Number {
+                value: *value,
+                ty: ty.clone(),
+                meta: meta.clone(),
+            });
+        }
+
+        // Not subtypes, but might be able to coerce
+        use NumericType::*;
+        match (ty, self) {
+            // We don't have enough information to coerce.
+            (Unknown, _) => Err(CoercionError::from(val).with_explicit(self.example_ty().unwrap_or("mm".to_owned()))),
+            (_, Unknown) => Err(val.into()),
+            (Any, _) => Ok(KclValue::Number {
+                value: *value,
+                ty: self.clone(),
+                meta: meta.clone(),
+            }),
+
+            // We don't actually need to coerce, since we just keep the partially-known type with the value.
+            (Default { .. }, Default { .. }) => Ok(KclValue::Number {
+                value: *value,
+                ty: ty.clone(),
+                meta: meta.clone(),
+            }),
+
+            // Known types and compatible, but needs adjustment.
+            (Known(UnitType::Length(l1)), Known(UnitType::Length(l2))) => Ok(KclValue::Number {
+                value: l1.adjust_to(*value, *l2),
+                ty: self.clone(),
+                meta: meta.clone(),
+            }),
+            (Known(UnitType::Angle(a1)), Known(UnitType::Angle(a2))) => Ok(KclValue::Number {
+                value: a1.adjust_to(*value, *a2),
+                ty: self.clone(),
+                meta: meta.clone(),
+            }),
+
+            // Known but incompatible.
+            (Known(_), Known(_)) => Err(val.into()),
+
+            // Known and unknown => we assume the rhs, possibly with adjustment
+            (Known(UnitType::Count), Default { .. }) | (Default { .. }, Known(UnitType::Count)) => {
+                Ok(KclValue::Number {
+                    value: *value,
+                    ty: Known(UnitType::Count),
+                    meta: meta.clone(),
+                })
+            }
+
+            (Known(UnitType::Length(l1)), Default { len: l2, .. })
+            | (Default { len: l1, .. }, Known(UnitType::Length(l2))) => Ok(KclValue::Number {
+                value: l1.adjust_to(*value, *l2),
+                ty: Known(UnitType::Length(*l2)),
+                meta: meta.clone(),
+            }),
+
+            (Known(UnitType::Angle(a1)), Default { angle: a2, .. })
+            | (Default { angle: a1, .. }, Known(UnitType::Angle(a2))) => Ok(KclValue::Number {
+                value: a1.adjust_to(*value, *a2),
+                ty: Known(UnitType::Angle(*a2)),
+                meta: meta.clone(),
+            }),
+
+            (_, _) => unreachable!(),
+        }
+    }
+}
+
+impl From<NumericType> for RuntimeType {
+    fn from(t: NumericType) -> RuntimeType {
+        RuntimeType::Primitive(PrimitiveType::Number(t))
+    }
 }
 
 impl From<UnitLen> for NumericType {
@@ -485,6 +611,39 @@ pub enum UnitLen {
     Yards,
 }
 
+impl UnitLen {
+    fn adjust_to(self, value: f64, to: UnitLen) -> f64 {
+        if self == to {
+            return value;
+        }
+
+        use UnitLen::*;
+        let (base, base_unit) = match self {
+            Mm => (value, Mm),
+            Cm => (value * 10.0, Mm),
+            M => (value * 1000.0, Mm),
+            Inches => (value, Inches),
+            Feet => (value * 12.0, Inches),
+            Yards => (value * 36.0, Inches),
+        };
+        let (base, base_unit) = match (base_unit, to) {
+            (Mm, Inches) | (Mm, Feet) | (Mm, Yards) => (base / 25.4, Inches),
+            (Inches, Mm) | (Inches, Cm) | (Inches, M) => (base * 25.4, Mm),
+            _ => (base, base_unit),
+        };
+
+        match (base_unit, to) {
+            (Mm, Mm) => base,
+            (Mm, Cm) => base / 10.0,
+            (Mm, M) => base / 1000.0,
+            (Inches, Inches) => base,
+            (Inches, Feet) => base / 12.0,
+            (Inches, Yards) => base / 36.0,
+            _ => unreachable!(),
+        }
+    }
+}
+
 impl std::fmt::Display for UnitLen {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -563,6 +722,19 @@ pub enum UnitAngle {
     Radians,
 }
 
+impl UnitAngle {
+    fn adjust_to(self, value: f64, to: UnitAngle) -> f64 {
+        use std::f64::consts::PI;
+        use UnitAngle::*;
+        match (self, to) {
+            (Degrees, Degrees) => value,
+            (Degrees, Radians) => (value / 180.0) * PI,
+            (Radians, Degrees) => 180.0 * value / PI,
+            (Radians, Radians) => value,
+        }
+    }
+}
+
 impl std::fmt::Display for UnitAngle {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -584,6 +756,28 @@ impl TryFrom<NumericSuffix> for UnitAngle {
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct CoercionError {
+    pub found: Option<RuntimeType>,
+    pub explicit_coercion: Option<String>,
+}
+
+impl CoercionError {
+    fn with_explicit(mut self, c: String) -> Self {
+        self.explicit_coercion = Some(c);
+        self
+    }
+}
+
+impl From<&'_ KclValue> for CoercionError {
+    fn from(value: &'_ KclValue) -> Self {
+        CoercionError {
+            found: value.principal_type(),
+            explicit_coercion: None,
+        }
+    }
+}
+
 impl KclValue {
     /// True if `self` has a type which is a subtype of `ty` without coercion.
     pub fn has_type(&self, ty: &RuntimeType) -> bool {
@@ -600,7 +794,7 @@ impl KclValue {
     ///   - result.principal_type().unwrap().subtype(ty)
     ///
     /// If self.principal_type() == ty then result == self
-    pub fn coerce(&self, ty: &RuntimeType, exec_state: &mut ExecState) -> Option<KclValue> {
+    pub fn coerce(&self, ty: &RuntimeType, exec_state: &mut ExecState) -> Result<KclValue, CoercionError> {
         match ty {
             RuntimeType::Primitive(ty) => self.coerce_to_primitive_type(ty, exec_state),
             RuntimeType::Array(ty, len) => self.coerce_to_array_type(ty, *len, exec_state, false),
@@ -610,40 +804,52 @@ impl KclValue {
         }
     }
 
-    fn coerce_to_primitive_type(&self, ty: &PrimitiveType, exec_state: &mut ExecState) -> Option<KclValue> {
+    fn coerce_to_primitive_type(
+        &self,
+        ty: &PrimitiveType,
+        exec_state: &mut ExecState,
+    ) -> Result<KclValue, CoercionError> {
         let value = match self {
             KclValue::MixedArray { value, .. } | KclValue::HomArray { value, .. } if value.len() == 1 => &value[0],
             _ => self,
         };
         match ty {
-            // TODO numeric type coercions
+            PrimitiveType::Number(ty) => ty.coerce(value),
-            PrimitiveType::Number(_ty) => match value {
-                KclValue::Number { .. } => Some(value.clone()),
-                _ => None,
-            },
             PrimitiveType::String => match value {
-                KclValue::String { .. } => Some(value.clone()),
+                KclValue::String { .. } => Ok(value.clone()),
-                _ => None,
+                _ => Err(self.into()),
             },
             PrimitiveType::Boolean => match value {
-                KclValue::Bool { .. } => Some(value.clone()),
+                KclValue::Bool { .. } => Ok(value.clone()),
-                _ => None,
+                _ => Err(self.into()),
             },
             PrimitiveType::Sketch => match value {
-                KclValue::Sketch { .. } => Some(value.clone()),
+                KclValue::Sketch { .. } => Ok(value.clone()),
-                _ => None,
+                _ => Err(self.into()),
             },
             PrimitiveType::Solid => match value {
-                KclValue::Solid { .. } => Some(value.clone()),
+                KclValue::Solid { .. } => Ok(value.clone()),
-                _ => None,
+                _ => Err(self.into()),
             },
             PrimitiveType::Plane => match value {
-                KclValue::Plane { .. } => Some(value.clone()),
+                KclValue::Plane { .. } => Ok(value.clone()),
                 KclValue::Object { value, meta } => {
-                    let origin = value.get("origin").and_then(Point3d::from_kcl_val)?;
+                    let origin = value
-                    let x_axis = value.get("xAxis").and_then(Point3d::from_kcl_val)?;
+                        .get("origin")
-                    let y_axis = value.get("yAxis").and_then(Point3d::from_kcl_val)?;
+                        .and_then(Point3d::from_kcl_val)
-                    let z_axis = value.get("zAxis").and_then(Point3d::from_kcl_val)?;
+                        .ok_or(CoercionError::from(self))?;
+                    let x_axis = value
+                        .get("xAxis")
+                        .and_then(Point3d::from_kcl_val)
+                        .ok_or(CoercionError::from(self))?;
+                    let y_axis = value
+                        .get("yAxis")
+                        .and_then(Point3d::from_kcl_val)
+                        .ok_or(CoercionError::from(self))?;
+                    let z_axis = value
+                        .get("zAxis")
+                        .and_then(Point3d::from_kcl_val)
+                        .ok_or(CoercionError::from(self))?;
 
                     let id = exec_state.mod_local.id_generator.next_uuid();
                     let plane = Plane {
@@ -659,75 +865,87 @@ impl KclValue {
                         meta: meta.clone(),
                     };
 
-                    Some(KclValue::Plane { value: Box::new(plane) })
+                    Ok(KclValue::Plane { value: Box::new(plane) })
                 }
-                _ => None,
+                _ => Err(self.into()),
             },
             PrimitiveType::Face => match value {
-                KclValue::Face { .. } => Some(value.clone()),
+                KclValue::Face { .. } => Ok(value.clone()),
-                _ => None,
+                _ => Err(self.into()),
             },
             PrimitiveType::Helix => match value {
-                KclValue::Helix { .. } => Some(value.clone()),
+                KclValue::Helix { .. } => Ok(value.clone()),
-                _ => None,
+                _ => Err(self.into()),
             },
             PrimitiveType::Edge => match value {
-                KclValue::Uuid { .. } => Some(value.clone()),
+                KclValue::Uuid { .. } => Ok(value.clone()),
-                KclValue::TagIdentifier { .. } => Some(value.clone()),
+                KclValue::TagIdentifier { .. } => Ok(value.clone()),
-                _ => None,
+                _ => Err(self.into()),
             },
             PrimitiveType::Axis2d => match value {
                 KclValue::Object { value: values, meta } => {
-                    if values.get("origin")?.has_type(&RuntimeType::point2d())
+                    if values
-                        && values.get("direction")?.has_type(&RuntimeType::point2d())
+                        .get("origin")
+                        .ok_or(CoercionError::from(self))?
+                        .has_type(&RuntimeType::point2d())
+                        && values
+                            .get("direction")
+                            .ok_or(CoercionError::from(self))?
+                            .has_type(&RuntimeType::point2d())
                     {
-                        return Some(value.clone());
+                        return Ok(value.clone());
                     }
 
-                    let origin = values.get("origin").and_then(|p| {
+                    let origin = values.get("origin").ok_or(self.into()).and_then(|p| {
                         p.coerce_to_array_type(&RuntimeType::number_any(), ArrayLen::Known(2), exec_state, true)
                     })?;
-                    let direction = values.get("direction").and_then(|p| {
+                    let direction = values.get("direction").ok_or(self.into()).and_then(|p| {
                         p.coerce_to_array_type(&RuntimeType::number_any(), ArrayLen::Known(2), exec_state, true)
                     })?;
 
-                    Some(KclValue::Object {
+                    Ok(KclValue::Object {
                         value: [("origin".to_owned(), origin), ("direction".to_owned(), direction)].into(),
                         meta: meta.clone(),
                     })
                 }
-                _ => None,
+                _ => Err(self.into()),
             },
             PrimitiveType::Axis3d => match value {
                 KclValue::Object { value: values, meta } => {
-                    if values.get("origin")?.has_type(&RuntimeType::point3d())
+                    if values
-                        && values.get("direction")?.has_type(&RuntimeType::point3d())
+                        .get("origin")
+                        .ok_or(CoercionError::from(self))?
+                        .has_type(&RuntimeType::point3d())
+                        && values
+                            .get("direction")
+                            .ok_or(CoercionError::from(self))?
+                            .has_type(&RuntimeType::point3d())
                     {
-                        return Some(value.clone());
+                        return Ok(value.clone());
                     }
 
-                    let origin = values.get("origin").and_then(|p| {
+                    let origin = values.get("origin").ok_or(self.into()).and_then(|p| {
                         p.coerce_to_array_type(&RuntimeType::number_any(), ArrayLen::Known(3), exec_state, true)
                     })?;
-                    let direction = values.get("direction").and_then(|p| {
+                    let direction = values.get("direction").ok_or(self.into()).and_then(|p| {
                         p.coerce_to_array_type(&RuntimeType::number_any(), ArrayLen::Known(3), exec_state, true)
                     })?;
 
-                    Some(KclValue::Object {
+                    Ok(KclValue::Object {
                         value: [("origin".to_owned(), origin), ("direction".to_owned(), direction)].into(),
                         meta: meta.clone(),
                     })
                 }
-                _ => None,
+                _ => Err(self.into()),
             },
             PrimitiveType::ImportedGeometry => match value {
-                KclValue::ImportedGeometry { .. } => Some(value.clone()),
+                KclValue::ImportedGeometry { .. } => Ok(value.clone()),
-                _ => None,
+                _ => Err(self.into()),
             },
             PrimitiveType::Tag => match value {
-                KclValue::TagDeclarator { .. } => Some(value.clone()),
+                KclValue::TagDeclarator { .. } => Ok(value.clone()),
-                KclValue::TagIdentifier { .. } => Some(value.clone()),
+                KclValue::TagIdentifier { .. } => Ok(value.clone()),
-                _ => None,
+                _ => Err(self.into()),
             },
         }
     }
@@ -738,37 +956,40 @@ impl KclValue {
         len: ArrayLen,
         exec_state: &mut ExecState,
         allow_shrink: bool,
-    ) -> Option<KclValue> {
+    ) -> Result<KclValue, CoercionError> {
         match self {
-            KclValue::HomArray { value, ty: aty } if aty.subtype(ty) => {
+            KclValue::HomArray { value, ty: aty } if aty.subtype(ty) => len
-                len.satisfied(value.len(), allow_shrink).map(|len| KclValue::HomArray {
+                .satisfied(value.len(), allow_shrink)
+                .map(|len| KclValue::HomArray {
                     value: value[..len].to_vec(),
                     ty: aty.clone(),
                 })
-            }
+                .ok_or(self.into()),
-            value if len.satisfied(1, false).is_some() && value.has_type(ty) => Some(KclValue::HomArray {
+            value if len.satisfied(1, false).is_some() && value.has_type(ty) => Ok(KclValue::HomArray {
                 value: vec![value.clone()],
                 ty: ty.clone(),
             }),
             KclValue::MixedArray { value, .. } => {
-                let len = len.satisfied(value.len(), allow_shrink)?;
+                let len = len
+                    .satisfied(value.len(), allow_shrink)
+                    .ok_or(CoercionError::from(self))?;
 
                 let value = value[..len]
                     .iter()
                     .map(|v| v.coerce(ty, exec_state))
-                    .collect::<Option<Vec<_>>>()?;
+                    .collect::<Result<Vec<_>, _>>()?;
 
-                Some(KclValue::HomArray { value, ty: ty.clone() })
+                Ok(KclValue::HomArray { value, ty: ty.clone() })
             }
-            KclValue::KclNone { .. } if len.satisfied(0, false).is_some() => Some(KclValue::HomArray {
+            KclValue::KclNone { .. } if len.satisfied(0, false).is_some() => Ok(KclValue::HomArray {
                 value: Vec::new(),
                 ty: ty.clone(),
             }),
-            _ => None,
+            _ => Err(self.into()),
         }
     }
 
-    fn coerce_to_tuple_type(&self, tys: &[RuntimeType], exec_state: &mut ExecState) -> Option<KclValue> {
+    fn coerce_to_tuple_type(&self, tys: &[RuntimeType], exec_state: &mut ExecState) -> Result<KclValue, CoercionError> {
         match self {
             KclValue::MixedArray { value, .. } | KclValue::HomArray { value, .. } if value.len() == tys.len() => {
                 let mut result = Vec::new();
@@ -776,50 +997,54 @@ impl KclValue {
                     result.push(value[i].coerce(t, exec_state)?);
                 }
 
-                Some(KclValue::MixedArray {
+                Ok(KclValue::MixedArray {
                     value: result,
                     meta: Vec::new(),
                 })
             }
-            KclValue::KclNone { meta, .. } if tys.is_empty() => Some(KclValue::MixedArray {
+            KclValue::KclNone { meta, .. } if tys.is_empty() => Ok(KclValue::MixedArray {
                 value: Vec::new(),
                 meta: meta.clone(),
             }),
-            value if tys.len() == 1 && value.has_type(&tys[0]) => Some(KclValue::MixedArray {
+            value if tys.len() == 1 && value.has_type(&tys[0]) => Ok(KclValue::MixedArray {
                 value: vec![value.clone()],
                 meta: Vec::new(),
             }),
-            _ => None,
+            _ => Err(self.into()),
         }
     }
 
-    fn coerce_to_union_type(&self, tys: &[RuntimeType], exec_state: &mut ExecState) -> Option<KclValue> {
+    fn coerce_to_union_type(&self, tys: &[RuntimeType], exec_state: &mut ExecState) -> Result<KclValue, CoercionError> {
         for t in tys {
-            if let Some(v) = self.coerce(t, exec_state) {
+            if let Ok(v) = self.coerce(t, exec_state) {
-                return Some(v);
+                return Ok(v);
             }
         }
 
-        None
+        Err(self.into())
     }
 
-    fn coerce_to_object_type(&self, tys: &[(String, RuntimeType)], _exec_state: &mut ExecState) -> Option<KclValue> {
+    fn coerce_to_object_type(
+        &self,
+        tys: &[(String, RuntimeType)],
+        _exec_state: &mut ExecState,
+    ) -> Result<KclValue, CoercionError> {
         match self {
             KclValue::Object { value, .. } => {
                 for (s, t) in tys {
                     // TODO coerce fields
-                    if !value.get(s)?.has_type(t) {
+                    if !value.get(s).ok_or(CoercionError::from(self))?.has_type(t) {
-                        return None;
+                        return Err(self.into());
                     }
                 }
                 // TODO remove non-required fields
-                Some(self.clone())
+                Ok(self.clone())
             }
-            KclValue::KclNone { meta, .. } if tys.is_empty() => Some(KclValue::Object {
+            KclValue::KclNone { meta, .. } if tys.is_empty() => Ok(KclValue::Object {
                 value: HashMap::new(),
                 meta: meta.clone(),
             }),
-            _ => None,
+            _ => Err(self.into()),
         }
     }
 
@@ -859,6 +1084,8 @@ impl KclValue {
 
 #[cfg(test)]
 mod test {
+    use crate::execution::{parse_execute, ExecTestResults};
+
     use super::*;
 
     fn values(exec_state: &mut ExecState) -> Vec<KclValue> {
@@ -990,7 +1217,7 @@ mod test {
             // Not a subtype
             assert!(v
                 .coerce(&RuntimeType::Primitive(PrimitiveType::Boolean), &mut exec_state)
-                .is_none());
+                .is_err());
         }
     }
 
@@ -1024,8 +1251,8 @@ mod test {
             },
             &mut exec_state,
         );
-        assert!(none.coerce(&aty1, &mut exec_state).is_none());
+        assert!(none.coerce(&aty1, &mut exec_state).is_err());
-        assert!(none.coerce(&aty1p, &mut exec_state).is_none());
+        assert!(none.coerce(&aty1p, &mut exec_state).is_err());
 
         let tty = RuntimeType::Tuple(vec![]);
         let tty1 = RuntimeType::Tuple(vec![RuntimeType::solid()]);
@@ -1038,7 +1265,7 @@ mod test {
             },
             &mut exec_state,
         );
-        assert!(none.coerce(&tty1, &mut exec_state).is_none());
+        assert!(none.coerce(&tty1, &mut exec_state).is_err());
 
         let oty = RuntimeType::Object(vec![]);
         assert_coerce_results(
@@ -1107,7 +1334,7 @@ mod test {
         assert_coerce_results(&obj2, &ty0, &obj2, &mut exec_state);
 
         let ty1 = RuntimeType::Object(vec![("foo".to_owned(), RuntimeType::Primitive(PrimitiveType::Boolean))]);
-        assert!(&obj0.coerce(&ty1, &mut exec_state).is_none());
+        assert!(&obj0.coerce(&ty1, &mut exec_state).is_err());
         assert_coerce_results(&obj1, &ty1, &obj1, &mut exec_state);
         assert_coerce_results(&obj2, &ty1, &obj2, &mut exec_state);
 
@@ -1119,19 +1346,19 @@ mod test {
             ),
             ("foo".to_owned(), RuntimeType::Primitive(PrimitiveType::Boolean)),
         ]);
-        assert!(&obj0.coerce(&ty2, &mut exec_state).is_none());
+        assert!(&obj0.coerce(&ty2, &mut exec_state).is_err());
-        assert!(&obj1.coerce(&ty2, &mut exec_state).is_none());
+        assert!(&obj1.coerce(&ty2, &mut exec_state).is_err());
         assert_coerce_results(&obj2, &ty2, &obj2, &mut exec_state);
 
         // field not present
         let tyq = RuntimeType::Object(vec![("qux".to_owned(), RuntimeType::Primitive(PrimitiveType::Boolean))]);
-        assert!(&obj0.coerce(&tyq, &mut exec_state).is_none());
+        assert!(&obj0.coerce(&tyq, &mut exec_state).is_err());
-        assert!(&obj1.coerce(&tyq, &mut exec_state).is_none());
+        assert!(&obj1.coerce(&tyq, &mut exec_state).is_err());
-        assert!(&obj2.coerce(&tyq, &mut exec_state).is_none());
+        assert!(&obj2.coerce(&tyq, &mut exec_state).is_err());
 
         // field with different type
         let ty1 = RuntimeType::Object(vec![("bar".to_owned(), RuntimeType::Primitive(PrimitiveType::Boolean))]);
-        assert!(&obj2.coerce(&ty1, &mut exec_state).is_none());
+        assert!(&obj2.coerce(&ty1, &mut exec_state).is_err());
     }
 
     #[tokio::test(flavor = "multi_thread")]
@@ -1209,8 +1436,8 @@ mod test {
         assert_coerce_results(&hom_arr, &tyh, &hom_arr, &mut exec_state);
         assert_coerce_results(&mixed1, &tym1, &mixed1, &mut exec_state);
         assert_coerce_results(&mixed2, &tym2, &mixed2, &mut exec_state);
-        assert!(&mixed1.coerce(&tym2, &mut exec_state).is_none());
+        assert!(&mixed1.coerce(&tym2, &mut exec_state).is_err());
-        assert!(&mixed2.coerce(&tym1, &mut exec_state).is_none());
+        assert!(&mixed2.coerce(&tym1, &mut exec_state).is_err());
 
         // Length subtyping
         let tyhn = RuntimeType::Array(
@@ -1227,15 +1454,15 @@ mod test {
         );
         assert_coerce_results(&hom_arr, &tyhn, &hom_arr, &mut exec_state);
         assert_coerce_results(&hom_arr, &tyh1, &hom_arr, &mut exec_state);
-        assert!(&hom_arr.coerce(&tyh3, &mut exec_state).is_none());
+        assert!(&hom_arr.coerce(&tyh3, &mut exec_state).is_err());
 
         let hom_arr0 = KclValue::HomArray {
             value: vec![],
             ty: RuntimeType::Primitive(PrimitiveType::Number(NumericType::count())),
         };
         assert_coerce_results(&hom_arr0, &tyhn, &hom_arr0, &mut exec_state);
-        assert!(&hom_arr0.coerce(&tyh1, &mut exec_state).is_none());
+        assert!(&hom_arr0.coerce(&tyh1, &mut exec_state).is_err());
-        assert!(&hom_arr0.coerce(&tyh3, &mut exec_state).is_none());
+        assert!(&hom_arr0.coerce(&tyh3, &mut exec_state).is_err());
 
         // Covariance
         // let tyh = RuntimeType::Array(Box::new(RuntimeType::Primitive(PrimitiveType::Number(NumericType::Any))), ArrayLen::Known(4));
@@ -1275,16 +1502,16 @@ mod test {
         assert_coerce_results(&mixed1, &tyhn, &hom_arr_2, &mut exec_state);
         assert_coerce_results(&mixed1, &tyh1, &hom_arr_2, &mut exec_state);
         assert_coerce_results(&mixed0, &tyhn, &hom_arr0, &mut exec_state);
-        assert!(&mixed0.coerce(&tyh, &mut exec_state).is_none());
+        assert!(&mixed0.coerce(&tyh, &mut exec_state).is_err());
-        assert!(&mixed0.coerce(&tyh1, &mut exec_state).is_none());
+        assert!(&mixed0.coerce(&tyh1, &mut exec_state).is_err());
 
         // Homogehous to mixed
         assert_coerce_results(&hom_arr_2, &tym1, &mixed1, &mut exec_state);
-        assert!(&hom_arr.coerce(&tym1, &mut exec_state).is_none());
+        assert!(&hom_arr.coerce(&tym1, &mut exec_state).is_err());
-        assert!(&hom_arr_2.coerce(&tym2, &mut exec_state).is_none());
+        assert!(&hom_arr_2.coerce(&tym2, &mut exec_state).is_err());
 
-        assert!(&mixed0.coerce(&tym1, &mut exec_state).is_none());
+        assert!(&mixed0.coerce(&tym1, &mut exec_state).is_err());
-        assert!(&mixed0.coerce(&tym2, &mut exec_state).is_none());
+        assert!(&mixed0.coerce(&tym2, &mut exec_state).is_err());
     }
 
     #[tokio::test(flavor = "multi_thread")]
@@ -1334,8 +1561,8 @@ mod test {
             RuntimeType::Primitive(PrimitiveType::Boolean),
             RuntimeType::Primitive(PrimitiveType::String),
         ]);
-        assert!(count.coerce(&tyb, &mut exec_state).is_none());
+        assert!(count.coerce(&tyb, &mut exec_state).is_err());
-        assert!(count.coerce(&tyb2, &mut exec_state).is_none());
+        assert!(count.coerce(&tyb2, &mut exec_state).is_err());
     }
 
     #[tokio::test(flavor = "multi_thread")]
@@ -1450,6 +1677,192 @@ mod test {
         assert_coerce_results(&a2d, &ty2d, &a2d, &mut exec_state);
         assert_coerce_results(&a3d, &ty3d, &a3d, &mut exec_state);
         assert_coerce_results(&a3d, &ty2d, &a2d, &mut exec_state);
-        assert!(a2d.coerce(&ty3d, &mut exec_state).is_none());
+        assert!(a2d.coerce(&ty3d, &mut exec_state).is_err());
+    }
+
+    #[tokio::test(flavor = "multi_thread")]
+    async fn coerce_numeric() {
+        let mut exec_state = ExecState::new(&crate::ExecutorContext::new_mock().await);
+
+        let count = KclValue::Number {
+            value: 1.0,
+            ty: NumericType::count(),
+            meta: Vec::new(),
+        };
+        let mm = KclValue::Number {
+            value: 1.0,
+            ty: NumericType::mm(),
+            meta: Vec::new(),
+        };
+        let inches = KclValue::Number {
+            value: 1.0,
+            ty: NumericType::Known(UnitType::Length(UnitLen::Inches)),
+            meta: Vec::new(),
+        };
+        let rads = KclValue::Number {
+            value: 1.0,
+            ty: NumericType::Known(UnitType::Angle(UnitAngle::Radians)),
+            meta: Vec::new(),
+        };
+        let default = KclValue::Number {
+            value: 1.0,
+            ty: NumericType::default(),
+            meta: Vec::new(),
+        };
+        let any = KclValue::Number {
+            value: 1.0,
+            ty: NumericType::Any,
+            meta: Vec::new(),
+        };
+        let unknown = KclValue::Number {
+            value: 1.0,
+            ty: NumericType::Unknown,
+            meta: Vec::new(),
+        };
+
+        // Trivial coercions
+        assert_coerce_results(&count, &NumericType::count().into(), &count, &mut exec_state);
+        assert_coerce_results(&mm, &NumericType::mm().into(), &mm, &mut exec_state);
+        assert_coerce_results(&any, &NumericType::Any.into(), &any, &mut exec_state);
+        assert_coerce_results(&unknown, &NumericType::Unknown.into(), &unknown, &mut exec_state);
+        assert_coerce_results(&default, &NumericType::default().into(), &default, &mut exec_state);
+
+        assert_coerce_results(&count, &NumericType::Any.into(), &count, &mut exec_state);
+        assert_coerce_results(&mm, &NumericType::Any.into(), &mm, &mut exec_state);
+        assert_coerce_results(&unknown, &NumericType::Any.into(), &unknown, &mut exec_state);
+        assert_coerce_results(&default, &NumericType::Any.into(), &default, &mut exec_state);
+
+        if !*CHECK_NUMERIC_TYPES {
+            return;
+        }
+
+        assert_eq!(
+            default
+                .coerce(
+                    &NumericType::Default {
+                        len: UnitLen::Yards,
+                        angle: UnitAngle::default()
+                    }
+                    .into(),
+                    &mut exec_state
+                )
+                .unwrap(),
+            default
+        );
+
+        // No coercion
+        assert!(count.coerce(&NumericType::mm().into(), &mut exec_state).is_err());
+        assert!(mm.coerce(&NumericType::count().into(), &mut exec_state).is_err());
+        assert!(unknown.coerce(&NumericType::mm().into(), &mut exec_state).is_err());
+        assert!(unknown.coerce(&NumericType::default().into(), &mut exec_state).is_err());
+
+        assert!(count.coerce(&NumericType::Unknown.into(), &mut exec_state).is_err());
+        assert!(mm.coerce(&NumericType::Unknown.into(), &mut exec_state).is_err());
+        assert!(default.coerce(&NumericType::Unknown.into(), &mut exec_state).is_err());
+
+        assert_eq!(
+            inches
+                .coerce(&NumericType::mm().into(), &mut exec_state)
+                .unwrap()
+                .as_f64()
+                .unwrap()
+                .round(),
+            25.0
+        );
+        assert_eq!(
+            rads.coerce(
+                &NumericType::Known(UnitType::Angle(UnitAngle::Degrees)).into(),
+                &mut exec_state
+            )
+            .unwrap()
+            .as_f64()
+            .unwrap()
+            .round(),
+            57.0
+        );
+        assert_eq!(
+            inches
+                .coerce(&NumericType::default().into(), &mut exec_state)
+                .unwrap()
+                .as_f64()
+                .unwrap()
+                .round(),
+            25.0
+        );
+        assert_eq!(
+            rads.coerce(&NumericType::default().into(), &mut exec_state)
+                .unwrap()
+                .as_f64()
+                .unwrap()
+                .round(),
+            57.0
+        );
+    }
+
+    #[track_caller]
+    fn assert_value_and_type(name: &str, result: &ExecTestResults, expected: f64, expected_ty: NumericType) {
+        let mem = result.exec_state.stack();
+        match mem
+            .memory
+            .get_from(name, result.mem_env, SourceRange::default(), 0)
+            .unwrap()
+        {
+            KclValue::Number { value, ty, .. } => {
+                assert_eq!(value.round(), expected);
+                assert_eq!(*ty, expected_ty);
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    #[tokio::test(flavor = "multi_thread")]
+    async fn combine_numeric() {
+        let program = r#"a = 5 + 4
+b = 5 - 2
+c = 5mm - 2mm + 10mm
+d = 5mm - 2 + 10
+e = 5 - 2mm + 10
+f = 30mm - 1inch
+
+g = 2 * 10
+h = 2 * 10mm
+i = 2mm * 10mm
+j = 2_ * 10
+k = 2_ * 3mm * 3mm
+
+l = 1 / 10
+m = 2mm / 1mm
+n = 10inch / 2mm
+o = 3mm / 3
+p = 3_ / 4
+q = 4inch / 2_
+"#;
+
+        let result = parse_execute(program).await.unwrap();
+        if *CHECK_NUMERIC_TYPES {
+            assert_eq!(result.exec_state.errors().len(), 2);
+        } else {
+            assert!(result.exec_state.errors().is_empty());
+        }
+
+        assert_value_and_type("a", &result, 9.0, NumericType::default());
+        assert_value_and_type("b", &result, 3.0, NumericType::default());
+        assert_value_and_type("c", &result, 13.0, NumericType::mm());
+        assert_value_and_type("d", &result, 13.0, NumericType::mm());
+        assert_value_and_type("e", &result, 13.0, NumericType::mm());
+        assert_value_and_type("f", &result, 5.0, NumericType::mm());
+
+        assert_value_and_type("g", &result, 20.0, NumericType::default());
+        assert_value_and_type("h", &result, 20.0, NumericType::mm());
+        assert_value_and_type("i", &result, 20.0, NumericType::Unknown);
+        assert_value_and_type("j", &result, 20.0, NumericType::default());
+        assert_value_and_type("k", &result, 18.0, NumericType::Unknown);
+
+        assert_value_and_type("l", &result, 0.0, NumericType::count());
+        assert_value_and_type("m", &result, 2.0, NumericType::count());
+        assert_value_and_type("n", &result, 127.0, NumericType::count());
+        assert_value_and_type("o", &result, 1.0, NumericType::mm());
+        assert_value_and_type("p", &result, 1.0, NumericType::count());
+        assert_value_and_type("q", &result, 2.0, NumericType::Known(UnitType::Length(UnitLen::Inches)));
     }
 }

rust/kcl-lib/src/std/args.rs

@@ -8,7 +8,7 @@ use kcmc::{
 };
 use kittycad_modeling_cmds as kcmc;
 use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 
 use crate::{
     errors::{KclError, KclErrorDetails},
@@ -72,7 +72,7 @@ impl KwArgs {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS)]
+#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS)]
 #[ts(export)]
 #[serde(rename_all = "camelCase")]
 pub struct TyF64 {
@@ -92,7 +92,7 @@ impl TyF64 {
         }
     }
 
-    pub fn map(mut self, n: f64) -> Self {
+    pub fn map_value(mut self, n: f64) -> Self {
         self.n = n;
         self
     }
@@ -209,7 +209,7 @@ impl Args {
             }));
         };
 
-        let arg = arg.value.coerce(ty, exec_state).ok_or_else(|| {
+        let arg = arg.value.coerce(ty, exec_state).map_err(|_| {
             let actual_type_name = arg.value.human_friendly_type();
             let msg_base = format!(
                 "This function expected the input argument to be {} but it's actually of type {actual_type_name}",
@@ -332,7 +332,7 @@ impl Args {
                 message: format!("This function requires a value for the special unlabeled first parameter, '{label}'"),
             }))?;
 
-        let arg = arg.value.coerce(ty, exec_state).ok_or_else(|| {
+        let arg = arg.value.coerce(ty, exec_state).map_err(|_| {
             let actual_type_name = arg.value.human_friendly_type();
             let msg_base = format!(
                 "This function expected the input argument to be {} but it's actually of type {actual_type_name}",
@@ -523,7 +523,7 @@ impl Args {
         })
     }
 
-    pub(crate) fn make_user_val_from_f64(&self, f: f64) -> KclValue {
+    pub(super) fn make_user_val_from_f64(&self, f: f64) -> KclValue {
         KclValue::from_number(
             f,
             vec![Metadata {
@@ -532,7 +532,7 @@ impl Args {
         )
     }
 
-    pub(crate) fn make_user_val_from_f64_with_type(&self, f: TyF64) -> KclValue {
+    pub(super) fn make_user_val_from_f64_with_type(&self, f: TyF64) -> KclValue {
         KclValue::from_number_with_type(
             f.n,
             f.ty,
@@ -542,7 +542,7 @@ impl Args {
         )
     }
 
-    pub(crate) fn make_user_val_from_f64_array(&self, f: Vec<f64>, ty: &NumericType) -> Result<KclValue, KclError> {
+    pub(super) fn make_user_val_from_f64_array(&self, f: Vec<f64>, ty: &NumericType) -> Result<KclValue, KclError> {
         let array = f
             .into_iter()
             .map(|n| KclValue::Number {
@@ -616,8 +616,7 @@ impl Args {
         let mut numbers = numbers.into_iter();
         let a = numbers.next().unwrap();
         let b = numbers.next().unwrap();
-        let ty = a.ty.combine_eq(&b.ty);
+        Ok(NumericType::combine_eq(a, b))
-        Ok((a.n, b.n, ty))
     }
 
     pub(crate) fn get_sketches(&self, exec_state: &mut ExecState) -> Result<(Vec<Sketch>, Sketch), KclError> {
@@ -627,16 +626,15 @@ impl Args {
                 source_ranges: vec![self.source_range],
             }));
         };
-        let sarg = arg0
+        let sarg = arg0.value.coerce(&RuntimeType::sketches(), exec_state).map_err(|_| {
-            .value
+            KclError::Type(KclErrorDetails {
-            .coerce(&RuntimeType::sketches(), exec_state)
-            .ok_or(KclError::Type(KclErrorDetails {
                 message: format!(
                     "Expected an array of sketches, found {}",
                     arg0.value.human_friendly_type()
                 ),
                 source_ranges: vec![self.source_range],
-            }))?;
+            })
+        })?;
         let sketches = match sarg {
             KclValue::HomArray { value, .. } => value.iter().map(|v| v.as_sketch().unwrap().clone()).collect(),
             _ => unreachable!(),
@@ -651,10 +649,12 @@ impl Args {
         let sarg = arg1
             .value
             .coerce(&RuntimeType::Primitive(PrimitiveType::Sketch), exec_state)
-            .ok_or(KclError::Type(KclErrorDetails {
+            .map_err(|_| {
+                KclError::Type(KclErrorDetails {
                     message: format!("Expected a sketch, found {}", arg1.value.human_friendly_type()),
                     source_ranges: vec![self.source_range],
-            }))?;
+                })
+            })?;
         let sketch = match sarg {
             KclValue::Sketch { value } => *value,
             _ => unreachable!(),
@@ -673,10 +673,12 @@ impl Args {
         let sarg = arg0
             .value
             .coerce(&RuntimeType::Primitive(PrimitiveType::Sketch), exec_state)
-            .ok_or(KclError::Type(KclErrorDetails {
+            .map_err(|_| {
+                KclError::Type(KclErrorDetails {
                     message: format!("Expected a sketch, found {}", arg0.value.human_friendly_type()),
                     source_ranges: vec![self.source_range],
-            }))?;
+                })
+            })?;
         match sarg {
             KclValue::Sketch { value } => Ok(*value),
             _ => unreachable!(),
@@ -718,13 +720,15 @@ impl Args {
         let sarg = arg1
             .value
             .coerce(&RuntimeType::Primitive(PrimitiveType::Sketch), exec_state)
-            .ok_or(KclError::Type(KclErrorDetails {
+            .map_err(|_| {
+                KclError::Type(KclErrorDetails {
                     message: format!(
                         "Expected a sketch for second argument, found {}",
                         arg1.value.human_friendly_type()
                     ),
                     source_ranges: vec![self.source_range],
-            }))?;
+                })
+            })?;
         let sketch = match sarg {
             KclValue::Sketch { value } => *value,
             _ => unreachable!(),
@@ -754,13 +758,15 @@ impl Args {
         let sarg = arg1
             .value
             .coerce(&RuntimeType::Primitive(PrimitiveType::Solid), exec_state)
-            .ok_or(KclError::Type(KclErrorDetails {
+            .map_err(|_| {
+                KclError::Type(KclErrorDetails {
                     message: format!(
                         "Expected a solid for second argument, found {}",
                         arg1.value.human_friendly_type()
                     ),
                     source_ranges: vec![self.source_range],
-            }))?;
+                })
+            })?;
         let solid = match sarg {
             KclValue::Solid { value } => value,
             _ => unreachable!(),

rust/kcl-lib/src/std/convert.rs

@@ -13,7 +13,7 @@ pub async fn int(_exec_state: &mut ExecState, args: Args) -> Result<KclValue, Kc
     let num = args.get_number_with_type()?;
     let converted = inner_int(num.n)?;
 
-    Ok(args.make_user_val_from_f64_with_type(num.map(converted)))
+    Ok(args.make_user_val_from_f64_with_type(num.map_value(converted)))
 }
 
 /// Convert a number to an integer.

rust/kcl-lib/src/std/mod.rs

@@ -139,12 +139,12 @@ lazy_static! {
         Box::new(crate::std::math::Ln),
         Box::new(crate::std::math::ToDegrees),
         Box::new(crate::std::math::ToRadians),
-        Box::new(crate::std::units::Mm),
+        Box::new(crate::std::units::FromMm),
-        Box::new(crate::std::units::Inch),
+        Box::new(crate::std::units::FromInches),
-        Box::new(crate::std::units::Ft),
+        Box::new(crate::std::units::FromFt),
-        Box::new(crate::std::units::M),
+        Box::new(crate::std::units::FromM),
-        Box::new(crate::std::units::Cm),
+        Box::new(crate::std::units::FromCm),
-        Box::new(crate::std::units::Yd),
+        Box::new(crate::std::units::FromYd),
         Box::new(crate::std::polar::Polar),
         Box::new(crate::std::assert::Assert),
         Box::new(crate::std::assert::AssertEqual),

rust/kcl-lib/src/std/polar.rs

@@ -8,7 +8,7 @@ use serde::{Deserialize, Serialize};
 use crate::{
     errors::KclError,
     execution::{ExecState, KclValue},
-    std::args::{Args, TyF64},
+    std::args::Args,
 };
 
 /// Data for polar coordinates.
@@ -19,7 +19,7 @@ pub struct PolarCoordsData {
     /// The angle of the line (in degrees).
     pub angle: f64,
     /// The length of the line.
-    pub length: TyF64,
+    pub length: f64,
 }
 
 /// Convert from polar/sphere coordinates to cartesian coordinates.
@@ -27,7 +27,7 @@ pub async fn polar(_exec_state: &mut ExecState, args: Args) -> Result<KclValue,
     let data: PolarCoordsData = args.get_data()?;
     let result = inner_polar(&data)?;
 
-    args.make_user_val_from_f64_array(result.to_vec(), &data.length.ty)
+    args.make_user_val_from_f64_array(result.to_vec(), &crate::execution::types::NumericType::Unknown)
 }
 
 /// Convert polar/sphere (azimuth, elevation, distance) coordinates to
@@ -49,7 +49,7 @@ pub async fn polar(_exec_state: &mut ExecState, args: Args) -> Result<KclValue,
 }]
 fn inner_polar(data: &PolarCoordsData) -> Result<[f64; 2], KclError> {
     let angle = data.angle.to_radians();
-    let x = data.length.n * angle.cos();
+    let x = data.length * angle.cos();
-    let y = data.length.n * angle.sin();
+    let y = data.length * angle.sin();
     Ok([x, y])
 }

rust/kcl-lib/src/std/units.rs

@@ -10,251 +10,257 @@ use crate::{
 };
 
 /// Millimeters conversion factor for current projects units.
-pub async fn mm(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
+pub async fn from_mm(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
-    let result = inner_mm(exec_state)?;
+    let input = args.get_number()?;
+    let result = inner_from_mm(input, exec_state)?;
 
     Ok(args.make_user_val_from_f64(result))
 }
 
-/// Millimeters conversion factor for current projects units.
+/// Converts a number from mm to the current default unit.
 ///
-/// No matter what units the current project uses, this function will always return the conversion
+/// No matter what units the current file uses, this function will always return a number equivalent
-/// factor to millimeters.
+/// to the input in millimeters.
 ///
-/// For example, if the current project uses inches, this function will return `(1/25.4)`.
+/// For example, if the current project uses inches, `fromMm(1)` will return `1/25.4`.
-/// If the current project uses millimeters, this function will return `1`.
+/// If the current project uses millimeters, `fromMm(1)` will return `1`.
 ///
 /// **Caution**: This function is only intended to be used when you absolutely MUST
 /// have different units in your code than the project settings. Otherwise, it is
 /// a bad pattern to use this function.
 ///
 /// We merely provide these functions for convenience and readability, as
-/// `10 * mm()` is more readable that your intent is "I want 10 millimeters" than
+/// `fromMm(10)` is more readable that your intent is "I want 10 millimeters" than
 /// `10 * (1/25.4)`, if the project settings are in inches.
 ///
 /// ```no_run
-/// totalWidth = 10 * mm()
+/// totalWidth = fromMm(10)
 /// ```
 #[stdlib {
-    name = "mm",
+    name = "fromMm",
     tags = ["units"],
 }]
-fn inner_mm(exec_state: &ExecState) -> Result<f64, KclError> {
+fn inner_from_mm(input: f64, exec_state: &ExecState) -> Result<f64, KclError> {
-    match exec_state.length_unit() {
+    Ok(match exec_state.length_unit() {
-        UnitLen::Mm => Ok(1.0),
+        UnitLen::Mm => input,
-        UnitLen::Inches => Ok(measurements::Length::from_millimeters(1.0).as_inches()),
+        UnitLen::Inches => measurements::Length::from_millimeters(input).as_inches(),
-        UnitLen::Feet => Ok(measurements::Length::from_millimeters(1.0).as_feet()),
+        UnitLen::Feet => measurements::Length::from_millimeters(input).as_feet(),
-        UnitLen::M => Ok(measurements::Length::from_millimeters(1.0).as_meters()),
+        UnitLen::M => measurements::Length::from_millimeters(input).as_meters(),
-        UnitLen::Cm => Ok(measurements::Length::from_millimeters(1.0).as_centimeters()),
+        UnitLen::Cm => measurements::Length::from_millimeters(input).as_centimeters(),
-        UnitLen::Yards => Ok(measurements::Length::from_millimeters(1.0).as_yards()),
+        UnitLen::Yards => measurements::Length::from_millimeters(input).as_yards(),
-    }
+    })
 }
 
 /// Inches conversion factor for current projects units.
-pub async fn inch(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
+pub async fn from_inches(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
-    let result = inner_inch(exec_state)?;
+    let input = args.get_number()?;
+    let result = inner_from_inches(input, exec_state)?;
 
     Ok(args.make_user_val_from_f64(result))
 }
 
-/// Inches conversion factor for current projects units.
+/// Converts a number from inches to the current default unit.
 ///
-/// No matter what units the current project uses, this function will always return the conversion
+/// No matter what units the current file uses, this function will always return a number equivalent
-/// factor to inches.
+/// to the input in inches.
 ///
-/// For example, if the current project uses inches, this function will return `1`.
+/// For example, if the current project uses inches, `fromInches(1)` will return `1`.
-/// If the current project uses millimeters, this function will return `25.4`.
+/// If the current project uses millimeters, `fromInches(1)` will return `25.4`.
 ///
 /// **Caution**: This function is only intended to be used when you absolutely MUST
 /// have different units in your code than the project settings. Otherwise, it is
 /// a bad pattern to use this function.
 ///
 /// We merely provide these functions for convenience and readability, as
-/// `10 * inch()` is more readable that your intent is "I want 10 inches" than
+/// `fromInches(10)` is more readable that your intent is "I want 10 inches" than
 /// `10 * 25.4`, if the project settings are in millimeters.
 ///
 /// ```no_run
-/// totalWidth = 10 * inch()
+/// totalWidth = fromInches(10)
 /// ```
 #[stdlib {
-    name = "inch",
+    name = "fromInches",
     tags = ["units"],
 }]
-fn inner_inch(exec_state: &ExecState) -> Result<f64, KclError> {
+fn inner_from_inches(input: f64, exec_state: &ExecState) -> Result<f64, KclError> {
     match exec_state.length_unit() {
-        UnitLen::Mm => Ok(measurements::Length::from_inches(1.0).as_millimeters()),
+        UnitLen::Mm => Ok(measurements::Length::from_inches(input).as_millimeters()),
-        UnitLen::Inches => Ok(1.0),
+        UnitLen::Inches => Ok(input),
-        UnitLen::Feet => Ok(measurements::Length::from_inches(1.0).as_feet()),
+        UnitLen::Feet => Ok(measurements::Length::from_inches(input).as_feet()),
-        UnitLen::M => Ok(measurements::Length::from_inches(1.0).as_meters()),
+        UnitLen::M => Ok(measurements::Length::from_inches(input).as_meters()),
-        UnitLen::Cm => Ok(measurements::Length::from_inches(1.0).as_centimeters()),
+        UnitLen::Cm => Ok(measurements::Length::from_inches(input).as_centimeters()),
-        UnitLen::Yards => Ok(measurements::Length::from_inches(1.0).as_yards()),
+        UnitLen::Yards => Ok(measurements::Length::from_inches(input).as_yards()),
     }
 }
 
 /// Feet conversion factor for current projects units.
-pub async fn ft(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
+pub async fn from_ft(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
-    let result = inner_ft(exec_state)?;
+    let input = args.get_number()?;
+    let result = inner_from_ft(input, exec_state)?;
 
     Ok(args.make_user_val_from_f64(result))
 }
 
-/// Feet conversion factor for current projects units.
+/// Converts a number from feet to the current default unit.
 ///
-/// No matter what units the current project uses, this function will always return the conversion
+/// No matter what units the current file uses, this function will always return a number equivalent
-/// factor to feet.
+/// to the input in feet.
 ///
-/// For example, if the current project uses inches, this function will return `12`.
+/// For example, if the current project uses inches, `fromFt(1)` will return `12`.
-/// If the current project uses millimeters, this function will return `304.8`.
+/// If the current project uses millimeters, `fromFt(1)` will return `304.8`.
-/// If the current project uses feet, this function will return `1`.
+/// If the current project uses feet, `fromFt(1)` will return `1`.
 ///
 /// **Caution**: This function is only intended to be used when you absolutely MUST
 /// have different units in your code than the project settings. Otherwise, it is
 /// a bad pattern to use this function.
 ///
 /// We merely provide these functions for convenience and readability, as
-/// `10 * ft()` is more readable that your intent is "I want 10 feet" than
+/// `fromFt(10)` is more readable that your intent is "I want 10 feet" than
 /// `10 * 304.8`, if the project settings are in millimeters.
 ///
 /// ```no_run
-/// totalWidth = 10 * ft()
+/// totalWidth = fromFt(10)
 /// ```
 #[stdlib {
-    name = "ft",
+    name = "fromFt",
     tags = ["units"],
 }]
-fn inner_ft(exec_state: &ExecState) -> Result<f64, KclError> {
+fn inner_from_ft(input: f64, exec_state: &ExecState) -> Result<f64, KclError> {
     match exec_state.length_unit() {
-        UnitLen::Mm => Ok(measurements::Length::from_feet(1.0).as_millimeters()),
+        UnitLen::Mm => Ok(measurements::Length::from_feet(input).as_millimeters()),
-        UnitLen::Inches => Ok(measurements::Length::from_feet(1.0).as_inches()),
+        UnitLen::Inches => Ok(measurements::Length::from_feet(input).as_inches()),
-        UnitLen::Feet => Ok(1.0),
+        UnitLen::Feet => Ok(input),
-        UnitLen::M => Ok(measurements::Length::from_feet(1.0).as_meters()),
+        UnitLen::M => Ok(measurements::Length::from_feet(input).as_meters()),
-        UnitLen::Cm => Ok(measurements::Length::from_feet(1.0).as_centimeters()),
+        UnitLen::Cm => Ok(measurements::Length::from_feet(input).as_centimeters()),
-        UnitLen::Yards => Ok(measurements::Length::from_feet(1.0).as_yards()),
+        UnitLen::Yards => Ok(measurements::Length::from_feet(input).as_yards()),
     }
 }
 
 /// Meters conversion factor for current projects units.
-pub async fn m(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
+pub async fn from_m(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
-    let result = inner_m(exec_state)?;
+    let input = args.get_number()?;
+    let result = inner_from_m(input, exec_state)?;
 
     Ok(args.make_user_val_from_f64(result))
 }
 
-/// Meters conversion factor for current projects units.
+/// Converts a number from meters to the current default unit.
 ///
-/// No matter what units the current project uses, this function will always return the conversion
+/// No matter what units the current file uses, this function will always return a number equivalent
-/// factor to meters.
+/// to the input in meters.
 ///
-/// For example, if the current project uses inches, this function will return `39.3701`.
+/// For example, if the current project uses inches, `fromM` will return `39.3701`.
-/// If the current project uses millimeters, this function will return `1000`.
+/// If the current project uses millimeters, `fromM` will return `1000`.
-/// If the current project uses meters, this function will return `1`.
+/// If the current project uses meters, `fromM` will return `1`.
 ///
 /// **Caution**: This function is only intended to be used when you absolutely MUST
 /// have different units in your code than the project settings. Otherwise, it is
 /// a bad pattern to use this function.
 ///
 /// We merely provide these functions for convenience and readability, as
-/// `10 * m()` is more readable that your intent is "I want 10 meters" than
+/// `fromM(10)` is more readable that your intent is "I want 10 meters" than
 /// `10 * 1000`, if the project settings are in millimeters.
 ///
 /// ```no_run
-/// totalWidth = 10 * m()
+/// totalWidth = 10 * fromM(10)
 /// ```
 #[stdlib {
-    name = "m",
+    name = "fromM",
     tags = ["units"],
 }]
-fn inner_m(exec_state: &ExecState) -> Result<f64, KclError> {
+fn inner_from_m(input: f64, exec_state: &ExecState) -> Result<f64, KclError> {
     match exec_state.length_unit() {
-        UnitLen::Mm => Ok(measurements::Length::from_meters(1.0).as_millimeters()),
+        UnitLen::Mm => Ok(measurements::Length::from_meters(input).as_millimeters()),
-        UnitLen::Inches => Ok(measurements::Length::from_meters(1.0).as_inches()),
+        UnitLen::Inches => Ok(measurements::Length::from_meters(input).as_inches()),
-        UnitLen::Feet => Ok(measurements::Length::from_meters(1.0).as_feet()),
+        UnitLen::Feet => Ok(measurements::Length::from_meters(input).as_feet()),
-        UnitLen::M => Ok(1.0),
+        UnitLen::M => Ok(input),
-        UnitLen::Cm => Ok(measurements::Length::from_meters(1.0).as_centimeters()),
+        UnitLen::Cm => Ok(measurements::Length::from_meters(input).as_centimeters()),
-        UnitLen::Yards => Ok(measurements::Length::from_meters(1.0).as_yards()),
+        UnitLen::Yards => Ok(measurements::Length::from_meters(input).as_yards()),
     }
 }
 
 /// Centimeters conversion factor for current projects units.
-pub async fn cm(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
+pub async fn from_cm(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
-    let result = inner_cm(exec_state)?;
+    let input = args.get_number()?;
+    let result = inner_from_cm(input, exec_state)?;
 
     Ok(args.make_user_val_from_f64(result))
 }
 
-/// Centimeters conversion factor for current projects units.
+/// Converts a number from centimeters to the current default unit.
 ///
-/// No matter what units the current project uses, this function will always return the conversion
+/// No matter what units the current file uses, this function will always return a number equivalent
-/// factor to centimeters.
+/// to the input in centimeters.
 ///
-/// For example, if the current project uses inches, this function will return `0.393701`.
+/// For example, if the current project uses inches, `fromCm` will return `0.393701`.
-/// If the current project uses millimeters, this function will return `10`.
+/// If the current project uses millimeters, `fromCm` will return `10`.
-/// If the current project uses centimeters, this function will return `1`.
+/// If the current project uses centimeters, `fromCm` will return `1`.
 ///
 /// **Caution**: This function is only intended to be used when you absolutely MUST
 /// have different units in your code than the project settings. Otherwise, it is
 /// a bad pattern to use this function.
 ///
 /// We merely provide these functions for convenience and readability, as
-/// `10 * cm()` is more readable that your intent is "I want 10 centimeters" than
+/// `fromCm(10)` is more readable that your intent is "I want 10 centimeters" than
 /// `10 * 10`, if the project settings are in millimeters.
 ///
 /// ```no_run
-/// totalWidth = 10 * cm()
+/// totalWidth = fromCm(10)
 /// ```
 #[stdlib {
-    name = "cm",
+    name = "fromCm",
     tags = ["units"],
 }]
-fn inner_cm(exec_state: &ExecState) -> Result<f64, KclError> {
+fn inner_from_cm(input: f64, exec_state: &ExecState) -> Result<f64, KclError> {
     match exec_state.length_unit() {
-        UnitLen::Mm => Ok(measurements::Length::from_centimeters(1.0).as_millimeters()),
+        UnitLen::Mm => Ok(measurements::Length::from_centimeters(input).as_millimeters()),
-        UnitLen::Inches => Ok(measurements::Length::from_centimeters(1.0).as_inches()),
+        UnitLen::Inches => Ok(measurements::Length::from_centimeters(input).as_inches()),
-        UnitLen::Feet => Ok(measurements::Length::from_centimeters(1.0).as_feet()),
+        UnitLen::Feet => Ok(measurements::Length::from_centimeters(input).as_feet()),
-        UnitLen::M => Ok(measurements::Length::from_centimeters(1.0).as_meters()),
+        UnitLen::M => Ok(measurements::Length::from_centimeters(input).as_meters()),
-        UnitLen::Cm => Ok(1.0),
+        UnitLen::Cm => Ok(input),
-        UnitLen::Yards => Ok(measurements::Length::from_centimeters(1.0).as_yards()),
+        UnitLen::Yards => Ok(measurements::Length::from_centimeters(input).as_yards()),
     }
 }
 
 /// Yards conversion factor for current projects units.
-pub async fn yd(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
+pub async fn from_yd(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
-    let result = inner_yd(exec_state)?;
+    let input = args.get_number()?;
+    let result = inner_from_yd(input, exec_state)?;
 
     Ok(args.make_user_val_from_f64(result))
 }
 
-/// Yards conversion factor for current projects units.
+/// Converts a number from yards to the current default unit.
 ///
-/// No matter what units the current project uses, this function will always return the conversion
+/// No matter what units the current file uses, this function will always return a number equivalent
-/// factor to yards.
+/// to the input in yards.
 ///
-/// For example, if the current project uses inches, this function will return `36`.
+/// For example, if the current project uses inches, `fromYd` will return `36`.
-/// If the current project uses millimeters, this function will return `914.4`.
+/// If the current project uses millimeters, `fromYd` will return `914.4`.
-/// If the current project uses yards, this function will return `1`.
+/// If the current project uses yards, `fromYd` will return `1`.
 ///
 /// **Caution**: This function is only intended to be used when you absolutely MUST
 /// have different units in your code than the project settings. Otherwise, it is
 /// a bad pattern to use this function.
 ///
 /// We merely provide these functions for convenience and readability, as
-/// `10 * yd()` is more readable that your intent is "I want 10 yards" than
+/// `fromYd(10)` is more readable that your intent is "I want 10 yards" than
 /// `10 * 914.4`, if the project settings are in millimeters.
 ///
 /// ```no_run
-/// totalWidth = 10 * yd()
+/// totalWidth = fromYd(10)
 /// ```
 #[stdlib {
-    name = "yd",
+    name = "fromYd",
     tags = ["units"],
 }]
-fn inner_yd(exec_state: &ExecState) -> Result<f64, KclError> {
+fn inner_from_yd(input: f64, exec_state: &ExecState) -> Result<f64, KclError> {
     match exec_state.length_unit() {
-        UnitLen::Mm => Ok(measurements::Length::from_yards(1.0).as_millimeters()),
+        UnitLen::Mm => Ok(measurements::Length::from_yards(input).as_millimeters()),
-        UnitLen::Inches => Ok(measurements::Length::from_yards(1.0).as_inches()),
+        UnitLen::Inches => Ok(measurements::Length::from_yards(input).as_inches()),
-        UnitLen::Feet => Ok(measurements::Length::from_yards(1.0).as_feet()),
+        UnitLen::Feet => Ok(measurements::Length::from_yards(input).as_feet()),
-        UnitLen::M => Ok(measurements::Length::from_yards(1.0).as_meters()),
+        UnitLen::M => Ok(measurements::Length::from_yards(input).as_meters()),
-        UnitLen::Cm => Ok(measurements::Length::from_yards(1.0).as_centimeters()),
+        UnitLen::Cm => Ok(measurements::Length::from_yards(input).as_centimeters()),
-        UnitLen::Yards => Ok(1.0),
+        UnitLen::Yards => Ok(input),
     }
 }

rust/kcl-lib/std/math.kcl

@@ -7,7 +7,7 @@
 /// circumference = 70
 ///
 /// exampleSketch = startSketchOn(XZ)
-///  |> circle(center = [0, 0], radius = circumference/ (2 * PI))
+///  |> circle(center = [0, 0], radius = circumference / (2 * PI))
 ///
 /// example = extrude(exampleSketch, length = 5)
 /// ```

rust/kcl-lib/std/sketch.kcl

@@ -1,4 +1,5 @@
 @no_std
+@settings(defaultLengthUnit = mm)
 
 /// Construct a 2-dimensional circle, of the specified radius, centered at
 /// the provided (x, y) origin point.

rust/kcl-lib/tests/double_map_fn/program_memory.snap

@@ -42,21 +42,24 @@ description: Variables in memory after executing double_map_fn.kcl
         "type": "Number",
         "value": 2.0,
         "ty": {
-          "type": "Unknown"
+          "type": "Known",
+          "type": "Count"
         }
       },
       {
         "type": "Number",
         "value": 3.0,
         "ty": {
-          "type": "Unknown"
+          "type": "Known",
+          "type": "Count"
         }
       },
       {
         "type": "Number",
         "value": 4.0,
         "ty": {
-          "type": "Unknown"
+          "type": "Known",
+          "type": "Count"
         }
       }
     ]

rust/kcl-lib/tests/fillet-and-shell/program_memory.snap

@@ -307,7 +307,13 @@ description: Variables in memory after executing fillet-and-shell.kcl
     "type": "Number",
     "value": 73.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Mm"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "caseThickness": {
@@ -327,7 +333,13 @@ description: Variables in memory after executing fillet-and-shell.kcl
     "type": "Number",
     "value": 38.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Mm"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "connectorPadding": {
@@ -367,7 +379,13 @@ description: Variables in memory after executing fillet-and-shell.kcl
     "type": "Number",
     "value": 58.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Mm"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "m25Screw": {

rust/kcl-lib/tests/flush_batch_on_end/ops.snap

@@ -51,7 +51,8 @@ description: Operations executed flush_batch_on_end.kcl
           "type": "Number",
           "value": 1.5,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []

rust/kcl-lib/tests/flush_batch_on_end/program_memory.snap

@@ -128,14 +128,16 @@ description: Variables in memory after executing flush_batch_on_end.kcl
     "type": "Number",
     "value": 1.5,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "outerDiameter": {
     "type": "Number",
     "value": 0.5469,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "outerProfile": {

rust/kcl-lib/tests/kcl_samples/ball-bearing/ops.snap

@@ -10,7 +10,8 @@ description: Operations executed ball-bearing.kcl
           "type": "Number",
           "value": -0.1565,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -666,7 +667,8 @@ description: Operations executed ball-bearing.kcl
           "type": "Number",
           "value": 36.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -900,7 +902,8 @@ description: Operations executed ball-bearing.kcl
           "type": "Number",
           "value": -0.1565,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []

rust/kcl-lib/tests/kcl_samples/ball-bearing/program_memory.snap

@@ -3425,14 +3425,16 @@ description: Variables in memory after executing ball-bearing.kcl
     "type": "Number",
     "value": 0.0313,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "chainWidth": {
     "type": "Number",
     "value": 0.125,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "insideWall": {
@@ -3631,7 +3633,8 @@ description: Variables in memory after executing ball-bearing.kcl
     "type": "Number",
     "value": 0.0625,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "linkRevolve": {

rust/kcl-lib/tests/kcl_samples/bench/ops.snap

@@ -58,7 +58,8 @@ description: Operations executed bench.kcl
           "type": "Number",
           "value": 2.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -117,7 +118,8 @@ description: Operations executed bench.kcl
           "type": "Number",
           "value": -2.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -234,7 +236,8 @@ description: Operations executed bench.kcl
           "type": "Number",
           "value": 28.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -306,7 +309,8 @@ description: Operations executed bench.kcl
           "type": "Number",
           "value": 2.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -365,7 +369,8 @@ description: Operations executed bench.kcl
           "type": "Number",
           "value": -2.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -482,7 +487,8 @@ description: Operations executed bench.kcl
           "type": "Number",
           "value": 28.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -554,7 +560,8 @@ description: Operations executed bench.kcl
           "type": "Number",
           "value": 2.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -613,7 +620,8 @@ description: Operations executed bench.kcl
           "type": "Number",
           "value": -2.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -730,7 +738,8 @@ description: Operations executed bench.kcl
           "type": "Number",
           "value": -28.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -902,7 +911,8 @@ description: Operations executed bench.kcl
           "type": "Number",
           "value": -30.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -1026,7 +1036,8 @@ description: Operations executed bench.kcl
           "type": "Number",
           "value": -30.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -1159,7 +1170,8 @@ description: Operations executed bench.kcl
           "type": "Number",
           "value": 28.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -1322,7 +1334,8 @@ description: Operations executed bench.kcl
           "type": "Number",
           "value": -28.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []

rust/kcl-lib/tests/kcl_samples/bracket/program_memory.snap

@@ -40,7 +40,13 @@ description: Variables in memory after executing bracket.kcl
     "type": "Number",
     "value": 3600.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Mm"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "mountingHoleDiameter": {

rust/kcl-lib/tests/kcl_samples/car-wheel-assembly/artifact_commands.snap

@@ -8440,7 +8440,7 @@ description: Artifact commands car-wheel-assembly.kcl
       "type": "move_path_pen",
       "path": "[uuid]",
       "to": {
-        "x": 0.47244094488188976,
+        "x": 0.4724409448818898,
         "y": 0.0,
         "z": 0.0
       }
@@ -8512,7 +8512,7 @@ description: Artifact commands car-wheel-assembly.kcl
       "path": "[uuid]",
       "segment": {
         "type": "tangential_arc",
-        "radius": 0.11811023622047244,
+        "radius": 0.11811023622047245,
         "offset": {
           "unit": "degrees",
           "value": 90.0

rust/kcl-lib/tests/kcl_samples/car-wheel-assembly/artifact_graph_flowchart.snap.md

@@ -79,85 +79,85 @@ flowchart LR
     158[Solid2d]
   end
   subgraph path167 [Path]
-    167["Path<br>[1241, 1301, 5]"]
+    167["Path<br>[1241, 1302, 5]"]
-    168["Segment<br>[1241, 1301, 5]"]
+    168["Segment<br>[1241, 1302, 5]"]
     169[Solid2d]
   end
   subgraph path179 [Path]
-    179["Path<br>[1659, 1705, 5]"]
+    179["Path<br>[1660, 1706, 5]"]
-    180["Segment<br>[1711, 1763, 5]"]
+    180["Segment<br>[1712, 1764, 5]"]
-    181["Segment<br>[1769, 1874, 5]"]
+    181["Segment<br>[1770, 1875, 5]"]
-    182["Segment<br>[1880, 1902, 5]"]
+    182["Segment<br>[1881, 1903, 5]"]
-    183["Segment<br>[1908, 1964, 5]"]
+    183["Segment<br>[1909, 1965, 5]"]
-    184["Segment<br>[1970, 1977, 5]"]
+    184["Segment<br>[1971, 1978, 5]"]
     185[Solid2d]
   end
   subgraph path195 [Path]
-    195["Path<br>[2109, 2155, 5]"]
+    195["Path<br>[2110, 2156, 5]"]
-    196["Segment<br>[2161, 2213, 5]"]
+    196["Segment<br>[2162, 2214, 5]"]
-    197["Segment<br>[2219, 2326, 5]"]
+    197["Segment<br>[2220, 2327, 5]"]
-    198["Segment<br>[2332, 2369, 5]"]
+    198["Segment<br>[2333, 2370, 5]"]
-    199["Segment<br>[2375, 2431, 5]"]
+    199["Segment<br>[2376, 2432, 5]"]
-    200["Segment<br>[2437, 2444, 5]"]
+    200["Segment<br>[2438, 2445, 5]"]
     201[Solid2d]
   end
   subgraph path212 [Path]
-    212["Path<br>[2953, 3000, 5]"]
+    212["Path<br>[2954, 3001, 5]"]
-    213["Segment<br>[3008, 3348, 5]"]
+    213["Segment<br>[3009, 3349, 5]"]
-    214["Segment<br>[3356, 3388, 5]"]
+    214["Segment<br>[3357, 3389, 5]"]
-    215["Segment<br>[3396, 3740, 5]"]
+    215["Segment<br>[3397, 3741, 5]"]
-    216["Segment<br>[3748, 3804, 5]"]
+    216["Segment<br>[3749, 3805, 5]"]
-    217["Segment<br>[3812, 3819, 5]"]
+    217["Segment<br>[3813, 3820, 5]"]
     218[Solid2d]
   end
   subgraph path235 [Path]
-    235["Path<br>[2953, 3000, 5]"]
+    235["Path<br>[2954, 3001, 5]"]
-    236["Segment<br>[3008, 3348, 5]"]
+    236["Segment<br>[3009, 3349, 5]"]
-    237["Segment<br>[3356, 3388, 5]"]
+    237["Segment<br>[3357, 3389, 5]"]
-    238["Segment<br>[3396, 3740, 5]"]
+    238["Segment<br>[3397, 3741, 5]"]
-    239["Segment<br>[3748, 3804, 5]"]
+    239["Segment<br>[3749, 3805, 5]"]
-    240["Segment<br>[3812, 3819, 5]"]
+    240["Segment<br>[3813, 3820, 5]"]
     241[Solid2d]
   end
   subgraph path258 [Path]
-    258["Path<br>[4347, 4442, 5]"]
+    258["Path<br>[4348, 4443, 5]"]
-    259["Segment<br>[4448, 4481, 5]"]
+    259["Segment<br>[4449, 4482, 5]"]
-    260["Segment<br>[4487, 4538, 5]"]
+    260["Segment<br>[4488, 4539, 5]"]
-    261["Segment<br>[4544, 4577, 5]"]
+    261["Segment<br>[4545, 4578, 5]"]
-    262["Segment<br>[4583, 4633, 5]"]
+    262["Segment<br>[4584, 4634, 5]"]
-    263["Segment<br>[4639, 4680, 5]"]
+    263["Segment<br>[4640, 4681, 5]"]
-    264["Segment<br>[4686, 4735, 5]"]
+    264["Segment<br>[4687, 4736, 5]"]
-    265["Segment<br>[4741, 4774, 5]"]
+    265["Segment<br>[4742, 4775, 5]"]
-    266["Segment<br>[4780, 4814, 5]"]
+    266["Segment<br>[4781, 4815, 5]"]
-    267["Segment<br>[4820, 4854, 5]"]
+    267["Segment<br>[4821, 4855, 5]"]
-    268["Segment<br>[4860, 4912, 5]"]
+    268["Segment<br>[4861, 4913, 5]"]
-    269["Segment<br>[4918, 4952, 5]"]
+    269["Segment<br>[4919, 4953, 5]"]
-    270["Segment<br>[4958, 5034, 5]"]
+    270["Segment<br>[4959, 5035, 5]"]
-    271["Segment<br>[5040, 5073, 5]"]
+    271["Segment<br>[5041, 5074, 5]"]
-    272["Segment<br>[5079, 5155, 5]"]
+    272["Segment<br>[5080, 5156, 5]"]
-    273["Segment<br>[5161, 5195, 5]"]
+    273["Segment<br>[5162, 5196, 5]"]
-    274["Segment<br>[5201, 5275, 5]"]
+    274["Segment<br>[5202, 5276, 5]"]
-    275["Segment<br>[5281, 5315, 5]"]
+    275["Segment<br>[5282, 5316, 5]"]
-    276["Segment<br>[5321, 5372, 5]"]
+    276["Segment<br>[5322, 5373, 5]"]
-    277["Segment<br>[5378, 5440, 5]"]
+    277["Segment<br>[5379, 5441, 5]"]
-    278["Segment<br>[5446, 5497, 5]"]
+    278["Segment<br>[5447, 5498, 5]"]
-    279["Segment<br>[5503, 5537, 5]"]
+    279["Segment<br>[5504, 5538, 5]"]
-    280["Segment<br>[5543, 5576, 5]"]
+    280["Segment<br>[5544, 5577, 5]"]
-    281["Segment<br>[5582, 5615, 5]"]
+    281["Segment<br>[5583, 5616, 5]"]
-    282["Segment<br>[5621, 5628, 5]"]
+    282["Segment<br>[5622, 5629, 5]"]
     283[Solid2d]
   end
   subgraph path334 [Path]
-    334["Path<br>[744, 784, 8]"]
+    334["Path<br>[745, 785, 8]"]
-    335["Segment<br>[792, 854, 8]"]
+    335["Segment<br>[793, 855, 8]"]
-    336["Segment<br>[862, 898, 8]"]
+    336["Segment<br>[863, 899, 8]"]
-    337["Segment<br>[906, 936, 8]"]
+    337["Segment<br>[907, 937, 8]"]
-    338["Segment<br>[944, 996, 8]"]
+    338["Segment<br>[945, 998, 8]"]
-    339["Segment<br>[1004, 1044, 8]"]
+    339["Segment<br>[1006, 1046, 8]"]
-    340["Segment<br>[1052, 1087, 8]"]
+    340["Segment<br>[1054, 1089, 8]"]
-    341["Segment<br>[1095, 1133, 8]"]
+    341["Segment<br>[1097, 1135, 8]"]
-    342["Segment<br>[1141, 1163, 8]"]
+    342["Segment<br>[1143, 1165, 8]"]
-    343["Segment<br>[1171, 1178, 8]"]
+    343["Segment<br>[1173, 1180, 8]"]
     344[Solid2d]
   end
   subgraph path365 [Path]
@@ -315,16 +315,16 @@ flowchart LR
   164["Sweep Extrusion<br>[1110, 1144, 5]"]
   165["Sweep Extrusion<br>[1110, 1144, 5]"]
   166["Sweep Extrusion<br>[1110, 1144, 5]"]
-  170["Sweep Extrusion<br>[1448, 1482, 5]"]
+  170["Sweep Extrusion<br>[1449, 1483, 5]"]
   171[Wall]
   172["SweepEdge Opposite"]
   173["SweepEdge Adjacent"]
-  174["Sweep Extrusion<br>[1448, 1482, 5]"]
+  174["Sweep Extrusion<br>[1449, 1483, 5]"]
-  175["Sweep Extrusion<br>[1448, 1482, 5]"]
+  175["Sweep Extrusion<br>[1449, 1483, 5]"]
-  176["Sweep Extrusion<br>[1448, 1482, 5]"]
+  176["Sweep Extrusion<br>[1449, 1483, 5]"]
-  177["Sweep Extrusion<br>[1448, 1482, 5]"]
+  177["Sweep Extrusion<br>[1449, 1483, 5]"]
-  178["Plane<br>[1636, 1653, 5]"]
+  178["Plane<br>[1637, 1654, 5]"]
-  186["Sweep Revolve<br>[1983, 2000, 5]"]
+  186["Sweep Revolve<br>[1984, 2001, 5]"]
   187[Wall]
   188[Wall]
   189[Wall]
@@ -332,8 +332,8 @@ flowchart LR
   191["SweepEdge Adjacent"]
   192["SweepEdge Adjacent"]
   193["SweepEdge Adjacent"]
-  194["Plane<br>[2086, 2103, 5]"]
+  194["Plane<br>[2087, 2104, 5]"]
-  202["Sweep Revolve<br>[2450, 2467, 5]"]
+  202["Sweep Revolve<br>[2451, 2468, 5]"]
   203[Wall]
   204[Wall]
   205[Wall]
@@ -342,8 +342,8 @@ flowchart LR
   208["SweepEdge Adjacent"]
   209["SweepEdge Adjacent"]
   210["SweepEdge Adjacent"]
-  211["Plane<br>[2922, 2945, 5]"]
+  211["Plane<br>[2923, 2946, 5]"]
-  219["Sweep Extrusion<br>[3867, 3913, 5]"]
+  219["Sweep Extrusion<br>[3868, 3914, 5]"]
   220[Wall]
   221[Wall]
   222[Wall]
@@ -358,8 +358,8 @@ flowchart LR
   231["SweepEdge Adjacent"]
   232["SweepEdge Opposite"]
   233["SweepEdge Adjacent"]
-  234["Plane<br>[2922, 2945, 5]"]
+  234["Plane<br>[2923, 2946, 5]"]
-  242["Sweep Extrusion<br>[3867, 3913, 5]"]
+  242["Sweep Extrusion<br>[3868, 3914, 5]"]
   243[Wall]
   244[Wall]
   245[Wall]
@@ -374,8 +374,8 @@ flowchart LR
   254["SweepEdge Adjacent"]
   255["SweepEdge Opposite"]
   256["SweepEdge Adjacent"]
-  257["Plane<br>[4324, 4341, 5]"]
+  257["Plane<br>[4325, 4342, 5]"]
-  284["Sweep Revolve<br>[5634, 5651, 5]"]
+  284["Sweep Revolve<br>[5635, 5652, 5]"]
   285[Wall]
   286[Wall]
   287[Wall]
@@ -424,8 +424,8 @@ flowchart LR
   330["SweepEdge Adjacent"]
   331["SweepEdge Adjacent"]
   332["SweepEdge Adjacent"]
-  333["Plane<br>[710, 736, 8]"]
+  333["Plane<br>[711, 737, 8]"]
-  345["Sweep Revolve<br>[1186, 1203, 8]"]
+  345["Sweep Revolve<br>[1188, 1205, 8]"]
   346[Wall]
   347[Wall]
   348[Wall]

rust/kcl-lib/tests/kcl_samples/car-wheel-assembly/ops.snap

@@ -231,7 +231,13 @@ description: Operations executed car-wheel-assembly.kcl
           "type": "Number",
           "value": 0.5,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Inches"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -422,7 +428,13 @@ description: Operations executed car-wheel-assembly.kcl
           "type": "Number",
           "value": 0.5,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Inches"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -567,7 +579,8 @@ description: Operations executed car-wheel-assembly.kcl
           "type": "Number",
           "value": -0.125,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -646,7 +659,8 @@ description: Operations executed car-wheel-assembly.kcl
           "type": "Number",
           "value": -0.125,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -754,7 +768,8 @@ description: Operations executed car-wheel-assembly.kcl
           "type": "Number",
           "value": 0.475,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -830,7 +845,8 @@ description: Operations executed car-wheel-assembly.kcl
           "type": "Number",
           "value": 0.95,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -880,7 +896,8 @@ description: Operations executed car-wheel-assembly.kcl
           "type": "Number",
           "value": -0.95,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -959,7 +976,8 @@ description: Operations executed car-wheel-assembly.kcl
           "type": "Number",
           "value": -0.475,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -1215,8 +1233,8 @@ description: Operations executed car-wheel-assembly.kcl
       "type": "FunctionCall",
       "name": "spoke",
       "functionSourceRange": [
-        2620,
+        2621,
-        4193,
+        4194,
         5
       ],
       "unlabeledArg": null,
@@ -1266,7 +1284,8 @@ description: Operations executed car-wheel-assembly.kcl
                       "type": "Number",
                       "value": 0.1,
                       "ty": {
-                        "type": "Unknown"
+                        "type": "Known",
+                        "type": "Count"
                       }
                     }
                   ]
@@ -1605,8 +1624,8 @@ description: Operations executed car-wheel-assembly.kcl
       "type": "FunctionCall",
       "name": "spoke",
       "functionSourceRange": [
-        2620,
+        2621,
-        4193,
+        4194,
         5
       ],
       "unlabeledArg": null,
@@ -1656,7 +1675,8 @@ description: Operations executed car-wheel-assembly.kcl
                       "type": "Number",
                       "value": -0.1,
                       "ty": {
-                        "type": "Unknown"
+                        "type": "Known",
+                        "type": "Count"
                       }
                     }
                   ]
@@ -2108,8 +2128,8 @@ description: Operations executed car-wheel-assembly.kcl
       "type": "FunctionCall",
       "name": "lug",
       "functionSourceRange": [
-        668,
+        669,
-        1293,
+        1295,
         8
       ],
       "unlabeledArg": null,

rust/kcl-lib/tests/kcl_samples/car-wheel-assembly/program_memory.snap

@@ -302,7 +302,13 @@ description: Variables in memory after executing car-wheel-assembly.kcl
     "type": "Number",
     "value": 0.5,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Inches"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "spacerPatternDiameter": {

rust/kcl-lib/tests/kcl_samples/color-cube/ops.snap

@@ -10,7 +10,8 @@ description: Operations executed color-cube.kcl
           "type": "Number",
           "value": 50.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -34,7 +35,8 @@ description: Operations executed color-cube.kcl
           "type": "Number",
           "value": -50.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -58,7 +60,8 @@ description: Operations executed color-cube.kcl
           "type": "Number",
           "value": -50.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -82,7 +85,8 @@ description: Operations executed color-cube.kcl
           "type": "Number",
           "value": -50.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -106,7 +110,8 @@ description: Operations executed color-cube.kcl
           "type": "Number",
           "value": 49.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -130,7 +135,8 @@ description: Operations executed color-cube.kcl
           "type": "Number",
           "value": -50.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []

rust/kcl-lib/tests/kcl_samples/color-cube/program_memory.snap

@@ -82,7 +82,8 @@ description: Variables in memory after executing color-cube.kcl
     "type": "Number",
     "value": 50.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "metalConstant": {

rust/kcl-lib/tests/kcl_samples/cycloidal-gear/ops.snap

@@ -201,7 +201,8 @@ description: Operations executed cycloidal-gear.kcl
           "type": "Number",
           "value": 0.75,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []

rust/kcl-lib/tests/kcl_samples/dodecahedron/ops.snap

@@ -316,7 +316,13 @@ description: Operations executed dodecahedron.kcl
           "type": "Number",
           "value": 5.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Inches"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -342,7 +348,13 @@ description: Operations executed dodecahedron.kcl
           "type": "Number",
           "value": 5.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Inches"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []

rust/kcl-lib/tests/kcl_samples/dodecahedron/program_memory.snap

@@ -1947,7 +1947,13 @@ description: Variables in memory after executing dodecahedron.kcl
     "type": "Number",
     "value": 5.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Inches"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   }
 }

rust/kcl-lib/tests/kcl_samples/dual-basin-utility-sink/ops.snap

@@ -1000,7 +1000,8 @@ description: Operations executed dual-basin-utility-sink.kcl
           "type": "Number",
           "value": 564.5,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -1010,7 +1011,13 @@ description: Operations executed dual-basin-utility-sink.kcl
           "type": "Number",
           "value": 6.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []

rust/kcl-lib/tests/kcl_samples/dual-basin-utility-sink/program_memory.snap

@@ -59,14 +59,16 @@ description: Variables in memory after executing dual-basin-utility-sink.kcl
     "type": "Number",
     "value": 564.5,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "blockWidth": {
     "type": "Number",
     "value": 1129.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "doorBody": {
@@ -1115,7 +1117,13 @@ description: Variables in memory after executing dual-basin-utility-sink.kcl
     "type": "Number",
     "value": 6.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Mm"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "doorGap": {
@@ -1205,7 +1213,8 @@ description: Variables in memory after executing dual-basin-utility-sink.kcl
     "type": "Number",
     "value": 547.5,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "floorPlane": {
@@ -1936,14 +1945,21 @@ description: Variables in memory after executing dual-basin-utility-sink.kcl
     "type": "Number",
     "value": 80.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Mm"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "handleOffset": {
     "type": "Number",
     "value": 228.75,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "handlePlane": {
@@ -5106,7 +5122,8 @@ description: Variables in memory after executing dual-basin-utility-sink.kcl
     "type": "Number",
     "value": 1116.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "lowerBeltLengthY": {
@@ -5540,7 +5557,13 @@ description: Variables in memory after executing dual-basin-utility-sink.kcl
     "type": "Number",
     "value": 7.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Mm"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "panelSpacing": {
@@ -5560,7 +5583,13 @@ description: Variables in memory after executing dual-basin-utility-sink.kcl
     "type": "Number",
     "value": 370.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Mm"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "pillarBody": {
@@ -8738,7 +8767,13 @@ description: Variables in memory after executing dual-basin-utility-sink.kcl
     "type": "Number",
     "value": 1700.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Mm"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "sinkWidth": {

rust/kcl-lib/tests/kcl_samples/enclosure/ops.snap

@@ -57,7 +57,13 @@ description: Operations executed enclosure.kcl
           "type": "Number",
           "value": 12.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -1394,7 +1400,13 @@ description: Operations executed enclosure.kcl
           "type": "Number",
           "value": 12.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -1604,7 +1616,13 @@ description: Operations executed enclosure.kcl
           "type": "Number",
           "value": 9.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []

rust/kcl-lib/tests/kcl_samples/exhaust-manifold/ops.snap

@@ -70,7 +70,13 @@ description: Operations executed exhaust-manifold.kcl
                       "type": "Number",
                       "value": 0.0,
                       "ty": {
-                        "type": "Unknown"
+                        "type": "Default",
+                        "len": {
+                          "type": "Inches"
+                        },
+                        "angle": {
+                          "type": "Degrees"
+                        }
                       }
                     },
                     {
@@ -371,7 +377,13 @@ description: Operations executed exhaust-manifold.kcl
                       "type": "Number",
                       "value": 2.0,
                       "ty": {
-                        "type": "Unknown"
+                        "type": "Default",
+                        "len": {
+                          "type": "Inches"
+                        },
+                        "angle": {
+                          "type": "Degrees"
+                        }
                       }
                     },
                     {
@@ -672,7 +684,13 @@ description: Operations executed exhaust-manifold.kcl
                       "type": "Number",
                       "value": 4.0,
                       "ty": {
-                        "type": "Unknown"
+                        "type": "Default",
+                        "len": {
+                          "type": "Inches"
+                        },
+                        "angle": {
+                          "type": "Degrees"
+                        }
                       }
                     },
                     {
@@ -973,7 +991,13 @@ description: Operations executed exhaust-manifold.kcl
                       "type": "Number",
                       "value": 6.0,
                       "ty": {
-                        "type": "Unknown"
+                        "type": "Default",
+                        "len": {
+                          "type": "Inches"
+                        },
+                        "angle": {
+                          "type": "Degrees"
+                        }
                       }
                     },
                     {

rust/kcl-lib/tests/kcl_samples/focusrite-scarlett-mounting-bracket/ops.snap

@@ -47,7 +47,8 @@ description: Operations executed focusrite-scarlett-mounting-bracket.kcl
                       "type": "Number",
                       "value": 44.0,
                       "ty": {
-                        "type": "Unknown"
+                        "type": "Known",
+                        "type": "Count"
                       }
                     },
                     "z": {
@@ -219,7 +220,13 @@ description: Operations executed focusrite-scarlett-mounting-bracket.kcl
           "type": "Number",
           "value": 88.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -556,7 +563,8 @@ description: Operations executed focusrite-scarlett-mounting-bracket.kcl
           "type": "Number",
           "value": 2.5,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -645,7 +653,8 @@ description: Operations executed focusrite-scarlett-mounting-bracket.kcl
           "type": "Number",
           "value": 54.666666666666664,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -942,7 +951,8 @@ description: Operations executed focusrite-scarlett-mounting-bracket.kcl
           "type": "Number",
           "value": 2.5,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -1031,7 +1041,8 @@ description: Operations executed focusrite-scarlett-mounting-bracket.kcl
           "type": "Number",
           "value": 54.666666666666664,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -1082,7 +1093,8 @@ description: Operations executed focusrite-scarlett-mounting-bracket.kcl
                       "type": "Number",
                       "value": -52.0,
                       "ty": {
-                        "type": "Unknown"
+                        "type": "Known",
+                        "type": "Count"
                       }
                     },
                     "y": {
@@ -1305,7 +1317,8 @@ description: Operations executed focusrite-scarlett-mounting-bracket.kcl
                       "type": "Number",
                       "value": -52.0,
                       "ty": {
-                        "type": "Unknown"
+                        "type": "Known",
+                        "type": "Count"
                       }
                     },
                     "y": {

rust/kcl-lib/tests/kcl_samples/focusrite-scarlett-mounting-bracket/program_memory.snap

@@ -471,7 +471,8 @@ description: Variables in memory after executing focusrite-scarlett-mounting-bra
                 "type": "Number",
                 "value": 44.0,
                 "ty": {
-                  "type": "Unknown"
+                  "type": "Known",
+                  "type": "Count"
                 }
               },
               "z": {
@@ -1401,7 +1402,8 @@ description: Variables in memory after executing focusrite-scarlett-mounting-bra
                 "type": "Number",
                 "value": -52.0,
                 "ty": {
-                  "type": "Unknown"
+                  "type": "Known",
+                  "type": "Count"
                 }
               },
               "y": {

rust/kcl-lib/tests/kcl_samples/food-service-spatula/ops.snap

@@ -345,7 +345,8 @@ description: Operations executed food-service-spatula.kcl
           "type": "Number",
           "value": -7.5,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []

rust/kcl-lib/tests/kcl_samples/french-press/ops.snap

@@ -1334,7 +1334,8 @@ description: Operations executed french-press.kcl
           "type": "Number",
           "value": 0.325,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []

rust/kcl-lib/tests/kcl_samples/gridfinity-baseplate-magnets/ops.snap

@@ -73,7 +73,13 @@ description: Operations executed gridfinity-baseplate-magnets.kcl
           "type": "Number",
           "value": 34.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -165,14 +171,16 @@ description: Operations executed gridfinity-baseplate-magnets.kcl
               "type": "Number",
               "value": 21.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Known",
+                "type": "Count"
               }
             },
             {
               "type": "Number",
               "value": 21.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Known",
+                "type": "Count"
               }
             },
             {
@@ -472,14 +480,16 @@ description: Operations executed gridfinity-baseplate-magnets.kcl
               "type": "Number",
               "value": 21.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Known",
+                "type": "Count"
               }
             },
             {
               "type": "Number",
               "value": 21.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Known",
+                "type": "Count"
               }
             },
             {

rust/kcl-lib/tests/kcl_samples/gridfinity-baseplate/ops.snap

@@ -73,7 +73,13 @@ description: Operations executed gridfinity-baseplate.kcl
           "type": "Number",
           "value": 34.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -165,14 +171,16 @@ description: Operations executed gridfinity-baseplate.kcl
               "type": "Number",
               "value": 21.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Known",
+                "type": "Count"
               }
             },
             {
               "type": "Number",
               "value": 21.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Known",
+                "type": "Count"
               }
             },
             {
@@ -472,14 +480,16 @@ description: Operations executed gridfinity-baseplate.kcl
               "type": "Number",
               "value": 21.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Known",
+                "type": "Count"
               }
             },
             {
               "type": "Number",
               "value": 21.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Known",
+                "type": "Count"
               }
             },
             {

rust/kcl-lib/tests/kcl_samples/gridfinity-bins-stacking-lip/ops.snap

@@ -73,7 +73,13 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
           "type": "Number",
           "value": 34.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -165,14 +171,16 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
               "type": "Number",
               "value": 21.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Known",
+                "type": "Count"
               }
             },
             {
               "type": "Number",
               "value": 21.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Known",
+                "type": "Count"
               }
             },
             {
@@ -472,14 +480,16 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
               "type": "Number",
               "value": 21.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Known",
+                "type": "Count"
               }
             },
             {
               "type": "Number",
               "value": 21.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Known",
+                "type": "Count"
               }
             },
             {
@@ -772,7 +782,13 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
           "type": "Number",
           "value": 42.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -884,7 +900,13 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
           "type": "Number",
           "value": 42.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -1020,7 +1042,13 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
           "type": "Number",
           "value": 42.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -1132,7 +1160,13 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
           "type": "Number",
           "value": 42.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -1268,7 +1302,13 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
           "type": "Number",
           "value": 42.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -1357,7 +1397,13 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
           "type": "Number",
           "value": 42.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -1455,7 +1501,13 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
           "type": "Number",
           "value": 7.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -1631,7 +1683,13 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
                       "type": "Number",
                       "value": 11.75,
                       "ty": {
-                        "type": "Unknown"
+                        "type": "Default",
+                        "len": {
+                          "type": "Mm"
+                        },
+                        "angle": {
+                          "type": "Degrees"
+                        }
                       }
                     }
                   ]
@@ -1790,7 +1848,13 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
           "type": "Number",
           "value": 76.5,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -1866,7 +1930,13 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
                       "type": "Number",
                       "value": 11.75,
                       "ty": {
-                        "type": "Unknown"
+                        "type": "Default",
+                        "len": {
+                          "type": "Mm"
+                        },
+                        "angle": {
+                          "type": "Degrees"
+                        }
                       }
                     }
                   ]
@@ -2025,7 +2095,13 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
           "type": "Number",
           "value": 118.5,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -2117,14 +2193,26 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
               "type": "Number",
               "value": 42.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Default",
+                "len": {
+                  "type": "Mm"
+                },
+                "angle": {
+                  "type": "Degrees"
+                }
               }
             },
             {
               "type": "Number",
               "value": 63.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Default",
+                "len": {
+                  "type": "Mm"
+                },
+                "angle": {
+                  "type": "Degrees"
+                }
               }
             },
             {
@@ -2254,14 +2342,26 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
               "type": "Number",
               "value": 42.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Default",
+                "len": {
+                  "type": "Mm"
+                },
+                "angle": {
+                  "type": "Degrees"
+                }
               }
             },
             {
               "type": "Number",
               "value": 63.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Default",
+                "len": {
+                  "type": "Mm"
+                },
+                "angle": {
+                  "type": "Degrees"
+                }
               }
             },
             {
@@ -2375,7 +2475,13 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
                       "type": "Number",
                       "value": 11.75,
                       "ty": {
-                        "type": "Unknown"
+                        "type": "Default",
+                        "len": {
+                          "type": "Mm"
+                        },
+                        "angle": {
+                          "type": "Degrees"
+                        }
                       }
                     }
                   ]
@@ -2665,7 +2771,13 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
                       "type": "Number",
                       "value": 80.25,
                       "ty": {
-                        "type": "Unknown"
+                        "type": "Default",
+                        "len": {
+                          "type": "Mm"
+                        },
+                        "angle": {
+                          "type": "Degrees"
+                        }
                       }
                     },
                     {
@@ -2685,7 +2797,13 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
                       "type": "Number",
                       "value": 11.75,
                       "ty": {
-                        "type": "Unknown"
+                        "type": "Default",
+                        "len": {
+                          "type": "Mm"
+                        },
+                        "angle": {
+                          "type": "Degrees"
+                        }
                       }
                     }
                   ]
@@ -3017,14 +3135,26 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
               "type": "Number",
               "value": 42.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Default",
+                "len": {
+                  "type": "Mm"
+                },
+                "angle": {
+                  "type": "Degrees"
+                }
               }
             },
             {
               "type": "Number",
               "value": 63.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Default",
+                "len": {
+                  "type": "Mm"
+                },
+                "angle": {
+                  "type": "Degrees"
+                }
               }
             },
             {
@@ -3154,14 +3284,26 @@ description: Operations executed gridfinity-bins-stacking-lip.kcl
               "type": "Number",
               "value": 42.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Default",
+                "len": {
+                  "type": "Mm"
+                },
+                "angle": {
+                  "type": "Degrees"
+                }
               }
             },
             {
               "type": "Number",
               "value": 63.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Default",
+                "len": {
+                  "type": "Mm"
+                },
+                "angle": {
+                  "type": "Degrees"
+                }
               }
             },
             {

rust/kcl-lib/tests/kcl_samples/gridfinity-bins-stacking-lip/program_memory.snap

@@ -19603,7 +19603,13 @@ description: Variables in memory after executing gridfinity-bins-stacking-lip.kc
                 "type": "Number",
                 "value": 11.75,
                 "ty": {
-                  "type": "Unknown"
+                  "type": "Default",
+                  "len": {
+                    "type": "Mm"
+                  },
+                  "angle": {
+                    "type": "Degrees"
+                  }
                 }
               }
             ]
@@ -19783,7 +19789,13 @@ description: Variables in memory after executing gridfinity-bins-stacking-lip.kc
                 "type": "Number",
                 "value": 11.75,
                 "ty": {
-                  "type": "Unknown"
+                  "type": "Default",
+                  "len": {
+                    "type": "Mm"
+                  },
+                  "angle": {
+                    "type": "Degrees"
+                  }
                 }
               }
             ]
@@ -19937,7 +19949,13 @@ description: Variables in memory after executing gridfinity-bins-stacking-lip.kc
                 "type": "Number",
                 "value": 80.25,
                 "ty": {
-                  "type": "Unknown"
+                  "type": "Default",
+                  "len": {
+                    "type": "Mm"
+                  },
+                  "angle": {
+                    "type": "Degrees"
+                  }
                 }
               },
               {
@@ -19957,7 +19975,13 @@ description: Variables in memory after executing gridfinity-bins-stacking-lip.kc
                 "type": "Number",
                 "value": 11.75,
                 "ty": {
-                  "type": "Unknown"
+                  "type": "Default",
+                  "len": {
+                    "type": "Mm"
+                  },
+                  "angle": {
+                    "type": "Degrees"
+                  }
                 }
               }
             ]

rust/kcl-lib/tests/kcl_samples/gridfinity-bins/ops.snap

@@ -73,7 +73,13 @@ description: Operations executed gridfinity-bins.kcl
           "type": "Number",
           "value": 34.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -165,14 +171,16 @@ description: Operations executed gridfinity-bins.kcl
               "type": "Number",
               "value": 21.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Known",
+                "type": "Count"
               }
             },
             {
               "type": "Number",
               "value": 21.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Known",
+                "type": "Count"
               }
             },
             {
@@ -472,14 +480,16 @@ description: Operations executed gridfinity-bins.kcl
               "type": "Number",
               "value": 21.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Known",
+                "type": "Count"
               }
             },
             {
               "type": "Number",
               "value": 21.0,
               "ty": {
-                "type": "Unknown"
+                "type": "Known",
+                "type": "Count"
               }
             },
             {
@@ -772,7 +782,13 @@ description: Operations executed gridfinity-bins.kcl
           "type": "Number",
           "value": 42.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -884,7 +900,13 @@ description: Operations executed gridfinity-bins.kcl
           "type": "Number",
           "value": 42.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -1020,7 +1042,13 @@ description: Operations executed gridfinity-bins.kcl
           "type": "Number",
           "value": 42.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -1132,7 +1160,13 @@ description: Operations executed gridfinity-bins.kcl
           "type": "Number",
           "value": 42.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -1268,7 +1302,13 @@ description: Operations executed gridfinity-bins.kcl
           "type": "Number",
           "value": 42.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -1357,7 +1397,13 @@ description: Operations executed gridfinity-bins.kcl
           "type": "Number",
           "value": 42.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -1455,7 +1501,13 @@ description: Operations executed gridfinity-bins.kcl
           "type": "Number",
           "value": 14.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []

rust/kcl-lib/tests/kcl_samples/i-beam/artifact_commands.snap

@@ -267,7 +267,7 @@ description: Artifact commands i-beam.kcl
     "command": {
       "type": "extrude",
       "target": "[uuid]",
-      "distance": 72.00000000000001,
+      "distance": 72.0,
       "faces": null
     }
   },

rust/kcl-lib/tests/kcl_samples/i-beam/artifact_graph_flowchart.snap.md

@@ -1,15 +1,15 @@
 ```mermaid
 flowchart LR
   subgraph path2 [Path]
-    2["Path<br>[462, 500, 0]"]
+    2["Path<br>[463, 501, 0]"]
-    3["Segment<br>[506, 537, 0]"]
+    3["Segment<br>[507, 538, 0]"]
-    4["Segment<br>[543, 575, 0]"]
+    4["Segment<br>[544, 576, 0]"]
-    5["Segment<br>[581, 631, 0]"]
+    5["Segment<br>[582, 632, 0]"]
-    6["Segment<br>[637, 691, 0]"]
+    6["Segment<br>[638, 692, 0]"]
-    7["Segment<br>[697, 719, 0]"]
+    7["Segment<br>[698, 720, 0]"]
   end
-  1["Plane<br>[438, 456, 0]"]
+  1["Plane<br>[439, 457, 0]"]
-  8["Sweep Extrusion<br>[773, 801, 0]"]
+  8["Sweep Extrusion<br>[774, 802, 0]"]
   1 --- 2
   2 --- 3
   2 --- 4

rust/kcl-lib/tests/kcl_samples/i-beam/ast.snap

@@ -18,10 +18,9 @@ description: Result of parsing i-beam.kcl
             "type": "Identifier"
           },
           "init": {
-            "commentStart": 196,
+            "arguments": [
-            "end": 0,
+              {
-            "left": {
+                "commentStart": 203,
-              "commentStart": 196,
                 "end": 0,
                 "raw": "6",
                 "start": 0,
@@ -31,18 +30,16 @@ description: Result of parsing i-beam.kcl
                   "value": 6.0,
                   "suffix": "None"
                 }
-            },
+              }
-            "operator": "*",
+            ],
-            "right": {
-              "arguments": [],
             "callee": {
               "abs_path": false,
-                "commentStart": 200,
+              "commentStart": 196,
               "end": 0,
               "name": {
-                  "commentStart": 200,
+                "commentStart": 196,
                 "end": 0,
-                  "name": "ft",
+                "name": "fromFt",
                 "start": 0,
                 "type": "Identifier"
               },
@@ -50,17 +47,13 @@ description: Result of parsing i-beam.kcl
               "start": 0,
               "type": "Name"
             },
-              "commentStart": 200,
+            "commentStart": 196,
             "end": 0,
             "start": 0,
             "type": "CallExpression",
             "type": "CallExpression"
           },
           "start": 0,
-            "type": "BinaryExpression",
-            "type": "BinaryExpression"
-          },
-          "start": 0,
           "type": "VariableDeclarator"
         },
         "end": 0,
@@ -73,19 +66,19 @@ description: Result of parsing i-beam.kcl
         "type": "VariableDeclaration"
       },
       {
-        "commentStart": 205,
+        "commentStart": 206,
         "declaration": {
-          "commentStart": 205,
+          "commentStart": 206,
           "end": 0,
           "id": {
-            "commentStart": 205,
+            "commentStart": 206,
             "end": 0,
             "name": "beamHeight",
             "start": 0,
             "type": "Identifier"
           },
           "init": {
-            "commentStart": 218,
+            "commentStart": 219,
             "end": 0,
             "raw": "4",
             "start": 0,
@@ -106,19 +99,19 @@ description: Result of parsing i-beam.kcl
         "type": "VariableDeclaration"
       },
       {
-        "commentStart": 220,
+        "commentStart": 221,
         "declaration": {
-          "commentStart": 220,
+          "commentStart": 221,
           "end": 0,
           "id": {
-            "commentStart": 220,
+            "commentStart": 221,
             "end": 0,
             "name": "flangeWidth",
             "start": 0,
             "type": "Identifier"
           },
           "init": {
-            "commentStart": 234,
+            "commentStart": 235,
             "end": 0,
             "raw": "2.663",
             "start": 0,
@@ -139,19 +132,19 @@ description: Result of parsing i-beam.kcl
         "type": "VariableDeclaration"
       },
       {
-        "commentStart": 240,
+        "commentStart": 241,
         "declaration": {
-          "commentStart": 240,
+          "commentStart": 241,
           "end": 0,
           "id": {
-            "commentStart": 240,
+            "commentStart": 241,
             "end": 0,
             "name": "flangeThickness",
             "start": 0,
             "type": "Identifier"
           },
           "init": {
-            "commentStart": 258,
+            "commentStart": 259,
             "end": 0,
             "raw": "0.293",
             "start": 0,
@@ -172,19 +165,19 @@ description: Result of parsing i-beam.kcl
         "type": "VariableDeclaration"
       },
       {
-        "commentStart": 264,
+        "commentStart": 265,
         "declaration": {
-          "commentStart": 264,
+          "commentStart": 265,
           "end": 0,
           "id": {
-            "commentStart": 264,
+            "commentStart": 265,
             "end": 0,
             "name": "webThickness",
             "start": 0,
             "type": "Identifier"
           },
           "init": {
-            "commentStart": 279,
+            "commentStart": 280,
             "end": 0,
             "raw": "0.193",
             "start": 0,
@@ -205,19 +198,19 @@ description: Result of parsing i-beam.kcl
         "type": "VariableDeclaration"
       },
       {
-        "commentStart": 285,
+        "commentStart": 286,
         "declaration": {
-          "commentStart": 285,
+          "commentStart": 286,
           "end": 0,
           "id": {
-            "commentStart": 285,
+            "commentStart": 286,
             "end": 0,
             "name": "rootRadius",
             "start": 0,
             "type": "Identifier"
           },
           "init": {
-            "commentStart": 298,
+            "commentStart": 299,
             "end": 0,
             "raw": "0.457",
             "start": 0,
@@ -238,12 +231,12 @@ description: Result of parsing i-beam.kcl
         "type": "VariableDeclaration"
       },
       {
-        "commentStart": 303,
+        "commentStart": 304,
         "declaration": {
-          "commentStart": 430,
+          "commentStart": 431,
           "end": 0,
           "id": {
-            "commentStart": 430,
+            "commentStart": 431,
             "end": 0,
             "name": "iBeam",
             "start": 0,
@@ -256,10 +249,10 @@ description: Result of parsing i-beam.kcl
                   {
                     "argument": {
                       "abs_path": false,
-                      "commentStart": 453,
+                      "commentStart": 454,
                       "end": 0,
                       "name": {
-                        "commentStart": 453,
+                        "commentStart": 454,
                         "end": 0,
                         "name": "XZ",
                         "start": 0,
@@ -270,7 +263,7 @@ description: Result of parsing i-beam.kcl
                       "type": "Name",
                       "type": "Name"
                     },
-                    "commentStart": 452,
+                    "commentStart": 453,
                     "end": 0,
                     "operator": "-",
                     "start": 0,
@@ -280,10 +273,10 @@ description: Result of parsing i-beam.kcl
                 ],
                 "callee": {
                   "abs_path": false,
-                  "commentStart": 438,
+                  "commentStart": 439,
                   "end": 0,
                   "name": {
-                    "commentStart": 438,
+                    "commentStart": 439,
                     "end": 0,
                     "name": "startSketchOn",
                     "start": 0,
@@ -293,7 +286,7 @@ description: Result of parsing i-beam.kcl
                   "start": 0,
                   "type": "Name"
                 },
-                "commentStart": 438,
+                "commentStart": 439,
                 "end": 0,
                 "start": 0,
                 "type": "CallExpression",
@@ -302,10 +295,10 @@ description: Result of parsing i-beam.kcl
               {
                 "arguments": [
                   {
-                    "commentStart": 477,
+                    "commentStart": 478,
                     "elements": [
                       {
-                        "commentStart": 478,
+                        "commentStart": 479,
                         "end": 0,
                         "raw": "0",
                         "start": 0,
@@ -317,14 +310,14 @@ description: Result of parsing i-beam.kcl
                         }
                       },
                       {
-                        "commentStart": 481,
+                        "commentStart": 482,
                         "end": 0,
                         "left": {
                           "abs_path": false,
-                          "commentStart": 481,
+                          "commentStart": 482,
                           "end": 0,
                           "name": {
-                            "commentStart": 481,
+                            "commentStart": 482,
                             "end": 0,
                             "name": "beamHeight",
                             "start": 0,
@@ -337,7 +330,7 @@ description: Result of parsing i-beam.kcl
                         },
                         "operator": "/",
                         "right": {
-                          "commentStart": 494,
+                          "commentStart": 495,
                           "end": 0,
                           "raw": "2",
                           "start": 0,
@@ -359,7 +352,7 @@ description: Result of parsing i-beam.kcl
                     "type": "ArrayExpression"
                   },
                   {
-                    "commentStart": 498,
+                    "commentStart": 499,
                     "end": 0,
                     "start": 0,
                     "type": "PipeSubstitution",
@@ -368,10 +361,10 @@ description: Result of parsing i-beam.kcl
                 ],
                 "callee": {
                   "abs_path": false,
-                  "commentStart": 462,
+                  "commentStart": 463,
                   "end": 0,
                   "name": {
-                    "commentStart": 462,
+                    "commentStart": 463,
                     "end": 0,
                     "name": "startProfileAt",
                     "start": 0,
@@ -381,7 +374,7 @@ description: Result of parsing i-beam.kcl
                   "start": 0,
                   "type": "Name"
                 },
-                "commentStart": 462,
+                "commentStart": 463,
                 "end": 0,
                 "start": 0,
                 "type": "CallExpression",
@@ -392,21 +385,21 @@ description: Result of parsing i-beam.kcl
                   {
                     "type": "LabeledArg",
                     "label": {
-                      "commentStart": 512,
+                      "commentStart": 513,
                       "end": 0,
                       "name": "length",
                       "start": 0,
                       "type": "Identifier"
                     },
                     "arg": {
-                      "commentStart": 521,
+                      "commentStart": 522,
                       "end": 0,
                       "left": {
                         "abs_path": false,
-                        "commentStart": 521,
+                        "commentStart": 522,
                         "end": 0,
                         "name": {
-                          "commentStart": 521,
+                          "commentStart": 522,
                           "end": 0,
                           "name": "flangeWidth",
                           "start": 0,
@@ -419,7 +412,7 @@ description: Result of parsing i-beam.kcl
                       },
                       "operator": "/",
                       "right": {
-                        "commentStart": 535,
+                        "commentStart": 536,
                         "end": 0,
                         "raw": "2",
                         "start": 0,
@@ -438,10 +431,10 @@ description: Result of parsing i-beam.kcl
                 ],
                 "callee": {
                   "abs_path": false,
-                  "commentStart": 506,
+                  "commentStart": 507,
                   "end": 0,
                   "name": {
-                    "commentStart": 506,
+                    "commentStart": 507,
                     "end": 0,
                     "name": "xLine",
                     "start": 0,
@@ -451,7 +444,7 @@ description: Result of parsing i-beam.kcl
                   "start": 0,
                   "type": "Name"
                 },
-                "commentStart": 506,
+                "commentStart": 507,
                 "end": 0,
                 "start": 0,
                 "type": "CallExpressionKw",
@@ -463,7 +456,7 @@ description: Result of parsing i-beam.kcl
                   {
                     "type": "LabeledArg",
                     "label": {
-                      "commentStart": 549,
+                      "commentStart": 550,
                       "end": 0,
                       "name": "length",
                       "start": 0,
@@ -472,10 +465,10 @@ description: Result of parsing i-beam.kcl
                     "arg": {
                       "argument": {
                         "abs_path": false,
-                        "commentStart": 559,
+                        "commentStart": 560,
                         "end": 0,
                         "name": {
-                          "commentStart": 559,
+                          "commentStart": 560,
                           "end": 0,
                           "name": "flangeThickness",
                           "start": 0,
@@ -486,7 +479,7 @@ description: Result of parsing i-beam.kcl
                         "type": "Name",
                         "type": "Name"
                       },
-                      "commentStart": 558,
+                      "commentStart": 559,
                       "end": 0,
                       "operator": "-",
                       "start": 0,
@@ -497,10 +490,10 @@ description: Result of parsing i-beam.kcl
                 ],
                 "callee": {
                   "abs_path": false,
-                  "commentStart": 543,
+                  "commentStart": 544,
                   "end": 0,
                   "name": {
-                    "commentStart": 543,
+                    "commentStart": 544,
                     "end": 0,
                     "name": "yLine",
                     "start": 0,
@@ -510,7 +503,7 @@ description: Result of parsing i-beam.kcl
                   "start": 0,
                   "type": "Name"
                 },
-                "commentStart": 543,
+                "commentStart": 544,
                 "end": 0,
                 "start": 0,
                 "type": "CallExpressionKw",
@@ -522,24 +515,24 @@ description: Result of parsing i-beam.kcl
                   {
                     "type": "LabeledArg",
                     "label": {
-                      "commentStart": 587,
+                      "commentStart": 588,
                       "end": 0,
                       "name": "endAbsolute",
                       "start": 0,
                       "type": "Identifier"
                     },
                     "arg": {
-                      "commentStart": 601,
+                      "commentStart": 602,
                       "end": 0,
                       "left": {
-                        "commentStart": 601,
+                        "commentStart": 602,
                         "end": 0,
                         "left": {
                           "abs_path": false,
-                          "commentStart": 601,
+                          "commentStart": 602,
                           "end": 0,
                           "name": {
-                            "commentStart": 601,
+                            "commentStart": 602,
                             "end": 0,
                             "name": "webThickness",
                             "start": 0,
@@ -552,7 +545,7 @@ description: Result of parsing i-beam.kcl
                         },
                         "operator": "/",
                         "right": {
-                          "commentStart": 616,
+                          "commentStart": 617,
                           "end": 0,
                           "raw": "2",
                           "start": 0,
@@ -570,10 +563,10 @@ description: Result of parsing i-beam.kcl
                       "operator": "+",
                       "right": {
                         "abs_path": false,
-                        "commentStart": 620,
+                        "commentStart": 621,
                         "end": 0,
                         "name": {
-                          "commentStart": 620,
+                          "commentStart": 621,
                           "end": 0,
                           "name": "rootRadius",
                           "start": 0,
@@ -592,10 +585,10 @@ description: Result of parsing i-beam.kcl
                 ],
                 "callee": {
                   "abs_path": false,
-                  "commentStart": 581,
+                  "commentStart": 582,
                   "end": 0,
                   "name": {
-                    "commentStart": 581,
+                    "commentStart": 582,
                     "end": 0,
                     "name": "xLine",
                     "start": 0,
@@ -605,7 +598,7 @@ description: Result of parsing i-beam.kcl
                   "start": 0,
                   "type": "Name"
                 },
-                "commentStart": 581,
+                "commentStart": 582,
                 "end": 0,
                 "start": 0,
                 "type": "CallExpressionKw",
@@ -615,14 +608,14 @@ description: Result of parsing i-beam.kcl
               {
                 "arguments": [
                   {
-                    "commentStart": 651,
+                    "commentStart": 652,
                     "end": 0,
                     "properties": [
                       {
-                        "commentStart": 653,
+                        "commentStart": 654,
                         "end": 0,
                         "key": {
-                          "commentStart": 653,
+                          "commentStart": 654,
                           "end": 0,
                           "name": "radius",
                           "start": 0,
@@ -632,10 +625,10 @@ description: Result of parsing i-beam.kcl
                         "type": "ObjectProperty",
                         "value": {
                           "abs_path": false,
-                          "commentStart": 662,
+                          "commentStart": 663,
                           "end": 0,
                           "name": {
-                            "commentStart": 662,
+                            "commentStart": 663,
                             "end": 0,
                             "name": "rootRadius",
                             "start": 0,
@@ -648,10 +641,10 @@ description: Result of parsing i-beam.kcl
                         }
                       },
                       {
-                        "commentStart": 674,
+                        "commentStart": 675,
                         "end": 0,
                         "key": {
-                          "commentStart": 674,
+                          "commentStart": 675,
                           "end": 0,
                           "name": "offset",
                           "start": 0,
@@ -660,7 +653,7 @@ description: Result of parsing i-beam.kcl
                         "start": 0,
                         "type": "ObjectProperty",
                         "value": {
-                          "commentStart": 683,
+                          "commentStart": 684,
                           "end": 0,
                           "raw": "90",
                           "start": 0,
@@ -678,7 +671,7 @@ description: Result of parsing i-beam.kcl
                     "type": "ObjectExpression"
                   },
                   {
-                    "commentStart": 689,
+                    "commentStart": 690,
                     "end": 0,
                     "start": 0,
                     "type": "PipeSubstitution",
@@ -687,10 +680,10 @@ description: Result of parsing i-beam.kcl
                 ],
                 "callee": {
                   "abs_path": false,
-                  "commentStart": 637,
+                  "commentStart": 638,
                   "end": 0,
                   "name": {
-                    "commentStart": 637,
+                    "commentStart": 638,
                     "end": 0,
                     "name": "tangentialArc",
                     "start": 0,
@@ -700,7 +693,7 @@ description: Result of parsing i-beam.kcl
                   "start": 0,
                   "type": "Name"
                 },
-                "commentStart": 637,
+                "commentStart": 638,
                 "end": 0,
                 "start": 0,
                 "type": "CallExpression",
@@ -711,14 +704,14 @@ description: Result of parsing i-beam.kcl
                   {
                     "type": "LabeledArg",
                     "label": {
-                      "commentStart": 703,
+                      "commentStart": 704,
                       "end": 0,
                       "name": "endAbsolute",
                       "start": 0,
                       "type": "Identifier"
                     },
                     "arg": {
-                      "commentStart": 717,
+                      "commentStart": 718,
                       "end": 0,
                       "raw": "0",
                       "start": 0,
@@ -733,10 +726,10 @@ description: Result of parsing i-beam.kcl
                 ],
                 "callee": {
                   "abs_path": false,
-                  "commentStart": 697,
+                  "commentStart": 698,
                   "end": 0,
                   "name": {
-                    "commentStart": 697,
+                    "commentStart": 698,
                     "end": 0,
                     "name": "yLine",
                     "start": 0,
@@ -746,7 +739,7 @@ description: Result of parsing i-beam.kcl
                   "start": 0,
                   "type": "Name"
                 },
-                "commentStart": 697,
+                "commentStart": 698,
                 "end": 0,
                 "start": 0,
                 "type": "CallExpressionKw",
@@ -758,7 +751,7 @@ description: Result of parsing i-beam.kcl
                   {
                     "type": "LabeledArg",
                     "label": {
-                      "commentStart": 734,
+                      "commentStart": 735,
                       "end": 0,
                       "name": "axis",
                       "start": 0,
@@ -766,10 +759,10 @@ description: Result of parsing i-beam.kcl
                     },
                     "arg": {
                       "abs_path": false,
-                      "commentStart": 741,
+                      "commentStart": 742,
                       "end": 0,
                       "name": {
-                        "commentStart": 741,
+                        "commentStart": 742,
                         "end": 0,
                         "name": "X",
                         "start": 0,
@@ -784,10 +777,10 @@ description: Result of parsing i-beam.kcl
                 ],
                 "callee": {
                   "abs_path": false,
-                  "commentStart": 725,
+                  "commentStart": 726,
                   "end": 0,
                   "name": {
-                    "commentStart": 725,
+                    "commentStart": 726,
                     "end": 0,
                     "name": "mirror2d",
                     "start": 0,
@@ -797,7 +790,7 @@ description: Result of parsing i-beam.kcl
                   "start": 0,
                   "type": "Name"
                 },
-                "commentStart": 725,
+                "commentStart": 726,
                 "end": 0,
                 "start": 0,
                 "type": "CallExpressionKw",
@@ -809,7 +802,7 @@ description: Result of parsing i-beam.kcl
                   {
                     "type": "LabeledArg",
                     "label": {
-                      "commentStart": 758,
+                      "commentStart": 759,
                       "end": 0,
                       "name": "axis",
                       "start": 0,
@@ -817,10 +810,10 @@ description: Result of parsing i-beam.kcl
                     },
                     "arg": {
                       "abs_path": false,
-                      "commentStart": 765,
+                      "commentStart": 766,
                       "end": 0,
                       "name": {
-                        "commentStart": 765,
+                        "commentStart": 766,
                         "end": 0,
                         "name": "Y",
                         "start": 0,
@@ -835,10 +828,10 @@ description: Result of parsing i-beam.kcl
                 ],
                 "callee": {
                   "abs_path": false,
-                  "commentStart": 749,
+                  "commentStart": 750,
                   "end": 0,
                   "name": {
-                    "commentStart": 749,
+                    "commentStart": 750,
                     "end": 0,
                     "name": "mirror2d",
                     "start": 0,
@@ -848,7 +841,7 @@ description: Result of parsing i-beam.kcl
                   "start": 0,
                   "type": "Name"
                 },
-                "commentStart": 749,
+                "commentStart": 750,
                 "end": 0,
                 "start": 0,
                 "type": "CallExpressionKw",
@@ -860,7 +853,7 @@ description: Result of parsing i-beam.kcl
                   {
                     "type": "LabeledArg",
                     "label": {
-                      "commentStart": 781,
+                      "commentStart": 782,
                       "end": 0,
                       "name": "length",
                       "start": 0,
@@ -868,10 +861,10 @@ description: Result of parsing i-beam.kcl
                     },
                     "arg": {
                       "abs_path": false,
-                      "commentStart": 790,
+                      "commentStart": 791,
                       "end": 0,
                       "name": {
-                        "commentStart": 790,
+                        "commentStart": 791,
                         "end": 0,
                         "name": "beamLength",
                         "start": 0,
@@ -886,10 +879,10 @@ description: Result of parsing i-beam.kcl
                 ],
                 "callee": {
                   "abs_path": false,
-                  "commentStart": 773,
+                  "commentStart": 774,
                   "end": 0,
                   "name": {
-                    "commentStart": 773,
+                    "commentStart": 774,
                     "end": 0,
                     "name": "extrude",
                     "start": 0,
@@ -899,7 +892,7 @@ description: Result of parsing i-beam.kcl
                   "start": 0,
                   "type": "Name"
                 },
-                "commentStart": 773,
+                "commentStart": 774,
                 "end": 0,
                 "start": 0,
                 "type": "CallExpressionKw",
@@ -907,7 +900,7 @@ description: Result of parsing i-beam.kcl
                 "unlabeled": null
               }
             ],
-            "commentStart": 438,
+            "commentStart": 439,
             "end": 0,
             "start": 0,
             "type": "PipeExpression",

rust/kcl-lib/tests/kcl_samples/i-beam/ops.snap

@@ -23,7 +23,7 @@ description: Operations executed i-beam.kcl
       "length": {
         "value": {
           "type": "Number",
-          "value": 72.00000000000001,
+          "value": 72.0,
           "ty": {
             "type": "Unknown"
           }

rust/kcl-lib/tests/kcl_samples/i-beam/program_memory.snap

@@ -214,7 +214,7 @@ description: Variables in memory after executing i-beam.kcl
           "type": "Inches"
         }
       },
-      "height": 72.00000000000001,
+      "height": 72.0,
       "startCapId": "[uuid]",
       "endCapId": "[uuid]",
       "units": {

rust/kcl-lib/tests/kcl_samples/keyboard/program_memory.snap

@@ -1897,42 +1897,78 @@ description: Variables in memory after executing keyboard.kcl
     "type": "Number",
     "value": 0.3,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Inches"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "row2": {
     "type": "Number",
     "value": 1.2,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Inches"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "row3": {
     "type": "Number",
     "value": 2.1,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Inches"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "row4": {
     "type": "Number",
     "value": 3.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Inches"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "row5": {
     "type": "Number",
     "value": 3.9,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Inches"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "row6": {
     "type": "Number",
     "value": 4.8,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Inches"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "seg01": {

rust/kcl-lib/tests/kcl_samples/kitt/program_memory.snap

@@ -3969,7 +3969,8 @@ description: Variables in memory after executing kitt.kcl
     "type": "Number",
     "value": 9.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "kitBellyButtonWidth": {
@@ -4028,7 +4029,13 @@ description: Variables in memory after executing kitt.kcl
     "type": "Number",
     "value": 24.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Mm"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "kitBody": {
@@ -7160,7 +7167,13 @@ description: Variables in memory after executing kitt.kcl
     "type": "Number",
     "value": 20.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Mm"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "kitFloppy1": {
@@ -9033,7 +9046,8 @@ description: Variables in memory after executing kitt.kcl
     "type": "Number",
     "value": 11.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "kitFloppyWidth": {
@@ -9525,7 +9539,13 @@ description: Variables in memory after executing kitt.kcl
     "type": "Number",
     "value": 24.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Mm"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "kitLeftEar": {

rust/kcl-lib/tests/kcl_samples/lego/ops.snap

@@ -81,7 +81,8 @@ description: Operations executed lego.kcl
           "type": "Number",
           "value": -1.7000000000000002,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []

rust/kcl-lib/tests/kcl_samples/lego/program_memory.snap

@@ -237,7 +237,8 @@ description: Variables in memory after executing lego.kcl
     "type": "Number",
     "value": 7.9333,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "lbumps": {
@@ -1931,7 +1932,8 @@ description: Variables in memory after executing lego.kcl
     "type": "Number",
     "value": 6.5,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "shellExtrude": {
@@ -2286,21 +2288,34 @@ description: Variables in memory after executing lego.kcl
     "type": "Number",
     "value": 1.5,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "totalLength": {
     "type": "Number",
     "value": 23.8,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Inches"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "totalWidth": {
     "type": "Number",
     "value": 15.8,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Inches"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "tubePattern": {
@@ -3204,7 +3219,8 @@ description: Variables in memory after executing lego.kcl
     "type": "Number",
     "value": 7.9,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "wbumps": {

rust/kcl-lib/tests/kcl_samples/makeup-mirror/ops.snap

@@ -70,7 +70,13 @@ description: Operations executed makeup-mirror.kcl
           "type": "Number",
           "value": 24.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -114,7 +120,13 @@ description: Operations executed makeup-mirror.kcl
           "type": "Number",
           "value": 24.5,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -153,7 +165,13 @@ description: Operations executed makeup-mirror.kcl
           "type": "Number",
           "value": 24.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -197,7 +215,13 @@ description: Operations executed makeup-mirror.kcl
           "type": "Number",
           "value": 49.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -236,7 +260,13 @@ description: Operations executed makeup-mirror.kcl
           "type": "Number",
           "value": 24.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -280,7 +310,13 @@ description: Operations executed makeup-mirror.kcl
           "type": "Number",
           "value": 24.5,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -319,7 +355,13 @@ description: Operations executed makeup-mirror.kcl
           "type": "Number",
           "value": 24.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -363,7 +405,13 @@ description: Operations executed makeup-mirror.kcl
           "type": "Number",
           "value": 49.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -402,7 +450,13 @@ description: Operations executed makeup-mirror.kcl
           "type": "Number",
           "value": 24.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -446,7 +500,13 @@ description: Operations executed makeup-mirror.kcl
           "type": "Number",
           "value": 49.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -485,7 +545,13 @@ description: Operations executed makeup-mirror.kcl
           "type": "Number",
           "value": 24.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -529,7 +595,13 @@ description: Operations executed makeup-mirror.kcl
           "type": "Number",
           "value": 73.5,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -568,7 +640,13 @@ description: Operations executed makeup-mirror.kcl
           "type": "Number",
           "value": 24.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -742,7 +820,8 @@ description: Operations executed makeup-mirror.kcl
           "type": "Number",
           "value": 165.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []

rust/kcl-lib/tests/kcl_samples/makeup-mirror/program_memory.snap

@@ -7,7 +7,8 @@ description: Variables in memory after executing makeup-mirror.kcl
     "type": "Number",
     "value": 90.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "archThickness": {
@@ -297,7 +298,13 @@ description: Variables in memory after executing makeup-mirror.kcl
     "type": "Number",
     "value": 24.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Mm"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "hingePartA1": {
@@ -1168,7 +1175,8 @@ description: Variables in memory after executing makeup-mirror.kcl
     "type": "Number",
     "value": 85.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "mirrorThickness": {

rust/kcl-lib/tests/kcl_samples/pipe-flange-assembly/ops.snap

@@ -1036,7 +1036,13 @@ description: Operations executed pipe-flange-assembly.kcl
           "type": "Number",
           "value": -1.563,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Inches"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -1236,7 +1242,13 @@ description: Operations executed pipe-flange-assembly.kcl
           "type": "Number",
           "value": -0.46875,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Inches"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -1500,7 +1512,8 @@ description: Operations executed pipe-flange-assembly.kcl
           "type": "Number",
           "value": 0.546875,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []
@@ -1550,7 +1563,8 @@ description: Operations executed pipe-flange-assembly.kcl
           "type": "Number",
           "value": -0.546875,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []

rust/kcl-lib/tests/kcl_samples/pipe-flange-assembly/program_memory.snap

@@ -49,14 +49,16 @@ description: Variables in memory after executing pipe-flange-assembly.kcl
     "type": "Number",
     "value": 0.5,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "boltHexFlatLength": {
     "type": "Number",
     "value": 0.2887,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "boltLength": {
@@ -234,28 +236,32 @@ description: Variables in memory after executing pipe-flange-assembly.kcl
     "type": "Number",
     "value": 0.625,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "hexNutFlatLength": {
     "type": "Number",
     "value": 0.5413,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "hexNutFlatToFlat": {
     "type": "Number",
     "value": 0.9375,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "hexNutThickness": {
     "type": "Number",
     "value": 0.5469,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "mountingHoleDiameter": {

rust/kcl-lib/tests/kcl_samples/poopy-shoe/ops.snap

@@ -201,7 +201,8 @@ description: Operations executed poopy-shoe.kcl
                       "type": "Number",
                       "value": -1.4375,
                       "ty": {
-                        "type": "Unknown"
+                        "type": "Known",
+                        "type": "Count"
                       }
                     },
                     "z": {
@@ -467,7 +468,13 @@ description: Operations executed poopy-shoe.kcl
                       "type": "Number",
                       "value": -3.875,
                       "ty": {
-                        "type": "Unknown"
+                        "type": "Default",
+                        "len": {
+                          "type": "Inches"
+                        },
+                        "angle": {
+                          "type": "Degrees"
+                        }
                       }
                     },
                     "y": {
@@ -762,7 +769,13 @@ description: Operations executed poopy-shoe.kcl
           "type": "Number",
           "value": 2.75,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Inches"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -797,7 +810,13 @@ description: Operations executed poopy-shoe.kcl
                       "type": "Number",
                       "value": -3.875,
                       "ty": {
-                        "type": "Unknown"
+                        "type": "Default",
+                        "len": {
+                          "type": "Inches"
+                        },
+                        "angle": {
+                          "type": "Degrees"
+                        }
                       }
                     },
                     "y": {

rust/kcl-lib/tests/kcl_samples/poopy-shoe/program_memory.snap

@@ -42,7 +42,8 @@ description: Variables in memory after executing poopy-shoe.kcl
                 "type": "Number",
                 "value": -1.4375,
                 "ty": {
-                  "type": "Unknown"
+                  "type": "Known",
+                  "type": "Count"
                 }
               },
               "z": {
@@ -209,7 +210,13 @@ description: Variables in memory after executing poopy-shoe.kcl
                 "type": "Number",
                 "value": -3.875,
                 "ty": {
-                  "type": "Unknown"
+                  "type": "Default",
+                  "len": {
+                    "type": "Inches"
+                  },
+                  "angle": {
+                    "type": "Degrees"
+                  }
                 }
               },
               "y": {
@@ -389,7 +396,13 @@ description: Variables in memory after executing poopy-shoe.kcl
                 "type": "Number",
                 "value": -3.875,
                 "ty": {
-                  "type": "Unknown"
+                  "type": "Default",
+                  "len": {
+                    "type": "Inches"
+                  },
+                  "angle": {
+                    "type": "Degrees"
+                  }
                 }
               },
               "y": {

rust/kcl-lib/tests/kcl_samples/router-template-cross-bar/artifact_graph_flowchart.snap.md

@@ -1,59 +1,59 @@
 ```mermaid
 flowchart LR
   subgraph path2 [Path]
-    2["Path<br>[535, 578, 0]"]
+    2["Path<br>[538, 581, 0]"]
-    3["Segment<br>[584, 637, 0]"]
+    3["Segment<br>[587, 640, 0]"]
-    4["Segment<br>[643, 745, 0]"]
+    4["Segment<br>[646, 748, 0]"]
-    5["Segment<br>[751, 804, 0]"]
+    5["Segment<br>[754, 807, 0]"]
-    6["Segment<br>[810, 857, 0]"]
+    6["Segment<br>[813, 860, 0]"]
-    7["Segment<br>[863, 958, 0]"]
+    7["Segment<br>[866, 961, 0]"]
-    8["Segment<br>[964, 1035, 0]"]
+    8["Segment<br>[967, 1038, 0]"]
-    9["Segment<br>[1041, 1092, 0]"]
+    9["Segment<br>[1044, 1095, 0]"]
-    10["Segment<br>[1098, 1151, 0]"]
+    10["Segment<br>[1101, 1154, 0]"]
-    11["Segment<br>[1157, 1226, 0]"]
+    11["Segment<br>[1160, 1229, 0]"]
-    12["Segment<br>[1232, 1268, 0]"]
+    12["Segment<br>[1235, 1271, 0]"]
-    13["Segment<br>[1274, 1304, 0]"]
+    13["Segment<br>[1277, 1307, 0]"]
-    14["Segment<br>[1310, 1340, 0]"]
+    14["Segment<br>[1313, 1343, 0]"]
-    15["Segment<br>[1346, 1376, 0]"]
+    15["Segment<br>[1349, 1379, 0]"]
-    16["Segment<br>[1382, 1412, 0]"]
+    16["Segment<br>[1385, 1415, 0]"]
-    17["Segment<br>[1418, 1447, 0]"]
+    17["Segment<br>[1421, 1450, 0]"]
-    18["Segment<br>[1453, 1483, 0]"]
+    18["Segment<br>[1456, 1486, 0]"]
-    19["Segment<br>[1489, 1518, 0]"]
+    19["Segment<br>[1492, 1521, 0]"]
-    20["Segment<br>[1524, 1553, 0]"]
+    20["Segment<br>[1527, 1556, 0]"]
-    21["Segment<br>[1559, 1655, 0]"]
+    21["Segment<br>[1562, 1658, 0]"]
-    22["Segment<br>[1661, 1717, 0]"]
+    22["Segment<br>[1664, 1720, 0]"]
-    23["Segment<br>[1723, 1730, 0]"]
+    23["Segment<br>[1726, 1733, 0]"]
     24[Solid2d]
   end
   subgraph path85 [Path]
-    85["Path<br>[1885, 1929, 0]"]
+    85["Path<br>[1888, 1932, 0]"]
-    86["Segment<br>[1935, 1997, 0]"]
+    86["Segment<br>[1938, 2000, 0]"]
-    87["Segment<br>[2003, 2116, 0]"]
+    87["Segment<br>[2006, 2119, 0]"]
-    88["Segment<br>[2122, 2242, 0]"]
+    88["Segment<br>[2125, 2245, 0]"]
-    89["Segment<br>[2248, 2304, 0]"]
+    89["Segment<br>[2251, 2307, 0]"]
-    90["Segment<br>[2310, 2317, 0]"]
+    90["Segment<br>[2313, 2320, 0]"]
     91[Solid2d]
   end
   subgraph path107 [Path]
-    107["Path<br>[2473, 2518, 0]"]
+    107["Path<br>[2476, 2521, 0]"]
-    108["Segment<br>[2524, 2584, 0]"]
+    108["Segment<br>[2527, 2587, 0]"]
-    109["Segment<br>[2590, 2703, 0]"]
+    109["Segment<br>[2593, 2706, 0]"]
-    110["Segment<br>[2709, 2829, 0]"]
+    110["Segment<br>[2712, 2832, 0]"]
-    111["Segment<br>[2835, 2891, 0]"]
+    111["Segment<br>[2838, 2894, 0]"]
-    112["Segment<br>[2897, 2904, 0]"]
+    112["Segment<br>[2900, 2907, 0]"]
     113[Solid2d]
   end
   subgraph path129 [Path]
-    129["Path<br>[3058, 3103, 0]"]
+    129["Path<br>[3061, 3106, 0]"]
-    130["Segment<br>[3109, 3176, 0]"]
+    130["Segment<br>[3112, 3179, 0]"]
-    131["Segment<br>[3182, 3295, 0]"]
+    131["Segment<br>[3185, 3298, 0]"]
-    132["Segment<br>[3301, 3421, 0]"]
+    132["Segment<br>[3304, 3424, 0]"]
-    133["Segment<br>[3427, 3483, 0]"]
+    133["Segment<br>[3430, 3486, 0]"]
-    134["Segment<br>[3489, 3496, 0]"]
+    134["Segment<br>[3492, 3499, 0]"]
     135[Solid2d]
   end
-  1["Plane<br>[512, 529, 0]"]
+  1["Plane<br>[515, 532, 0]"]
-  25["Sweep Extrusion<br>[1773, 1803, 0]"]
+  25["Sweep Extrusion<br>[1776, 1806, 0]"]
   26[Wall]
   27[Wall]
   28[Wall]
@@ -113,7 +113,7 @@ flowchart LR
   82["SweepEdge Adjacent"]
   83["SweepEdge Opposite"]
   84["SweepEdge Adjacent"]
-  92["Sweep Extrusion<br>[2361, 2392, 0]"]
+  92["Sweep Extrusion<br>[2364, 2395, 0]"]
   93[Wall]
   94[Wall]
   95[Wall]
@@ -128,7 +128,7 @@ flowchart LR
   104["SweepEdge Adjacent"]
   105["SweepEdge Opposite"]
   106["SweepEdge Adjacent"]
-  114["Sweep Extrusion<br>[2947, 2978, 0]"]
+  114["Sweep Extrusion<br>[2950, 2981, 0]"]
   115[Wall]
   116[Wall]
   117[Wall]
@@ -143,7 +143,7 @@ flowchart LR
   126["SweepEdge Adjacent"]
   127["SweepEdge Opposite"]
   128["SweepEdge Adjacent"]
-  136["Sweep Extrusion<br>[3540, 3570, 0]"]
+  136["Sweep Extrusion<br>[3543, 3573, 0]"]
   137[Wall]
   138[Wall]
   139[Wall]
@@ -158,9 +158,9 @@ flowchart LR
   148["SweepEdge Adjacent"]
   149["SweepEdge Opposite"]
   150["SweepEdge Adjacent"]
-  151["StartSketchOnFace<br>[1845, 1879, 0]"]
+  151["StartSketchOnFace<br>[1848, 1882, 0]"]
-  152["StartSketchOnFace<br>[2433, 2467, 0]"]
+  152["StartSketchOnFace<br>[2436, 2470, 0]"]
-  153["StartSketchOnFace<br>[3020, 3052, 0]"]
+  153["StartSketchOnFace<br>[3023, 3055, 0]"]
   1 --- 2
   2 --- 3
   2 --- 4

rust/kcl-lib/tests/kcl_samples/router-template-slate/artifact_graph_flowchart.snap.md

@@ -1,42 +1,42 @@
 ```mermaid
 flowchart LR
   subgraph path2 [Path]
-    2["Path<br>[534, 577, 0]"]
+    2["Path<br>[537, 580, 0]"]
-    3["Segment<br>[583, 622, 0]"]
+    3["Segment<br>[586, 625, 0]"]
-    4["Segment<br>[628, 726, 0]"]
+    4["Segment<br>[631, 729, 0]"]
-    5["Segment<br>[732, 808, 0]"]
+    5["Segment<br>[735, 811, 0]"]
-    6["Segment<br>[814, 883, 0]"]
+    6["Segment<br>[817, 886, 0]"]
-    7["Segment<br>[889, 929, 0]"]
+    7["Segment<br>[892, 932, 0]"]
-    8["Segment<br>[935, 971, 0]"]
+    8["Segment<br>[938, 974, 0]"]
-    9["Segment<br>[1011, 1041, 0]"]
+    9["Segment<br>[1014, 1044, 0]"]
-    10["Segment<br>[1047, 1076, 0]"]
+    10["Segment<br>[1050, 1079, 0]"]
-    11["Segment<br>[1082, 1111, 0]"]
+    11["Segment<br>[1085, 1114, 0]"]
-    12["Segment<br>[1117, 1146, 0]"]
+    12["Segment<br>[1120, 1149, 0]"]
-    13["Segment<br>[1152, 1252, 0]"]
+    13["Segment<br>[1155, 1255, 0]"]
-    14["Segment<br>[1258, 1314, 0]"]
+    14["Segment<br>[1261, 1317, 0]"]
-    15["Segment<br>[1320, 1327, 0]"]
+    15["Segment<br>[1323, 1330, 0]"]
     16[Solid2d]
   end
   subgraph path52 [Path]
-    52["Path<br>[1482, 1582, 0]"]
+    52["Path<br>[1485, 1585, 0]"]
-    53["Segment<br>[1588, 1635, 0]"]
+    53["Segment<br>[1591, 1638, 0]"]
-    54["Segment<br>[1641, 1756, 0]"]
+    54["Segment<br>[1644, 1759, 0]"]
-    55["Segment<br>[1762, 1882, 0]"]
+    55["Segment<br>[1765, 1885, 0]"]
-    56["Segment<br>[1888, 1944, 0]"]
+    56["Segment<br>[1891, 1947, 0]"]
-    57["Segment<br>[1950, 1957, 0]"]
+    57["Segment<br>[1953, 1960, 0]"]
     58[Solid2d]
   end
   subgraph path74 [Path]
-    74["Path<br>[2114, 2213, 0]"]
+    74["Path<br>[2117, 2216, 0]"]
-    75["Segment<br>[2219, 2265, 0]"]
+    75["Segment<br>[2222, 2268, 0]"]
-    76["Segment<br>[2271, 2363, 0]"]
+    76["Segment<br>[2274, 2366, 0]"]
-    77["Segment<br>[2369, 2466, 0]"]
+    77["Segment<br>[2372, 2469, 0]"]
-    78["Segment<br>[2472, 2528, 0]"]
+    78["Segment<br>[2475, 2531, 0]"]
-    79["Segment<br>[2534, 2541, 0]"]
+    79["Segment<br>[2537, 2544, 0]"]
     80[Solid2d]
   end
-  1["Plane<br>[511, 528, 0]"]
+  1["Plane<br>[514, 531, 0]"]
-  17["Sweep Extrusion<br>[1370, 1400, 0]"]
+  17["Sweep Extrusion<br>[1373, 1403, 0]"]
   18[Wall]
   19[Wall]
   20[Wall]
@@ -71,7 +71,7 @@ flowchart LR
   49["SweepEdge Opposite"]
   50["SweepEdge Adjacent"]
   51["SweepEdge Opposite"]
-  59["Sweep Extrusion<br>[2001, 2033, 0]"]
+  59["Sweep Extrusion<br>[2004, 2036, 0]"]
   60[Wall]
   61[Wall]
   62[Wall]
@@ -86,7 +86,7 @@ flowchart LR
   71["SweepEdge Adjacent"]
   72["SweepEdge Opposite"]
   73["SweepEdge Adjacent"]
-  81["Sweep Extrusion<br>[2584, 2616, 0]"]
+  81["Sweep Extrusion<br>[2587, 2619, 0]"]
   82[Wall]
   83[Wall]
   84[Wall]
@@ -101,8 +101,8 @@ flowchart LR
   93["SweepEdge Adjacent"]
   94["SweepEdge Opposite"]
   95["SweepEdge Adjacent"]
-  96["StartSketchOnFace<br>[1442, 1476, 0]"]
+  96["StartSketchOnFace<br>[1445, 1479, 0]"]
-  97["StartSketchOnFace<br>[2074, 2108, 0]"]
+  97["StartSketchOnFace<br>[2077, 2111, 0]"]
   1 --- 2
   2 --- 3
   2 --- 4

rust/kcl-lib/tests/kcl_samples/router-template-slate/program_memory.snap

@@ -28,9 +28,9 @@ description: Variables in memory after executing router-template-slate.kcl
           "id": "[uuid]",
           "sourceRange": [],
           "tag": {
-            "commentStart": 615,
+            "commentStart": 618,
-            "end": 621,
+            "end": 624,
-            "start": 615,
+            "start": 618,
             "type": "TagDeclarator",
             "value": "seg01"
           },
@@ -48,9 +48,9 @@ description: Variables in memory after executing router-template-slate.kcl
           "id": "[uuid]",
           "sourceRange": [],
           "tag": {
-            "commentStart": 801,
+            "commentStart": 804,
-            "end": 807,
+            "end": 810,
-            "start": 801,
+            "start": 804,
             "type": "TagDeclarator",
             "value": "seg05"
           },
@@ -61,9 +61,9 @@ description: Variables in memory after executing router-template-slate.kcl
           "id": "[uuid]",
           "sourceRange": [],
           "tag": {
-            "commentStart": 876,
+            "commentStart": 879,
-            "end": 882,
+            "end": 885,
-            "start": 876,
+            "start": 879,
             "type": "TagDeclarator",
             "value": "seg04"
           },
@@ -74,9 +74,9 @@ description: Variables in memory after executing router-template-slate.kcl
           "id": "[uuid]",
           "sourceRange": [],
           "tag": {
-            "commentStart": 922,
+            "commentStart": 925,
-            "end": 928,
+            "end": 931,
-            "start": 922,
+            "start": 925,
             "type": "TagDeclarator",
             "value": "seg03"
           },
@@ -139,9 +139,9 @@ description: Variables in memory after executing router-template-slate.kcl
               28.1188
             ],
             "tag": {
-              "commentStart": 615,
+              "commentStart": 618,
-              "end": 621,
+              "end": 624,
-              "start": 615,
+              "start": 618,
               "type": "TagDeclarator",
               "value": "seg01"
             },
@@ -189,9 +189,9 @@ description: Variables in memory after executing router-template-slate.kcl
               20.0
             ],
             "tag": {
-              "commentStart": 801,
+              "commentStart": 804,
-              "end": 807,
+              "end": 810,
-              "start": 801,
+              "start": 804,
               "type": "TagDeclarator",
               "value": "seg05"
             },
@@ -214,9 +214,9 @@ description: Variables in memory after executing router-template-slate.kcl
               -12.4937
             ],
             "tag": {
-              "commentStart": 876,
+              "commentStart": 879,
-              "end": 882,
+              "end": 885,
-              "start": 876,
+              "start": 879,
               "type": "TagDeclarator",
               "value": "seg04"
             },
@@ -239,9 +239,9 @@ description: Variables in memory after executing router-template-slate.kcl
               -12.4937
             ],
             "tag": {
-              "commentStart": 922,
+              "commentStart": 925,
-              "end": 928,
+              "end": 931,
-              "start": 922,
+              "start": 925,
               "type": "TagDeclarator",
               "value": "seg03"
             },
@@ -264,9 +264,9 @@ description: Variables in memory after executing router-template-slate.kcl
               -122.4938
             ],
             "tag": {
-              "commentStart": 964,
+              "commentStart": 967,
-              "end": 970,
+              "end": 973,
-              "start": 964,
+              "start": 967,
               "type": "TagDeclarator",
               "value": "seg02"
             },
@@ -514,9 +514,9 @@ description: Variables in memory after executing router-template-slate.kcl
           "id": "[uuid]",
           "sourceRange": [],
           "tag": {
-            "commentStart": 1613,
+            "commentStart": 1616,
-            "end": 1634,
+            "end": 1637,
-            "start": 1613,
+            "start": 1616,
             "type": "TagDeclarator",
             "value": "rectangleSegmentA001"
           },
@@ -527,9 +527,9 @@ description: Variables in memory after executing router-template-slate.kcl
           "id": "[uuid]",
           "sourceRange": [],
           "tag": {
-            "commentStart": 1734,
+            "commentStart": 1737,
-            "end": 1755,
+            "end": 1758,
-            "start": 1734,
+            "start": 1737,
             "type": "TagDeclarator",
             "value": "rectangleSegmentB001"
           },
@@ -540,9 +540,9 @@ description: Variables in memory after executing router-template-slate.kcl
           "id": "[uuid]",
           "sourceRange": [],
           "tag": {
-            "commentStart": 1860,
+            "commentStart": 1863,
-            "end": 1881,
+            "end": 1884,
-            "start": 1860,
+            "start": 1863,
             "type": "TagDeclarator",
             "value": "rectangleSegmentC001"
           },
@@ -570,9 +570,9 @@ description: Variables in memory after executing router-template-slate.kcl
               -12.4937
             ],
             "tag": {
-              "commentStart": 1613,
+              "commentStart": 1616,
-              "end": 1634,
+              "end": 1637,
-              "start": 1613,
+              "start": 1616,
               "type": "TagDeclarator",
               "value": "rectangleSegmentA001"
             },
@@ -595,9 +595,9 @@ description: Variables in memory after executing router-template-slate.kcl
               -12.4937
             ],
             "tag": {
-              "commentStart": 1734,
+              "commentStart": 1737,
-              "end": 1755,
+              "end": 1758,
-              "start": 1734,
+              "start": 1737,
               "type": "TagDeclarator",
               "value": "rectangleSegmentB001"
             },
@@ -620,9 +620,9 @@ description: Variables in memory after executing router-template-slate.kcl
               -92.4938
             ],
             "tag": {
-              "commentStart": 1860,
+              "commentStart": 1863,
-              "end": 1881,
+              "end": 1884,
-              "start": 1860,
+              "start": 1863,
               "type": "TagDeclarator",
               "value": "rectangleSegmentC001"
             },
@@ -704,9 +704,9 @@ description: Variables in memory after executing router-template-slate.kcl
                 "id": "[uuid]",
                 "sourceRange": [],
                 "tag": {
-                  "commentStart": 615,
+                  "commentStart": 618,
-                  "end": 621,
+                  "end": 624,
-                  "start": 615,
+                  "start": 618,
                   "type": "TagDeclarator",
                   "value": "seg01"
                 },
@@ -724,9 +724,9 @@ description: Variables in memory after executing router-template-slate.kcl
                 "id": "[uuid]",
                 "sourceRange": [],
                 "tag": {
-                  "commentStart": 801,
+                  "commentStart": 804,
-                  "end": 807,
+                  "end": 810,
-                  "start": 801,
+                  "start": 804,
                   "type": "TagDeclarator",
                   "value": "seg05"
                 },
@@ -737,9 +737,9 @@ description: Variables in memory after executing router-template-slate.kcl
                 "id": "[uuid]",
                 "sourceRange": [],
                 "tag": {
-                  "commentStart": 876,
+                  "commentStart": 879,
-                  "end": 882,
+                  "end": 885,
-                  "start": 876,
+                  "start": 879,
                   "type": "TagDeclarator",
                   "value": "seg04"
                 },
@@ -750,9 +750,9 @@ description: Variables in memory after executing router-template-slate.kcl
                 "id": "[uuid]",
                 "sourceRange": [],
                 "tag": {
-                  "commentStart": 922,
+                  "commentStart": 925,
-                  "end": 928,
+                  "end": 931,
-                  "start": 922,
+                  "start": 925,
                   "type": "TagDeclarator",
                   "value": "seg03"
                 },
@@ -815,9 +815,9 @@ description: Variables in memory after executing router-template-slate.kcl
                     28.1188
                   ],
                   "tag": {
-                    "commentStart": 615,
+                    "commentStart": 618,
-                    "end": 621,
+                    "end": 624,
-                    "start": 615,
+                    "start": 618,
                     "type": "TagDeclarator",
                     "value": "seg01"
                   },
@@ -865,9 +865,9 @@ description: Variables in memory after executing router-template-slate.kcl
                     20.0
                   ],
                   "tag": {
-                    "commentStart": 801,
+                    "commentStart": 804,
-                    "end": 807,
+                    "end": 810,
-                    "start": 801,
+                    "start": 804,
                     "type": "TagDeclarator",
                     "value": "seg05"
                   },
@@ -890,9 +890,9 @@ description: Variables in memory after executing router-template-slate.kcl
                     -12.4937
                   ],
                   "tag": {
-                    "commentStart": 876,
+                    "commentStart": 879,
-                    "end": 882,
+                    "end": 885,
-                    "start": 876,
+                    "start": 879,
                     "type": "TagDeclarator",
                     "value": "seg04"
                   },
@@ -915,9 +915,9 @@ description: Variables in memory after executing router-template-slate.kcl
                     -12.4937
                   ],
                   "tag": {
-                    "commentStart": 922,
+                    "commentStart": 925,
-                    "end": 928,
+                    "end": 931,
-                    "start": 922,
+                    "start": 925,
                     "type": "TagDeclarator",
                     "value": "seg03"
                   },
@@ -940,9 +940,9 @@ description: Variables in memory after executing router-template-slate.kcl
                     -122.4938
                   ],
                   "tag": {
-                    "commentStart": 964,
+                    "commentStart": 967,
-                    "end": 970,
+                    "end": 973,
-                    "start": 964,
+                    "start": 967,
                     "type": "TagDeclarator",
                     "value": "seg02"
                   },
@@ -1239,9 +1239,9 @@ description: Variables in memory after executing router-template-slate.kcl
           "id": "[uuid]",
           "sourceRange": [],
           "tag": {
-            "commentStart": 2243,
+            "commentStart": 2246,
-            "end": 2264,
+            "end": 2267,
-            "start": 2243,
+            "start": 2246,
             "type": "TagDeclarator",
             "value": "rectangleSegmentA002"
           },
@@ -1283,9 +1283,9 @@ description: Variables in memory after executing router-template-slate.kcl
               -12.4937
             ],
             "tag": {
-              "commentStart": 2243,
+              "commentStart": 2246,
-              "end": 2264,
+              "end": 2267,
-              "start": 2243,
+              "start": 2246,
               "type": "TagDeclarator",
               "value": "rectangleSegmentA002"
             },
@@ -1405,9 +1405,9 @@ description: Variables in memory after executing router-template-slate.kcl
                 "id": "[uuid]",
                 "sourceRange": [],
                 "tag": {
-                  "commentStart": 615,
+                  "commentStart": 618,
-                  "end": 621,
+                  "end": 624,
-                  "start": 615,
+                  "start": 618,
                   "type": "TagDeclarator",
                   "value": "seg01"
                 },
@@ -1425,9 +1425,9 @@ description: Variables in memory after executing router-template-slate.kcl
                 "id": "[uuid]",
                 "sourceRange": [],
                 "tag": {
-                  "commentStart": 801,
+                  "commentStart": 804,
-                  "end": 807,
+                  "end": 810,
-                  "start": 801,
+                  "start": 804,
                   "type": "TagDeclarator",
                   "value": "seg05"
                 },
@@ -1438,9 +1438,9 @@ description: Variables in memory after executing router-template-slate.kcl
                 "id": "[uuid]",
                 "sourceRange": [],
                 "tag": {
-                  "commentStart": 876,
+                  "commentStart": 879,
-                  "end": 882,
+                  "end": 885,
-                  "start": 876,
+                  "start": 879,
                   "type": "TagDeclarator",
                   "value": "seg04"
                 },
@@ -1451,9 +1451,9 @@ description: Variables in memory after executing router-template-slate.kcl
                 "id": "[uuid]",
                 "sourceRange": [],
                 "tag": {
-                  "commentStart": 922,
+                  "commentStart": 925,
-                  "end": 928,
+                  "end": 931,
-                  "start": 922,
+                  "start": 925,
                   "type": "TagDeclarator",
                   "value": "seg03"
                 },
@@ -1516,9 +1516,9 @@ description: Variables in memory after executing router-template-slate.kcl
                     28.1188
                   ],
                   "tag": {
-                    "commentStart": 615,
+                    "commentStart": 618,
-                    "end": 621,
+                    "end": 624,
-                    "start": 615,
+                    "start": 618,
                     "type": "TagDeclarator",
                     "value": "seg01"
                   },
@@ -1566,9 +1566,9 @@ description: Variables in memory after executing router-template-slate.kcl
                     20.0
                   ],
                   "tag": {
-                    "commentStart": 801,
+                    "commentStart": 804,
-                    "end": 807,
+                    "end": 810,
-                    "start": 801,
+                    "start": 804,
                     "type": "TagDeclarator",
                     "value": "seg05"
                   },
@@ -1591,9 +1591,9 @@ description: Variables in memory after executing router-template-slate.kcl
                     -12.4937
                   ],
                   "tag": {
-                    "commentStart": 876,
+                    "commentStart": 879,
-                    "end": 882,
+                    "end": 885,
-                    "start": 876,
+                    "start": 879,
                     "type": "TagDeclarator",
                     "value": "seg04"
                   },
@@ -1616,9 +1616,9 @@ description: Variables in memory after executing router-template-slate.kcl
                     -12.4937
                   ],
                   "tag": {
-                    "commentStart": 922,
+                    "commentStart": 925,
-                    "end": 928,
+                    "end": 931,
-                    "start": 922,
+                    "start": 925,
                     "type": "TagDeclarator",
                     "value": "seg03"
                   },
@@ -1641,9 +1641,9 @@ description: Variables in memory after executing router-template-slate.kcl
                     -122.4938
                   ],
                   "tag": {
-                    "commentStart": 964,
+                    "commentStart": 967,
-                    "end": 970,
+                    "end": 973,
-                    "start": 964,
+                    "start": 967,
                     "type": "TagDeclarator",
                     "value": "seg02"
                   },
@@ -1924,7 +1924,8 @@ description: Variables in memory after executing router-template-slate.kcl
     "type": "Number",
     "value": 10.75,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "length002": {
@@ -2040,9 +2041,9 @@ description: Variables in memory after executing router-template-slate.kcl
             28.1188
           ],
           "tag": {
-            "commentStart": 615,
+            "commentStart": 618,
-            "end": 621,
+            "end": 624,
-            "start": 615,
+            "start": 618,
             "type": "TagDeclarator",
             "value": "seg01"
           },
@@ -2090,9 +2091,9 @@ description: Variables in memory after executing router-template-slate.kcl
             20.0
           ],
           "tag": {
-            "commentStart": 801,
+            "commentStart": 804,
-            "end": 807,
+            "end": 810,
-            "start": 801,
+            "start": 804,
             "type": "TagDeclarator",
             "value": "seg05"
           },
@@ -2115,9 +2116,9 @@ description: Variables in memory after executing router-template-slate.kcl
             -12.4937
           ],
           "tag": {
-            "commentStart": 876,
+            "commentStart": 879,
-            "end": 882,
+            "end": 885,
-            "start": 876,
+            "start": 879,
             "type": "TagDeclarator",
             "value": "seg04"
           },
@@ -2140,9 +2141,9 @@ description: Variables in memory after executing router-template-slate.kcl
             -12.4937
           ],
           "tag": {
-            "commentStart": 922,
+            "commentStart": 925,
-            "end": 928,
+            "end": 931,
-            "start": 922,
+            "start": 925,
             "type": "TagDeclarator",
             "value": "seg03"
           },
@@ -2165,9 +2166,9 @@ description: Variables in memory after executing router-template-slate.kcl
             -122.4938
           ],
           "tag": {
-            "commentStart": 964,
+            "commentStart": 967,
-            "end": 970,
+            "end": 973,
-            "start": 964,
+            "start": 967,
             "type": "TagDeclarator",
             "value": "seg02"
           },
@@ -2412,9 +2413,9 @@ description: Variables in memory after executing router-template-slate.kcl
             -12.4937
           ],
           "tag": {
-            "commentStart": 1613,
+            "commentStart": 1616,
-            "end": 1634,
+            "end": 1637,
-            "start": 1613,
+            "start": 1616,
             "type": "TagDeclarator",
             "value": "rectangleSegmentA001"
           },
@@ -2437,9 +2438,9 @@ description: Variables in memory after executing router-template-slate.kcl
             -12.4937
           ],
           "tag": {
-            "commentStart": 1734,
+            "commentStart": 1737,
-            "end": 1755,
+            "end": 1758,
-            "start": 1734,
+            "start": 1737,
             "type": "TagDeclarator",
             "value": "rectangleSegmentB001"
           },
@@ -2462,9 +2463,9 @@ description: Variables in memory after executing router-template-slate.kcl
             -92.4938
           ],
           "tag": {
-            "commentStart": 1860,
+            "commentStart": 1863,
-            "end": 1881,
+            "end": 1884,
-            "start": 1860,
+            "start": 1863,
             "type": "TagDeclarator",
             "value": "rectangleSegmentC001"
           },
@@ -2546,9 +2547,9 @@ description: Variables in memory after executing router-template-slate.kcl
               "id": "[uuid]",
               "sourceRange": [],
               "tag": {
-                "commentStart": 615,
+                "commentStart": 618,
-                "end": 621,
+                "end": 624,
-                "start": 615,
+                "start": 618,
                 "type": "TagDeclarator",
                 "value": "seg01"
               },
@@ -2566,9 +2567,9 @@ description: Variables in memory after executing router-template-slate.kcl
               "id": "[uuid]",
               "sourceRange": [],
               "tag": {
-                "commentStart": 801,
+                "commentStart": 804,
-                "end": 807,
+                "end": 810,
-                "start": 801,
+                "start": 804,
                 "type": "TagDeclarator",
                 "value": "seg05"
               },
@@ -2579,9 +2580,9 @@ description: Variables in memory after executing router-template-slate.kcl
               "id": "[uuid]",
               "sourceRange": [],
               "tag": {
-                "commentStart": 876,
+                "commentStart": 879,
-                "end": 882,
+                "end": 885,
-                "start": 876,
+                "start": 879,
                 "type": "TagDeclarator",
                 "value": "seg04"
               },
@@ -2592,9 +2593,9 @@ description: Variables in memory after executing router-template-slate.kcl
               "id": "[uuid]",
               "sourceRange": [],
               "tag": {
-                "commentStart": 922,
+                "commentStart": 925,
-                "end": 928,
+                "end": 931,
-                "start": 922,
+                "start": 925,
                 "type": "TagDeclarator",
                 "value": "seg03"
               },
@@ -2657,9 +2658,9 @@ description: Variables in memory after executing router-template-slate.kcl
                   28.1188
                 ],
                 "tag": {
-                  "commentStart": 615,
+                  "commentStart": 618,
-                  "end": 621,
+                  "end": 624,
-                  "start": 615,
+                  "start": 618,
                   "type": "TagDeclarator",
                   "value": "seg01"
                 },
@@ -2707,9 +2708,9 @@ description: Variables in memory after executing router-template-slate.kcl
                   20.0
                 ],
                 "tag": {
-                  "commentStart": 801,
+                  "commentStart": 804,
-                  "end": 807,
+                  "end": 810,
-                  "start": 801,
+                  "start": 804,
                   "type": "TagDeclarator",
                   "value": "seg05"
                 },
@@ -2732,9 +2733,9 @@ description: Variables in memory after executing router-template-slate.kcl
                   -12.4937
                 ],
                 "tag": {
-                  "commentStart": 876,
+                  "commentStart": 879,
-                  "end": 882,
+                  "end": 885,
-                  "start": 876,
+                  "start": 879,
                   "type": "TagDeclarator",
                   "value": "seg04"
                 },
@@ -2757,9 +2758,9 @@ description: Variables in memory after executing router-template-slate.kcl
                   -12.4937
                 ],
                 "tag": {
-                  "commentStart": 922,
+                  "commentStart": 925,
-                  "end": 928,
+                  "end": 931,
-                  "start": 922,
+                  "start": 925,
                   "type": "TagDeclarator",
                   "value": "seg03"
                 },
@@ -2782,9 +2783,9 @@ description: Variables in memory after executing router-template-slate.kcl
                   -122.4938
                 ],
                 "tag": {
-                  "commentStart": 964,
+                  "commentStart": 967,
-                  "end": 970,
+                  "end": 973,
-                  "start": 964,
+                  "start": 967,
                   "type": "TagDeclarator",
                   "value": "seg02"
                 },
@@ -3078,9 +3079,9 @@ description: Variables in memory after executing router-template-slate.kcl
             -12.4937
           ],
           "tag": {
-            "commentStart": 2243,
+            "commentStart": 2246,
-            "end": 2264,
+            "end": 2267,
-            "start": 2243,
+            "start": 2246,
             "type": "TagDeclarator",
             "value": "rectangleSegmentA002"
           },
@@ -3200,9 +3201,9 @@ description: Variables in memory after executing router-template-slate.kcl
               "id": "[uuid]",
               "sourceRange": [],
               "tag": {
-                "commentStart": 615,
+                "commentStart": 618,
-                "end": 621,
+                "end": 624,
-                "start": 615,
+                "start": 618,
                 "type": "TagDeclarator",
                 "value": "seg01"
               },
@@ -3220,9 +3221,9 @@ description: Variables in memory after executing router-template-slate.kcl
               "id": "[uuid]",
               "sourceRange": [],
               "tag": {
-                "commentStart": 801,
+                "commentStart": 804,
-                "end": 807,
+                "end": 810,
-                "start": 801,
+                "start": 804,
                 "type": "TagDeclarator",
                 "value": "seg05"
               },
@@ -3233,9 +3234,9 @@ description: Variables in memory after executing router-template-slate.kcl
               "id": "[uuid]",
               "sourceRange": [],
               "tag": {
-                "commentStart": 876,
+                "commentStart": 879,
-                "end": 882,
+                "end": 885,
-                "start": 876,
+                "start": 879,
                 "type": "TagDeclarator",
                 "value": "seg04"
               },
@@ -3246,9 +3247,9 @@ description: Variables in memory after executing router-template-slate.kcl
               "id": "[uuid]",
               "sourceRange": [],
               "tag": {
-                "commentStart": 922,
+                "commentStart": 925,
-                "end": 928,
+                "end": 931,
-                "start": 922,
+                "start": 925,
                 "type": "TagDeclarator",
                 "value": "seg03"
               },
@@ -3311,9 +3312,9 @@ description: Variables in memory after executing router-template-slate.kcl
                   28.1188
                 ],
                 "tag": {
-                  "commentStart": 615,
+                  "commentStart": 618,
-                  "end": 621,
+                  "end": 624,
-                  "start": 615,
+                  "start": 618,
                   "type": "TagDeclarator",
                   "value": "seg01"
                 },
@@ -3361,9 +3362,9 @@ description: Variables in memory after executing router-template-slate.kcl
                   20.0
                 ],
                 "tag": {
-                  "commentStart": 801,
+                  "commentStart": 804,
-                  "end": 807,
+                  "end": 810,
-                  "start": 801,
+                  "start": 804,
                   "type": "TagDeclarator",
                   "value": "seg05"
                 },
@@ -3386,9 +3387,9 @@ description: Variables in memory after executing router-template-slate.kcl
                   -12.4937
                 ],
                 "tag": {
-                  "commentStart": 876,
+                  "commentStart": 879,
-                  "end": 882,
+                  "end": 885,
-                  "start": 876,
+                  "start": 879,
                   "type": "TagDeclarator",
                   "value": "seg04"
                 },
@@ -3411,9 +3412,9 @@ description: Variables in memory after executing router-template-slate.kcl
                   -12.4937
                 ],
                 "tag": {
-                  "commentStart": 922,
+                  "commentStart": 925,
-                  "end": 928,
+                  "end": 931,
-                  "start": 922,
+                  "start": 925,
                   "type": "TagDeclarator",
                   "value": "seg03"
                 },
@@ -3436,9 +3437,9 @@ description: Variables in memory after executing router-template-slate.kcl
                   -122.4938
                 ],
                 "tag": {
-                  "commentStart": 964,
+                  "commentStart": 967,
-                  "end": 970,
+                  "end": 973,
-                  "start": 964,
+                  "start": 967,
                   "type": "TagDeclarator",
                   "value": "seg02"
                 },
@@ -3712,7 +3713,8 @@ description: Variables in memory after executing router-template-slate.kcl
     "type": "Number",
     "value": 20.75,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "templateDiameter": {

rust/kcl-lib/tests/kcl_samples/sheet-metal-bracket/ops.snap

@@ -25,7 +25,13 @@ description: Operations executed sheet-metal-bracket.kcl
           "type": "Number",
           "value": 5.5,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Inches"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []
@@ -51,7 +57,8 @@ description: Operations executed sheet-metal-bracket.kcl
           "type": "Number",
           "value": 0.5,
           "ty": {
-            "type": "Unknown"
+            "type": "Known",
+            "type": "Count"
           }
         },
         "sourceRange": []

rust/kcl-lib/tests/kcl_samples/sheet-metal-bracket/program_memory.snap

@@ -1788,7 +1788,8 @@ description: Variables in memory after executing sheet-metal-bracket.kcl
     "type": "Number",
     "value": 0.1875,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "componentBoltPatternX": {
@@ -1834,14 +1835,21 @@ description: Variables in memory after executing sheet-metal-bracket.kcl
     "type": "Number",
     "value": 5.5,
     "ty": {
-      "type": "Unknown"
+      "type": "Default",
+      "len": {
+        "type": "Inches"
+      },
+      "angle": {
+        "type": "Degrees"
+      }
     }
   },
   "flangeLength": {
     "type": "Number",
     "value": 1.5,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "hatHeight": {
@@ -3745,7 +3753,8 @@ description: Variables in memory after executing sheet-metal-bracket.kcl
     "type": "Number",
     "value": 0.25,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "mountingBoltPatternX": {
@@ -3778,7 +3787,8 @@ description: Variables in memory after executing sheet-metal-bracket.kcl
     "type": "Number",
     "value": 0.75,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "rightFlangeBoltPattern": {

rust/kcl-lib/tests/kcl_samples/socket-head-cap-screw/ops.snap

@@ -148,7 +148,13 @@ description: Operations executed socket-head-cap-screw.kcl
           "type": "Number",
           "value": -0.14250000000000002,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Inches"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []

rust/kcl-lib/tests/kcl_samples/socket-head-cap-screw/program_memory.snap

@@ -451,14 +451,16 @@ description: Variables in memory after executing socket-head-cap-screw.kcl
     "type": "Number",
     "value": 0.1563,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "boltHexFlatLength": {
     "type": "Number",
     "value": 0.0902,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "boltLength": {

rust/kcl-lib/tests/kcl_samples/walkie-talkie/program_memory.snap

@@ -83,7 +83,8 @@ description: Variables in memory after executing walkie-talkie.kcl
     "type": "Number",
     "value": 0.48,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "buttonThickness": {
@@ -254,7 +255,8 @@ description: Variables in memory after executing walkie-talkie.kcl
     "type": "Number",
     "value": 1.25,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "speakerBoxHeight": {

rust/kcl-lib/tests/pipe_as_arg/ops.snap

@@ -58,7 +58,13 @@ description: Operations executed pipe_as_arg.kcl
           "type": "Number",
           "value": 400.0,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []

rust/kcl-lib/tests/riddle_small/program_memory.snap

@@ -20,14 +20,16 @@ description: Variables in memory after executing riddle_small.kcl
     "type": "Number",
     "value": -26.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "oy": {
     "type": "Number",
     "value": 34.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "r": {

rust/kcl-lib/tests/rotate_after_fillet/ops.snap

@@ -163,7 +163,13 @@ description: Operations executed rotate_after_fillet.kcl
           "type": "Number",
           "value": -0.46875,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []

rust/kcl-lib/tests/rotate_after_fillet/program_memory.snap

@@ -49,14 +49,16 @@ description: Variables in memory after executing rotate_after_fillet.kcl
     "type": "Number",
     "value": 0.5,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "boltHexFlatLength": {
     "type": "Number",
     "value": 0.2887,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "boltLength": {

rust/kcl-lib/tests/scale_after_fillet/ops.snap

@@ -163,7 +163,13 @@ description: Operations executed scale_after_fillet.kcl
           "type": "Number",
           "value": -0.46875,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []

rust/kcl-lib/tests/scale_after_fillet/program_memory.snap

@@ -49,14 +49,16 @@ description: Variables in memory after executing scale_after_fillet.kcl
     "type": "Number",
     "value": 0.5,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "boltHexFlatLength": {
     "type": "Number",
     "value": 0.2887,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "boltLength": {

rust/kcl-lib/tests/sketch_on_face_after_fillets_referencing_face/program_memory.snap

@@ -33,7 +33,8 @@ description: Variables in memory after executing sketch_on_face_after_fillets_re
     "type": "Number",
     "value": 1800.0,
     "ty": {
-      "type": "Unknown"
+      "type": "Known",
+      "type": "Count"
     }
   },
   "bracket": {

rust/kcl-lib/tests/translate_after_fillet/ops.snap

@@ -163,7 +163,13 @@ description: Operations executed translate_after_fillet.kcl
           "type": "Number",
           "value": -0.46875,
           "ty": {
-            "type": "Unknown"
+            "type": "Default",
+            "len": {
+              "type": "Mm"
+            },
+            "angle": {
+              "type": "Degrees"
+            }
           }
         },
         "sourceRange": []