modeling-app/rust/kcl-lib/tests/array_range_expr/input.kcl

r1 = [0..4]
assert(r1[4], isEqualTo = 4, error = "last element is included")

four = 4
zero = 0
r2 = [zero..four]
assert(r2[4], isEqualTo = 4, error = "last element is included")

five = four + 1
r3 = [zero..five]
assert(r3[4], isEqualTo = 4, error = "second-to-last element is included")
assert(r3[5], isEqualTo = 5, error = "last element is included")

r4 = [zero + 1 .. five - 1]
assert(r4[0], isEqualTo = 1, error = "first element is 1")
assert(r4[2], isEqualTo = 3, error = "second-to-last element is 3")
assert(r4[3], isEqualTo = 4, error = "last element is 4")
Implement dynamic ranges (#4151) Closes #4021 Allows array ranges (e.g., `[0..10]`) to take expression instead of just numeric literals as their start and end values. Both expressions are required (we don't support `[0..]`, etc.). I've created a new kind of expression in the AST. The alternative was to represent the internals of an array as some kind of pattern which could initially be fully explicit or ranges. I figured the chosen version was simpler and easier to extend to open ranges, whereas the latter would be easier to extend to mixed ranges or other patterns. I chose simpler, it'll be easy enough to refactor if necessary. Parsing is tested implicitly by the tests of execution and unparsing. --------- Signed-off-by: Nick Cameron <nrc@ncameron.org> Co-authored-by: Adam Chalmers <adam.chalmers@zoo.dev> 2024-10-17 02:58:04 +13:00			`r1 = [0..4]`
Kwargs: assert functions (#6406) Closes https://github.com/KittyCAD/modeling-app/issues/6408 2025-04-22 12:44:52 -05:00			`assert(r1[4], isEqualTo = 4, error = "last element is included")`
Implement dynamic ranges (#4151) Closes #4021 Allows array ranges (e.g., `[0..10]`) to take expression instead of just numeric literals as their start and end values. Both expressions are required (we don't support `[0..]`, etc.). I've created a new kind of expression in the AST. The alternative was to represent the internals of an array as some kind of pattern which could initially be fully explicit or ranges. I figured the chosen version was simpler and easier to extend to open ranges, whereas the latter would be easier to extend to mixed ranges or other patterns. I chose simpler, it'll be easy enough to refactor if necessary. Parsing is tested implicitly by the tests of execution and unparsing. --------- Signed-off-by: Nick Cameron <nrc@ncameron.org> Co-authored-by: Adam Chalmers <adam.chalmers@zoo.dev> 2024-10-17 02:58:04 +13:00
			`four = 4`
			`zero = 0`
			`r2 = [zero..four]`
Kwargs: assert functions (#6406) Closes https://github.com/KittyCAD/modeling-app/issues/6408 2025-04-22 12:44:52 -05:00			`assert(r2[4], isEqualTo = 4, error = "last element is included")`
Implement dynamic ranges (#4151) Closes #4021 Allows array ranges (e.g., `[0..10]`) to take expression instead of just numeric literals as their start and end values. Both expressions are required (we don't support `[0..]`, etc.). I've created a new kind of expression in the AST. The alternative was to represent the internals of an array as some kind of pattern which could initially be fully explicit or ranges. I figured the chosen version was simpler and easier to extend to open ranges, whereas the latter would be easier to extend to mixed ranges or other patterns. I chose simpler, it'll be easy enough to refactor if necessary. Parsing is tested implicitly by the tests of execution and unparsing. --------- Signed-off-by: Nick Cameron <nrc@ncameron.org> Co-authored-by: Adam Chalmers <adam.chalmers@zoo.dev> 2024-10-17 02:58:04 +13:00
Remove some deprecated functions from std (#6531) Signed-off-by: Nick Cameron <nrc@ncameron.org> 2025-04-29 12:24:18 +12:00			`five = four + 1`
Implement dynamic ranges (#4151) Closes #4021 Allows array ranges (e.g., `[0..10]`) to take expression instead of just numeric literals as their start and end values. Both expressions are required (we don't support `[0..]`, etc.). I've created a new kind of expression in the AST. The alternative was to represent the internals of an array as some kind of pattern which could initially be fully explicit or ranges. I figured the chosen version was simpler and easier to extend to open ranges, whereas the latter would be easier to extend to mixed ranges or other patterns. I chose simpler, it'll be easy enough to refactor if necessary. Parsing is tested implicitly by the tests of execution and unparsing. --------- Signed-off-by: Nick Cameron <nrc@ncameron.org> Co-authored-by: Adam Chalmers <adam.chalmers@zoo.dev> 2024-10-17 02:58:04 +13:00			`r3 = [zero..five]`
Kwargs: assert functions (#6406) Closes https://github.com/KittyCAD/modeling-app/issues/6408 2025-04-22 12:44:52 -05:00			`assert(r3[4], isEqualTo = 4, error = "second-to-last element is included")`
			`assert(r3[5], isEqualTo = 5, error = "last element is included")`
Implement dynamic ranges (#4151) Closes #4021 Allows array ranges (e.g., `[0..10]`) to take expression instead of just numeric literals as their start and end values. Both expressions are required (we don't support `[0..]`, etc.). I've created a new kind of expression in the AST. The alternative was to represent the internals of an array as some kind of pattern which could initially be fully explicit or ranges. I figured the chosen version was simpler and easier to extend to open ranges, whereas the latter would be easier to extend to mixed ranges or other patterns. I chose simpler, it'll be easy enough to refactor if necessary. Parsing is tested implicitly by the tests of execution and unparsing. --------- Signed-off-by: Nick Cameron <nrc@ncameron.org> Co-authored-by: Adam Chalmers <adam.chalmers@zoo.dev> 2024-10-17 02:58:04 +13:00
Remove some deprecated functions from std (#6531) Signed-off-by: Nick Cameron <nrc@ncameron.org> 2025-04-29 12:24:18 +12:00			`r4 = [zero + 1 .. five - 1]`
Kwargs: assert functions (#6406) Closes https://github.com/KittyCAD/modeling-app/issues/6408 2025-04-22 12:44:52 -05:00			`assert(r4[0], isEqualTo = 1, error = "first element is 1")`
			`assert(r4[2], isEqualTo = 3, error = "second-to-last element is 3")`
			`assert(r4[3], isEqualTo = 4, error = "last element is 4")`