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:
alexmandClaude committed 2026-10-05 05:43:58 +00:00
1 parent f43bbfe0cf
commit 82e18f7966
1567 files changed
+3670 -981

No files matched your search

+26
View File
@@ -0,0 +1,26 @@
// Numbers: every arithmetic operator, both numeric types, and the conversions between them.
// EXPECT: 3.5
// EXPECT: 3
// EXPECT: 1
// EXPECT: -4
// EXPECT: 512
// EXPECT: 2.0
// EXPECT: 27
// EXPECT: 28
// EXPECT: 5
// EXPECT: 7 -7 -7
DECLARE A, B : INTEGER
DECLARE X : FLOAT
A <- 7
B <- 2
OUTPUT A / B
OUTPUT A DIV B
OUTPUT A MOD B
OUTPUT -2 ^ 2
OUTPUT 2 ^ 3 ^ 2
OUTPUT 4 / 2
X <- 27.54
OUTPUT INT(X)
OUTPUT ROUND(X)
OUTPUT ABS(-5)
OUTPUT 7 DIV 1, " ", -7 DIV 1, " ", (-7) DIV 1
+11
View File
@@ -0,0 +1,11 @@
// A FLOAT formula with a FUNCTION; classic first program in any language.
// EXPECT: 212.0
// EXPECT: 37.0
FUNCTION TO_FAHRENHEIT(C : FLOAT) RETURNS FLOAT
RETURN C * 9 / 5 + 32
ENDFUNCTION
FUNCTION TO_CELSIUS(F : FLOAT) RETURNS FLOAT
RETURN (F - 32) * 5 / 9
ENDFUNCTION
OUTPUT TO_FAHRENHEIT(100.0)
OUTPUT TO_CELSIUS(98.6)
@@ -0,0 +1,11 @@
// Finance flavor: a loop that updates a FLOAT, with ROUND for reporting.
// EXPECT: 1628.89
FUNCTION BALANCE_AFTER(Principal : FLOAT, Rate : FLOAT, Years : INTEGER) RETURNS FLOAT
DECLARE B : FLOAT
B <- Principal
FOR Y <- 0 TO Years
B <- B * (1 + Rate)
NEXT Y
RETURN B
ENDFUNCTION
OUTPUT ROUND(BALANCE_AFTER(1000.0, 0.05, 10) * 100) / 100
+13
View File
@@ -0,0 +1,13 @@
// Recursion with a DECREASES measure and a REQUIRE.
// EXPECT: 6
// EXPECT: 1
FUNCTION GCD(A : INTEGER, B : INTEGER) RETURNS INTEGER
REQUIRE A >= 0 AND B >= 0
DECREASES B
IF B == 0 THEN
RETURN A
ENDIF
RETURN GCD(B, A MOD B)
ENDFUNCTION
OUTPUT GCD(48, 18)
OUTPUT GCD(17, 5)
+19
View File
@@ -0,0 +1,19 @@
// An ARRAY of BOOL, nested loops with STEP, and a LIST answer.
// EXPECT: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
FUNCTION PRIMES_UP_TO(N : INTEGER) RETURNS LIST OF INTEGER
DECLARE IsPrime : ARRAY[N + 1] OF BOOL
DECLARE Found : LIST OF INTEGER
FOR I <- 0 TO N + 1
IsPrime[I] <- I >= 2
NEXT I
FOR I <- 2 TO N + 1
IF IsPrime[I] THEN
APPEND(Found, I)
FOR J <- I * I TO N + 1 STEP I
IsPrime[J] <- FALSE
NEXT J
ENDIF
NEXT I
RETURN Found
ENDFUNCTION
OUTPUT PRIMES_UP_TO(30)
@@ -0,0 +1,25 @@
// Memoised recursion. A FUNCTION cannot take BYREF, so the memo table has to travel through a PROCEDURE
// with the answer coming back BYREF too. Finding: this is the idiom; it reads heavier than in most languages.
// EXPECT: 6765
// EXPECT: 12586269025
PROCEDURE FIB(N : INTEGER, BYREF Memo : HASHMAP OF INTEGER : INTEGER, BYREF Result : INTEGER)
IF N < 2 THEN
Result <- N
RETURN
ENDIF
IF N IN Memo THEN
Result <- Memo[N]
RETURN
ENDIF
DECLARE A, B : INTEGER
CALL FIB(N - 1, Memo, A)
CALL FIB(N - 2, Memo, B)
Memo[N] <- A + B
Result <- A + B
ENDPROCEDURE
DECLARE M : HASHMAP OF INTEGER : INTEGER
DECLARE R : INTEGER
CALL FIB(20, M, R)
OUTPUT R
CALL FIB(50, M, R)
OUTPUT R
+34
View File
@@ -0,0 +1,34 @@
// Text flavor: splitting a sentence into words by hand, since the notation has no SPLIT, then tallying.
// EXPECT: {"a": 2, "is": 2, "rose": 3}
// A HASHMAP prints its keys smallest first, whatever order they were added in.
FUNCTION WORDS(S : STRING) RETURNS LIST OF STRING
DECLARE Out : LIST OF STRING
DECLARE W : STRING
W <- ""
FOR EACH C IN S
IF C == ' ' THEN
IF LENGTH(W) > 0 THEN
APPEND(Out, W)
ENDIF
W <- ""
ELSE
W <- W & C
ENDIF
NEXT C
IF LENGTH(W) > 0 THEN
APPEND(Out, W)
ENDIF
RETURN Out
ENDFUNCTION
FUNCTION TALLY(Ws : LIST OF STRING) RETURNS HASHMAP OF STRING : INTEGER
DECLARE T : HASHMAP OF STRING : INTEGER
FOR EACH W IN Ws
IF W IN T THEN
T[W] <- T[W] + 1
ELSE
T[W] <- 1
ENDIF
NEXT W
RETURN T
ENDFUNCTION
OUTPUT TALLY(WORDS("a rose is a rose is rose"))
+17
View File
@@ -0,0 +1,17 @@
// Cryptography flavor: CHAR arithmetic with ORD and CHR, MOD to wrap.
// EXPECT: KHOOR, ZRUOG!
// EXPECT: HELLO, WORLD!
FUNCTION SHIFT(S : STRING, K : INTEGER) RETURNS STRING
DECLARE Out : STRING
Out <- ""
FOR EACH C IN S
IF C >= 'A' AND C <= 'Z' THEN
Out <- Out & CHR((ORD(C) - ORD('A') + K) MOD 26 + ORD('A'))
ELSE
Out <- Out & C
ENDIF
NEXT C
RETURN Out
ENDFUNCTION
OUTPUT SHIFT("HELLO, WORLD!", 3)
OUTPUT SHIFT(SHIFT("HELLO, WORLD!", 3), 23)
+17
View File
@@ -0,0 +1,17 @@
// Two positions moving toward each other; a WHILE with a compound guard.
// EXPECT: TRUE
// EXPECT: FALSE
// EXPECT: TRUE
FUNCTION IS_PALINDROME(S : STRING) RETURNS BOOL
DECLARE Lo, Hi : INTEGER
Lo <- 0
Hi <- LENGTH(S) - 1
WHILE Lo < Hi AND S[Lo] == S[Hi]
Lo <- Lo + 1
Hi <- Hi - 1
ENDWHILE
RETURN Lo >= Hi
ENDFUNCTION
OUTPUT IS_PALINDROME("racecar")
OUTPUT IS_PALINDROME("rose")
OUTPUT IS_PALINDROME("")
@@ -0,0 +1,19 @@
// An in-place sort with a PROCEDURE and BYREF, plus a loop invariant.
// EXPECT: [1, 2, 3, 5, 8, 9]
PROCEDURE INSERTION_SORT(BYREF L : LIST OF INTEGER)
FOR I <- 1 TO LENGTH(L)
INVARIANT FORALL K IN [1, I) : L[K - 1] <= L[K]
DECLARE Key, J : INTEGER
Key <- L[I]
J <- I - 1
WHILE J >= 0 AND L[J] > Key
L[J + 1] <- L[J]
J <- J - 1
ENDWHILE
L[J + 1] <- Key
NEXT I
ENDPROCEDURE
DECLARE Xs : LIST OF INTEGER
Xs <- [5, 2, 9, 1, 8, 3]
CALL INSERTION_SORT(Xs)
OUTPUT Xs
@@ -0,0 +1,27 @@
// Two-dimensional ARRAYs, triple nested loops, ROWS and COLUMNS.
// EXPECT: 19 22
// EXPECT: 43 50
FUNCTION MATMUL(A : ARRAY[2, 2] OF INTEGER, B : ARRAY[2, 2] OF INTEGER) RETURNS ARRAY[2, 2] OF INTEGER
DECLARE C : ARRAY[ROWS(A), COLUMNS(B)] OF INTEGER
FOR I <- 0 TO ROWS(A)
FOR J <- 0 TO COLUMNS(B)
C[I, J] <- 0
FOR K <- 0 TO COLUMNS(A)
C[I, J] <- C[I, J] + A[I, K] * B[K, J]
NEXT K
NEXT J
NEXT I
RETURN C
ENDFUNCTION
DECLARE A, B, C : ARRAY[2, 2] OF INTEGER
A[0, 0] <- 1
A[0, 1] <- 2
A[1, 0] <- 3
A[1, 1] <- 4
B[0, 0] <- 5
B[0, 1] <- 6
B[1, 0] <- 7
B[1, 1] <- 8
C <- MATMUL(A, B)
OUTPUT C[0, 0], " ", C[0, 1]
OUTPUT C[1, 0], " ", C[1, 1]
+37
View File
@@ -0,0 +1,37 @@
// Records in a LIST, a FUNCTION over them, and "find the best".
// EXPECT: Bob
// EXPECT: 86.5
TYPE Student
DECLARE Name : STRING
DECLARE Marks : LIST OF INTEGER
ENDTYPE
FUNCTION MEAN(Xs : LIST OF INTEGER) RETURNS FLOAT
REQUIRE LENGTH(Xs) >= 1
DECLARE Total : INTEGER
Total <- 0
FOR EACH X IN Xs
Total <- Total + X
NEXT X
RETURN Total / LENGTH(Xs)
ENDFUNCTION
FUNCTION TOP(Ss : LIST OF Student) RETURNS Student
REQUIRE LENGTH(Ss) >= 1
DECLARE Best : Student
Best <- Ss[0]
FOR EACH S IN Ss
IF MEAN(S.Marks) > MEAN(Best.Marks) THEN
Best <- S
ENDIF
NEXT S
RETURN Best
ENDFUNCTION
DECLARE A, B : Student
DECLARE Class : LIST OF Student
A.Name <- "Ann"
A.Marks <- [70, 80, 90]
B.Name <- "Bob"
B.Marks <- [88, 85]
APPEND(Class, A)
APPEND(Class, B)
OUTPUT TOP(Class).Name
OUTPUT MEAN(TOP(Class).Marks)
@@ -0,0 +1,25 @@
// A LIST used as a stack: APPEND to push, REMOVE the last to pop. Balanced brackets.
// EXPECT: TRUE
// EXPECT: FALSE
// EXPECT: FALSE
FUNCTION BALANCED(S : STRING) RETURNS BOOL
DECLARE Stack : LIST OF CHAR
DECLARE Pairs : HASHMAP OF CHAR : CHAR
Pairs[')'] <- '('
Pairs[']'] <- '['
Pairs['}'] <- '{'
FOR EACH C IN S
IF C == '(' OR C == '[' OR C == '{' THEN
APPEND(Stack, C)
ELSEIF C IN Pairs THEN
IF LENGTH(Stack) == 0 OR Stack[LENGTH(Stack) - 1] != Pairs[C] THEN
RETURN FALSE
ENDIF
REMOVE(Stack, LENGTH(Stack) - 1)
ENDIF
NEXT C
RETURN LENGTH(Stack) == 0
ENDFUNCTION
OUTPUT BALANCED("{[()()]}")
OUTPUT BALANCED("([)]")
OUTPUT BALANCED("((")
+30
View File
@@ -0,0 +1,30 @@
// Graph flavor: breadth-first search with a LIST as a queue (REMOVE at 0) and a SET of seen nodes.
// Finding: a neighbour cannot be called Next, because names ignore case and NEXT is a keyword.
// EXPECT: [0, 1, 2, 3, 4]
FUNCTION BFS(Adj : HASHMAP OF INTEGER : LIST OF INTEGER, Start : INTEGER) RETURNS LIST OF INTEGER
DECLARE Queue, Order : LIST OF INTEGER
DECLARE Seen : SET OF INTEGER
APPEND(Queue, Start)
ADD(Seen, Start)
WHILE LENGTH(Queue) > 0
DECLARE Node : INTEGER
Node <- Queue[0]
REMOVE(Queue, 0)
APPEND(Order, Node)
IF Node IN Adj THEN
FOR EACH Nb IN Adj[Node]
IF NOT (Nb IN Seen) THEN
ADD(Seen, Nb)
APPEND(Queue, Nb)
ENDIF
NEXT Nb
ENDIF
ENDWHILE
RETURN Order
ENDFUNCTION
DECLARE G : HASHMAP OF INTEGER : LIST OF INTEGER
G[0] <- [1, 2]
G[1] <- [3]
G[2] <- [3, 4]
G[3] <- [4]
OUTPUT BFS(G, 0)
+49
View File
@@ -0,0 +1,49 @@
// Simulation flavor: one step of Conway's Life on a small two-dimensional ARRAY; a blinker turns.
// Finding: the function cannot be called STEP, nor the new grid Next: both are keywords, whatever their case.
// EXPECT: 0 1 0
// EXPECT: 0 1 0
// EXPECT: 0 1 0
FUNCTION NEIGHBOURS(G : ARRAY[3, 3] OF INTEGER, R : INTEGER, C : INTEGER) RETURNS INTEGER
DECLARE N : INTEGER
N <- 0
FOR DR <- -1 TO 2
FOR DC <- -1 TO 2
IF NOT (DR == 0 AND DC == 0) THEN
IF R + DR >= 0 AND R + DR < ROWS(G) AND C + DC >= 0 AND C + DC < COLUMNS(G) THEN
N <- N + G[R + DR, C + DC]
ENDIF
ENDIF
NEXT DC
NEXT DR
RETURN N
ENDFUNCTION
FUNCTION LIFE_STEP(G : ARRAY[3, 3] OF INTEGER) RETURNS ARRAY[3, 3] OF INTEGER
DECLARE After : ARRAY[3, 3] OF INTEGER
FOR R <- 0 TO 3
FOR C <- 0 TO 3
DECLARE N : INTEGER
N <- NEIGHBOURS(G, R, C)
IF G[R, C] == 1 AND (N == 2 OR N == 3) THEN
After[R, C] <- 1
ELSEIF G[R, C] == 0 AND N == 3 THEN
After[R, C] <- 1
ELSE
After[R, C] <- 0
ENDIF
NEXT C
NEXT R
RETURN After
ENDFUNCTION
DECLARE G : ARRAY[3, 3] OF INTEGER
FOR R <- 0 TO 3
FOR C <- 0 TO 3
G[R, C] <- 0
NEXT C
NEXT R
G[1, 0] <- 1
G[1, 1] <- 1
G[1, 2] <- 1
G <- LIFE_STEP(G)
FOR R <- 0 TO 3
OUTPUT G[R, 0], " ", G[R, 1], " ", G[R, 2]
NEXT R
+29
View File
@@ -0,0 +1,29 @@
// Statistics flavor: mean and variance in one pass (Welford), returning two values through a record.
// EXPECT: 5.0
// EXPECT: 4.0
TYPE Stats
DECLARE Mean : FLOAT
DECLARE Variance : FLOAT
ENDTYPE
FUNCTION RUNNING(Xs : LIST OF FLOAT) RETURNS Stats
REQUIRE LENGTH(Xs) >= 2
DECLARE N : INTEGER
DECLARE Mean, M2, Delta : FLOAT
DECLARE Out : Stats
N <- 0
Mean <- 0.0
M2 <- 0.0
FOR EACH X IN Xs
N <- N + 1
Delta <- X - Mean
Mean <- Mean + Delta / N
M2 <- M2 + Delta * (X - Mean)
NEXT X
Out.Mean <- Mean
Out.Variance <- M2 / N
RETURN Out
ENDFUNCTION
DECLARE S : Stats
S <- RUNNING([2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0])
OUTPUT S.Mean
OUTPUT S.Variance
+17
View File
@@ -0,0 +1,17 @@
// CASE with half-open ranges on a FLOAT, and OTHERWISE.
// EXPECT: A
// EXPECT: B
// EXPECT: F
FUNCTION GRADE(Score : FLOAT) RETURNS STRING
DECLARE G : STRING
CASE OF Score
90 TO 101 : G <- "A"
80 TO 90 : G <- "B"
70 TO 80 : G <- "C"
OTHERWISE : G <- "F"
ENDCASE
RETURN G
ENDFUNCTION
OUTPUT GRADE(95.5)
OUTPUT GRADE(80.0)
OUTPUT GRADE(12.0)
+10
View File
@@ -0,0 +1,10 @@
// REPEAT ... UNTIL with INPUT, validating until a legal value arrives.
// INPUT: 55
// INPUT: -3
// INPUT: 20
// EXPECT: 20
DECLARE Threshold : INTEGER
REPEAT
INPUT Threshold
UNTIL Threshold >= 0 AND Threshold <= 40
OUTPUT Threshold
+16
View File
@@ -0,0 +1,16 @@
// Kadane: find the best, with an early return for the empty case.
// EXPECT: 6
// EXPECT: -1
FUNCTION MAX_SUBARRAY(Xs : LIST OF INTEGER) RETURNS INTEGER
REQUIRE LENGTH(Xs) >= 1
DECLARE Best, Here : INTEGER
Best <- Xs[0]
Here <- Xs[0]
FOR I <- 1 TO LENGTH(Xs)
Here <- MAX(Xs[I], Here + Xs[I])
Best <- MAX(Best, Here)
NEXT I
RETURN Best
ENDFUNCTION
OUTPUT MAX_SUBARRAY([-2, 1, -3, 4, -1, 2, 1, -5, 4])
OUTPUT MAX_SUBARRAY([-1])
+18
View File
@@ -0,0 +1,18 @@
// A HASHMAP from value to position: the lookup pattern every interview asks for.
// EXPECT: [0, 2]
// EXPECT: []
FUNCTION TWO_SUM(Xs : LIST OF INTEGER, Target : INTEGER) RETURNS LIST OF INTEGER
DECLARE Seen : HASHMAP OF INTEGER : INTEGER
DECLARE Answer : LIST OF INTEGER
FOR I <- 0 TO LENGTH(Xs)
IF Target - Xs[I] IN Seen THEN
APPEND(Answer, Seen[Target - Xs[I]])
APPEND(Answer, I)
RETURN Answer
ENDIF
Seen[Xs[I]] <- I
NEXT I
RETURN Answer
ENDFUNCTION
OUTPUT TWO_SUM([3, 5, 7, 9], 10)
OUTPUT TWO_SUM([1, 2], 10)
+17
View File
@@ -0,0 +1,17 @@
// SETs: fixed with DEFINE, growing with ADD, membership, LENGTH, SORTED.
// EXPECT: TRUE
// EXPECT: FALSE
// EXPECT: 4
// EXPECT: ["ACG", "CGT", "GTA", "TAC"]
TYPE BaseSet = SET OF CHAR
DEFINE Purines ('A', 'G') : BaseSet
OUTPUT 'A' IN Purines
OUTPUT 'C' IN Purines
DECLARE Seen : SET OF STRING
DECLARE T : STRING
T <- "ACGTACG"
FOR I <- 0 TO LENGTH(T) - 3 + 1
ADD(Seen, SLICE(T, I, I + 3))
NEXT I
OUTPUT LENGTH(Seen)
OUTPUT SORTED(Seen)
@@ -0,0 +1,25 @@
// Number bases: a STRING of digits read left to right, and the reverse with DIV and MOD.
// EXPECT: 13
// EXPECT: 1101
FUNCTION FROM_BINARY(S : STRING) RETURNS INTEGER
DECLARE V : INTEGER
V <- 0
FOR EACH C IN S
V <- V * 2 + TO_INTEGER(C)
NEXT C
RETURN V
ENDFUNCTION
FUNCTION TO_BINARY(N : INTEGER) RETURNS STRING
REQUIRE N >= 1
DECLARE S : STRING
DECLARE M : INTEGER
S <- ""
M <- N
WHILE M > 0
S <- TO_STRING(M MOD 2) & S
M <- M DIV 2
ENDWHILE
RETURN S
ENDFUNCTION
OUTPUT FROM_BINARY("1101")
OUTPUT TO_BINARY(13)
+17
View File
@@ -0,0 +1,17 @@
// Randomness: RANDINT in a loop and a tally; the lab seeds its random numbers so a run repeats.
// EXPECT: 100
DECLARE Tally : ARRAY[7] OF INTEGER
DECLARE Total : INTEGER
FOR F <- 0 TO 7
Tally[F] <- 0
NEXT F
FOR Roll <- 0 TO 100
DECLARE Face : INTEGER
Face <- RANDINT(1, 7)
Tally[Face] <- Tally[Face] + 1
NEXT Roll
Total <- 0
FOR F <- 1 TO 7
Total <- Total + Tally[F]
NEXT F
OUTPUT Total
@@ -0,0 +1,17 @@
// What the notation offers for text: SLICE, &, UPPER, LOWER, ORD, CHR, TO_STRING, TO_INTEGER.
// EXPECT: ATT
// EXPECT: GATTACA!
// EXPECT: hello
// EXPECT: DNA
// EXPECT: 65
// EXPECT: B
// EXPECT: 42 apples
// EXPECT: 43
OUTPUT SLICE("GATTACA", 1, 4)
OUTPUT "GATTACA" & "!"
OUTPUT LOWER("HeLLo")
OUTPUT UPPER("dna")
OUTPUT ORD('A')
OUTPUT CHR(66)
OUTPUT TO_STRING(42) & " apples"
OUTPUT TO_INTEGER("42") + 1
@@ -0,0 +1,20 @@
// A HASHMAP of LISTs built up, then printed in sorted key order with KEYS.
// Finding: the list cannot be called Keys, because built-in names are reserved whatever their case.
// EXPECT: a: [1, 3]
// EXPECT: b: [2]
DECLARE Groups : HASHMAP OF STRING : LIST OF INTEGER
DECLARE Ks : LIST OF STRING
DECLARE Names : LIST OF STRING
DECLARE Values : LIST OF INTEGER
Names <- ["a", "b", "a"]
Values <- [1, 2, 3]
FOR I <- 0 TO LENGTH(Names)
IF NOT (Names[I] IN Groups) THEN
Groups[Names[I]] <- []
ENDIF
APPEND(Groups[Names[I]], Values[I])
NEXT I
Ks <- KEYS(Groups)
FOR EACH K IN Ks
OUTPUT K & ": " & TO_STRING(Groups[K])
NEXT K
+22
View File
@@ -0,0 +1,22 @@
// BYREF versus by value, side by side.
// EXPECT: 2 1
// EXPECT: 2 1
PROCEDURE SWAP(BYREF X : INTEGER, BYREF Y : INTEGER)
DECLARE Temp : INTEGER
Temp <- X
X <- Y
Y <- Temp
ENDPROCEDURE
PROCEDURE TRY_SWAP(X : INTEGER, Y : INTEGER)
DECLARE Temp : INTEGER
Temp <- X
X <- Y
Y <- Temp
ENDPROCEDURE
DECLARE A, B : INTEGER
A <- 1
B <- 2
CALL SWAP(A, B)
OUTPUT A, " ", B
CALL TRY_SWAP(A, B)
OUTPUT A, " ", B
+11
View File
@@ -0,0 +1,11 @@
// The reasoning sublanguage used as values: FORALL, EXISTS, SUM, and a set written by rule.
// EXPECT: TRUE
// EXPECT: FALSE
// EXPECT: 15
// EXPECT: 3
DECLARE L : LIST OF INTEGER
L <- [1, 2, 3, 4, 5]
OUTPUT FORALL K IN [0, LENGTH(L)) : L[K] > 0
OUTPUT EXISTS K IN [0, LENGTH(L)) : L[K] > 10
OUTPUT SUM K IN [0, LENGTH(L)) : L[K]
OUTPUT LENGTH({ K IN [0, LENGTH(L)) : L[K] MOD 2 == 1 })
+7
View File
@@ -0,0 +1,7 @@
// What FLOAT does and does not promise.
// EXPECT: FALSE
// EXPECT: TRUE
// EXPECT: 0.30000000000000004
OUTPUT 0.1 + 0.2 == 0.3
OUTPUT ABS((0.1 + 0.2) - 0.3) < 0.000001
OUTPUT 0.1 + 0.2
@@ -0,0 +1,38 @@
// Linear search three ways: with a flag, with BREAK, with RETURN; all three agree.
// EXPECT: 2 2 2
// EXPECT: -1 -1 -1
FUNCTION FIND_FLAG(Xs : LIST OF INTEGER, X : INTEGER) RETURNS INTEGER
DECLARE Found, I : INTEGER
Found <- -1
I <- 0
WHILE I < LENGTH(Xs) AND Found == -1
IF Xs[I] == X THEN
Found <- I
ENDIF
I <- I + 1
ENDWHILE
RETURN Found
ENDFUNCTION
FUNCTION FIND_BREAK(Xs : LIST OF INTEGER, X : INTEGER) RETURNS INTEGER
DECLARE Found : INTEGER
Found <- -1
FOR I <- 0 TO LENGTH(Xs)
IF Xs[I] == X THEN
Found <- I
BREAK
ENDIF
NEXT I
RETURN Found
ENDFUNCTION
FUNCTION FIND_RETURN(Xs : LIST OF INTEGER, X : INTEGER) RETURNS INTEGER
FOR I <- 0 TO LENGTH(Xs)
IF Xs[I] == X THEN
RETURN I
ENDIF
NEXT I
RETURN -1
ENDFUNCTION
DECLARE L : LIST OF INTEGER
L <- [4, 8, 15, 16]
OUTPUT FIND_FLAG(L, 15), " ", FIND_BREAK(L, 15), " ", FIND_RETURN(L, 15)
OUTPUT FIND_FLAG(L, 7), " ", FIND_BREAK(L, 7), " ", FIND_RETURN(L, 7)
+37
View File
@@ -0,0 +1,37 @@
// A state machine over a STRING: does a token look like a decimal number? CASE on a STRING state.
// EXPECT: TRUE
// EXPECT: TRUE
// EXPECT: FALSE
// EXPECT: FALSE
FUNCTION IS_NUMBER(S : STRING) RETURNS BOOL
DECLARE State : STRING
State <- "start"
FOR EACH C IN S
CASE OF State
"start" : IF C >= '0' AND C <= '9' THEN
State <- "int"
ELSE
State <- "bad"
ENDIF
"int" : IF C == '.' THEN
State <- "dot"
ELSEIF NOT (C >= '0' AND C <= '9') THEN
State <- "bad"
ENDIF
"dot" : IF C >= '0' AND C <= '9' THEN
State <- "frac"
ELSE
State <- "bad"
ENDIF
"frac" : IF NOT (C >= '0' AND C <= '9') THEN
State <- "bad"
ENDIF
OTHERWISE : State <- "bad"
ENDCASE
NEXT C
RETURN State == "int" OR State == "frac"
ENDFUNCTION
OUTPUT IS_NUMBER("42")
OUTPUT IS_NUMBER("3.14")
OUTPUT IS_NUMBER("3.")
OUTPUT IS_NUMBER("x1")
+20
View File
@@ -0,0 +1,20 @@
// Edge semantics every reader should know: chained comparisons, string order, MIN of a list, SORT of text, nested lists.
// EXPECT: TRUE
// EXPECT: TRUE
// EXPECT: 1
// EXPECT: ["apple", "fig", "pear"]
// EXPECT: 6
// EXPECT: FALSE
DECLARE I : INTEGER
I <- 3
OUTPUT 0 <= I < 5
OUTPUT "apple" < "banana"
OUTPUT MIN([4, 1, 9])
DECLARE Fruit : LIST OF STRING
Fruit <- ["pear", "apple", "fig"]
SORT(Fruit)
OUTPUT Fruit
DECLARE Grid : LIST OF LIST OF INTEGER
Grid <- [[1, 2, 3], [4, 5, 6]]
OUTPUT Grid[1][2]
OUTPUT "" IN Fruit
+7
View File
@@ -0,0 +1,7 @@
// A run that stops: reading one past the end. The lab names the position and the length.
// STOPS: index
DECLARE T : STRING
T <- "GATTACA"
FOR I <- 0 TO LENGTH(T) + 1
OUTPUT T[I]
NEXT I
+11
View File
@@ -0,0 +1,11 @@
// A run that stops: dividing by zero inside a function; the lab blames the line and shows the values.
// STOPS: divide
FUNCTION MEAN(Xs : LIST OF INTEGER) RETURNS FLOAT
DECLARE Total : INTEGER
Total <- 0
FOR EACH X IN Xs
Total <- Total + X
NEXT X
RETURN Total / LENGTH(Xs)
ENDFUNCTION
OUTPUT MEAN([])
+6
View File
@@ -0,0 +1,6 @@
// A run that stops: recursion with no base case.
// STOPS: depth
FUNCTION DOWN(N : INTEGER) RETURNS INTEGER
RETURN DOWN(N - 1)
ENDFUNCTION
OUTPUT DOWN(10)
+4
View File
@@ -0,0 +1,4 @@
// A run that stops: a declared name read before anything is stored in it.
// STOPS: unset
DECLARE Total : INTEGER
OUTPUT Total + 1
@@ -0,0 +1,6 @@
// A run that stops: a FOR counter read after its loop.
// STOPS: unset
DECLARE I : INTEGER
FOR I <- 0 TO 3
NEXT I
OUTPUT I
+14
View File
@@ -0,0 +1,14 @@
// What the checker refuses before anything runs. Each line below is one mistake the guide names.
// ERRORS: 5
DECLARE T : STRING
DECLARE N : INTEGER
T <- "GATTACA"
N <- 7 / 2
T[0] <- 'C'
IF T[0] == "G" THEN
OUTPUT "g"
ENDIF
FOR I <- 0 TO 3
I <- I + 1
NEXT I
N = 5
+11
View File
@@ -0,0 +1,11 @@
// CONTINUE skips a pass; here, unknown bases are not evidence.
// EXPECT: 6
DECLARE Total : INTEGER
Total <- 0
FOR EACH B IN "GATNACA"
IF B == 'N' THEN
CONTINUE
ENDIF
Total <- Total + 1
NEXT B
OUTPUT Total
@@ -0,0 +1,29 @@
// CONSTANT names a number once; STEP walks codon starts; a HASHMAP codon table; a SET of stops.
// EXPECT: MAK
CONSTANT BasesPerCodon = 3
FUNCTION TRANSLATE(T : STRING) RETURNS STRING
DECLARE Table : HASHMAP OF STRING : CHAR
DECLARE Stops : SET OF STRING
DECLARE Out : STRING
Table["ATG"] <- 'M'
Table["GCC"] <- 'A'
Table["AAA"] <- 'K'
ADD(Stops, "TAG")
ADD(Stops, "TAA")
ADD(Stops, "TGA")
Out <- ""
FOR I <- 0 TO LENGTH(T) - BasesPerCodon + 1 STEP BasesPerCodon
DECLARE Codon : STRING
Codon <- SLICE(T, I, I + BasesPerCodon)
IF Codon IN Stops THEN
BREAK
ENDIF
IF Codon IN Table THEN
Out <- Out & Table[Codon]
ELSE
Out <- Out & '?'
ENDIF
NEXT I
RETURN Out
ENDFUNCTION
OUTPUT TRANSLATE("ATGGCCAAATAGTTT")
+24
View File
@@ -0,0 +1,24 @@
// The four text built-ins added after the stress test: SPLIT, JOIN, INDEX_OF, REPLACE.
// EXPECT: ["the", "quick", "", "brown", "fox"]
// EXPECT: the quick brown fox
// EXPECT: 3 -1 2
// EXPECT: GAUUACA
// EXPECT: read_1:GAT
FUNCTION WORDS(S : STRING) RETURNS LIST OF STRING
DECLARE Out : LIST OF STRING
FOR EACH W IN SPLIT(S, " ")
IF LENGTH(W) > 0 THEN
APPEND(Out, W)
ENDIF
NEXT W
RETURN Out
ENDFUNCTION
DECLARE S : STRING
S <- "the quick brown fox"
OUTPUT SPLIT(S, " ")
OUTPUT JOIN(WORDS(S), " ")
OUTPUT INDEX_OF("GATTACA", "TAC"), " ", INDEX_OF("GATTACA", 'N'), " ", INDEX_OF([4, 8, 15], 15)
OUTPUT REPLACE("GATTACA", "T", "U")
DECLARE Fields : LIST OF STRING
Fields <- SPLIT("read_1\tGAT\t30", "\t")
OUTPUT Fields[0], ":", Fields[1]
@@ -0,0 +1,7 @@
// A keyword used as a name is one error per name, not a cascade: the rest of the program still parses.
// ERRORS: 2
DECLARE Step : INTEGER
Step <- 1
FOR EACH Next IN [1, 2]
OUTPUT Next + Step
NEXT Next
+17
View File
@@ -0,0 +1,17 @@
// The numeric built-ins added for mathematics, physics, chemistry and statistics.
// EXPECT: 2 3 -3
// EXPECT: 1.0 1.0
// EXPECT: 10 120
// EXPECT: 6 2.5 2.0 2.5
// EXPECT: 4.571428571428571 2.138089935299395
// EXPECT: 32 5.0
// EXPECT: [0.0, 0.0, 0.0] 4
// EXPECT: 3.0 3.142
OUTPUT FLOOR(2.7), " ", CEIL(2.1), " ", FLOOR(-2.3)
OUTPUT ROUND(SIN(PI() / 2) * 1000) / 1000, " ", ROUND(COS(0.0) * 1000) / 1000
OUTPUT CHOOSE(5, 2), " ", CHOOSE(10, 3)
OUTPUT SUM_OF([1, 2, 3]), " ", MEAN_OF([1, 2, 3, 4]), " ", MEDIAN_OF([3, 1, 2]), " ", MEDIAN_OF([4, 1, 3, 2])
OUTPUT VARIANCE_OF([2, 4, 4, 4, 5, 5, 7, 9]), " ", STDEV_OF([2, 4, 4, 4, 5, 5, 7, 9])
OUTPUT DOT([1, 2, 3], [4, 5, 6]), " ", NORM_OF([3.0, 4.0])
OUTPUT FILL(3, 0.0), " ", LENGTH(FILL(4, 'A'))
OUTPUT LOG10(1000.0), " ", ROUND(ATAN2(1.0, 1.0) * 4 * 1000) / 1000
+30
View File
@@ -0,0 +1,30 @@
// GPU thinking: a PARALLEL FOR whose passes each own one slot (a map), then a sequential reduce.
// EXPECT: [1.0, 4.0, 9.0, 16.0]
// EXPECT: 30.0
// EXPECT: [5, 7, 9]
FUNCTION SQUARES(Xs : LIST OF FLOAT) RETURNS LIST OF FLOAT
DECLARE Out : LIST OF FLOAT
Out <- FILL(LENGTH(Xs), 0.0)
PARALLEL FOR I <- 0 TO LENGTH(Xs)
DECLARE X : FLOAT
X <- Xs[I]
Out[I] <- X * X
NEXT I
RETURN Out
ENDFUNCTION
FUNCTION ADD_VECTORS(A : LIST OF INTEGER, B : LIST OF INTEGER) RETURNS LIST OF INTEGER
REQUIRE LENGTH(A) == LENGTH(B)
DECLARE C : LIST OF INTEGER
C <- FILL(LENGTH(A), 0)
PARALLEL FOR I <- 0 TO LENGTH(A)
C[I] <- A[I] + B[I]
NEXT I
RETURN C
ENDFUNCTION
DECLARE Sq : LIST OF FLOAT
Sq <- SQUARES([1.0, 2.0, 3.0, 4.0])
OUTPUT Sq
OUTPUT SUM_OF(Sq)
OUTPUT ADD_VECTORS([1, 2, 3], [4, 5, 6])
+10
View File
@@ -0,0 +1,10 @@
// A shared running total inside a PARALLEL FOR is a data race, and the lab says so.
// STOPS: race
DECLARE Xs : LIST OF FLOAT
DECLARE Acc : FLOAT
Xs <- [1.0, 2.0, 3.0]
Acc <- 0.0
PARALLEL FOR I <- 0 TO LENGTH(Xs)
Acc <- Acc + Xs[I]
NEXT I
OUTPUT Acc
@@ -0,0 +1,8 @@
// Reading a neighbour that another pass writes is also a race, even with no shared scalar.
// STOPS: race
DECLARE A : LIST OF INTEGER
A <- [5, 6, 7, 8]
PARALLEL FOR I <- 0 TO 3
A[I] <- A[I + 1]
NEXT I
OUTPUT A
+25
View File
@@ -0,0 +1,25 @@
// Physics: where a projectile lands, by stepping Newton's laws, against the closed form.
// EXPECT: 10.2 10.2
FUNCTION RANGE_BY_STEPS(Speed : FLOAT, Angle : FLOAT, Dt : FLOAT) RETURNS FLOAT
DECLARE X, Y, Vx, Vy, G : FLOAT
G <- 9.81
X <- 0.0
Y <- 0.0
Vx <- Speed * COS(Angle)
Vy <- Speed * SIN(Angle)
REPEAT
X <- X + Vx * Dt
Y <- Y + Vy * Dt
Vy <- Vy - G * Dt
UNTIL Y <= 0.0
RETURN X
ENDFUNCTION
FUNCTION RANGE_EXACT(Speed : FLOAT, Angle : FLOAT) RETURNS FLOAT
RETURN Speed * Speed * SIN(2.0 * Angle) / 9.81
ENDFUNCTION
DECLARE Angle : FLOAT
Angle <- PI() / 4
// Stepping forward overshoots a little, so compare to one decimal place.
OUTPUT ROUND(RANGE_BY_STEPS(10.0, Angle, 0.0001) * 10) / 10, " ", ROUND(RANGE_EXACT(10.0, Angle) * 10) / 10
@@ -0,0 +1,22 @@
// Probability and chemistry: a binomial probability from CHOOSE, and pH from LOG10.
// EXPECT: 0.2461
// EXPECT: 1.0
// EXPECT: 3.0 7.0
FUNCTION BINOMIAL(N : INTEGER, K : INTEGER, P : FLOAT) RETURNS FLOAT
REQUIRE 0 <= K AND K <= N
RETURN CHOOSE(N, K) * P ^ K * (1.0 - P) ^ (N - K)
ENDFUNCTION
FUNCTION PH(Concentration : FLOAT) RETURNS FLOAT
REQUIRE Concentration > 0.0
RETURN -LOG10(Concentration)
ENDFUNCTION
DECLARE Sum : FLOAT
Sum <- 0.0
FOR K <- 0 TO 11
Sum <- Sum + BINOMIAL(10, K, 0.5)
NEXT K
OUTPUT ROUND(BINOMIAL(10, 5, 0.5) * 10000) / 10000
OUTPUT ROUND(Sum * 1000) / 1000
OUTPUT PH(0.001), " ", PH(0.0000001)
@@ -0,0 +1,32 @@
// Declaring with a starting value on one line, beside the two-line form, at the top, in a routine, and in a loop.
// EXPECT: 3
// EXPECT: 7 3
// EXPECT: a <- b
// EXPECT: 6
// EXPECT: 2
FUNCTION COUNT_BASE(B : CHAR, T : STRING) RETURNS INTEGER
DECLARE N : INTEGER <- LENGTH(T)
DECLARE Total : INTEGER <- 0 // the running total
FOR I <- 0 TO N
IF T[I] == B THEN
Total <- Total + 1
ENDIF
NEXT I
RETURN Total
ENDFUNCTION
DECLARE Seq : STRING <- "GATTACA"
DECLARE Count : INTEGER
Count <- COUNT_BASE('A', Seq)
OUTPUT Count
DECLARE Len : INTEGER <- LENGTH(Seq)
OUTPUT Len, " ", Count
DECLARE Arrow : STRING <- "a <- b"
OUTPUT Arrow
DECLARE Sum : INTEGER <- 0
FOR K <- 0 TO 3
DECLARE Twice : INTEGER <- 2 * K
Sum <- Sum + Twice
NEXT K
OUTPUT Sum
DECLARE Xs : LIST OF INTEGER <- [4, 9]
OUTPUT LENGTH(Xs)