3a457e6ad6
Many of our tests in `tests/lean/run/` produce output from `#eval` (or `#check`) statements, that is then ignored. This PR tries to capture all the useful output using `#guard_msgs`. I've only done a cursory check that the output is still sane --- there is a chance that some "unchecked" tests have already accumulated regressions and this just cements them! In the other direction, I did identify two rotten tests: * a minor one in `setStructInstNotation.lean`, where a comment says `Set Nat`, but `#check` actually prints `?_`. Weird? * `CompilerProbe.lean` is generating empty output, apparently indicating that something is broken, but I don't know the signficance of this file. In any case, I'll ask about these elsewhere. (This started by noticing that a recent `grind` test file had an untested `trace_state`, and then got carried away.)
89 lines
2.7 KiB
Text
89 lines
2.7 KiB
Text
theorem zero_lt_of_lt : {a b : Nat} → a < b → 0 < b
|
||
| 0, _, h => h
|
||
| a+1, b, h =>
|
||
have : a < b := Nat.lt_trans (Nat.lt_succ_self _) h
|
||
zero_lt_of_lt this
|
||
|
||
def fold {m α β} [Monad m] (as : Array α) (b : β) (f : α → β → m β) : m β := do
|
||
let rec loop : (i : Nat) → i ≤ as.size → β → m β
|
||
| 0, h, b => pure b
|
||
| i+1, h, b => do
|
||
have h' : i < as.size := Nat.lt_of_lt_of_le (Nat.lt_succ_self i) h
|
||
have : as.size - 1 < as.size := Nat.sub_lt (zero_lt_of_lt h') (by decide)
|
||
have : as.size - 1 - i < as.size := Nat.lt_of_le_of_lt (Nat.sub_le (as.size - 1) i) this
|
||
let b ← f (as.get ⟨as.size - 1 - i, this⟩) b
|
||
loop i (Nat.le_of_lt h') b
|
||
loop as.size (Nat.le_refl _) b
|
||
|
||
#guard (Id.run $ fold #[1, 2, 3, 4] 0 (pure $ · + ·)) == 10
|
||
|
||
theorem ex : (Id.run $ fold #[1, 2, 3, 4] 0 (pure $ · + ·)) = 10 :=
|
||
rfl
|
||
|
||
def fold2 {m α β} [Monad m] (as : Array α) (b : β) (f : α → β → m β) : m β :=
|
||
let rec loop (i : Nat) (h : i ≤ as.size) (b : β) : m β := do
|
||
match i, h with
|
||
| 0, h => return b
|
||
| i+1, h =>
|
||
have h' : i < as.size := Nat.lt_of_lt_of_le (Nat.lt_succ_self i) h
|
||
have : as.size - 1 < as.size := Nat.sub_lt (zero_lt_of_lt h') (by decide)
|
||
have : as.size - 1 - i < as.size := Nat.lt_of_le_of_lt (Nat.sub_le (as.size - 1) i) this
|
||
let b ← f (as.get ⟨as.size - 1 - i, this⟩) b
|
||
loop i (Nat.le_of_lt h') b
|
||
loop as.size (Nat.le_refl _) b
|
||
|
||
def f (x : Nat) (ref : IO.Ref Nat) : IO Nat := do
|
||
let mut x := x
|
||
if x == 0 then
|
||
x ← ref.get
|
||
IO.println x
|
||
return x + 1
|
||
|
||
def fTest : IO Unit := do
|
||
unless (← f 0 (← IO.mkRef 10)) == 11 do throw $ IO.userError "unexpected"
|
||
unless (← f 1 (← IO.mkRef 10)) == 2 do throw $ IO.userError "unexpected"
|
||
|
||
def g (x y : Nat) (ref : IO.Ref (Nat × Nat)) : IO (Nat × Nat) := do
|
||
let mut (x, y) := (x, y)
|
||
if x == 0 then
|
||
(x, y) ← ref.get
|
||
IO.println ("x: " ++ toString x ++ ", y: " ++ toString y)
|
||
return (x, y)
|
||
|
||
def gTest : IO Unit := do
|
||
unless (← g 2 1 (← IO.mkRef (10, 20))) == (2, 1) do throw $ IO.userError "unexpected"
|
||
unless (← g 0 1 (← IO.mkRef (10, 20))) == (10, 20) do throw $ IO.userError "unexpected"
|
||
return ()
|
||
|
||
/--
|
||
info: x: 2, y: 1
|
||
x: 10, y: 20
|
||
-/
|
||
#guard_msgs in
|
||
#eval gTest
|
||
|
||
macro "ret!" x:term : doElem => `(doElem| return $x)
|
||
|
||
def f1 (x : Nat) : Nat := Id.run <| do
|
||
let mut x := x
|
||
if x == 0 then
|
||
ret! 100
|
||
x := x + 1
|
||
ret! x
|
||
|
||
theorem ex1 : f1 0 = 100 := rfl
|
||
theorem ex2 : f1 1 = 2 := rfl
|
||
theorem ex3 : f1 3 = 4 := rfl
|
||
|
||
syntax "inc!" ident : doElem
|
||
|
||
macro_rules
|
||
| `(doElem| inc! $x) => `(doElem| $x:ident := $x + 1)
|
||
|
||
def f2 (x : Nat) : Nat := Id.run <| do
|
||
let mut x := x
|
||
inc! x
|
||
ret! x
|
||
|
||
theorem ex4 : f2 0 = 1 := rfl
|
||
theorem ex5 : f2 3 = 4 := rfl
|