9af0a0e18b
@Kha `withReader` is a well-behaved version of `adaptReader`. `adaptReader` is
too general, and it often produces counterintuitive elaboration
errors.
Here are two super annoying issues I hit all the time:
1- `adaptReader` + polymorphic code
```
def ex1 : ReaderT Nat IO Unit :=
adaptReader (fun x => x + 1) $
IO.println "foo" -- 3 Errors here failed to synthesize `Monad ?m` and `MonadIO ?m`, and don't know how to synthesize `Type → Type`
```
2- `adaptReader` and notation that requires the expected type
```
structure Context :=
(x y : Nat)
def ex2 : ReaderT Context IO Nat :=
adaptReader (fun s => { s with x := 10 }) $ -- Error at the structure instance
...
```
In the example above, I have to write `fun (s : Context) => ...` to
fix the problem.
The two problems above happen in the old and new frontends. However,
there is a new problem specific for the new frontend. In the new
frontend, a `do` is only elaborated when the expected type is known.
So, `adaptReader (fun ctx => ...) do ...` seldom works :(
As I said above, the issue is that `adaptReader` is too general. Its
type is
```
{ρ ρ' : Type u_1} → {m m' : Type u_1 → Type u_2} → [MonadReaderAdapter ρ ρ' m m'] → {α : Type u_1} → (ρ' → ρ) → m α → m' α
```
`withReader` is a simpler version of `adaptReader`
```
withReader : {ρ : Type u_1} → {m : Type u_1 → Type u_2} → [MonadWithReader ρ m] → {α : Type u_1} → (ρ → ρ) → m α → m α
```
It doesn't have any of the problems above. Moreover, I managed to replace
every single instance of `adaptReader` with `withReader` at the stdlib
and tests. We don't need the `adaptReader` generality.
55 lines
1.4 KiB
Text
55 lines
1.4 KiB
Text
import Lean.CoreM
|
|
new_frontend
|
|
open Lean
|
|
|
|
structure MyState :=
|
|
(traceState : TraceState := {})
|
|
(s : Nat := 0)
|
|
|
|
abbrev M := CoreM
|
|
|
|
def tst1 : M Unit :=
|
|
do trace! `module ("hello" ++ MessageData.nest 9 (Format.line ++ "world"));
|
|
trace! `module.aux "another message";
|
|
pure ()
|
|
|
|
def tst2 (b : Bool) : M Unit :=
|
|
traceCtx `module $ do
|
|
tst1;
|
|
trace! `bughunt "at test2";
|
|
when b $ throwError "error";
|
|
tst1;
|
|
pure ()
|
|
|
|
partial def ack : Nat → Nat → Nat
|
|
| 0, n => n+1
|
|
| m+1, 0 => ack m 1
|
|
| m+1, n+1 => ack m (ack (m+1) n)
|
|
|
|
def slow (b : Bool) : Nat :=
|
|
ack 4 (cond b 0 1)
|
|
|
|
def tst3 (b : Bool) : M Unit :=
|
|
do traceCtx `module $ do {
|
|
tst2 b;
|
|
tst1
|
|
};
|
|
trace! `bughunt "at end of tst3";
|
|
-- Messages are computed lazily. The following message will only be computed
|
|
-- if `trace.slow is active.
|
|
trace! `slow ("slow message: " ++ toString (slow b))
|
|
|
|
def run (x : M Unit) : M Unit :=
|
|
withReader
|
|
(fun ctx =>
|
|
-- Try commeting/uncommeting the following `setBool`s
|
|
let opts := ctx.options;
|
|
let opts := opts.setBool `trace.module true;
|
|
-- let opts := opts.setBool `trace.module.aux false;
|
|
let opts := opts.setBool `trace.bughunt true;
|
|
-- let opts := opts.setBool `trace.slow true;
|
|
{ ctx with options := opts })
|
|
(«catch» («finally» x printTraces) (fun _ => IO.println "ERROR"))
|
|
|
|
#eval run (tst3 true)
|
|
#eval run (tst3 false)
|