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,33 @@
|
||||
# probe: a struct method that raises, caught by the caller
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: withdrew 30 left 120
|
||||
# expect-stdout: refused 200 : insufficient funds
|
||||
# expect-stdout: withdrew 120 left 0
|
||||
# expect-stdout: ada 0
|
||||
struct Account(Movable):
|
||||
var owner: String
|
||||
var balance: Int
|
||||
|
||||
def __init__(out self, owner: String, balance: Int):
|
||||
self.owner = owner
|
||||
self.balance = balance
|
||||
|
||||
def withdraw(mut self, amount: Int) raises:
|
||||
if amount > self.balance:
|
||||
raise Error("insufficient funds")
|
||||
self.balance -= amount
|
||||
|
||||
def deposit(mut self, amount: Int):
|
||||
self.balance += amount
|
||||
|
||||
|
||||
def main():
|
||||
var acct = Account("ada", 100)
|
||||
acct.deposit(50)
|
||||
for amount in [30, 200, 120]:
|
||||
try:
|
||||
acct.withdraw(amount)
|
||||
print("withdrew", amount, "left", acct.balance)
|
||||
except e:
|
||||
print("refused", amount, ":", e)
|
||||
print(acct.owner, acct.balance)
|
||||
@@ -0,0 +1,26 @@
|
||||
# probe: binary search over a sorted list, found and not found
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: 7 3
|
||||
# expect-stdout: 1 0
|
||||
# expect-stdout: 13 6
|
||||
# expect-stdout: 4 -1
|
||||
# expect-stdout: 0 -1
|
||||
# expect-stdout: 14 -1
|
||||
def search(xs: List[Int], target: Int) -> Int:
|
||||
var lo = 0
|
||||
var hi = len(xs) - 1
|
||||
while lo <= hi:
|
||||
var mid = (lo + hi) // 2
|
||||
if xs[mid] == target:
|
||||
return mid
|
||||
elif xs[mid] < target:
|
||||
lo = mid + 1
|
||||
else:
|
||||
hi = mid - 1
|
||||
return -1
|
||||
|
||||
|
||||
def main():
|
||||
var xs: List[Int] = [1, 3, 5, 7, 9, 11, 13]
|
||||
for t in [7, 1, 13, 4, 0, 14]:
|
||||
print(t, search(xs, t))
|
||||
@@ -0,0 +1,20 @@
|
||||
# probe: var shadowing inside if and loop blocks
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: inner 11
|
||||
# expect-stdout: outer 1
|
||||
# expect-stdout: loop 0
|
||||
# expect-stdout: loop 100
|
||||
# expect-stdout: loop 200
|
||||
# expect-stdout: total 0
|
||||
def main():
|
||||
var x = 1
|
||||
if x == 1:
|
||||
var x = 10
|
||||
x += 1
|
||||
print("inner", x)
|
||||
print("outer", x)
|
||||
var total = 0
|
||||
for i in range(3):
|
||||
var total = i * 100
|
||||
print("loop", total)
|
||||
print("total", total)
|
||||
@@ -0,0 +1,21 @@
|
||||
# probe: sorting a List[Int] in place with nested loops and a swap
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: [1, 2, 5, 5, 6, 9]
|
||||
# expect-stdout: 0
|
||||
def bubble_sort(mut xs: List[Int]):
|
||||
var n = len(xs)
|
||||
for i in range(n):
|
||||
for j in range(n - 1 - i):
|
||||
if xs[j] > xs[j + 1]:
|
||||
var tmp = xs[j]
|
||||
xs[j] = xs[j + 1]
|
||||
xs[j + 1] = tmp
|
||||
|
||||
|
||||
def main():
|
||||
var xs: List[Int] = [5, 2, 9, 1, 5, 6]
|
||||
bubble_sort(xs)
|
||||
print(xs)
|
||||
var empty = List[Int]()
|
||||
bubble_sort(empty)
|
||||
print(len(empty))
|
||||
@@ -0,0 +1,23 @@
|
||||
# probe: shifting letters through an alphabet string with find()
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: khoor zruog
|
||||
# expect-stdout: hello world
|
||||
# expect-stdout: bcd
|
||||
def shift(s: String, k: Int) -> String:
|
||||
var alphabet = String("abcdefghijklmnopqrstuvwxyz")
|
||||
var out = String("")
|
||||
for i in range(s.count_codepoints()):
|
||||
var c = String(s[codepoint=i])
|
||||
var at = alphabet.find(c)
|
||||
if at < 0:
|
||||
out += c
|
||||
else:
|
||||
out += String(alphabet[codepoint=(at + k) % 26])
|
||||
return out
|
||||
|
||||
|
||||
def main():
|
||||
var secret = shift("hello world", 3)
|
||||
print(secret)
|
||||
print(shift(secret, 23))
|
||||
print(shift("xyz", 4))
|
||||
@@ -0,0 +1,26 @@
|
||||
# probe: closures capturing mut state and var snapshots
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: count 4
|
||||
# expect-stdout: count 9
|
||||
# expect-stdout: 101 0
|
||||
def main():
|
||||
var count = 0
|
||||
var step = 2
|
||||
|
||||
def tick() {mut count, imm step}:
|
||||
count += step
|
||||
|
||||
tick()
|
||||
tick()
|
||||
print("count", count)
|
||||
step = 5
|
||||
tick()
|
||||
print("count", count)
|
||||
|
||||
var base = 100
|
||||
|
||||
def from_base(x: Int) {var base} -> Int:
|
||||
return base + x
|
||||
|
||||
base = 0
|
||||
print(from_base(1), base)
|
||||
@@ -0,0 +1,26 @@
|
||||
# probe: while loops, a step count, and tracking a maximum
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: longest below 30: 27 with 111 steps
|
||||
# expect-stdout: 111
|
||||
def steps(n0: Int) -> Int:
|
||||
var n = n0
|
||||
var count = 0
|
||||
while n != 1:
|
||||
if n % 2 == 0:
|
||||
n = n // 2
|
||||
else:
|
||||
n = 3 * n + 1
|
||||
count += 1
|
||||
return count
|
||||
|
||||
|
||||
def main():
|
||||
var best = 0
|
||||
var best_n = 1
|
||||
for n in range(1, 30):
|
||||
var s = steps(n)
|
||||
if s > best:
|
||||
best = s
|
||||
best_n = n
|
||||
print("longest below 30:", best_n, "with", best, "steps")
|
||||
print(steps(27))
|
||||
@@ -0,0 +1,17 @@
|
||||
# probe: comptime constants and expressions used at run time
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: 8 4 32
|
||||
# expect-stdout: #.#.#.#.
|
||||
# expect-stdout: hi!
|
||||
comptime WIDTH = 8
|
||||
comptime HEIGHT = WIDTH // 2
|
||||
comptime GREETING = "hi"
|
||||
|
||||
|
||||
def main():
|
||||
print(WIDTH, HEIGHT, WIDTH * HEIGHT)
|
||||
var row = String("")
|
||||
for x in range(WIDTH):
|
||||
row += "#" if x % 2 == 0 else "."
|
||||
print(row)
|
||||
print(GREETING + "!")
|
||||
@@ -0,0 +1,32 @@
|
||||
# probe: with over a struct with __enter__ and __exit__, normal and failing
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: begin load
|
||||
# expect-stdout: loading
|
||||
# expect-stdout: end load
|
||||
# expect-stdout: begin parse
|
||||
# expect-stdout: inside parse
|
||||
# expect-stdout: end parse after error: bad token
|
||||
# expect-stdout: done
|
||||
@fieldwise_init
|
||||
struct Section(Copyable, Movable):
|
||||
var name: String
|
||||
|
||||
def __enter__(self) -> Self:
|
||||
print("begin", self.name)
|
||||
return self.copy()
|
||||
|
||||
def __exit__(self):
|
||||
print("end", self.name)
|
||||
|
||||
def __exit__(self, err: Error) -> Bool:
|
||||
print("end", self.name, "after error:", err)
|
||||
return True
|
||||
|
||||
|
||||
def main() raises:
|
||||
with Section("load"):
|
||||
print("loading")
|
||||
with Section("parse") as s:
|
||||
print("inside", s.name)
|
||||
raise Error("bad token")
|
||||
print("done")
|
||||
@@ -0,0 +1,19 @@
|
||||
# probe: a Dict as an inventory: update, pop, get with a default, keys
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: sold out: 2
|
||||
# expect-stdout: kiwis: 0
|
||||
# expect-stdout: plums: 9
|
||||
# expect-stdout: apples 8
|
||||
# expect-stdout: plums 9
|
||||
def main() raises:
|
||||
var stock = Dict[String, Int]()
|
||||
stock["apples"] = 5
|
||||
stock["pears"] = 2
|
||||
stock["plums"] = 9
|
||||
stock["apples"] += 3
|
||||
var gone = stock.pop("pears")
|
||||
print("sold out:", gone)
|
||||
print("kiwis:", stock.get("kiwis").or_else(0))
|
||||
print("plums:", stock.get("plums").or_else(0))
|
||||
for k in stock.keys():
|
||||
print(k, stock[k])
|
||||
@@ -0,0 +1,29 @@
|
||||
# probe: raising through calls, catching, and finally
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: checked 42
|
||||
# expect-stdout: age 42
|
||||
# expect-stdout: checked -3
|
||||
# expect-stdout: bad: negative age
|
||||
# expect-stdout: checked x
|
||||
# expect-stdout: bad: String is not convertible to integer with base 10: 'x'
|
||||
def parse_age(s: String) raises -> Int:
|
||||
var n = atol(s)
|
||||
if n < 0:
|
||||
raise Error("negative age")
|
||||
return n
|
||||
|
||||
|
||||
def describe(s: String) -> String:
|
||||
try:
|
||||
var n = parse_age(s)
|
||||
return "age " + String(n)
|
||||
except e:
|
||||
return "bad: " + String(e)
|
||||
finally:
|
||||
print("checked", s)
|
||||
|
||||
|
||||
def main():
|
||||
print(describe("42"))
|
||||
print(describe("-3"))
|
||||
print(describe("x"))
|
||||
@@ -0,0 +1,13 @@
|
||||
# probe: literal-only arithmetic is exact; with a variable it runs in Float64
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: 0.3 0.3
|
||||
# expect-stdout: 0.30000000000000004 0.30000000000000004
|
||||
# expect-stdout: 2.0 1.0
|
||||
# expect-stdout: 1.0
|
||||
def main():
|
||||
var one = 1.0
|
||||
print(0.1 + 0.2, 0.1 * 3.0)
|
||||
var tenth = 0.1
|
||||
print(tenth + 0.2, tenth * 3.0)
|
||||
print(2.0 / 3.0 * 3.0, one / 3.0 * 3.0)
|
||||
print(1e16 + 1.0 - 1e16)
|
||||
@@ -0,0 +1,25 @@
|
||||
# probe: recursion with a Dict memo passed as mut
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: 0 0
|
||||
# expect-stdout: 5 5
|
||||
# expect-stdout: 10 55
|
||||
# expect-stdout: 15 610
|
||||
# expect-stdout: 20 6765
|
||||
# expect-stdout: 25 75025
|
||||
# expect-stdout: 30 832040
|
||||
# expect-stdout: memo size: 29
|
||||
def fib(n: Int, mut memo: Dict[Int, Int]) raises -> Int:
|
||||
if n < 2:
|
||||
return n
|
||||
if n in memo:
|
||||
return memo[n]
|
||||
var v = fib(n - 1, memo) + fib(n - 2, memo)
|
||||
memo[n] = v
|
||||
return v
|
||||
|
||||
|
||||
def main() raises:
|
||||
var memo = Dict[Int, Int]()
|
||||
for n in range(0, 31, 5):
|
||||
print(n, fib(n, memo))
|
||||
print("memo size:", len(memo))
|
||||
@@ -0,0 +1,44 @@
|
||||
# probe: a normalised fraction type with arithmetic and printing
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: 1/2 1/3
|
||||
# expect-stdout: 5/6
|
||||
# expect-stdout: 1/6
|
||||
# expect-stdout: -1/3
|
||||
def gcd(a: Int, b: Int) -> Int:
|
||||
var x = a if a >= 0 else -a
|
||||
var y = b if b >= 0 else -b
|
||||
while y != 0:
|
||||
var t = x % y
|
||||
x = y
|
||||
y = t
|
||||
return x
|
||||
|
||||
|
||||
@fieldwise_init
|
||||
struct Frac(Copyable, Movable, Writable):
|
||||
var num: Int
|
||||
var den: Int
|
||||
|
||||
@staticmethod
|
||||
def make(n: Int, d: Int) -> Frac:
|
||||
var g = gcd(n, d)
|
||||
var sign = -1 if d < 0 else 1
|
||||
return Frac(sign * n // g, sign * d // g)
|
||||
|
||||
def __add__(self, other: Self) -> Self:
|
||||
return Frac.make(self.num * other.den + other.num * self.den, self.den * other.den)
|
||||
|
||||
def __mul__(self, other: Self) -> Self:
|
||||
return Frac.make(self.num * other.num, self.den * other.den)
|
||||
|
||||
def write_to(self, mut writer: Some[Writer]):
|
||||
writer.write(self.num, "/", self.den)
|
||||
|
||||
|
||||
def main():
|
||||
var half = Frac.make(1, 2)
|
||||
var third = Frac.make(2, 6)
|
||||
print(half, third)
|
||||
print(half + third)
|
||||
print(half * third)
|
||||
print(Frac.make(3, -9))
|
||||
@@ -0,0 +1,19 @@
|
||||
# probe: a function as a compile-time parameter, f: def(Int) thin -> Int in brackets (the manual's inplace_transform), with a named function and a lambda that captures nothing
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: [-3, -1, -4]
|
||||
# expect-stdout: [9, 1, 16]
|
||||
def map_in_place[f: def(Int) thin -> Int](mut xs: List[Int]):
|
||||
for i in range(len(xs)):
|
||||
xs[i] = f(xs[i])
|
||||
|
||||
|
||||
def negate(x: Int) -> Int:
|
||||
return -x
|
||||
|
||||
|
||||
def main():
|
||||
var xs: List[Int] = [3, 1, 4]
|
||||
map_in_place[negate](xs)
|
||||
print(xs)
|
||||
map_in_place[lambda (x: Int) -> Int: x * x](xs)
|
||||
print(xs)
|
||||
@@ -0,0 +1,22 @@
|
||||
# probe: functions as values the way the manual passes them: a type parameter F: def(Int) -> Int with f: F, for a named function, a lambda, and a capturing lambda
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: [1, 4, 9, 16]
|
||||
# expect-stdout: [10, 20, 30, 40]
|
||||
# expect-stdout: [101, 102, 103, 104]
|
||||
def apply_all[F: def(Int) -> Int, //](f: F, xs: List[Int]) -> List[Int]:
|
||||
var out = List[Int]()
|
||||
for x in xs:
|
||||
out.append(f(x))
|
||||
return out^
|
||||
|
||||
|
||||
def square(x: Int) -> Int:
|
||||
return x * x
|
||||
|
||||
|
||||
def main():
|
||||
var xs: List[Int] = [1, 2, 3, 4]
|
||||
print(apply_all(square, xs))
|
||||
print(apply_all(lambda (x: Int) -> Int: x * 10, xs))
|
||||
var offset = 100
|
||||
print(apply_all(lambda (x: Int) -> Int: x + offset, xs))
|
||||
@@ -0,0 +1,22 @@
|
||||
# probe: recursion, // and % on Int
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: 6 1 9
|
||||
# expect-stdout: 12 42
|
||||
# expect-stdout: lcm 1..10: 2520
|
||||
def gcd(a: Int, b: Int) -> Int:
|
||||
if b == 0:
|
||||
return a
|
||||
return gcd(b, a % b)
|
||||
|
||||
|
||||
def lcm(a: Int, b: Int) -> Int:
|
||||
return a // gcd(a, b) * b
|
||||
|
||||
|
||||
def main():
|
||||
print(gcd(48, 18), gcd(17, 5), gcd(0, 9))
|
||||
print(lcm(4, 6), lcm(21, 6))
|
||||
var total = 1
|
||||
for k in range(1, 11):
|
||||
total = lcm(total, k)
|
||||
print("lcm 1..10:", total)
|
||||
@@ -0,0 +1,24 @@
|
||||
# probe: a list of structs, averages, and round()
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: ada 84.0 84.0
|
||||
# expect-stdout: bo 77.0 77.0
|
||||
@fieldwise_init
|
||||
struct Student(Copyable, Movable):
|
||||
var name: String
|
||||
var scores: List[Int]
|
||||
|
||||
def mean(self) -> Float64:
|
||||
var total = 0
|
||||
for s in self.scores:
|
||||
total += s
|
||||
return Float64(total) / Float64(len(self.scores))
|
||||
|
||||
|
||||
def main():
|
||||
var a: List[Int] = [90, 85, 77]
|
||||
var b: List[Int] = [60, 72, 81, 95]
|
||||
var people = List[Student]()
|
||||
people.append(Student("ada", a^))
|
||||
people.append(Student("bo", b^))
|
||||
for p in people:
|
||||
print(p.name, p.mean(), round(p.mean()))
|
||||
@@ -0,0 +1,22 @@
|
||||
# probe: sized integers wrapping, and // and % with negative operands
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: 125
|
||||
# expect-stdout: -126
|
||||
# expect-stdout: -121
|
||||
# expect-stdout: 254
|
||||
# expect-stdout: 7 3 2 1 2
|
||||
# expect-stdout: -7 3 -3 2 -2
|
||||
# expect-stdout: 7 -3 -3 -2 -2
|
||||
# expect-stdout: -7 -3 2 -1 2
|
||||
def main():
|
||||
var a: Int8 = 120
|
||||
for _ in range(3):
|
||||
a += 5
|
||||
print(a)
|
||||
var u: UInt8 = 3
|
||||
u -= 5
|
||||
print(u)
|
||||
for pair in [(7, 3), (-7, 3), (7, -3), (-7, -3)]:
|
||||
var x = pair[0]
|
||||
var y = pair[1]
|
||||
print(x, y, x // y, x % y, x / y)
|
||||
@@ -0,0 +1,14 @@
|
||||
# probe: the same with a capturing lambda: the compiler names its type def(x: Int) -> Int, with no thin
|
||||
# expect: compile-error
|
||||
# note: kept as a checker test; the code below is exactly what godbolt rejected
|
||||
def apply_all(xs: List[Int], f: def(Int) -> Int) -> List[Int]:
|
||||
var out = List[Int]()
|
||||
for x in xs:
|
||||
out.append(f(x))
|
||||
return out^
|
||||
|
||||
|
||||
def main():
|
||||
var xs: List[Int] = [1, 2, 3, 4]
|
||||
var offset = 10
|
||||
print(apply_all(xs, lambda (x: Int) -> Int: x + offset))
|
||||
@@ -0,0 +1,19 @@
|
||||
# probe: a function passed as a plain def(Int) -> Int argument is a compile error in 1.1.0 (that type is a type, not a value's): the compiler's words for a named function and a lambda
|
||||
# expect: compile-error
|
||||
# note: kept as a checker test; the code below is exactly what godbolt rejected
|
||||
# note: kept as a checker test; the code below is exactly what godbolt rejected
|
||||
def apply_all(xs: List[Int], f: def(Int) -> Int) -> List[Int]:
|
||||
var out = List[Int]()
|
||||
for x in xs:
|
||||
out.append(f(x))
|
||||
return out^
|
||||
|
||||
|
||||
def square(x: Int) -> Int:
|
||||
return x * x
|
||||
|
||||
|
||||
def main():
|
||||
var xs: List[Int] = [1, 2, 3, 4]
|
||||
print(apply_all(xs, square))
|
||||
print(apply_all(xs, lambda (x: Int) -> Int: x * 10))
|
||||
@@ -0,0 +1,36 @@
|
||||
# probe: values with a __deinit__ inside a loop and a branch
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: make keep
|
||||
# expect-stdout: make loop0
|
||||
# expect-stdout: drop loop0
|
||||
# expect-stdout: pass 0
|
||||
# expect-stdout: make loop1
|
||||
# expect-stdout: odd pass uses loop1
|
||||
# expect-stdout: drop loop1
|
||||
# expect-stdout: make loop2
|
||||
# expect-stdout: drop loop2
|
||||
# expect-stdout: pass 2
|
||||
# expect-stdout: after loop keep
|
||||
# expect-stdout: drop keep
|
||||
# expect-stdout: end
|
||||
struct Tag(Movable):
|
||||
var name: String
|
||||
|
||||
def __init__(out self, name: String):
|
||||
self.name = name
|
||||
print("make", name)
|
||||
|
||||
def __deinit__(deinit self):
|
||||
print("drop", self.name)
|
||||
|
||||
|
||||
def main():
|
||||
var keep = Tag("keep")
|
||||
for i in range(3):
|
||||
var t = Tag("loop" + String(i))
|
||||
if i == 1:
|
||||
print("odd pass uses", t.name)
|
||||
else:
|
||||
print("pass", i)
|
||||
print("after loop", keep.name)
|
||||
print("end")
|
||||
@@ -0,0 +1,38 @@
|
||||
# probe: copy and move constructors through var arguments and transfers
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: new a
|
||||
# expect-stdout: copy a
|
||||
# expect-stdout: consumed a+
|
||||
# expect-stdout: free a+
|
||||
# expect-stdout: move a
|
||||
# expect-stdout: holding a
|
||||
# expect-stdout: free a
|
||||
struct Box(Copyable, Movable):
|
||||
var label: String
|
||||
|
||||
def __init__(out self, label: String):
|
||||
self.label = label
|
||||
print("new", label)
|
||||
|
||||
def __init__(out self, *, copy: Self):
|
||||
self.label = copy.label + "+"
|
||||
print("copy", copy.label)
|
||||
|
||||
def __init__(out self, *, deinit move: Self):
|
||||
self.label = move.label^
|
||||
print("move", self.label)
|
||||
|
||||
def __deinit__(deinit self):
|
||||
print("free", self.label)
|
||||
|
||||
|
||||
def consume(var b: Box):
|
||||
print("consumed", b.label)
|
||||
|
||||
|
||||
def main():
|
||||
var a = Box("a")
|
||||
var b = a.copy()
|
||||
consume(b^)
|
||||
var c = a^
|
||||
print("holding", c.label)
|
||||
@@ -0,0 +1,26 @@
|
||||
# probe: List[List[Int]] built row by row, multiplied and printed
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: [7, 10]
|
||||
# expect-stdout: [15, 22]
|
||||
def matmul(a: List[List[Int]], b: List[List[Int]]) -> List[List[Int]]:
|
||||
var out = List[List[Int]]()
|
||||
for i in range(len(a)):
|
||||
var row = List[Int]()
|
||||
for j in range(len(b[0])):
|
||||
var s = 0
|
||||
for k in range(len(b)):
|
||||
s += a[i][k] * b[k][j]
|
||||
row.append(s)
|
||||
out.append(row^)
|
||||
return out^
|
||||
|
||||
|
||||
def main():
|
||||
var a = List[List[Int]]()
|
||||
var r1: List[Int] = [1, 2]
|
||||
var r2: List[Int] = [3, 4]
|
||||
a.append(r1^)
|
||||
a.append(r2^)
|
||||
var c = matmul(a, a)
|
||||
for row in c:
|
||||
print(row)
|
||||
@@ -0,0 +1,22 @@
|
||||
# probe: a function returning Optional, tested and unwrapped
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: ada at 0
|
||||
# expect-stdout: cy at 2
|
||||
# expect-stdout: dee missing
|
||||
# expect-stdout: 0 None
|
||||
def index_of(xs: List[String], x: String) -> Optional[Int]:
|
||||
for i in range(len(xs)):
|
||||
if xs[i] == x:
|
||||
return i
|
||||
return None
|
||||
|
||||
|
||||
def main():
|
||||
var names: List[String] = ["ada", "bo", "cy"]
|
||||
for q in ["ada", "cy", "dee"]:
|
||||
var r = index_of(names, q)
|
||||
if r:
|
||||
print(q, "at", r.value())
|
||||
else:
|
||||
print(q, "missing")
|
||||
print(index_of(names, "ada"), index_of(names, "zed"))
|
||||
@@ -0,0 +1,21 @@
|
||||
# probe: overloaded functions picked by count and by type
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: an Int 3
|
||||
# expect-stdout: a String hi
|
||||
# expect-stdout: a pair 1,2
|
||||
def describe(x: Int) -> String:
|
||||
return "an Int " + String(x)
|
||||
|
||||
|
||||
def describe(x: String) -> String:
|
||||
return "a String " + x
|
||||
|
||||
|
||||
def describe(x: Int, y: Int) -> String:
|
||||
return "a pair " + String(x) + "," + String(y)
|
||||
|
||||
|
||||
def main():
|
||||
print(describe(3))
|
||||
print(describe("hi"))
|
||||
print(describe(1, 2))
|
||||
@@ -0,0 +1,27 @@
|
||||
# probe: mut arguments changing a caller's list and struct
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: 7
|
||||
# expect-stdout: [0, 10, 20, 30, 0, 10] 6
|
||||
@fieldwise_init
|
||||
struct Counter(Copyable, Movable):
|
||||
var hits: Int
|
||||
|
||||
|
||||
def bump(mut c: Counter, by: Int):
|
||||
c.hits += by
|
||||
|
||||
|
||||
def fill(mut xs: List[Int], n: Int):
|
||||
for i in range(n):
|
||||
xs.append(i * 10)
|
||||
|
||||
|
||||
def main():
|
||||
var c = Counter(0)
|
||||
bump(c, 3)
|
||||
bump(c, 4)
|
||||
print(c.hits)
|
||||
var xs = List[Int]()
|
||||
fill(xs, 4)
|
||||
fill(xs, 2)
|
||||
print(xs, len(xs))
|
||||
@@ -0,0 +1,20 @@
|
||||
# probe: codepoint indexing, lower(), and early returns
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: Level True
|
||||
# expect-stdout: rotor True
|
||||
# expect-stdout: Mojo False
|
||||
# expect-stdout: a True
|
||||
# expect-stdout: True
|
||||
# expect-stdout: abBA True
|
||||
def is_palindrome(s: String) -> Bool:
|
||||
var t = s.lower()
|
||||
var n = t.count_codepoints()
|
||||
for i in range(n // 2):
|
||||
if String(t[codepoint=i]) != String(t[codepoint=n - 1 - i]):
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def main():
|
||||
for w in ["Level", "rotor", "Mojo", "a", "", "abBA"]:
|
||||
print(w, is_palindrome(w))
|
||||
@@ -0,0 +1,21 @@
|
||||
# probe: the sieve of Eratosthenes with a List[Bool]
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: 15 [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
|
||||
def primes_below(n: Int) -> List[Int]:
|
||||
var is_prime = List[Bool]()
|
||||
for _ in range(n):
|
||||
is_prime.append(True)
|
||||
var out = List[Int]()
|
||||
for i in range(2, n):
|
||||
if is_prime[i]:
|
||||
out.append(i)
|
||||
var j = i * i
|
||||
while j < n:
|
||||
is_prime[j] = False
|
||||
j += i
|
||||
return out^
|
||||
|
||||
|
||||
def main():
|
||||
var ps = primes_below(50)
|
||||
print(len(ps), ps)
|
||||
@@ -0,0 +1,26 @@
|
||||
# probe: a FIFO queue with pop(0) and a fieldwise struct
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: first
|
||||
# expect-stdout: second
|
||||
# expect-stdout: third
|
||||
# expect-stdout: fourth
|
||||
@fieldwise_init
|
||||
struct Queue(Movable):
|
||||
var items: List[String]
|
||||
|
||||
def enqueue(mut self, x: String):
|
||||
self.items.append(x)
|
||||
|
||||
def dequeue(mut self) -> String:
|
||||
return self.items.pop(0)
|
||||
|
||||
|
||||
def main():
|
||||
var q = Queue(List[String]())
|
||||
q.enqueue("first")
|
||||
q.enqueue("second")
|
||||
q.enqueue("third")
|
||||
print(q.dequeue())
|
||||
q.enqueue("fourth")
|
||||
while len(q.items) > 0:
|
||||
print(q.dequeue())
|
||||
@@ -0,0 +1,23 @@
|
||||
# probe: run-length encoding a string
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: aaabccdddd -> 3a1b2c4d
|
||||
# expect-stdout: abc -> 1a1b1c
|
||||
# expect-stdout: ->
|
||||
# expect-stdout: zzzzzzzzzz -> 10z
|
||||
def encode(s: String) -> String:
|
||||
var out = String("")
|
||||
var n = s.count_codepoints()
|
||||
var i = 0
|
||||
while i < n:
|
||||
var c = String(s[codepoint=i])
|
||||
var run = 1
|
||||
while i + run < n and String(s[codepoint=i + run]) == c:
|
||||
run += 1
|
||||
out += String(run) + c
|
||||
i += run
|
||||
return out
|
||||
|
||||
|
||||
def main():
|
||||
for s in ["aaabccdddd", "abc", "", "zzzzzzzzzz"]:
|
||||
print(s, "->", encode(s))
|
||||
@@ -0,0 +1,22 @@
|
||||
# probe: a Set: add, membership, size, and iteration order
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: unique: 4
|
||||
# expect-stdout: 4
|
||||
# expect-stdout: 1
|
||||
# expect-stdout: 9
|
||||
# expect-stdout: 7
|
||||
# expect-stdout: dups: [4, 1, 9]
|
||||
from std.collections import Set
|
||||
|
||||
|
||||
def main():
|
||||
var seen = Set[Int]()
|
||||
var dups = List[Int]()
|
||||
for x in [4, 1, 4, 9, 1, 7, 9]:
|
||||
if x in seen:
|
||||
dups.append(x)
|
||||
seen.add(x)
|
||||
print("unique:", len(seen))
|
||||
for x in seen:
|
||||
print(x)
|
||||
print("dups:", dups)
|
||||
@@ -0,0 +1,16 @@
|
||||
# probe: SIMD arithmetic, broadcasting, and reductions
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: [1.5, 2.0, -3.0, 4.25]
|
||||
# expect-stdout: [3.0, 4.0, -6.0, 8.5]
|
||||
# expect-stdout: [2.5, 3.0, -2.0, 5.25]
|
||||
# expect-stdout: 4.75 4.25 -3.0
|
||||
# expect-stdout: [6, 2, 8, 2] 12
|
||||
def main():
|
||||
var v = SIMD[DType.float32, 4](1.5, 2.0, -3.0, 4.25)
|
||||
var w = SIMD[DType.float32, 4](2.0)
|
||||
print(v)
|
||||
print(v * w)
|
||||
print(v + 1.0)
|
||||
print(v.reduce_add(), v.reduce_max(), v.reduce_min())
|
||||
var k = SIMD[DType.int32, 4](3, 1, 4, 1)
|
||||
print(k * 2, k.reduce_mul())
|
||||
@@ -0,0 +1,33 @@
|
||||
# probe: a struct wrapping a List with mut methods and an Optional result
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: size 3
|
||||
# expect-stdout: 15 8 1
|
||||
# expect-stdout: None
|
||||
struct Stack(Movable):
|
||||
var items: List[Int]
|
||||
|
||||
def __init__(out self):
|
||||
self.items = List[Int]()
|
||||
|
||||
def push(mut self, x: Int):
|
||||
self.items.append(x)
|
||||
|
||||
def pop(mut self) -> Optional[Int]:
|
||||
if len(self.items) == 0:
|
||||
return None
|
||||
return self.items.pop()
|
||||
|
||||
def size(self) -> Int:
|
||||
return len(self.items)
|
||||
|
||||
|
||||
def main():
|
||||
var s = Stack()
|
||||
for x in [4, 8, 15]:
|
||||
s.push(x)
|
||||
print("size", s.size())
|
||||
var a = s.pop()
|
||||
var b = s.pop()
|
||||
print(a, b, s.size())
|
||||
_ = s.pop()
|
||||
print(s.pop())
|
||||
@@ -0,0 +1,22 @@
|
||||
# probe: building strings with +, String(), join, and String(t"...") from a t-string
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: item1, item2, item3
|
||||
# expect-stdout: ada: 1 | bo: 3
|
||||
# expect-stdout: 0-1-4-9-16
|
||||
def label(name: String, score: Int) -> String:
|
||||
return String(t"{name}: {score}")
|
||||
|
||||
|
||||
def main():
|
||||
var parts = List[String]()
|
||||
for i in range(1, 4):
|
||||
parts.append("item" + String(i))
|
||||
var joined = String(", ").join(parts)
|
||||
print(joined)
|
||||
print(label("ada", 1), "|", label("bo", 3))
|
||||
var line = String("")
|
||||
for i in range(5):
|
||||
line += String(i * i)
|
||||
if i < 4:
|
||||
line += "-"
|
||||
print(line)
|
||||
@@ -0,0 +1,22 @@
|
||||
# probe: a t-string is a TString of its values' types, not a String: returning one from a function declared -> String is a compile error
|
||||
# expect: compile-error
|
||||
# note: kept as a checker test; the code below is exactly what godbolt rejected
|
||||
# note: kept as a checker test; the code below is exactly what godbolt rejected
|
||||
# note: kept as a checker test; the code below is exactly what godbolt rejected
|
||||
def label(name: String, score: Int) -> String:
|
||||
return t"{name}: {score}"
|
||||
|
||||
|
||||
def main():
|
||||
var parts = List[String]()
|
||||
for i in range(1, 4):
|
||||
parts.append("item" + String(i))
|
||||
var joined = String(", ").join(parts)
|
||||
print(joined)
|
||||
print(label("ada", 1), "|", label("bo", 3))
|
||||
var line = String("")
|
||||
for i in range(5):
|
||||
line += String(i * i)
|
||||
if i < 4:
|
||||
line += "-"
|
||||
print(line)
|
||||
@@ -0,0 +1,25 @@
|
||||
# probe: Float64 arithmetic and how print writes floats
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: -40.0 C is -40.0 F
|
||||
# expect-stdout: 0.0 C is 32.0 F
|
||||
# expect-stdout: 36.6 C is 97.88000000000001 F
|
||||
# expect-stdout: 100.0 C is 212.0 F
|
||||
# expect-stdout: 37.0
|
||||
# expect-stdout: mean 24.15
|
||||
def c_to_f(c: Float64) -> Float64:
|
||||
return c * 9.0 / 5.0 + 32.0
|
||||
|
||||
|
||||
def f_to_c(f: Float64) -> Float64:
|
||||
return (f - 32.0) * 5.0 / 9.0
|
||||
|
||||
|
||||
def main():
|
||||
var readings: List[Float64] = [-40.0, 0.0, 36.6, 100.0]
|
||||
for c in readings:
|
||||
print(c, "C is", c_to_f(c), "F")
|
||||
print(f_to_c(98.6))
|
||||
var total = 0.0
|
||||
for c in readings:
|
||||
total += c
|
||||
print("mean", total / 4.0)
|
||||
@@ -0,0 +1,35 @@
|
||||
# probe: a trait with a default method, used by two structs
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: a shape of area 7.0
|
||||
# expect-stdout: a square of side 4.0
|
||||
trait Shape:
|
||||
def area(self) -> Float64:
|
||||
...
|
||||
|
||||
def describe(self) -> String:
|
||||
return "a shape of area " + String(self.area())
|
||||
|
||||
|
||||
@fieldwise_init
|
||||
struct Rect(Shape, Copyable, Movable):
|
||||
var w: Float64
|
||||
var h: Float64
|
||||
|
||||
def area(self) -> Float64:
|
||||
return self.w * self.h
|
||||
|
||||
|
||||
@fieldwise_init
|
||||
struct Square(Shape, Copyable, Movable):
|
||||
var side: Float64
|
||||
|
||||
def area(self) -> Float64:
|
||||
return self.side * self.side
|
||||
|
||||
def describe(self) -> String:
|
||||
return "a square of side " + String(self.side)
|
||||
|
||||
|
||||
def main():
|
||||
print(Rect(2.0, 3.5).describe())
|
||||
print(Square(4.0).describe())
|
||||
@@ -0,0 +1,39 @@
|
||||
# probe: operator overloading and write_to on a small struct
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: Vec2(1.5, 0.5)
|
||||
# expect-stdout: Vec2(0.5, 3.5)
|
||||
# expect-stdout: Vec2(3.0, 6.0)
|
||||
# expect-stdout: -2.5
|
||||
# expect-stdout: True False
|
||||
@fieldwise_init
|
||||
struct Vec2(Copyable, Movable, Writable):
|
||||
var x: Float64
|
||||
var y: Float64
|
||||
|
||||
def __add__(self, other: Self) -> Self:
|
||||
return Vec2(self.x + other.x, self.y + other.y)
|
||||
|
||||
def __sub__(self, other: Self) -> Self:
|
||||
return Vec2(self.x - other.x, self.y - other.y)
|
||||
|
||||
def __mul__(self, k: Float64) -> Self:
|
||||
return Vec2(self.x * k, self.y * k)
|
||||
|
||||
def __eq__(self, other: Self) -> Bool:
|
||||
return self.x == other.x and self.y == other.y
|
||||
|
||||
def dot(self, other: Self) -> Float64:
|
||||
return self.x * other.x + self.y * other.y
|
||||
|
||||
def write_to(self, mut writer: Some[Writer]):
|
||||
writer.write("Vec2(", self.x, ", ", self.y, ")")
|
||||
|
||||
|
||||
def main():
|
||||
var a = Vec2(1.0, 2.0)
|
||||
var b = Vec2(0.5, -1.5)
|
||||
print(a + b)
|
||||
print(a - b)
|
||||
print(a * 3.0)
|
||||
print(a.dot(b))
|
||||
print(a == Vec2(1.0, 2.0), a == b)
|
||||
@@ -0,0 +1,20 @@
|
||||
# probe: splitting text and counting words in a Dict, in insertion order
|
||||
# status: the expected output is Programming+'s interpreter's prediction; corpus.py verify confirms or refutes it on godbolt
|
||||
# expect-stdout: the 3
|
||||
# expect-stdout: cat 1
|
||||
# expect-stdout: and 2
|
||||
# expect-stdout: hat 1
|
||||
# expect-stdout: bat 1
|
||||
# expect-stdout: distinct: 5
|
||||
def main() raises:
|
||||
var text = String("the cat and the hat and the bat")
|
||||
var counts = Dict[String, Int]()
|
||||
for w in text.split(" "):
|
||||
var word = String(w)
|
||||
if word in counts:
|
||||
counts[word] += 1
|
||||
else:
|
||||
counts[word] = 1
|
||||
for e in counts.items():
|
||||
print(e.key, e.value)
|
||||
print("distinct:", len(counts))
|
||||
Reference in new issue
Block a user