(You need `Pluto#main` to run this notebook)

👀 Reading hidden code

176 μs

This notebook contains visual debugging:

👀 Reading hidden code

235 μs

begin

1.2228445449938519

asdf

end

👀 Reading hidden code

@visual_debug begin

(1+2) + (7-6)

plot(2000 .+ 30 .* rand(2+2))

4+5

sqrt(sqrt(sqrt(5)))

md"# asdf"

end

108 ms

and visual testing:

👀 Reading hidden code

209 μs

∈

Int64

👀 Reading hidden code

@test 4+4 ∈ [1:7...]

36.6 ms

👀 Reading hidden code

TableOfContents()

10.8 μs

👀 Reading hidden code

using HypertextLiteral

: @htl, @htl_str

4.5 ms

👀 Reading hidden code

using PlutoUI

162 ms

Type definitions

👀 Reading hidden code

165 μs

abstract type TestResult end

👀 Reading hidden code

336 μs

abstract type Fail <: TestResult end

👀 Reading hidden code

323 μs

abstract type Pass <: TestResult end

👀 Reading hidden code

355 μs

Any

const Code = Any

👀 Reading hidden code

125 μs

struct Correct <: Pass

expr::Code

end

👀 Reading hidden code

1.2 ms

struct WrongCall <: Fail

expr::Code

arg_results::Vector

end

👀 Reading hidden code

1.2 ms

struct Error <: Fail

expr::Code

error

end

👀 Reading hidden code

1.1 ms

struct Wrong <: Fail

expr::Code

result

end

👀 Reading hidden code

1.1 ms

struct CorrectCall <: Pass

expr::Code

arg_results::Vector

end

👀 Reading hidden code

1.2 ms

Test macro

👀 Reading hidden code

159 μs

test (generic function with 1 method)

function test(expr)

if Meta.isexpr(expr, :call)

quote

expr_raw = $(QuoteNode(expr))

try

arg_results = [$((expr.args[2:end] .|> esc)...)]

result = $(esc(:eval))(Expr(:call, $(expr.args[1] |> QuoteNode), arg_results...))

if result === true

CorrectCall(expr_raw, arg_results)

elseif result === false

WrongCall(expr_raw, arg_results)

else

Wrong(expr_raw, result)

end

catch e

rethrow(e)

# Error(expr_raw, e)

end

👀 Reading hidden code

1.1 ms

👀 Reading hidden code

8.8 μs

