Move the engine core into core/, a project of its own (pplus-core)
What programs mean (the languages, translators, Mojo checker and
interpreter, prover, fuzzer, machine model, catalog problems and the Mojo
corpus with godbolt's stored answers) was mixed into the site's tree, so a
change to the prover and a change to a button went through the same gate
and the same docs. This moves all of it under core/, laid out as its own
repository, ready to be extracted with its history and pinned here as a
git submodule.
- core/: src/{engines,services,sync,mojo,exercises,curriculum,common},
mojo/, syntax/mojo.xml, its tests (with Workspace and workForProblem in
place of the site's Session), scripts (corpus pipeline, play, the
exercise and probe starters, engines export/diff), and its docs
(engines, trust, mojo-corpus, exercises, coverage). Its own pixi.toml,
package.json, README, AGENTS.md and CI workflow.
- core/tests/boundary.test.mjs: library modules use no DOM, import no
page widget, and import nothing outside src/.
- core/scripts/cli.mjs: pixi run cli check|run|prove|fuzz|translate.
- core/scripts/dafny.py: Dafny 4.11.0 pinned by version and SHA-256 per
platform, fetched into .tools/ (pixi run dafny-fetch, pixi run dafny).
- The site imports core only as #core/<path>.js: an import map in
index.html, "imports" in package.json for node, core's declarations for
tsc. The site's TypeScript builds core first (npm run build).
- assemble.sh, the Quarto engine copy, the render cache key, check-pages,
quarto-export and quarto-css read core/dist and core/mojo; quarto-css
copies core's syntax/mojo.xml into the extension.
- Site tests that covered engines moved to core; the rest keep Session.
- README, AGENTS.md, docs/app.md, docs/deploy.md and the CI workflow
describe the split (checkout with submodules; core's tests and corpus
status run against the pinned commit).
Gate: site 110 pass; core 307 pass; corpus status --strict passes.
Manual check: the assembled site opens Bridge (count-base-proved),
Developer and Hardware (count-base) with the editor, the stepper and the
board, and no module errors.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FgvbRdoEheAHqsRmr2WuKZ
This commit is contained in:
1567 files changed
+3670
-981
No files matched your search
@@ -0,0 +1,19 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Every Mojo program must include a function named `main()` as the entry point
|
||||
def boot():
|
||||
print("MQ Robotics control daemon starting")
|
||||
|
||||
|
||||
def main():
|
||||
boot()
|
||||
@@ -0,0 +1,15 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Code blocks such as functions, conditions, and loops are defined with a colon followed by indented lines
|
||||
def main():
|
||||
print("MQ Robotics nav stack online")
|
||||
@@ -0,0 +1,19 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Mojo uses the `def` keyword to define functions
|
||||
def heartbeat() -> String:
|
||||
return "heartbeat ok"
|
||||
|
||||
|
||||
def main():
|
||||
print(heartbeat())
|
||||
@@ -0,0 +1,19 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: You must declare the type of each function parameter and argument; the return type follows `->`
|
||||
def grid_cells(rows: Int, cols: Int) -> Int:
|
||||
return rows * cols
|
||||
|
||||
|
||||
def main():
|
||||
print("Grid cells:", grid_cells(3, 4))
|
||||
@@ -0,0 +1,22 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Values are passed back using the `return` keyword; the return type is declared with the `-> type` syntax
|
||||
# Ring-buffer helpers for the sensor ingest loop
|
||||
|
||||
|
||||
def grow_capacity(n: Int) -> Int:
|
||||
return n * 2
|
||||
|
||||
|
||||
def main():
|
||||
print("New capacity:", grow_capacity(21))
|
||||
@@ -0,0 +1,20 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: A docstring is a string literal in triple quotes placed as the first statement in a function body
|
||||
def log_command(name: String) -> String:
|
||||
"""Return a log line announcing the command being dispatched."""
|
||||
return "Dispatching command: " + name
|
||||
|
||||
|
||||
def main():
|
||||
print(log_command("rotate-90"))
|
||||
@@ -0,0 +1,19 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Keyword arguments are specified using `argument_name = argument_value` and can be passed in any order
|
||||
def set_limits(max_speed: Int, max_accel: Int):
|
||||
print("speed:", max_speed, "accel:", max_accel)
|
||||
|
||||
|
||||
def main():
|
||||
set_limits(max_speed=2, max_accel=5)
|
||||
@@ -0,0 +1,19 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: An optional argument includes a default value, and must appear after any required arguments
|
||||
def spin_up(rpm: Int, ramp_ms: Int = 100) -> Int:
|
||||
return rpm + ramp_ms
|
||||
|
||||
|
||||
def main():
|
||||
print("total:", spin_up(900))
|
||||
@@ -0,0 +1,21 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: A single star (`*`) in the argument list marks the following arguments as keyword-only
|
||||
def run_diagnostic(name: String, *, verbose: Bool) -> String:
|
||||
if verbose:
|
||||
return name + " [verbose]"
|
||||
return name
|
||||
|
||||
|
||||
def main():
|
||||
print(run_diagnostic("imu", verbose=True))
|
||||
@@ -0,0 +1,22 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Use the variadic argument syntax `*argument_name` to accept a variable number of arguments
|
||||
def total(*readings: Int) -> Int:
|
||||
var s = 0
|
||||
for r in readings:
|
||||
s += r
|
||||
return s
|
||||
|
||||
|
||||
def main():
|
||||
print("sum:", total(3, 4, 5))
|
||||
@@ -0,0 +1,21 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Use `pass` as a no-op placeholder when a block requires a body but has nothing to do
|
||||
def run_self_test():
|
||||
# TODO: implement the real self-test later; this is just a stub
|
||||
pass
|
||||
|
||||
|
||||
def main():
|
||||
run_self_test()
|
||||
print("self-test stub ran")
|
||||
@@ -0,0 +1,23 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Implement separate versions of a function with different argument types to "overload" it
|
||||
def footprint(side: Int) -> Int:
|
||||
return side * side
|
||||
|
||||
|
||||
def footprint(w: Int, h: Int) -> Int:
|
||||
return w * h
|
||||
|
||||
|
||||
def main():
|
||||
print(footprint(4), footprint(2, 3))
|
||||
@@ -0,0 +1,21 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Functions are non-raising by default; add the `raises` keyword to propagate an error to the caller
|
||||
def read_sensor(id: Int) raises -> Int:
|
||||
if id < 0:
|
||||
raise Error("bad sensor id")
|
||||
return id * 10
|
||||
|
||||
|
||||
def main() raises:
|
||||
print("reading:", read_sensor(2))
|
||||
@@ -0,0 +1,17 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Explicitly-declared variables are created with the `var` keyword
|
||||
def main():
|
||||
var tick_count = 0
|
||||
tick_count += 1
|
||||
print("Ticks processed:", tick_count)
|
||||
@@ -0,0 +1,17 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Late initialization works only if the variable is declared with a type
|
||||
def main():
|
||||
var threshold: Int
|
||||
threshold = 10
|
||||
print("threshold:", threshold)
|
||||
@@ -0,0 +1,16 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Since variables are strongly typed, you can't assign a value of a different type
|
||||
def main():
|
||||
var count: Int = 5
|
||||
print("count:", count)
|
||||
@@ -0,0 +1,18 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: A variable owns its value; ownership is transferred with the `^` sigil, which leaves the source uninitialized
|
||||
def main():
|
||||
var a: List[Int] = [1, 2, 3]
|
||||
var b = a.copy()
|
||||
a.append(4)
|
||||
print("a:", len(a), "b:", len(b))
|
||||
@@ -0,0 +1,18 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Use the `ref name` syntax to bind a reference to a value rather than an owned copy
|
||||
def main():
|
||||
var readings: List[Int] = [10, 20, 30]
|
||||
ref first = readings[0]
|
||||
first = 99
|
||||
print("first:", readings[0])
|
||||
@@ -0,0 +1,19 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Numeric operators don't automatically narrow or widen operands to a common type
|
||||
def widen_add(reading: Int8, total: Int64) -> Int64:
|
||||
return Int64(reading) + total
|
||||
|
||||
|
||||
def main():
|
||||
print("total:", widen_add(100, 1000))
|
||||
@@ -0,0 +1,19 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Convert the operands to the target type's constructor before dividing to avoid integer truncation
|
||||
def avg_latency(total_ms: Int, num_loops: Int) -> Float64:
|
||||
return Float64(total_ms) / Float64(num_loops)
|
||||
|
||||
|
||||
def main():
|
||||
print("avg latency:", avg_latency(7, 2))
|
||||
@@ -0,0 +1,19 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: A `SIMD` value is a fixed-size vector defined by two parameters: a `DType` and the number of elements
|
||||
comptime Velocity = SIMD[.float32, 4]
|
||||
|
||||
|
||||
def main():
|
||||
var v = Velocity(1.0, 2.0, 3.0, 4.0)
|
||||
print("Velocity lane 0:", v[0])
|
||||
@@ -0,0 +1,21 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Math operations on SIMD values are applied elementwise, on each individual element in the vector
|
||||
def combine_counts(a: SIMD[.int32, 4], b: SIMD[.int32, 4]) -> SIMD[.int32, 4]:
|
||||
return a + b
|
||||
|
||||
|
||||
def main():
|
||||
var imu_a = SIMD[.int32, 4](1, 2, 3, 4)
|
||||
var imu_b = SIMD[.int32, 4](10, 20, 30, 40)
|
||||
print("Combined counts:", combine_counts(imu_a, imu_b))
|
||||
@@ -0,0 +1,19 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: `String` supports a variety of operators and common methods, such as `upper()`
|
||||
def device_tag(family: String, model: String) -> String:
|
||||
return (family + "-" + model).upper()
|
||||
|
||||
|
||||
def main():
|
||||
print(device_tag("mq", "amr"))
|
||||
@@ -0,0 +1,18 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Index a `List` with `list[i]` to read an element; assign to `list[i]` to replace it in place
|
||||
def main():
|
||||
var path: List[Int] = [10, 20, 30]
|
||||
path[0] = 15
|
||||
print("first waypoint:", path[0])
|
||||
print("waypoints:", len(path))
|
||||
@@ -0,0 +1,25 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: A `Tuple` is an ordered collection; unpack it or index it to get individual values
|
||||
def scan_stats() -> Tuple[Int, Int]:
|
||||
var num_scans = 4
|
||||
var total_points = 512
|
||||
return (num_scans, total_points)
|
||||
|
||||
|
||||
def main():
|
||||
var stats = scan_stats()
|
||||
var scans = stats[0]
|
||||
var points = stats[1]
|
||||
print("scans:", scans)
|
||||
print("points:", points)
|
||||
@@ -0,0 +1,18 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: A given `List` can only hold one type of value, specified at compile time as a parameter
|
||||
def main():
|
||||
var waypoints = List[Int]()
|
||||
waypoints.append(128)
|
||||
waypoints.append(256)
|
||||
print("Queued waypoints:", len(waypoints))
|
||||
@@ -0,0 +1,22 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: `Dict` holds key-value pairs; specify the key type and value type as parameters
|
||||
from std.collections import Dict
|
||||
|
||||
|
||||
def main() raises:
|
||||
var joint_angles = Dict[String, Int]()
|
||||
joint_angles["joint_3"] = 128
|
||||
joint_angles["joint_8"] = 256
|
||||
print("joint angle:", joint_angles["joint_3"])
|
||||
print("joints:", len(joint_angles))
|
||||
@@ -0,0 +1,22 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: `Set` represents a collection of unique values
|
||||
from std.collections import Set
|
||||
|
||||
|
||||
def main():
|
||||
var seen = Set[Int]()
|
||||
seen.add(1)
|
||||
seen.add(1)
|
||||
seen.add(2)
|
||||
print("unique:", len(seen))
|
||||
@@ -0,0 +1,33 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: An `Optional` represents a value that may or may not be present
|
||||
from std.collections import Optional
|
||||
|
||||
|
||||
def cache_lookup(sensor_id: Int) -> Optional[Int]:
|
||||
if sensor_id == 7:
|
||||
return 512
|
||||
return None
|
||||
|
||||
|
||||
def main() raises:
|
||||
var hit = cache_lookup(7)
|
||||
var miss = cache_lookup(3)
|
||||
if hit:
|
||||
print("hit:", hit.value())
|
||||
else:
|
||||
print("hit:", hit)
|
||||
if miss:
|
||||
print("miss:", miss.value())
|
||||
else:
|
||||
print("miss:", miss)
|
||||
@@ -0,0 +1,19 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Exponentiation uses two stars (`**`), not a caret
|
||||
def square_area(side: Int) -> Int:
|
||||
return side**2
|
||||
|
||||
|
||||
def main():
|
||||
print("area:", square_area(4))
|
||||
@@ -0,0 +1,20 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Use `//` for floor division; the modulo operator `%` returns the remainder
|
||||
def split_into_bins(total: Int, per_bin: Int) -> Tuple[Int, Int]:
|
||||
return total // per_bin, total % per_bin
|
||||
|
||||
|
||||
def main():
|
||||
var result = split_into_bins(17, 5)
|
||||
print("bins:", result[0], "left:", result[1])
|
||||
@@ -0,0 +1,19 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Mojo provides six comparison operators: `==`, `!=`, `<`, `<=`, `>`, and `>=`, each returning a `Bool`
|
||||
def battery_low(level: Int) -> Bool:
|
||||
return level <= 20
|
||||
|
||||
|
||||
def main():
|
||||
print("low:", battery_low(20))
|
||||
@@ -0,0 +1,19 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: You can chain comparisons; `a < b < c` is equivalent to `(a < b) and (b < c)`
|
||||
def in_range(temp: Int) -> Bool:
|
||||
return 0 <= temp <= 85
|
||||
|
||||
|
||||
def main():
|
||||
print("in range:", in_range(90))
|
||||
@@ -0,0 +1,22 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Bitwise OR (`|`) keeps bits that are set in either operand
|
||||
def status_word(ready: Int, armed: Int) -> Int:
|
||||
return ready | armed
|
||||
|
||||
|
||||
def main():
|
||||
var READY = 1
|
||||
var ARMED = 2
|
||||
var flags = status_word(READY, ARMED)
|
||||
print("armed:", (flags & ARMED) != 0)
|
||||
@@ -0,0 +1,19 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: With `and`, both operands must be truthy; if the left side is falsy, the right side isn't evaluated
|
||||
def can_drive(has_fix: Bool, calibrated: Bool) -> Bool:
|
||||
return has_fix and calibrated
|
||||
|
||||
|
||||
def main():
|
||||
print("go:", can_drive(True, False))
|
||||
@@ -0,0 +1,20 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: The `in` operator checks whether a collection contains a value
|
||||
def is_allowed(sensor_id: Int, allowed: List[Int]) -> Bool:
|
||||
return sensor_id in allowed
|
||||
|
||||
|
||||
def main():
|
||||
var allowed: List[Int] = [2, 4, 6]
|
||||
print("ok:", is_allowed(4, allowed))
|
||||
@@ -0,0 +1,19 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: A conditional expression has the form `value_if_true if condition else value_if_false`
|
||||
def speed_label(speed: Int) -> String:
|
||||
return "fast" if speed > 10 else "slow"
|
||||
|
||||
|
||||
def main():
|
||||
print("mode:", speed_label(12))
|
||||
@@ -0,0 +1,17 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Compound assignment forms like `*=` update the left-hand value instead of creating a new one
|
||||
def main():
|
||||
var scale = 2
|
||||
scale *= 3
|
||||
print("scale:", scale)
|
||||
@@ -0,0 +1,20 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Precedence determines what runs first (multiply before add); when in doubt, use parentheses
|
||||
def path_cost(setup: Int, per_segment: Int, segments: Int) -> Int:
|
||||
# setup plus per-segment cost, then multiplied across the segments
|
||||
return (setup + per_segment) * segments
|
||||
|
||||
|
||||
def main():
|
||||
print("Total distance:", path_cost(2, 3, 4))
|
||||
@@ -0,0 +1,23 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: The `if` statement executes an indented block when its boolean expression evaluates to `True`
|
||||
def route_task(queue_depth: Int) -> String:
|
||||
if queue_depth > 100:
|
||||
return "overflow-core"
|
||||
else:
|
||||
return "fast-core"
|
||||
|
||||
|
||||
def main():
|
||||
print(route_task(250))
|
||||
print(route_task(40))
|
||||
@@ -0,0 +1,20 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: The `while` loop repeatedly executes a block while its boolean expression evaluates to `True`
|
||||
def main():
|
||||
var attempt = 1
|
||||
var total = 0
|
||||
while attempt <= 5:
|
||||
total += attempt
|
||||
attempt += 1
|
||||
print("Retry budget:", total)
|
||||
@@ -0,0 +1,20 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: In a `for` loop, `continue` skips the rest of the block and resumes with the next element
|
||||
def main():
|
||||
var total = 0
|
||||
for i in range(1, 10):
|
||||
if i % 3 == 0:
|
||||
continue
|
||||
total += i
|
||||
print("Scheduled units:", total)
|
||||
@@ -0,0 +1,26 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Use `elif` to add another condition to an `if`, checked only when the earlier branches were false
|
||||
def power_mode(level: Int) -> String:
|
||||
if level >= 80:
|
||||
return "boost"
|
||||
elif level >= 30:
|
||||
return "cruise"
|
||||
else:
|
||||
return "sleep"
|
||||
|
||||
|
||||
def main():
|
||||
print(power_mode(95))
|
||||
print(power_mode(50))
|
||||
print(power_mode(10))
|
||||
@@ -0,0 +1,18 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: A range is a sequence of integers generated by `range(start, stop, step)`
|
||||
def main():
|
||||
var total = 0
|
||||
for i in range(0, 10, 2):
|
||||
total += i
|
||||
print("total:", total)
|
||||
@@ -0,0 +1,18 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Add the `ref` keyword before the loop variable to bind a reference and mutate the collection in place
|
||||
def main():
|
||||
var readings: List[Int] = [1, 2, 3]
|
||||
for ref r in readings:
|
||||
r += 10
|
||||
print("first:", readings[0])
|
||||
@@ -0,0 +1,23 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: All collection types in the `collections` module support `for` loop iteration over each element
|
||||
def total_points(batch: List[Int]) -> Int:
|
||||
var total = 0
|
||||
for count in batch:
|
||||
total += count
|
||||
return total
|
||||
|
||||
|
||||
def main():
|
||||
var batch: List[Int] = [12, 8, 20, 5]
|
||||
print("total points:", total_points(batch))
|
||||
@@ -0,0 +1,21 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: By declaring `raises`, you tell Mojo a function may raise an error; raise one with `raise Error("...")`
|
||||
def validate_velocity(n: Int) raises -> Int:
|
||||
if n <= 0:
|
||||
raise Error("velocity must be positive")
|
||||
return n
|
||||
|
||||
|
||||
def main() raises:
|
||||
print("Validated:", validate_velocity(256))
|
||||
@@ -0,0 +1,24 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Mojo uses `try`/`except` to detect and handle errors
|
||||
def checked(n: Int) raises -> Int:
|
||||
if n < 0:
|
||||
raise Error("negative reading")
|
||||
return n
|
||||
|
||||
|
||||
def main():
|
||||
try:
|
||||
print("value:", checked(-1))
|
||||
except:
|
||||
print("value: 0")
|
||||
@@ -0,0 +1,26 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: To re-raise a caught error, use `raise` with the `^` sigil to transfer ownership of the error value
|
||||
def attempt() raises:
|
||||
try:
|
||||
raise Error("sensor fault")
|
||||
except e:
|
||||
print("logging:", e)
|
||||
raise e^
|
||||
|
||||
|
||||
def main():
|
||||
try:
|
||||
attempt()
|
||||
except:
|
||||
print("recovered")
|
||||
@@ -0,0 +1,20 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: A `with` statement context manager releases its resource at the end of the block, even if an error occurs
|
||||
def main() raises:
|
||||
# MQ Robotics stores the active calibration profile on disk.
|
||||
with open("calib.txt", "w") as f:
|
||||
f.write("max_speed=1.5")
|
||||
|
||||
with open("calib.txt", "r") as f:
|
||||
print(f.read())
|
||||
@@ -0,0 +1,28 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: All struct fields are declared with `var` and a type annotation, and must be initialized in the constructor
|
||||
struct LidarScan(Copyable, Movable):
|
||||
var near_points: Int
|
||||
var far_points: Int
|
||||
|
||||
def __init__(out self, near_points: Int, far_points: Int):
|
||||
self.near_points = near_points
|
||||
self.far_points = far_points
|
||||
|
||||
def total(self) -> Int:
|
||||
return self.near_points + self.far_points
|
||||
|
||||
|
||||
def main():
|
||||
var scan = LidarScan(8, 256)
|
||||
print("Total points:", scan.total())
|
||||
@@ -0,0 +1,26 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: An instance method takes `self` as an explicit first argument, letting it act on a particular instance of the struct
|
||||
struct Battery:
|
||||
var charge: Int
|
||||
|
||||
def __init__(out self, charge: Int):
|
||||
self.charge = charge
|
||||
|
||||
def is_low(self) -> Bool:
|
||||
return self.charge < 20
|
||||
|
||||
|
||||
def main():
|
||||
var b = Battery(15)
|
||||
print("low:", b.is_low())
|
||||
@@ -0,0 +1,31 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: To let a method mutate the instance, declare its receiver as `mut self`
|
||||
struct FrameCounter(Copyable, Movable):
|
||||
var count: Int
|
||||
|
||||
def __init__(out self, count: Int):
|
||||
self.count = count
|
||||
|
||||
def increment(mut self):
|
||||
self.count += 1
|
||||
|
||||
def get(self) -> Int:
|
||||
return self.count
|
||||
|
||||
|
||||
def main():
|
||||
var counter = FrameCounter(0)
|
||||
counter.increment()
|
||||
counter.increment()
|
||||
print("Frames handled:", counter.get())
|
||||
@@ -0,0 +1,21 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: A `@staticmethod` can be called without an instance and doesn't receive `self`, so it can't access fields
|
||||
struct Encoder:
|
||||
@staticmethod
|
||||
def ticks_per_rev() -> Int:
|
||||
return 4096
|
||||
|
||||
|
||||
def main():
|
||||
print("ppr:", Encoder.ticks_per_rev())
|
||||
@@ -0,0 +1,25 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: The `@fieldwise_init` decorator generates a field-wise constructor, so you don't have to write `__init__` by hand
|
||||
@fieldwise_init
|
||||
struct LidarScan(Copyable, Movable):
|
||||
var near_points: Int
|
||||
var far_points: Int
|
||||
|
||||
def total(self) -> Int:
|
||||
return self.near_points + self.far_points
|
||||
|
||||
|
||||
def main():
|
||||
var scan = LidarScan(8, 256)
|
||||
print("Total points:", scan.total())
|
||||
@@ -0,0 +1,27 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: A move-only type is `Movable` but not `Copyable`; transfer it with the `^` sigil
|
||||
struct FileHandle(Movable):
|
||||
var fd: Int
|
||||
|
||||
def __init__(out self, fd: Int):
|
||||
self.fd = fd
|
||||
|
||||
|
||||
def take(var h: FileHandle) -> Int:
|
||||
return h.fd
|
||||
|
||||
|
||||
def main():
|
||||
var h = FileHandle(3)
|
||||
print("fd:", take(h^))
|
||||
@@ -0,0 +1,28 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Mojo evaluates `a + b` by calling `a.__add__(b)`
|
||||
struct EnergyBudget(Copyable, Movable):
|
||||
var millijoules: Int
|
||||
|
||||
def __init__(out self, millijoules: Int):
|
||||
self.millijoules = millijoules
|
||||
|
||||
def __add__(self, other: Self) -> Self:
|
||||
return Self(self.millijoules + other.millijoules)
|
||||
|
||||
|
||||
def main():
|
||||
var drive_budget = EnergyBudget(100)
|
||||
var sense_budget = EnergyBudget(56)
|
||||
var total = drive_budget + sense_budget
|
||||
print("combined budget:", total.millijoules)
|
||||
@@ -0,0 +1,27 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: A unary operator like `-x` calls `__neg__()`, returning a new value representing the result
|
||||
struct Offset(Copyable, Movable):
|
||||
var v: Int
|
||||
|
||||
def __init__(out self, v: Int):
|
||||
self.v = v
|
||||
|
||||
def __neg__(self) -> Self:
|
||||
return Self(-self.v)
|
||||
|
||||
|
||||
def main():
|
||||
var o = Offset(5)
|
||||
var n = -o
|
||||
print("neg:", n.v)
|
||||
@@ -0,0 +1,27 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Implement `__eq__()` to support `==`; the `Equatable` trait provides `__eq__()` and `__ne__()`
|
||||
struct Version(Copyable, Movable):
|
||||
var major: Int
|
||||
|
||||
def __init__(out self, major: Int):
|
||||
self.major = major
|
||||
|
||||
def __eq__(self, other: Self) -> Bool:
|
||||
return self.major == other.major
|
||||
|
||||
|
||||
def main():
|
||||
var a = Version(2)
|
||||
var b = Version(2)
|
||||
print("equal:", a == b)
|
||||
@@ -0,0 +1,34 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Implement `__getitem__()` to support subscript reads (`obj[i]`)
|
||||
struct Frame(Copyable, Movable):
|
||||
var a: Int
|
||||
var b: Int
|
||||
var c: Int
|
||||
|
||||
def __init__(out self, a: Int, b: Int, c: Int):
|
||||
self.a = a
|
||||
self.b = b
|
||||
self.c = c
|
||||
|
||||
def __getitem__(self, i: Int) -> Int:
|
||||
if i == 0:
|
||||
return self.a
|
||||
if i == 1:
|
||||
return self.b
|
||||
return self.c
|
||||
|
||||
|
||||
def main():
|
||||
var f = Frame(10, 20, 30)
|
||||
print("channel 1:", f[1])
|
||||
@@ -0,0 +1,19 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: `from module import name` imports a specific member from a module
|
||||
from std.math import sqrt
|
||||
|
||||
|
||||
def main():
|
||||
var root = sqrt(144.0)
|
||||
print("Square root:", root)
|
||||
@@ -0,0 +1,22 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Arguments are read-only by default; the `mut` convention lets the function write back to the caller's value
|
||||
def record_sample(mut total: Int, sample: Int):
|
||||
total += sample
|
||||
|
||||
|
||||
def main():
|
||||
var total = 0
|
||||
record_sample(total, 12)
|
||||
record_sample(total, 8)
|
||||
print("Total distance:", total)
|
||||
@@ -0,0 +1,21 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: The `^` transfer sigil ends a variable's lifetime and transfers ownership into a `var` argument
|
||||
def load_map(var cells: List[Int]) -> Int:
|
||||
return len(cells)
|
||||
|
||||
|
||||
def main():
|
||||
var cells: List[Int] = [16, 32, 64, 128]
|
||||
var result = load_map(cells^)
|
||||
print("map cells loaded:", result)
|
||||
@@ -0,0 +1,28 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: A `ref` return value must name an origin; it returns a reference to an existing value, not a copy
|
||||
struct CommandQueue(Copyable, Movable):
|
||||
var depth: Int
|
||||
|
||||
def __init__(out self, depth: Int):
|
||||
self.depth = depth
|
||||
|
||||
def borrow_depth(ref self) -> ref[self.depth] Int:
|
||||
return self.depth
|
||||
|
||||
|
||||
def main():
|
||||
var q = CommandQueue(4)
|
||||
ref d = q.borrow_depth()
|
||||
d = 10
|
||||
print("queue depth:", q.depth)
|
||||
@@ -0,0 +1,25 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: By the end of a constructor, all of the struct's fields must be initialized
|
||||
struct Waypoint(Copyable, Movable):
|
||||
var x: Int
|
||||
var y: Int
|
||||
|
||||
def __init__(out self, x: Int, y: Int):
|
||||
self.x = x
|
||||
self.y = y
|
||||
|
||||
|
||||
def main():
|
||||
var w = Waypoint(3, 7)
|
||||
print("y:", w.y)
|
||||
@@ -0,0 +1,33 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Like any method, `__init__()` can be overloaded to construct the object from different arguments
|
||||
struct RobotConfig(Copyable, Movable):
|
||||
var name: String
|
||||
var max_rate: Int
|
||||
|
||||
def __init__(out self, name: String, max_rate: Int):
|
||||
self.name = name
|
||||
self.max_rate = max_rate
|
||||
|
||||
# Re-badge an existing config under a new name, keeping its rate. This takes
|
||||
# a different second-argument type than the constructor above, so it must be
|
||||
# a separate overload — a default argument couldn't express both forms.
|
||||
def __init__(out self, name: String, template: Self):
|
||||
self.name = name
|
||||
self.max_rate = template.max_rate
|
||||
|
||||
|
||||
def main():
|
||||
var base = RobotConfig("base", 512)
|
||||
var arm = RobotConfig("arm", base)
|
||||
print("Robot:", arm.name, "max_rate:", arm.max_rate)
|
||||
@@ -0,0 +1,27 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: An `@implicit` single-argument constructor enables implicit conversion from the source type
|
||||
struct Celsius(Copyable, Movable):
|
||||
var deg: Int
|
||||
|
||||
@implicit
|
||||
def __init__(out self, deg: Int):
|
||||
self.deg = deg
|
||||
|
||||
|
||||
def report(t: Celsius):
|
||||
print("temp:", t.deg)
|
||||
|
||||
|
||||
def main():
|
||||
report(25)
|
||||
@@ -0,0 +1,33 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Conforming to `Copyable` gives a type a compiler-synthesized `.copy()` method
|
||||
struct ScanBuffer(Copyable):
|
||||
var samples: List[Int]
|
||||
|
||||
def __init__(out self, var samples: List[Int]):
|
||||
self.samples = samples^
|
||||
|
||||
def push(mut self, t: Int):
|
||||
self.samples.append(t)
|
||||
|
||||
def size(self) -> Int:
|
||||
return len(self.samples)
|
||||
|
||||
|
||||
def main():
|
||||
var original: List[Int] = [1, 2, 3]
|
||||
var snapshot = ScanBuffer(original^)
|
||||
var working = snapshot.copy()
|
||||
working.push(99)
|
||||
print("snapshot size:", snapshot.size())
|
||||
print("working size:", working.size())
|
||||
@@ -0,0 +1,24 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: The `ImplicitlyCopyable` trait lets the compiler copy a value on a plain assignment (`var b = a`)
|
||||
struct Reading(ImplicitlyCopyable, Movable):
|
||||
var v: Int
|
||||
|
||||
def __init__(out self, v: Int):
|
||||
self.v = v
|
||||
|
||||
|
||||
def main():
|
||||
var a = Reading(5)
|
||||
var b = a
|
||||
print("a:", a.v, "b:", b.v)
|
||||
@@ -0,0 +1,32 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Mojo calls a value's `__deinit__()` destructor when its lifetime ends (ASAP, last-use destruction)
|
||||
struct MotorHandle:
|
||||
var motor_id: Int
|
||||
|
||||
def __init__(out self, motor_id: Int):
|
||||
self.motor_id = motor_id
|
||||
print("Acquired motor", self.motor_id)
|
||||
|
||||
def __deinit__(deinit self):
|
||||
print("Released motor", self.motor_id)
|
||||
|
||||
|
||||
def drive():
|
||||
var handle = MotorHandle(0)
|
||||
print("Driving with motor", handle.motor_id)
|
||||
|
||||
|
||||
def main():
|
||||
drive()
|
||||
print("Scheduler idle")
|
||||
@@ -0,0 +1,16 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Assign an expression to a compile-time constant with `comptime`, which evaluates it once at compile time
|
||||
def main():
|
||||
comptime tick_budget = 50 * 20
|
||||
print("tick budget:", tick_budget)
|
||||
@@ -0,0 +1,21 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: `comptime for` fully unrolls a loop at compile time over a compile-time sequence like `range(LIMIT)`
|
||||
comptime NUM_AXES = 4
|
||||
|
||||
|
||||
def main():
|
||||
var total = 0
|
||||
comptime for i in range(NUM_AXES):
|
||||
total += i
|
||||
print("axis sum:", total)
|
||||
@@ -0,0 +1,19 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Parameters in `[]` are compile-time inputs; arguments in `()` are run-time values
|
||||
def scale[factor: Int](x: Int) -> Int:
|
||||
return x * factor
|
||||
|
||||
|
||||
def main():
|
||||
print("Scaled:", scale[3](14))
|
||||
@@ -0,0 +1,25 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: A parameterized struct adds compile-time parameters in `[]` after its name; they are accessible on instances (e.g. `b.size`)
|
||||
struct Buffer[size: Int](Copyable, Movable):
|
||||
def __init__(out self):
|
||||
pass
|
||||
|
||||
def capacity(self) -> Int:
|
||||
return Self.size
|
||||
|
||||
|
||||
def main():
|
||||
var b = Buffer[8]()
|
||||
print("capacity:", b.capacity())
|
||||
print("size:", b.size)
|
||||
@@ -0,0 +1,34 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Declare trait conformance in parentheses after the struct name; the compiler enforces the trait's requirements
|
||||
trait Sensor:
|
||||
def read(self) -> String:
|
||||
...
|
||||
|
||||
|
||||
struct Lidar(Sensor):
|
||||
var name: String
|
||||
|
||||
def __init__(out self, name: String):
|
||||
self.name = name
|
||||
|
||||
def read(self) -> String:
|
||||
return "Reading from " + self.name
|
||||
|
||||
|
||||
def announce[T: Sensor](sensor: T):
|
||||
print(sensor.read())
|
||||
|
||||
|
||||
def main():
|
||||
announce(Lidar("lidar-front"))
|
||||
@@ -0,0 +1,32 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: A trait can include a default method implementation that conforming structs inherit unless they override it
|
||||
trait Greeter:
|
||||
def name(self) -> String:
|
||||
...
|
||||
|
||||
def greet(self) -> String:
|
||||
return "hello " + self.name()
|
||||
|
||||
|
||||
struct Robot(Greeter):
|
||||
def __init__(out self):
|
||||
pass
|
||||
|
||||
def name(self) -> String:
|
||||
return "amr"
|
||||
|
||||
|
||||
def main():
|
||||
var r = Robot()
|
||||
print(r.greet())
|
||||
@@ -0,0 +1,28 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: The `Sized` trait requires a type to implement `__len__()`, which the built-in `len()` function uses
|
||||
struct Track(Sized):
|
||||
var name: String
|
||||
var waypoints: List[Int]
|
||||
|
||||
def __init__(out self, name: String, var waypoints: List[Int]):
|
||||
self.name = name
|
||||
self.waypoints = waypoints^
|
||||
|
||||
def __len__(self) -> Int:
|
||||
return len(self.waypoints)
|
||||
|
||||
|
||||
def main():
|
||||
var t = Track("loop-a", [10, 20, 30, 40, 50])
|
||||
print("len:", len(t))
|
||||
@@ -0,0 +1,21 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: `Some[Trait]` is shorthand for a trait-constrained generic parameter; `def f(v: Some[Writable])` is equivalent to `def f[T: Writable](v: T)`
|
||||
# Logs any value the telemetry bus touches, whatever its type.
|
||||
def log_value(value: Some[Writable]):
|
||||
print("telemetry:", value)
|
||||
|
||||
|
||||
def main():
|
||||
log_value(42)
|
||||
log_value("ready")
|
||||
@@ -0,0 +1,21 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: `comptime assert cond, "msg"` asserts a condition at compile time; if false, compilation fails
|
||||
def make_drive[num_motors: Int]() -> Int:
|
||||
# The drive train must pair motors across an even motor count.
|
||||
comptime assert num_motors % 2 == 0, "num_motors must be even"
|
||||
return num_motors * 64
|
||||
|
||||
|
||||
def main():
|
||||
print("Drive slots:", make_drive[8]())
|
||||
@@ -0,0 +1,23 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: The `comptime` keyword forces an expression to be evaluated at compile time
|
||||
comptime dim = 8
|
||||
|
||||
|
||||
def transform_size[dim: Int]() -> Int:
|
||||
# a dim x dim transform matrix has dim * dim entries
|
||||
return dim * dim
|
||||
|
||||
|
||||
def main():
|
||||
print("matrix entries:", transform_size[dim]())
|
||||
@@ -0,0 +1,27 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Use `reflect[T]` to inspect a type at compile time, querying members like `field_count()`
|
||||
struct RobotConfig(Copyable, Movable):
|
||||
var max_speed: Int
|
||||
var wheel_radius: Int
|
||||
var num_sensors: Int
|
||||
|
||||
def __init__(out self, max_speed: Int, wheel_radius: Int, num_sensors: Int):
|
||||
self.max_speed = max_speed
|
||||
self.wheel_radius = wheel_radius
|
||||
self.num_sensors = num_sensors
|
||||
|
||||
|
||||
def main():
|
||||
comptime field_count = reflect[RobotConfig].field_count()
|
||||
print("RobotConfig fields:", field_count)
|
||||
@@ -0,0 +1,24 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: Use the free function `unsafe_alloc[T](n)` to allocate space for `n` uninitialized values of `T`
|
||||
from std.memory.alloc import unsafe_alloc
|
||||
|
||||
|
||||
def main():
|
||||
# Stage a single encoder reading in a scratch buffer.
|
||||
var ptr = unsafe_alloc[Int](1)
|
||||
ptr.unsafe_write(copy=99)
|
||||
var value = ptr[]
|
||||
print("Encoder count:", value)
|
||||
ptr.unsafe_deinit_pointee()
|
||||
ptr.unsafe_free()
|
||||
@@ -0,0 +1,19 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: With space for multiple values, `ptr[unsafe_offset=i]` accesses the element at offset `i`
|
||||
def main():
|
||||
var ptr = alloc[Int]({count = 2}).unsafe_leak()
|
||||
ptr[unsafe_offset=0] = 10
|
||||
ptr[unsafe_offset=1] = 20
|
||||
print("second:", ptr[unsafe_offset=1])
|
||||
ptr.unsafe_free()
|
||||
@@ -0,0 +1,23 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: `assert_equal` from the `testing` module asserts that two values are equal
|
||||
from std.testing import assert_equal
|
||||
|
||||
|
||||
def total_distance(near: Int, far: Int) -> Int:
|
||||
return near + far
|
||||
|
||||
|
||||
def main() raises:
|
||||
assert_equal(total_distance(100, 50), 150)
|
||||
print("All checks passed!")
|
||||
@@ -0,0 +1,26 @@
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Copyright (c) 2026, Modular Inc. All rights reserved.
|
||||
#
|
||||
# Licensed under the Apache License v2.0 with LLVM Exceptions:
|
||||
# https://llvm.org/LICENSE.txt
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ===----------------------------------------------------------------------=== #
|
||||
# Mojo concept: `assert_raises` from the `testing` module is a context manager that asserts its `with` block raises an error
|
||||
from std.testing import assert_raises
|
||||
|
||||
|
||||
def clamp(n: Int) raises -> Int:
|
||||
if n < 0:
|
||||
raise Error("negative speed")
|
||||
return n
|
||||
|
||||
|
||||
def main() raises:
|
||||
with assert_raises():
|
||||
_ = clamp(-1)
|
||||
print("raised as expected")
|
||||
Reference in new issue
Block a user