begin
    var"#578#expr_raw" = $(QuoteNode(:(x == [1, 2 + 2])))
    try
        var"#579#arg_results" = [x, [1, 2 + 2]]
        var"#580#result" = eval(Main.workspace#5.Expr(:call, :(==), var"#579#arg_results"...))
        if var"#580#result" === true
            Main.workspace#5.CorrectCall(var"#578#expr_raw", var"#579#arg_results")
        elseif var"#580#result" === false
            Main.workspace#5.WrongCall(var"#578#expr_raw", var"#579#arg_results")
        else
            Main.workspace#5.Wrong(var"#578#expr_raw", var"#580#result")
        end
    catch var"#583#e"
        Main.workspace#5.rethrow(var"#583#e")
    end
end

var"@test"; macroexpand(@__MODULE__, :(@test x == [1,2+2]); recursive=false) |> prettycolors

👀 Reading hidden code

171 ms

:(x == [1, 2 + 2])

e = :(x == [1,2+2])

👀 Reading hidden code

25.9 μs

Int64

x = [1,3]

👀 Reading hidden code

13.6 μs

WrongWrong

expr

:(missing == 2)

result

missing

@test missing == 2

👀 Reading hidden code

33.9 ms

@test 2+2 == 2+2

👀 Reading hidden code

4.9 ms

Int64

@test x == [1,2+2]

👀 Reading hidden code

17.9 ms

Any

0.841182

0.714187

0.689559

0.88402

0.217284

0.0364617

0.107563

0.268536

0.517695

0.546633

0.686819

0.993796

0.111377

0.655218

0.379838

0.537636

0.337462

0.272813

0.454145

0.745083

0.736718

0.834363

0.65025

0.863411

0.0464059

0.449314

0.900367

0.264023

0.959682

0.478604

Any

Float64

0.761655

0.755356

0.780505

0.935753

0.690835

0.482981

0.271449

0.434128

0.030103

0.784639

@test rand(50) == [rand(50),2]

👀 Reading hidden code

98.6 ms

always_false(

Float64

0.85138

0.346274

0.535081

0.0778775

0.888425

0.177395

0.95075

0.38655

0.386556

0.0675576

0.93877

0.504753

0.972742

0.990426

0.15842

0.667525

0.81775

0.121175

0.63918

0.0715341

0.561185

0.0499582

0.152873

0.38255

0.0915835

0.0199396

0.281361

0.2113

0.00296292

0.161595

Float64

0.532995

0.712883

0.144612

0.987705

0.414004

0.623872

0.921269

0.61948

0.348157

0.32426

0.380376

0.65871

0.127907

0.811677

0.392806

0.22444

0.793021

0.117175

0.732623

0.53857

0.743985

0.427879

0.494493

0.567283

0.317689

0.816974

0.759589

0.660388

0.76576

0.427062

)

@test always_false(rand(50), rand(50),123)

👀 Reading hidden code

24.1 ms

false

@visual_debug !always_false(rand(2), rand(2),123)

👀 Reading hidden code

17.7 ms

!(!(always_false(rand(2), rand(2), 123; r = 123)))

@visual_debug !!always_false(rand(2), rand(2),123; r=123)

👀 Reading hidden code

30.9 ms

always_false([1, 2, 3]...)

@visual_debug always_false([1,2,3]...)

👀 Reading hidden code

32.8 ms

Expr
  head: Symbol call
  args: Array{Any}((4,))
    1: Symbol f
    2: Int64 1
    3: Expr
      head: Symbol ...
      args: Array{Any}((1,))
        1: Int64 2
    4: Expr
      head: Symbol kw
      args: Array{Any}((2,))
        1: Symbol x
        2: Int64 3

Dump(:(

f(1,2...,x=3)

))

👀 Reading hidden code

24.4 μs

always_false (generic function with 1 method)

always_false(args...; kwargs...) = false

👀 Reading hidden code

1.1 ms

isless(

)

@test isless(2+2,1)

👀 Reading hidden code

7.3 ms

isless(

)

@test isless(1,2+2)

👀 Reading hidden code

1.5 ms

@bind n Slider(1:10)

👀 Reading hidden code

253 ms

iseven(

)

@test iseven(n^2)

👀 Reading hidden code

51.3 ms

@bind k Slider(0:15)

👀 Reading hidden code

630 μs

∈

Any

@test 4+4 ∈ [1:k...]

👀 Reading hidden code

29.2 ms

isempty(

Int64

)

@test isempty((1:k) .^ 2)

👀 Reading hidden code

60.8 ms

isempty(

Float64

1.0

1.41421

)

@test isempty([1,sqrt(2)])

👀 Reading hidden code

33.6 ms

∈

Float64

4.47214

5.0

6.0

7.0

8.0

9.0

👀 Reading hidden code

54.1 ms

∈

Float64

0.409678

0.933379

0.250468

0.0464133

0.52336

0.489122

0.0733721

0.269072

0.854858

0.92991

0.923468

0.71594

0.258934

0.697178

0.073499

0.604747

0.637055

0.286104

0.487529

0.988277

0.305635

0.346931

0.131314

0.338618

0.0136216

0.358896

0.38575

0.512054

0.788815

0.468759

@test 1 ∈ rand(60)

👀 Reading hidden code

1.5 ms

Float64

0.366585

0.510064

0.505071

0.585561

0.0719386

0.648759

0.959657

0.475301

0.238582

0.0484285

0.589032

0.144788

0.108446

0.566049

0.115325

0.752534

0.849831

0.0466752

0.557603

0.426883

0.817547

0.708668

0.56163

0.461358

0.22979

0.541572

0.687032

0.180752

0.74956

0.0110259

∋

@test rand(60) ∋ 1

👀 Reading hidden code

8.9 ms

html"""

<style>

pt-dot {

flex: 0 0 auto;

background: grey;

width: 1em;

height: 1em;

bottom: -.1em;

border-radius: 100%;

margin-right: .7em;

display: block;

position: relative;

}

.fail > pt-dot {

background: #f75d5d;

}

.pass > pt-dot {

background: #56a038;

}

.pluto-test {

font-family: "JuliaMono", monospace;

font-size: 0.75rem;

padding: 4px;

min-height: 25px;

}

.pluto-test.pass {

color: rgba(0,0,0,.5);

}

.pluto-test.fail {

background: linear-gradient(90deg, #ff2e2e14, transparent);

border-radius: 7px;

}

.pluto-test>.arg_result {

flex: 0 0 auto;

}

.pluto-test>.arg_result>div,

.pluto-test>.arg_result>div>pluto-display>div {

display: inline-flex;

}

.pluto-test>.comma {

margin-right: .5em;

}

.pluto-test.call>code {

padding: 0px;

}

.pluto-test.call.infix-operator>div {

overflow-x: auto;

}

.pluto-test {

display: flex;

align-items: baseline;

}

.pluto-test.call.infix-operator>.fname {

margin: 0px .6em;

/*color: darkred;*/

}

"""

👀 Reading hidden code

110 μs

true

(@test isodd(3)) isa Pass

👀 Reading hidden code

3.8 ms

begin

macro test(expr)

test(expr)

end

function Base.show(io::IO, m::MIME"text/html", call::Union{WrongCall,CorrectCall})

fname = call.expr.args[1]

infix = length(call.arg_results) == 2 && Meta.isbinaryoperator(fname)

classes = [

"pluto-test",

"call",

(isa(call,CorrectCall) ? "correct" : "wrong"),

(isa(call,Pass) ? "pass" : "fail"),

infix ? "infix-operator" : "prefix-operator",

]

result = @htl("""

<pt-dot></pt-dot>

$(infix ? @htl("""

$(emb(call.arg_results[1]) |> div)<span class="fname">$(fname)</span>$(emb(call.arg_results[2]) |> div)

""") : @htl("""

<span class="fname">$(fname)(</span>$(

commas(

map(div(;class="arg_result"), embed_display.(call.arg_results))

)

)<span>)</span>

"""))

</div>

""")

Base.show(io, m, result)

end

# function Base.show(io::IO, m::MIME"text/html", c::Correct)

# result = @htl("""

# <div class=$([

# "pluto-test", "pass", "correct",

# ])>

# <pt-dot></pt-dot>

# <span>$((string(remove_linenums(c.expr))))</span>

# </div>

# """)

# Base.show(io, m, result)

# end

end

👀 Reading hidden code

497 ms

flatmap (generic function with 1 method)

flatmap(args...) = vcat(map(args...)...)

👀 Reading hidden code

433 μs

commas (generic function with 2 methods)

function commas(xs, comma=@htl("<span class='comma'>, </span>"))

flatmap(enumerate(xs)) do (i,x)

if i == length(xs)

[x]

else

[x,comma]

end

👀 Reading hidden code

238 ms

embed_display (generic function with 1 method)

emb = embed_display

👀 Reading hidden code

13.1 μs

div (generic function with 1 method)

div(x; class="", style="") = @htl("<div class=$(class) style=$(style)>$(x)</div>")

👀 Reading hidden code

1.6 ms

div (generic function with 2 methods)

div(; class="", style="") = x -> @htl("<div class=$(class) style=$(style)>$(x)</div>")

👀 Reading hidden code

2.0 ms

👀 Reading hidden code

59.9 μs

prettycolors (generic function with 1 method)

prettycolors(e) = Markdown.MD([Markdown.Code("julia", string(remove_linenums(e)))])

👀 Reading hidden code

474 μs

remove_linenums (generic function with 1 method)

remove_linenums(e::Expr) = if e.head === :macrocall

Expr(e.head, (remove_linenums(x) for x in e.args)...)

else

Expr(e.head, (remove_linenums(x) for x in e.args if !(x isa LineNumberNode))...)

end

👀 Reading hidden code

1.9 ms

remove_linenums (generic function with 2 methods)

remove_linenums(x) = x

👀 Reading hidden code

337 μs

DEbugging 1

md"""

# DEbugging 1

"""

👀 Reading hidden code

169 μs

onestep (generic function with 1 method)

function onestep(e::Expr; m=Module())

results = Any[]

# push!(results, e)

arg_results = Any[a for a in e.args]

for (i,a) in enumerate(e.args)

arg_results[i] = if a isa QuoteNode

elseif (e.head === :call || e.head === :let) && i == 1

elseif a isa Expr

inner_results = onestep(a; m=m)

for ir in inner_results

arg_results[i] = ir

push!(results, Expr(e.head, arg_results...))

end

inner_results[end]

else

end

# push!(results, Expr(e.head, arg_results...))

end

push!(results, Core.eval(m, Expr(e.head, arg_results...)))

results

end

👀 Reading hidden code

3.6 ms

expr_debug (generic function with 1 method)

function expr_debug(x)

e = remove_linenums(x)

Any[e, onestep(e)...]

end

👀 Reading hidden code

1000 μs

UInt64

👀 Reading hidden code

2.3 ms

expr_hash (generic function with 1 method)

👀 Reading hidden code

1.1 ms

expr_hash (generic function with 2 methods)

👀 Reading hidden code

357 μs

debug_result = expr_debug(:(

let

r = if rand(Bool)

else

end

y = sqrt(4)

y == sqrt(sqrt(r))

end

));

👀 Reading hidden code

10.2 ms

@bind step Slider(1:length(debug_result))

👀 Reading hidden code

646 μs

let
    r = if rand(Bool)
            20
        else
            16
        end
    y = sqrt(4)
    y == sqrt(sqrt(r))
end

debug_result[step] |> prettycolors

👀 Reading hidden code

101 μs

Debugging 1.5

md"""

# Debugging 1.5

"""

👀 Reading hidden code

163 μs

struct Computed

end

👀 Reading hidden code

861 μs

computed (generic function with 1 method)

computed(x) = Computed(x)

👀 Reading hidden code

343 μs

👀 Reading hidden code

67.0 μs

expand_computed (generic function with 1 method)

expand_computed(x) = x

👀 Reading hidden code

356 μs

expand_computed (generic function with 2 methods)

expand_computed(c::Computed) = c.x

👀 Reading hidden code

375 μs

expand_computed (generic function with 3 methods)

expand_computed(e::Expr) = Expr(e.head, expand_computed.(e.args)...)

👀 Reading hidden code

468 μs

onestep_light (generic function with 1 method)

function onestep_light(e::Expr; m=Module())

results = Any[]

# will be modified

arg_results = Any[a for a in e.args]

if e.head === :call || e.head === :begin || e.head === :block

# push!(results, e)

for (i,a) in enumerate(e.args)

arg_results[i] = if a isa QuoteNode

elseif (Meta.isexpr(e, :call) || Meta.isexpr(e, :let)) && i == 1

elseif a isa Expr

inner_results = onestep_light(a; m=m)

for ir in inner_results

arg_results[i] = ir

push!(results, Expr(e.head, arg_results...))

end

inner_results[end]

else

end

# push!(results, Expr(e.head, arg_results...))

end

push!(results, Computed(Core.eval(m, expand_computed(Expr(e.head, arg_results...)))))

results

end

👀 Reading hidden code

3.8 ms

@eval_step_by_step (macro with 1 method)

macro eval_step_by_step(e)

Computed

if can_interpret(e)

quote

Any[$(QuoteNode(e)), $(onestep_light(e; m=__module__))...]

end

else

quote

[$(QuoteNode(e)), Computed($(esc(e)))]

end

👀 Reading hidden code

843 μs

quote
    Main.workspace#6.Any[$(QuoteNode(:(sqrt(sqrt(3))))), Any[:(sqrt(Computed(1.7320508075688772))), Computed(1.3160740129524924)]...]
end

remove_linenums( @macroexpand @eval_step_by_step sqrt(sqrt(3)) )

👀 Reading hidden code

1.6 ms

Any

:(sqrt(sqrt(length([1, 2]))))

:(sqrt(sqrt(length(Computed([1, 2])))))

:(sqrt(sqrt(Computed(2))))

:(sqrt(Computed(1.41421)))

ComputedComputed

1.18921

@eval_step_by_step sqrt(sqrt(length([1,2])))

👀 Reading hidden code

14.6 ms

Any

:(xasdf = 123)

ComputedComputed

@eval_step_by_step xasdf = 123

👀 Reading hidden code

146 μs

Error message

UndefVarError: xasdf not defined

Stack trace

Here is what happened, the most recent locations are first:

from This cell: line 1
```
xasdf
```

xasdf

👀 Reading hidden code

---

Any

quote
    Computed(3)
    2 + 3
    4 + 5
    sqrt(sqrt(sqrt(5)))
end

quote
    Computed(3)
    Computed(5)
    4 + 5
    sqrt(sqrt(sqrt(5)))
end

quote
    Computed(3)
    Computed(5)
    Computed(9)
    sqrt(sqrt(sqrt(5)))
end

quote
    Computed(3)
    Computed(5)
    Computed(9)
    sqrt(sqrt(Computed(2.23607)))
end

quote
    Computed(3)
    Computed(5)
    Computed(9)
    sqrt(Computed(1.49535))
end

quote
    Computed(3)
    Computed(5)
    Computed(9)
    Computed(1.22284)
end

ComputedComputed

1.22284

onestep_light(quote

1+2

2+3

4+5

sqrt(sqrt(sqrt(5)))

end |> remove_linenums)

👀 Reading hidden code

145 ms

can_interpret (generic function with 1 method)

can_interpret(x) = true

👀 Reading hidden code

821 μs

can_interpret_call_arg (generic function with 1 method)

can_interpret_call_arg(e::Expr) = !(e.head === :(...) || e.head === :kw || e.head === :parameters)

👀 Reading hidden code

633 μs

can_interpret_call_arg (generic function with 2 methods)

can_interpret_call_arg(x) = true

👀 Reading hidden code

331 μs

true

Meta.isbinaryoperator(:(==))

👀 Reading hidden code

26.1 μs

can_interpret (generic function with 2 methods)

can_interpret(e::Expr) = if false

false

elseif e.head === :call && !all(can_interpret_call_arg, e.args)

false

# elseif e.head === :(=) || e.head === :macrocall

# false

else

all(can_interpret, e.args)

end

👀 Reading hidden code

633 μs

Displaying

👀 Reading hidden code

164 μs

👀 Reading hidden code

58.7 μs

find_computed! (generic function with 1 method)

find_computed!(found, c::Computed) = push!(found, c)

👀 Reading hidden code

365 μs

find_computed! (generic function with 2 methods)

find_computed!(found, expr::Expr) = find_computed!.([found], expr.args)

👀 Reading hidden code

467 μs

find_computed! (generic function with 3 methods)

find_computed!(found, x) = nothing

👀 Reading hidden code

359 μs

find_computed (generic function with 1 method)

find_computed(x) = let

r = Any[]

find_computed!(r, x)

end

👀 Reading hidden code

449 μs

Vector{Any}

Any

ComputedComputed

Any

ComputedComputed

Any

ComputedComputed

Any

ComputedComputed

2.23607

Any

ComputedComputed

1.49535

Any

ComputedComputed

1.22284

Any

ComputedComputed

1.22284

onestep_light(quote

1+2

2+3

4+5

sqrt(sqrt(sqrt(5)))

end |> remove_linenums) .|> find_computed

👀 Reading hidden code

600 ms

slot! (generic function with 1 method)

slot!(found, c::Computed) = let

k = Symbol("__slot", join(rand('a':'z', 16)), "__")

found[k] = c

end

👀 Reading hidden code

604 μs

slot! (generic function with 2 methods)

slot!(found, x) = x

👀 Reading hidden code

347 μs

slot! (generic function with 3 methods)

slot!(found, e::Expr) = Expr(e.head, slot!.([found], e.args)...)

👀 Reading hidden code

520 μs

slot (generic function with 1 method)

slot(e) = let

d = Dict{Symbol,Any}()

new_e = slot!(d, e)

d, new_e

end

👀 Reading hidden code

515 μs

Tuple{Dict{Symbol, Any}, Any}

Dict{Symbol, Any}Dict

:__slotnxytlsodyfzwmphb__

ComputedComputed

quote
    __slotnxytlsodyfzwmphb__ + (7 - 6)
    2 + 3
    4 + 5
    sqrt(sqrt(sqrt(5)))
end

Dict{Symbol, Any}Dict

:__slotrjxcgsefqvchsibx__

ComputedComputed

:__slothmbxravykrbwxjoj__

ComputedComputed

quote
    __slotrjxcgsefqvchsibx__ + __slothmbxravykrbwxjoj__
    2 + 3
    4 + 5
    sqrt(sqrt(sqrt(5)))
end

Dict{Symbol, Any}Dict

:__slotuzssipycurygfvxf__

ComputedComputed

quote
    __slotuzssipycurygfvxf__
    2 + 3
    4 + 5
    sqrt(sqrt(sqrt(5)))
end

Dict{Symbol, Any}Dict

:__slotcrmklxkewtndbzgp__

ComputedComputed

:__slotmtzrfaqrmrdwhgqc__

ComputedComputed

quote
    __slotmtzrfaqrmrdwhgqc__
    __slotcrmklxkewtndbzgp__
    4 + 5
    sqrt(sqrt(sqrt(5)))
end

Dict{Symbol, Any}Dict

:__slotistrhpgrwuuwlfbq__

ComputedComputed

:__slotejiswroinnyeqrio__

ComputedComputed

:__slotgwzyjpfdgatnprvg__

ComputedComputed

quote
    __slotgwzyjpfdgatnprvg__
    __slotejiswroinnyeqrio__
    __slotistrhpgrwuuwlfbq__
    sqrt(sqrt(sqrt(5)))
end

Dict{Symbol, Any}Dict

:__slotgjbsxlkxgjsxhrvh__

ComputedComputed

:__slotnqhogjcqnhxaoidr__

ComputedComputed

:__slotwagstwwxkyccmlxz__

ComputedComputed

:__slotocawnjfeyunhykbl__

ComputedComputed

2.23607

quote
    __slotwagstwwxkyccmlxz__
    __slotgjbsxlkxgjsxhrvh__
    __slotnqhogjcqnhxaoidr__
    sqrt(sqrt(__slotocawnjfeyunhykbl__))
end

Dict{Symbol, Any}Dict

:__slotdzagxpyiixfdhrbg__

ComputedComputed

:__slotxmvfquwjhcutmngj__

ComputedComputed

1.49535

:__slotbxrserffzkgdpigf__

ComputedComputed

:__slotahxmtqsdxgyawnid__

ComputedComputed

quote
    __slotahxmtqsdxgyawnid__
    __slotbxrserffzkgdpigf__
    __slotdzagxpyiixfdhrbg__
    sqrt(__slotxmvfquwjhcutmngj__)
end

Dict{Symbol, Any}Dict

:__slotnzevslralcpqkfmk__

ComputedComputed

:__slotgwqhlrewhrrjlwtb__

ComputedComputed

1.22284

:__slotqzublnwzbtundbco__

ComputedComputed

:__slotxdegmiuvctsbgwvh__

ComputedComputed

quote
    __slotqzublnwzbtundbco__
    __slotxdegmiuvctsbgwvh__
    __slotnzevslralcpqkfmk__
    __slotgwqhlrewhrrjlwtb__
end

Dict{Symbol, Any}Dict

:__slothujctdavmdabtfpx__

ComputedComputed

1.22284

:__slothujctdavmdabtfpx__

onestep_light(quote

(1+2) + (7-6)

2+3

4+5

sqrt(sqrt(sqrt(5)))

end |> remove_linenums) .|> slot

👀 Reading hidden code

314 ms

preish (generic function with 1 method)

preish(x) = @htl("<pre-ish>$(x)</pre-ish>")

👀 Reading hidden code

474 μs

display_slotted (generic function with 1 method)

function display_slotted(expr)

d, e = slot(expr)

s = string(e |> remove_linenums)

lines = split(s, "\n")

r = r"\_\_slot[a-z]{16}\_\_"

@htl("""<slotted-code>

map(lines) do l

keys = [Symbol(m.match) for m in eachmatch(r, l)]

rest = split(l, r; keepempty=true)

result = vcat((

[preish(r), embed_display(d[k].x)]

for (r,k) in zip(rest, keys)

)...)

push!(result, preish(last(rest)))

@htl("<line-like>$(result)</line-like>")

end

)

</slotted-code>""")

end

👀 Reading hidden code

10.9 ms

html"""

<style>

slotted-code {

font-family: "JuliaMono", monospace;

font-size: .75rem;

display: flex;

flex-direction: column;

}

pre-ish {

white-space: pre;

}

slotted-code pluto-display>div {

display: inline-block;

}

line-like {

display: flex;

}

"""

👀 Reading hidden code

103 μs

# rs = @eval_step_by_step(begin

# (1+2) + (7-6)

# first(2000 .+ 30 .* rand(2+2))

# 4+5

# sqrt(sqrt(sqrt(5)))

# end) .|> display_slotted

👀 Reading hidden code

8.8 μs

using Plots

👀 Reading hidden code

3.3 s

plot (generic function with 1 method)

plot(args...; kwargs...) = Plots.plot(args...; size=(100,100), kwargs...)

👀 Reading hidden code

1.4 ms

HypertextLiteral.Result

begin

(1 + 2) + (7 - 6)

plot(2000 .+ 30 .* rand(2 + 2))

4 + 5

sqrt(sqrt(sqrt(5)))

end

begin

+ (7 - 6)

plot(2000 .+ 30 .* rand(2 + 2))

4 + 5

sqrt(sqrt(sqrt(5)))

end

begin

plot(2000 .+ 30 .* rand(2 + 2))

4 + 5

sqrt(sqrt(sqrt(5)))

end

begin

plot(2000 .+ 30 .* rand(2 + 2))

4 + 5

sqrt(sqrt(sqrt(5)))

end

begin

plot(2000 .+ 30 .* rand(

))

4 + 5

sqrt(sqrt(sqrt(5)))

end

begin

plot(2000 .+ 30 .*

Float64

0.67208

0.929538

0.555801

0.189847

)

4 + 5

sqrt(sqrt(sqrt(5)))

end

begin

plot(2000 .+

Float64

20.1624

27.8862

16.674

5.69541

)

4 + 5

sqrt(sqrt(sqrt(5)))

end

begin

plot(

Float64

2020.16

2027.89

2016.67

2005.7

)

4 + 5

sqrt(sqrt(sqrt(5)))

end

begin

4 + 5

sqrt(sqrt(sqrt(5)))

end

begin

sqrt(sqrt(sqrt(5)))

end

begin

sqrt(sqrt(

2.23607

))

end

begin

sqrt(

1.49535

)

end

begin

1.22284

end

1.22284

rs = @eval_step_by_step(begin

(1+2) + (7-6)

plot(2000 .+ 30 .* rand(2+2))

4+5

sqrt(sqrt(sqrt(5)))

end) .|> display_slotted

👀 Reading hidden code

3.6 s

@bind rindex Slider(eachindex(rs))

👀 Reading hidden code

30.0 ms

begin

(1 + 2) + (7 - 6)

plot(2000 .+ 30 .* rand(2 + 2))

4 + 5

sqrt(sqrt(sqrt(5)))

end

rs[rindex]

👀 Reading hidden code

11.7 μs

begin

1.2228445449938519

end

frames(rs)

👀 Reading hidden code

32.2 μs

@visual_debug (macro with 1 method)

macro visual_debug(expr)

frames

display_slotted

var"@eval_step_by_step"

quote

@eval_step_by_step($(expr)) .|> display_slotted |> frames

end

👀 Reading hidden code

595 μs

begin

1.2228445449938519

end

@visual_debug begin

(1+2) + (7-6)

plot(2000 .+ 30 .* rand(2+2))

4+5

sqrt(sqrt(sqrt(5)))

end

👀 Reading hidden code

2.2 ms

frames (generic function with 1 method)

function frames(fs)

@htl("""

<div>

<p-frames>

$(fs)

</p-frames>

const div = currentScript.parentElement

const input = div.querySelector("input.timescrub")

const frames = div.querySelector("p-frames")

const setviz = () => {

Array.from(frames.children).forEach((f,i) => {

f.style.display = i + 1 === input.valueAsNumber ? "inherit" : "none"

})

}

setviz()

input.addEventListener("input", setviz)

</script>

</div>

""")

end

👀 Reading hidden code

702 μs

👀 Reading hidden code

60.2 μs

👀 Reading hidden code

58.8 μs

👀 Reading hidden code

58.3 μs

👀 Reading hidden code

58.2 μs

👀 Reading hidden code

58.5 μs

👀 Reading hidden code

59.0 μs

In the cloud (experimental)

On your computer

Frontmatter

Preview

(You need `Pluto#main` to run this notebook)

asdf

asdf

Type definitions

Test macro

DEbugging 1

Debugging 1.5

Displaying

(You need Pluto#main to run this notebook)

asdf

asdf

Type definitions

Test macro

DEbugging 1

Debugging 1.5

Displaying

(You need `Pluto#main` to run this notebook)