` HTML element,
23 | but also has a filter button
24 | that allows you to switch between filtered and unfiltered states. -/
25 | @[widget_module]
26 | def FilterDetails : Component FilterDetailsProps where
27 | javascript := include_str ".." / ".." / ".lake" / "build" / "js" / "filterDetails.js"
28 |
29 | end ProofWidgets
30 |
--------------------------------------------------------------------------------
/widget/src/filterDetails.tsx:
--------------------------------------------------------------------------------
1 | import * as React from 'react';
2 | import HtmlDisplay, { Html } from './htmlDisplay';
3 |
4 | interface FilterDetailsProps {
5 | summary : Html
6 | filtered : Html
7 | all : Html
8 | initiallyFiltered : boolean
9 | }
10 |
11 | export default function FilterDetails(props: FilterDetailsProps) {
12 | const [isFiltered, setFiltered] = React.useState(props.initiallyFiltered);
13 |
14 | return =
5 | 'running' | { done: { result: S } }
6 |
7 | /** An object for passing a function by reference. */
8 | export type Fn = {
9 | fn: () => void
10 | }
11 |
12 | /** Returns a promise of a response to this request
13 | * as well as a function you can call to cancel the request.
14 | * The output of a cancelled RPC request is determined by its handler implementation:
15 | * it could ignore the cancellation altogether,
16 | * return a `null` result,
17 | * or throw an error. */
18 | export function callCancellable(rs: RpcSessionAtPos, name: string, params: T):
19 | [Promise, Fn] {
20 | const cancelFn = {
21 | fn: () => {}
22 | }
23 | const promise = new Promise(async (resolve, reject) => {
24 | const id: RequestId = await rs.call(name, params)
25 | const i = window.setInterval(async () => {
26 | try {
27 | const response : CheckRequestResponse = await rs.call('ProofWidgets.checkRequest', id)
28 | if (response === 'running') return
29 | window.clearInterval(i)
30 | resolve(response.done.result)
31 | } catch (e) {
32 | window.clearInterval(i)
33 | reject(e)
34 | }
35 | }, 100)
36 | cancelFn.fn = () => {
37 | void rs.call('ProofWidgets.cancelRequest', id)
38 | }
39 | })
40 | return [promise, cancelFn]
41 | }
42 |
--------------------------------------------------------------------------------
/widget/src/ofRpcMethod.tsx:
--------------------------------------------------------------------------------
1 | import * as React from 'react'
2 | import { DocumentPosition, mapRpcError, useAsyncPersistent, useRpcSession } from '@leanprover/infoview'
3 | import { Html, default as HtmlDisplay } from './htmlDisplay'
4 | import { Fn, callCancellable } from './cancellable'
5 |
6 | declare type Props = any & { pos : DocumentPosition };
7 | // The string template is replaced in OfRpcMethod.lean.
8 | const RPC_METHOD = '$RPC_METHOD'
9 | // HACK: TS runs dead-code elimination
10 | // and eliminates the `callCancellable` branch if we use a string literal,
11 | // so use a runtime value.
12 | const RPC_CANCELLABLE = window.toString()
13 |
14 | export default React.memo((props: Props) => {
15 | const rs = useRpcSession()
16 | const cancelRef = React.useRef({ fn: () => {} })
17 | const st = useAsyncPersistent(async () => {
18 | if (RPC_CANCELLABLE === 'true') {
19 | cancelRef.current.fn()
20 | const [res, cancel] = callCancellable(rs, RPC_METHOD, props)
21 | cancelRef.current = cancel
22 | return res
23 | } else
24 | return rs.call(RPC_METHOD, props)
25 | }, [rs, props])
26 |
27 | // This effect runs once on startup, does nothing,
28 | // and sets up a cleanup function that runs when the component is unmounted.
29 | React.useEffect(() => {
30 | return () => { cancelRef.current.fn() }
31 | }, [])
32 |
33 | return st.state === 'rejected' ?
34 | ![Six photos of parrots arranged in a grid.]({"https://")
16 |
17 | def htmlLetters : Array ProofWidgets.Html := #[
18 | H,
19 | T,
20 | M,
21 | L
22 | ]
23 |
24 | -- HTML children can be interpolated with `{ }` (single node) and `{... }` (multiple nodes)
25 | def x := You can use {...htmlLetters} in Lean {.text s!"{1 + 3}"}!
26 | #html x 27 | 28 | -- Use `MarkdownDisplay` to render Markdown 29 | open ProofWidgets in 30 | #html
20 |
24 |
25 | #html Plot (fn 0)
26 | #html Plot (fn 0.2)
27 | #html Plot (fn 0.4)
28 | #html Plot (fn 0.6)
29 |
30 | /-!
31 | # Bonus demo: animated plots!
32 | -/
33 |
34 | def mkFrames (fn : Float → Float → Float) (steps := 100) : Array Html:=
35 | List.range (steps + 1) |>.toArray |>.map (fun t => Plot (fn (t.toFloat / steps.toFloat)))
36 |
37 | structure AnimatedHtmlProps where
38 | frames : Array Html
39 | framesPerSecond? : Option Nat := none
40 | deriving Server.RpcEncodable
41 |
42 | @[widget_module]
43 | def AnimatedHtml : Component AnimatedHtmlProps where
44 | javascript := include_str ".." / ".." / ".lake" / "build" / "js" / "animatedHtml.js"
45 |
46 | open scoped ProofWidgets.Jsx in
47 | -- put your cursor on the below line to see an animated widget
48 | #html
: ProofWidgets.Html -/ 20 | #guard_msgs in 21 | #check
22 | 23 | variable (attrs children) 24 | /-- info:Content : ProofWidgets.Html -/
38 | #guard_msgs in
39 | #check Content
40 |
41 | def ProdComponent : ProofWidgets.Component (Nat × Nat) where
42 | javascript := ""
43 |
44 | /-- info:
63 |
--------------------------------------------------------------------------------
/widget/src/presentSelection.tsx:
--------------------------------------------------------------------------------
1 | import {
2 | DocumentPosition, GoalsLocation, InteractiveGoal, mapRpcError, PanelWidgetProps,
3 | RpcPtr, useAsyncPersistent,
4 | useRpcSession
5 | } from "@leanprover/infoview";
6 | import ExprPresentation from "./exprPresentation";
7 |
8 | function findGoalForLocation(goals: InteractiveGoal[], loc: GoalsLocation): InteractiveGoal {
9 | for (const g of goals) {
10 | if (g.mvarId === loc.mvarId) return g
11 | }
12 | throw new Error(`Could not find goal for location ${JSON.stringify(loc)}`)
13 | }
14 |
15 | type ExprWithCtx = RpcPtr<'ProofWidgets.ExprWithCtx'>
16 |
17 | interface GoalsLocationsToExprsResponse {
18 | exprs: ExprWithCtx[]
19 | }
20 |
21 | /**
22 | * Display the expression corresponding to a given `GoalsLocation` using {@link ExprPresentation}.
23 | */
24 | export function GoalsLocationPresentation({ pos, goals, loc }:
25 | { pos: DocumentPosition, goals: InteractiveGoal[], loc: GoalsLocation }) {
26 | const rs = useRpcSession()
27 | const st = useAsyncPersistent(async () => {
28 | const g = findGoalForLocation(goals, loc)
29 | if (g.ctx === undefined) throw new Error(`Lean server 1.1.2 or newer is required.`)
30 | const ret: GoalsLocationsToExprsResponse =
31 | await rs.call('ProofWidgets.goalsLocationsToExprs', { locations: [[g.ctx, loc]] })
32 | return ret.exprs[0]
33 | }, [rs, goals, loc])
34 |
35 | if (st.state === 'loading')
36 | return <>Loading..
37 | else if (st.state === 'rejected')
38 | return <>Error: {mapRpcError(st.error).message}
39 | else
40 | return
15 |
16 |
24 |
26 | }
27 |
--------------------------------------------------------------------------------
/widget/src/animatedHtml.tsx:
--------------------------------------------------------------------------------
1 | import * as React from 'react';
2 | import { Html, default as HtmlDisplay } from './htmlDisplay';
3 |
4 | interface AnimatedHtmlProps {
5 | frames: Html[]
6 | framesPerSecond?: number
7 | }
8 |
9 | /** Display the series of HTML frames as a time-dependent animation. This will only look reasonable
10 | * if the frames are related somehow, e.g. are all instances of a single component with slightly
11 | * different props. */
12 | export default function AnimatedHtml(props: AnimatedHtmlProps) {
13 | const { frames } = props
14 | const framesPerSecond = props.framesPerSecond ?? 10
15 | if (framesPerSecond <= 0 || framesPerSecond > 60) {
16 | throw new Error(`Invalid fps ${framesPerSecond}. Should be between 0 and 60.`)
17 | }
18 | const [t, setT] = React.useState(0)
19 | React.useEffect(() => {
20 | const interval = window.setInterval(() => setT(t => t + 1), 1000.0 / framesPerSecond)
21 | return () => window.clearInterval(interval)
22 | }, [framesPerSecond])
23 |
24 | const frame = frames[t % frames.length]
25 |
26 | return
16 |
24 | {mapRpcError(st.error).message}
35 | : st.state === 'loading' ? 36 | <>Loading.. 37 | : 38 |26 | #html x 27 | 28 | -- Use `MarkdownDisplay` to render Markdown 29 | open ProofWidgets in 30 | #html
: ProofWidgets.Html -/ 20 | #guard_msgs in 21 | #check
22 | 23 | variable (attrs children) 24 | /-- info:
{...children}
: ProofWidgets.Html -/
25 | #guard_msgs in
26 | #check element "div" attrs children
27 |
28 | structure CustomProps where
29 | val : Nat
30 | str : String
31 | deriving Server.RpcEncodable
32 |
33 | def CustomComponent : ProofWidgets.Component CustomProps where
34 | javascript := ""
35 |
36 | -- TODO: spacing between attributes
37 | /-- info: Init!!!
,
55 | state := { state := isvg.init
56 | time := 0
57 | selected := none
58 | mousePos := none
59 | idToData := isvg.render 0 none none isvg.init |>.idToDataList}
60 | }
61 |
62 | #html
45 |
52 | }
53 |
--------------------------------------------------------------------------------
/ProofWidgets/Component/Panel/SelectionPanel.lean:
--------------------------------------------------------------------------------
1 | module
2 |
3 | public meta import Lean.Meta.ExprLens
4 | public meta import ProofWidgets.Component.Panel.Basic
5 | public meta import ProofWidgets.Presentation.Expr
6 |
7 | public meta section -- Needed for RPC calls in SelectionPanel
8 |
9 | open ProofWidgets in
10 | /-- Save the expression corresponding to a goals location. -/
11 | def Lean.SubExpr.GoalsLocation.saveExprWithCtx (loc : GoalsLocation) : MetaM ExprWithCtx :=
12 | let mvarId := loc.mvarId
13 | match loc.loc with
14 | | .hyp fv =>
15 | mvarId.withContext <|
16 | ExprWithCtx.save (mkFVar fv)
17 | | .hypType fv pos => mvarId.withContext do
18 | let tp ← Meta.inferType (mkFVar fv)
19 | Meta.viewSubexpr (visit := fun _ => ExprWithCtx.save) pos tp
20 | | .hypValue fv pos => mvarId.withContext do
21 | let some val ← fv.getValue?
22 | | throwError "fvar {mkFVar fv} is not a let-binding"
23 | Meta.viewSubexpr (visit := fun _ => ExprWithCtx.save) pos val
24 | | .target pos => mvarId.withContext do
25 | let tp ← Meta.inferType (mkMVar mvarId)
26 | Meta.viewSubexpr (visit := fun _ => ExprWithCtx.save) pos tp
27 |
28 | namespace ProofWidgets
29 | open Lean Server
30 |
31 | structure GoalsLocationsToExprsParams where
32 | locations : Array (WithRpcRef Elab.ContextInfo × SubExpr.GoalsLocation)
33 | deriving RpcEncodable
34 |
35 | structure GoalsLocationsToExprsResponse where
36 | exprs : Array (WithRpcRef ExprWithCtx)
37 | deriving RpcEncodable
38 |
39 | /-- Compute expressions corresponding to the given `GoalsLocation`s. -/
40 | @[server_rpc_method]
41 | def goalsLocationsToExprs (args : GoalsLocationsToExprsParams) :
42 | RequestM (RequestTask GoalsLocationsToExprsResponse) :=
43 | RequestM.asTask do
44 | let mut exprs := #[]
45 | for ⟨ref, loc⟩ in args.locations do
46 | let ci := ref.val
47 | exprs := exprs.push (← WithRpcRef.mk (← ci.runMetaM {} loc.saveExprWithCtx))
48 | return { exprs }
49 |
50 | /-- Display a list of all expressions selected in the goal state, with a choice of which `Expr`
51 | presenter should be used to display each of those expressions.
52 |
53 | Expressions can be selected using shift-click. -/
54 | @[widget_module]
55 | def SelectionPanel : Component PanelWidgetProps where
56 | javascript := include_str ".." / ".." / ".." / ".lake" / "build" / "js" / "presentSelection.js"
57 |
58 | end ProofWidgets
59 |
--------------------------------------------------------------------------------
/ProofWidgets/Component/Panel/Basic.lean:
--------------------------------------------------------------------------------
1 | module
2 |
3 | public meta import ProofWidgets.Compat
4 | public meta import ProofWidgets.Component.Basic
5 | public meta import Lean.Elab.Tactic
6 | public meta import Lean.Widget.Commands
7 |
8 | public meta section
9 |
10 | namespace ProofWidgets
11 | open Lean Elab Tactic
12 |
13 | /-- In the infoview, an **info block** is a top-level collapsible block corresponding to a given
14 | location in a Lean file (e.g. with the header `▼ Basic.lean:12:34`).
15 |
16 | A **panel widget** is a component which can appear as a panel inside an info block in the infoview.
17 | For example, a tactic state display.
18 | The type `PanelWidgetProps` represents the props passed to a panel widget.
19 | The TypeScript version is exported as `PanelWidgetProps` from `@leanprover/infoview`.
20 |
21 | Note that to be a good citizen which doesn't mess up the infoview layout,
22 | a panel widget should be a block element,
23 | and should provide some way to collapse it,
24 | for example by using `Selected expressions
46 | {props.selectedLocations.length > 0 ? 47 | props.selectedLocations.map(loc => 48 |` as the top-level tag. -/
25 | structure PanelWidgetProps : Type where
26 | /-- Cursor position in the file at which the widget is being displayed. -/
27 | pos : Lsp.Position
28 | /-- The current tactic-mode goals. -/
29 | goals : Array Widget.InteractiveGoal
30 | /-- The current term-mode goal, if any. -/
31 | termGoal? : Option Widget.InteractiveTermGoal
32 | /-- Locations currently selected in the goal state. -/
33 | selectedLocations : Array SubExpr.GoalsLocation
34 | deriving Server.RpcEncodable
35 |
36 | /-- Display the selected panel widgets in the nested tactic script. For example,
37 | assuming we have written a `GeometryDisplay` component,
38 | ```lean
39 | by with_panel_widgets [GeometryDisplay]
40 | simp
41 | rfl
42 | ```
43 | will show the geometry display alongside the usual tactic state throughout the proof.
44 | -/
45 | syntax (name := withPanelWidgetsTacticStx)
46 | "with_panel_widgets" "[" Widget.widgetInstanceSpec,+ "]" tacticSeq : tactic
47 |
48 | @[tactic withPanelWidgetsTacticStx]
49 | def withPanelWidgets : Tactic
50 | | stx@`(tactic| with_panel_widgets [ $specs,* ] $seq) => do
51 | specs.getElems.forM fun specStx => do
52 | let spec ← Widget.elabWidgetInstanceSpec specStx
53 | let wi ← Widget.evalWidgetInstance spec
54 | Widget.savePanelWidgetInfo wi.javascriptHash wi.props stx
55 | evalTacticSeq seq
56 | | _ => throwUnsupportedSyntax
57 |
58 | end ProofWidgets
59 |
--------------------------------------------------------------------------------
/ProofWidgets/Demos/LazyComputation.lean:
--------------------------------------------------------------------------------
1 | module
2 |
3 | public meta import ProofWidgets.Component.Basic
4 |
5 | public meta section
6 |
7 | open ProofWidgets
8 | open Lean Meta Server Elab Tactic
9 |
10 | /-- A `MetaM String` continuation, containing both the computation and all monad state. -/
11 | structure MetaMStringCont where
12 | ci : Elab.ContextInfo
13 | lctx : LocalContext
14 | -- We can only derive `TypeName` for type constants, so this must be monomorphic.
15 | k : MetaM String
16 | deriving TypeName
17 |
18 | structure RunnerWidgetProps where
19 | /-- A continuation to run and print the results of when the button is clicked. -/
20 | k : WithRpcRef MetaMStringCont
21 | -- Make it possible for widgets to receive `RunnerWidgetProps`. Uses the `TypeName` instance.
22 | deriving RpcEncodable
23 |
24 | @[server_rpc_method]
25 | def runMetaMStringCont : RunnerWidgetProps → RequestM (RequestTask String)
26 | | {k := ref} => RequestM.asTask do
27 | let {ci, lctx, k} := ref.val
28 | ci.runMetaM lctx k
29 |
30 | @[widget_module]
31 | def runnerWidget : Component RunnerWidgetProps where
32 | javascript := "
33 | import { RpcContext, mapRpcError } from '@leanprover/infoview'
34 | import * as React from 'react';
35 | const e = React.createElement;
36 |
37 | export default function(props) {
38 | const [contents, setContents] = React.useState('Run!')
39 | const rs = React.useContext(RpcContext)
40 | return e('button', { onClick: () => {
41 | setContents('Running..')
42 | rs.call('runMetaMStringCont', props)
43 | .then(setContents)
44 | .catch(e => { setContents(mapRpcError(e).message) })
45 | }}, contents)
46 | }
47 | "
48 |
49 | syntax (name := makeRunnerTac) "make_runner" : tactic
50 |
51 | @[tactic makeRunnerTac] def makeRunner : Tactic
52 | | `(tactic| make_runner%$tk) => do
53 | let x : MetaM String := do
54 | return "Hello, world!"
55 | -- Store the continuation and monad context.
56 | let props : RunnerWidgetProps := {
57 | k := ← WithRpcRef.mk {
58 | ci := { ← CommandContextInfo.save with }
59 | lctx := (← getLCtx)
60 | k := x
61 | }
62 | }
63 | -- Save a widget together with a pointer to `props`.
64 | Widget.savePanelWidgetInfo runnerWidget.javascriptHash (rpcEncode props) tk
65 | | _ => throwUnsupportedSyntax
66 |
67 | example : True := by
68 | make_runner
69 | trivial
70 |
--------------------------------------------------------------------------------
/.github/workflows/build.yml:
--------------------------------------------------------------------------------
1 | on:
2 | push:
3 | pull_request:
4 |
5 | name: ci
6 |
7 | jobs:
8 | build:
9 | name: ${{ matrix.name }}
10 | runs-on: ${{ matrix.os }}
11 | defaults:
12 | run:
13 | shell: ${{ matrix.shell || 'sh' }}
14 | strategy:
15 | matrix:
16 | include:
17 | - name: Build on Ubuntu
18 | os: ubuntu-latest
19 | # TODO: investigate why `lake build` deadlocks on macOS (issue #33)
20 | #- name: Build on macOS
21 | # os: macos-latest
22 | - name: Build on Windows
23 | os: windows-latest
24 | shell: msys2 {0}
25 | steps:
26 | - name: Install MSYS2 (Windows)
27 | if: matrix.os == 'windows-latest'
28 | uses: msys2/setup-msys2@v2
29 | with:
30 | path-type: inherit
31 | install: curl unzip
32 |
33 | - name: Install elan
34 | shell: bash
35 | run: |
36 | curl -sSfLO https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh
37 | chmod +x elan-init.sh
38 | ./elan-init.sh -y --default-toolchain none
39 | echo "$HOME/.elan/bin" >> $GITHUB_PATH
40 |
41 | - uses: actions/checkout@v4
42 |
43 | - name: Setup Node.js
44 | uses: actions/setup-node@v4
45 | with:
46 | node-version: '24'
47 |
48 | - name: Build package
49 | run: lake build ProofWidgets
50 |
51 | - name: Try publishing @leanprover-community/proofwidgets4
52 | if: ${{ startsWith(github.ref, 'refs/tags/v') && !contains(github.ref, '-pre') && matrix.os == 'ubuntu-latest' }}
53 | continue-on-error: true
54 | run: cd widget/ && npm publish --access=public
55 |
56 | - name: Build demos
57 | run: lake build ProofWidgets.Demos
58 |
59 | - name: Run tests
60 | run: lake test
61 |
62 | - name: Create GitHub release for tag (Ubuntu)
63 | if: github.ref_type == 'tag' && matrix.os == 'ubuntu-latest'
64 | uses: softprops/action-gh-release@v2
65 | with:
66 | prerelease: ${{ contains(github.ref, '-pre') }}
67 |
68 | - name: Upload release archive (Ubuntu)
69 | if: github.ref_type == 'tag' && matrix.os == 'ubuntu-latest'
70 | run: lake upload $RELEASE_TAG
71 | env:
72 | GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
73 | RELEASE_TAG: ${{ github.ref_name }}
74 |
75 | - name: Test release archive (Ubuntu)
76 | if: github.ref_type == 'tag' && matrix.os == 'ubuntu-latest'
77 | run: lake clean && lake build :release && lake build --no-build
78 | env:
79 | NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
80 |
--------------------------------------------------------------------------------
/ProofWidgets/Util.lean:
--------------------------------------------------------------------------------
1 | /-
2 | Copyright (c) 2024 Eric Wieser. All rights reserved.
3 | Released under Apache 2.0 license as described in the file LICENSE.
4 | Authors: Eric Wieser
5 | -/
6 | module
7 |
8 | public meta import Lean.PrettyPrinter.Delaborator.Basic
9 |
10 | public meta section
11 |
12 | namespace ProofWidgets.Util
13 | open Lean
14 |
15 | /-- Sends `#[a, b, c]` to `` `(term| $a ++ $b ++ $c)``-/
16 | def joinArrays {m} [Monad m] [MonadRef m] [MonadQuotation m] (arr : Array Term) : m Term := do
17 | if h : 0 < arr.size then
18 | arr.foldlM (fun x xs => `($x ++ $xs)) arr[0] (start := 1)
19 | else
20 | `(#[])
21 |
22 | /-- Collapse adjacent `inl (_ : α)`s into a `β` using `f`.
23 | For example, `#[.inl a₁, .inl a₂, .inr b, .inl a₃] ↦ #[← f #[a₁, a₂], b, ← f #[a₃]]`. -/
24 | def foldInlsM {m} [Monad m] (arr : Array (α ⊕ β)) (f : Array α → m β) : m (Array β) := do
25 | let mut ret : Array β := #[]
26 | let mut pending_inls : Array α := #[]
27 | for c in arr do
28 | match c with
29 | | .inl ci =>
30 | pending_inls := pending_inls.push ci
31 | | .inr cis =>
32 | if pending_inls.size ≠ 0 then
33 | ret := ret.push <| ← f pending_inls
34 | pending_inls := #[]
35 | ret := ret.push cis
36 | if pending_inls.size ≠ 0 then
37 | ret := ret.push <| ← f pending_inls
38 | return ret
39 |
40 | end ProofWidgets.Util
41 |
42 | namespace Lean.PrettyPrinter.Delaborator
43 | open SubExpr
44 |
45 | /-- Delaborate the elements of a list literal separately, calling `elem` on each. -/
46 | partial def delabListLiteral {α} (elem : DelabM α) : DelabM (Array α) :=
47 | go #[]
48 | where
49 | go (acc : Array α) : DelabM (Array α) := do
50 | match_expr ← getExpr with
51 | | List.nil _ => return acc
52 | | List.cons _ _ _ =>
53 | let hd ← withNaryArg 1 elem
54 | withNaryArg 2 $ go (acc.push hd)
55 | | _ => failure
56 |
57 | /-- Delaborate the elements of an array literal separately, calling `elem` on each. -/
58 | partial def delabArrayLiteral {α} (elem : DelabM α) : DelabM (Array α) := do
59 | match_expr ← getExpr with
60 | | List.toArray _ _ => withNaryArg 1 <| delabListLiteral elem
61 | | _ => failure
62 |
63 | /-- A copy of `Delaborator.annotateTermInfo` for other syntactic categories. -/
64 | def annotateTermLikeInfo (stx : TSyntax n) : DelabM (TSyntax n) := do
65 | let stx ← annotateCurPos ⟨stx⟩
66 | addTermInfo (← getPos) stx (← getExpr)
67 | pure ⟨stx⟩
68 |
69 | /-- A copy of `Delaborator.withAnnotateTermInfo` for other syntactic categories. -/
70 | def withAnnotateTermLikeInfo (d : DelabM (TSyntax n)) : DelabM (TSyntax n) := do
71 | let stx ← d
72 | annotateTermLikeInfo stx
73 |
74 | end Lean.PrettyPrinter.Delaborator
75 |
--------------------------------------------------------------------------------
/ProofWidgets/Component/HtmlDisplay.lean:
--------------------------------------------------------------------------------
1 | module
2 |
3 | public meta import Lean.Server.Rpc.Basic
4 | public meta import Lean.Elab.Command
5 |
6 | public meta import ProofWidgets.Data.Html
7 |
8 | public meta section
9 |
10 | namespace ProofWidgets
11 | open Lean Server
12 |
13 | structure HtmlDisplayProps where
14 | html : Html
15 | deriving RpcEncodable
16 |
17 | @[widget_module]
18 | def HtmlDisplay : Component HtmlDisplayProps where
19 | javascript := include_str ".." / ".." / ".lake" / "build" / "js" / "htmlDisplay.js"
20 |
21 | @[widget_module]
22 | def HtmlDisplayPanel : Component HtmlDisplayProps where
23 | javascript := include_str ".." / ".." / ".lake" / "build" / "js" / "htmlDisplayPanel.js"
24 |
25 | open Lean Server Elab Command
26 |
27 | /-- Any term `t : α` with a `HtmlEval α` instance
28 | can be evaluated in a `#html t` command.
29 |
30 | This is analogous to how `Lean.MetaEval` supports `#eval`. -/
31 | class HtmlEval (α : Type u) where
32 | eval : α → CommandElabM Html
33 |
34 | instance : HtmlEval Html where
35 | eval ht := pure ht
36 |
37 | instance [MonadLiftT m CommandElabM] : HtmlEval (m Html) where
38 | eval := monadLift
39 |
40 | instance : HtmlEval (CoreM Html) where
41 | eval := liftCoreM
42 |
43 | instance : HtmlEval (MetaM Html) where
44 | eval x := liftTermElabM x
45 |
46 | instance : HtmlEval (TermElabM Html) where
47 | eval := liftTermElabM
48 |
49 | namespace HtmlCommand
50 |
51 | open Elab Command
52 |
53 | unsafe def evalCommandMHtmlUnsafe (stx : Term) : TermElabM (CommandElabM Html) := do
54 | let tp := mkApp (mkConst ``CommandElabM) (mkConst ``Html)
55 | Term.evalTerm _ tp stx
56 |
57 | @[implemented_by evalCommandMHtmlUnsafe]
58 | opaque evalCommandMHtml : Term → TermElabM (CommandElabM Html)
59 |
60 | /-- Display a value of type `Html` in the infoview.
61 |
62 | The input can be a pure value
63 | or a computation in any Lean metaprogramming monad
64 | (e.g. `CommandElabM Html`). -/
65 | syntax (name := htmlCmd) "#html " term : command
66 |
67 | @[command_elab htmlCmd]
68 | def elabHtmlCmd : CommandElab := fun
69 | | stx@`(#html $t:term) => do
70 | let htX ← liftTermElabM <| evalCommandMHtml <| ← ``(HtmlEval.eval $t)
71 | let ht ← htX
72 | liftCoreM <| Widget.savePanelWidgetInfo
73 | (hash HtmlDisplayPanel.javascript)
74 | (return json% { html: $(← rpcEncode ht) })
75 | stx
76 | | stx => throwError "Unexpected syntax {stx}."
77 |
78 | end HtmlCommand
79 | end ProofWidgets
80 |
81 | /-- Construct a structured message from ProofWidgets HTML.
82 |
83 | For the meaning of `alt`, see `MessageData.ofWidget`. -/
84 | def Lean.MessageData.ofHtml (h : ProofWidgets.Html) (alt : String) : CoreM MessageData :=
85 | MessageData.ofComponent ProofWidgets.HtmlDisplay ⟨h⟩ alt
86 |
--------------------------------------------------------------------------------
/ProofWidgets/Component/Recharts.lean:
--------------------------------------------------------------------------------
1 | module
2 |
3 | public meta import ProofWidgets.Component.Basic
4 |
5 | public meta section
6 |
7 | namespace ProofWidgets.Recharts
8 | open Lean
9 |
10 | @[widget_module]
11 | def Recharts : Widget.Module where
12 | javascript := include_str ".." / ".." / ".lake" / "build" / "js" / "recharts.js"
13 |
14 | inductive LineChartLayout where
15 | | horizontal
16 | | vertical
17 | deriving FromJson, ToJson
18 |
19 | inductive LineChartSyncMethod where
20 | | index | value
21 | deriving FromJson, ToJson
22 |
23 | structure LineChartMargin where
24 | top : Nat := 5
25 | right : Nat := 5
26 | bottom : Nat := 5
27 | left : Nat := 5
28 | deriving FromJson, ToJson
29 |
30 | structure LineChartProps where
31 | layout : LineChartLayout := .horizontal
32 | syncId? : Option String := none
33 | syncMethod? : Option LineChartSyncMethod := some .index
34 | width : Nat
35 | height : Nat
36 | data : Array Json
37 | margin : LineChartMargin := {}
38 | deriving FromJson, ToJson
39 |
40 | /-- See https://recharts.org/en-US/api/LineChart. -/
41 | def LineChart : Component LineChartProps where
42 | javascript := Recharts.javascript
43 | «export» := "LineChart"
44 |
45 | inductive AxisType where
46 | /-- Treat values as numbers: spacing on axis by numeric difference. -/
47 | | number
48 | /-- Treat values as categorical: equal spacing between values. -/
49 | | category
50 | deriving FromJson, ToJson
51 |
52 | structure AxisProps where
53 | dataKey? : Option Json := none
54 | domain? : Option (Array Json) := none
55 | allowDataOverflow : Bool := false
56 | /-- How values along this axis should be interpreted.
57 | The Recharts default is `category`. -/
58 | type : AxisType := .number
59 | -- TODO: There are many more props
60 | deriving FromJson, ToJson
61 |
62 | /-- See https://recharts.org/en-US/api/XAxis. -/
63 | def XAxis : Component AxisProps where
64 | javascript := Recharts.javascript
65 | «export» := "XAxis"
66 |
67 | /-- See https://recharts.org/en-US/api/YAxis. -/
68 | def YAxis : Component AxisProps where
69 | javascript := Recharts.javascript
70 | «export» := "YAxis"
71 |
72 | inductive LineType where
73 | | basis | basisClosed | basisOpen | linear | linearClosed | natural | monotoneX | monotoneY
74 | | monotone | step | stepBefore | stepAfter
75 | deriving FromJson, ToJson
76 |
77 | structure LineProps where
78 | type : LineType := .linear
79 | dataKey : Json
80 | stroke : String
81 | dot? : Option Bool := none
82 | -- TODO: There are many more props
83 | deriving FromJson, ToJson
84 |
85 | /-- See https://recharts.org/en-US/api/Line. -/
86 | def Line : Component LineProps where
87 | javascript := Recharts.javascript
88 | «export» := "Line"
89 |
90 | end ProofWidgets.Recharts
91 |
--------------------------------------------------------------------------------
/widget/src/rbTree.tsx:
--------------------------------------------------------------------------------
1 | import * as React from 'react';
2 | import Tree from 'react-d3-tree';
3 | import type { RawNodeDatum, CustomNodeElementProps } from 'react-d3-tree';
4 | import { CodeWithInfos, DocumentPosition, InteractiveCode } from '@leanprover/infoview';
5 |
6 | type RBTreeVarsColour =
7 | 'red' | 'black' | 'blue'
8 |
9 | type RBTreeVars =
10 | 'empty' |
11 | { var: CodeWithInfos } |
12 | { node: { color: RBTreeVarsColour, l: RBTreeVars, a: CodeWithInfos, r: RBTreeVars } }
13 |
14 | type RBNodeDatum = RawNodeDatum & { expr?: CodeWithInfos, color?: string }
15 |
16 | /** Turn {@link RBTreeVars} into a representation `react-d3-tree` can use. */
17 | function treeToData(tree: RBTreeVars): RBNodeDatum {
18 | // The `name`s are just placeholders. They are not rendered
19 | if ('empty' === tree) {
20 | return {
21 | name: 'empty',
22 | color: 'black',
23 | }
24 | } else if ('var' in tree) {
25 | return {
26 | name: 'var',
27 | expr: tree.var,
28 | }
29 | } else if ('node' in tree) {
30 | const { color, l, a, r } = tree.node
31 | return {
32 | name: 'node',
33 | expr: a,
34 | color,
35 | children: [
36 | treeToData(l),
37 | treeToData(r)
38 | ]
39 | }
40 | }
41 | throw new Error(`unknown RBTreeVars constructor '${JSON.stringify(tree)}'`)
42 | }
43 |
44 | function renderForeignObjectNode({ nodeDatum }: CustomNodeElementProps, pos: DocumentPosition,
45 | foreignObjectProps: React.SVGProps): JSX.Element {
46 | const nodeDatum_ = nodeDatum as RBNodeDatum
47 | return (
48 |
49 |
51 | {nodeDatum_.expr &&
53 |
54 | )
55 | }
56 |
57 | export default function ({ pos, tree }: { pos: DocumentPosition, tree: RBTreeVars }) {
58 | const nodeSize = { x: 40, y: 80 }
59 | const foreignObjectProps = { width: nodeSize.x, height: nodeSize.y, y: -10, x: -4 }
60 | const r = React.useRef(null)
61 | const [t, setT] = React.useState(null)
62 | React.useLayoutEffect(() => {
63 | const elt = r.current
64 | if (elt == null) { return }
65 | if (t != null) { return }
66 | const b = elt.getBoundingClientRect()
67 | if (!b.width || !b.height) { return }
68 | setT({ x: b.width / 2, y: 20 })
69 |
70 | })
71 | return (
72 | ())
30 |
31 | /* A temporary element that we use to put colors in canonical form;
32 | * there seems to be no way of doing this with a pure function.
33 | * It must be in the DOM to pick up CSS styles. */
34 | const colEl = document.createElement('div')
35 | colEl.style.display = 'none'
36 | document.body.appendChild(colEl)
37 | const getCssColour = (col: string) => {
38 | colEl.style.color = col
39 | col = getComputedStyle(colEl).color
40 | /* The value is guaranteed to be `rgb` or `rgba` in [0, 255].
41 | * We convert this to `rgba` in [0, 1]. */
42 | const gps = col.match(/[( ]\w+/g)
43 | if (!gps) throw new Error(`cannot parse colour '${col}'`)
44 | const cols = gps.map(x => parseInt(x.substring(1), 10))
45 | let r, g, b, a
46 | if (cols.length === 3) {
47 | [r, g, b] = cols
48 | a = '255'
49 | } else if (cols.length === 4) {
50 | [r, g, b, a] = cols
51 | } else {
52 | throw new Error(`unexpected channels in '${col}'`)
53 | }
54 | return `rgba(${r}/255,${g}/255,${b}/255,${a}/255)`
55 | }
56 |
57 | const colForeground = getCssColour('var(--vscode-editor-foreground)')
58 | const colBackground = getCssColour('var(--vscode-editor-background)')
59 | const colTooltipBackground = getCssColour('var(--vscode-editorHoverWidget-background)')
60 | const colTooltipForeground = getCssColour('var(--vscode-editorHoverWidget-foreground)')
61 | const colTooltipBorder = getCssColour('var(--vscode-editorHoverWidget-border)')
62 |
63 | document.body.removeChild(colEl)
64 |
65 | const sty = props.sty +
66 | `
67 | theme {
68 | color foreground = ${colForeground}
69 | color background = ${colBackground}
70 | color tooltipBackground = ${colTooltipBackground}
71 | color tooltipForeground = ${colTooltipForeground}
72 | color tooltipBorder = ${colTooltipBorder}
73 | }
74 | `
75 |
76 | return {
27 | if ('text' in html) {
28 | return <>{html.text}
29 | } else if ('element' in html) {
30 | const [tag, attrsList, cs] = html.element
31 | const attrs: any = {}
32 | for (const [k,v] of attrsList) {
33 | attrs[k] = v
34 | }
35 | const children = await Promise.all(cs.map(async html => await renderHtml(rs, pos, html)))
36 | if (tag === "hr") {
37 | // React is greatly concerned by
s having children. 38 | return
39 | } else if (children.length === 0) { 40 | return React.createElement(tag, attrs) 41 | } else { 42 | return React.createElement(tag, attrs, children) 43 | } 44 | } else if ('component' in html) { 45 | const [hash, export_, props, cs] = html.component 46 | const children = await Promise.all(cs.map(async html => await renderHtml(rs, pos, html))) 47 | const dynProps = {...props, pos} 48 | const mod = await importWidgetModule(rs, pos, hash) 49 | if (!(export_ in mod)) throw new Error(`Module '${hash}' does not export '${export_}'`) 50 | if (children.length === 0) { 51 | return React.createElement(mod[export_], dynProps) 52 | } else { 53 | return React.createElement(mod[export_], dynProps, children) 54 | } 55 | } else { 56 | return Unknown HTML variant: {JSON.stringify(html)} 57 | } 58 | } 59 | 60 | export default function HtmlDisplay({html} : {html: Html}): JSX.Element { 61 | const rs = useRpcSession() 62 | const pos = React.useContext(EnvPosContext)! 63 | const state = useAsyncPersistent(() => renderHtml(rs, pos, html), [rs, pos, html]) 64 | if (state.state === 'resolved') 65 | return state.value 66 | else if (state.state === 'rejected') 67 | return Error rendering HTML: {mapRpcError(state.error).message} 68 | return <> 69 | } 70 | -------------------------------------------------------------------------------- /widget/src/exprPresentation.tsx: -------------------------------------------------------------------------------- 1 | import * as React from 'react' 2 | import { RpcSessionAtPos, RpcPtr, Name, mapRpcError, useAsyncPersistent, 3 | useRpcSession} from '@leanprover/infoview' 4 | import HtmlDisplay, { Html } from './htmlDisplay' 5 | import InteractiveExpr from './interactiveExpr' 6 | 7 | type ExprWithCtx = RpcPtr<'ProofWidgets.ExprWithCtx'> 8 | 9 | interface ExprPresentationData { 10 | name: Name 11 | userName: string 12 | html: Html 13 | } 14 | 15 | async function getExprPresentations(rs: RpcSessionAtPos, expr: ExprWithCtx): 16 | Promise {
17 | const ret: any = await rs.call('ProofWidgets.getExprPresentations', { expr })
18 | return ret.presentations
19 | }
20 |
21 | /** Display the given expression using an `ExprPresenter`. The server is queried for registered
22 | * `ExprPresenter`s. A dropdown is shown allowing the user to select which of these should be used
23 | * to display the expression. */
24 | export default function ({ expr }: { expr: ExprWithCtx }): JSX.Element {
25 | const rs = useRpcSession()
26 | type Selection =
27 | { tag: 'auto' } |
28 | // Here `none` means use the default, that is `InteractiveExpr`.
29 | // We assume no presenter is registered under this name.
30 | { tag: 'manual', name: Name | 'none' }
31 | const [selection, setSelection] = React.useState({ tag: 'auto' })
32 | const st = useAsyncPersistent>(async () => {
33 | const ret = await getExprPresentations(rs, expr)
34 | setSelection(s => {
35 | // If there was a manually selected presenter which no longer applies, reset to auto.
36 | if (s.tag === 'manual' && s.name !== undefined &&
37 | !ret.some(d => d.name === s.name))
38 | return { tag: 'auto' }
39 | return s
40 | })
41 | return new Map(ret.map(v => [v.name, v]))
42 | }, [rs, expr])
43 |
44 | if (st.state === 'rejected')
45 | return <>Error: {mapRpcError(st.error).message}
46 | else if (st.state === 'resolved') {
47 | let selectionName: Name | 'none' = 'none'
48 | if (selection.tag === 'auto' && 0 < st.value.size)
49 | selectionName = Array.from(st.value.values())[0].name
50 | else if (selection.tag === 'manual' &&
51 | (selection.name === 'none' || st.value.has(selection.name)))
52 | selectionName = selection.name
53 |
54 | // For explanation of flow-root see https://stackoverflow.com/a/32301823
55 | return
42 | {.text node}
49 |
50 | boundingShape := .rect (rx*4).toFloat 20
51 | details? :=
52 | match doc? with
53 | | some d =>
54 | acc.push {source := a, target := b}}
67 | forces={#[
68 | .link { distance? := Float.ofNat (maxRadius * 2) },
69 | .collide { radius? := Float.ofNat maxRadius },
70 | .x { strength? := some 0.05 },
71 | .y { strength? := some 0.05 }
72 | ]}
73 | showDetails={true}
74 | />
75 | Widget.savePanelWidgetInfo
76 | (hash HtmlDisplayPanel.javascript)
77 | (return json% { html : $(← Server.rpcEncode html) })
78 | stx
79 | | stx => throwError "Unexpected syntax {stx}"
80 |
81 | def a : Nat := 0
82 | def b : Nat := 1
83 | def foo (c : Nat) : Nat × Int := (a + b * c, a / b)
84 |
85 | -- Put your cursor here.
86 | #expr_graph foo
87 |
--------------------------------------------------------------------------------
/RELEASES.md:
--------------------------------------------------------------------------------
1 | # ProofWidgets4 releases
2 |
3 | This file contains work-in-progress notes for the upcoming release, as well as previous releases.
4 | Please check the [releases](https://github.com/leanprover-community/ProofWidgets4/releases) page for the build artifacts.
5 |
6 | v0.0.49 (WIP)
7 | -------------
8 | * Published [@leanprover-community/proofwidgets4](https://www.npmjs.com/package/@leanprover-community/proofwidgets4) on NPM.
9 | This allows importing ProofWidgets4 JS components from widgets defined in other Lean packages.
10 | NPM support is experimental: see [discussion](https://leanprover.zulipchat.com/#narrow/channel/270676-lean4/topic/ProofWidgets.2EHtml.20to.20JSX.2EElement/near/488669256).
11 |
12 | v0.0.47
13 | -------
14 | * Generalized `GraphDisplay.Vertex.radius` to `GraphDisplay.Vertex.boundingShape`.
15 | * Added demo of metavariable graph display in tactic proofs.
16 |
17 | v0.0.46
18 | -------
19 |
20 | * Renamed `DigraphDisplay` to `GraphDisplay`.
21 | Undirected graphs can be rendered by turning off arrowheads.
22 | * Added support for edge labels and more customization to `GraphDisplay`.
23 |
24 | v0.0.45
25 | -------
26 |
27 | * Updated Lean to v4.14.0-rc1.
28 |
29 | v0.0.44
30 | -------
31 |
32 | * Added `DigraphDisplay` component. It uses [d3-force](https://d3js.org/d3-force) for layout
33 | and can accommodate a variety of display styles.
34 | See `Demos/Digraph.lean` for more.
35 | * Added `MarkdownDisplay` component to display Markdown (including LaTeX).
36 | * Fixed cloud release issue (see [Zulip](https://leanprover.zulipchat.com/#narrow/channel/287929-mathlib4/topic/cache.20and.20proofwidgets)).
37 |
38 | v0.0.30
39 | -------
40 |
41 | * Moved the toolchain to `leanprover/lean4:v4.7.0-rc1`.
42 | * Performance improvements for widgets using `mk_rpc_widget%`. Redundant, duplicate calls were previously made to the underlying RPC method; this has been fixed. Furthermore, serverside execution of the RPC method gets cancelled by the infoview as long as its results are no longer needed (for example because the user moved the cursor elsewhere). To opt into this mechanism, use `@[server_rpc_method_cancellable]` instead of `@[server_rpc_method]`. RPC methods using that attribute can check whether they have been cancelled using [IO.checkCanceled](https://leanprover-community.github.io/mathlib4_docs/Init/System/IO.html#IO.checkCanceled), and immediately return with an error or a partial result.
43 |
44 | v0.0.29
45 | -------
46 |
47 | * Moved the toolchain to `leanprover/lean4:v4.6.0`.
48 | * Exposed `theme.background` to Penrose style programs.
49 |
50 | v0.0.26 - v0.0.28
51 | -------
52 |
53 | * Toolchain bumps and associated tweaks.
54 |
55 | v0.0.25
56 | -------
57 |
58 | * Build the demos in CI.
59 |
60 | v0.0.24
61 | -------
62 |
63 | * Moved the toolchain to `leanprover/lean4:v4.5.0-rc1`.
64 | This brings changes to the user widget API described [here](https://github.com/leanprover/lean4/blob/master/RELEASES.md#v450).
65 | * **Removed** `ProofWidgets.savePanelWidgetInfo`. For now you should use `Lean.Widget.savePanelWidgetInfo` instead.
66 | An example migration can be found [here](https://github.com/leanprover-community/ProofWidgets4/compare/v0.0.23..v0.0.24#diff-c48bcbf1b4d226947726f7a0fe8c945f082f4195b34681638ca61a776bbf778eL49-R52).
67 | * The `with_panel_widgets` tactic now optionally accepts props for each listed widget.
68 | * Several components now use `mk_rpc_widget%` instead of JavaScript string literals.
69 | * Fixes and improvements in the `PenroseDiagram` component and the `Euclidean` demo.
70 |
--------------------------------------------------------------------------------
/ProofWidgets/Demos/Graph/Basic.lean:
--------------------------------------------------------------------------------
1 | module
2 |
3 | public meta import ProofWidgets.Component.GraphDisplay
4 | public meta import ProofWidgets.Component.HtmlDisplay
5 |
6 | public meta section
7 |
8 | /-! ## Directed graphs with `GraphDisplay` -/
9 |
10 | open ProofWidgets Jsx
11 |
12 | /-! ### Basic usage -/
13 |
14 | def mkEdge (st : String × String) : GraphDisplay.Edge := {source := st.1, target := st.2}
15 |
16 | -- Place your cursor here.
17 | #html ` to draw non-SVG elements.
60 | label :=
61 | -- TODO: the extra `
64 | }
65 | ]}
66 | edges={#[{ source := "a", target := "b" }]}
67 | />
68 |
69 | /-! ### Edge labels
70 |
71 | Arbitrary SVG elements can be used as edge labels. -/
72 |
73 | #html
79 | {GraphDisplay.mkCircle #[("r", "10")]}
80 | 1
81 |
82 | },
83 | { source := "b", target := "c"
84 | -- Use `` to draw non-SVG elements.
85 | label? :=
86 | -- TODO: the extra `
89 | }
90 | ]}
91 | forces={#[
92 | .link { distance? := some 100 }
93 | ]}
94 | />
95 |
96 | /-! ### Extra details
97 |
98 | A details box with extra information can be displayed below the graph.
99 | Click on vertices and edges to view their details. -/
100 |
101 | #html
81 |
86 | renderForeignObjectNode(rd3tProps, pos, foreignObjectProps)}
87 | orientation='vertical' />
88 |
89 | )
90 | }
91 |
--------------------------------------------------------------------------------
/ProofWidgets/Demos/Dynkin.lean:
--------------------------------------------------------------------------------
1 | module
2 |
3 | public meta import ProofWidgets.Component.HtmlDisplay
4 |
5 | public meta section
6 |
7 | /-! Ported from Lean 3 code by Oliver Nash:
8 | https://gist.github.com/ocfnash/fb61a17d0f1598edcc752999f17b70c6 -/
9 |
10 | def List.product : List α → List β → List (α × β)
11 | | [], _ => []
12 | | a::as, bs => bs.map ((a, ·)) ++ as.product bs
13 |
14 | @[expose] def Matrix (n m α : Type) := n → m → α
15 |
16 | namespace Matrix
17 |
18 | open ProofWidgets
19 | open scoped Jsx
20 |
21 | variable {n : Nat} (A : Matrix (Fin n) (Fin n) Int)
22 |
23 | def nat_index (i j : Nat) : Int :=
24 | if h : i < n ∧ j < n then A ⟨i, h.1⟩ ⟨j, h.2⟩ else 999
25 |
26 | /-- TODO Delete me once `get_node_pos` smart enough to infer layout from values in `A`. -/
27 | def get_node_pos_E : Nat → Nat × Nat
28 | | 0 => ⟨0, 0⟩
29 | | 1 => ⟨2, 1⟩
30 | | (i+1) => ⟨i, 0⟩
31 |
32 | /-- TODO Use `A` to infer sensible layout. -/
33 | def get_node_pos (n : Nat) : Nat → Nat × Nat := if n < 6 then ((·, 0)) else get_node_pos_E
34 |
35 | def get_node_cx (n i : Nat) : Int := 20 + (get_node_pos n i).1 * 40
36 |
37 | def get_node_cy (n i : Nat) : Int := 20 + (get_node_pos n i).2 * 40
38 |
39 | def get_node_html (n i : Nat) : Html :=
40 |
74 | {Html.element "svg" #[] (M.get_edges_html ++ Matrix.get_nodes_html n).toArray}
75 |
76 |
77 | end Matrix
78 |
79 | def cartanMatrix.E₈ : Matrix (Fin 8) (Fin 8) Int :=
80 | fun i j =>
81 | [[ 2, 0, -1, 0, 0, 0, 0, 0],
82 | [ 0, 2, 0, -1, 0, 0, 0, 0],
83 | [-1, 0, 2, -1, 0, 0, 0, 0],
84 | [ 0, -1, -1, 2, -1, 0, 0, 0],
85 | [ 0, 0, 0, -1, 2, -1, 0, 0],
86 | [ 0, 0, 0, 0, -1, 2, -1, 0],
87 | [ 0, 0, 0, 0, 0, -1, 2, -1],
88 | [ 0, 0, 0, 0, 0, 0, -1, 2]][i]![j]!
89 |
90 | -- Place your cursor here
91 | #html cartanMatrix.E₈.toHtml
92 |
--------------------------------------------------------------------------------
/widget/src/penroseDisplay.tsx:
--------------------------------------------------------------------------------
1 | /*
2 | Copyright (c) 2022 Wojciech Nawrocki. All rights reserved.
3 | Released under Apache 2.0 license as described in the file LICENSE.
4 | Authors: Wojciech Nawrocki
5 | */
6 | import * as React from 'react';
7 |
8 | import { PenroseCanvas } from './penroseCanvas';
9 | import { Html, default as HtmlDisplay } from './htmlDisplay';
10 |
11 | interface DiagramData {
12 | embeds: [string, Html][],
13 | dsl: string,
14 | sty: string,
15 | sub: string,
16 | maxOptSteps: number,
17 | }
18 |
19 | export default function(props: DiagramData): JSX.Element {
20 | const {embeds, dsl, sub} = props
21 | const mkElt = (html: Html): JSX.Element =>
22 |
23 |
25 |
26 | const embedNodes =
27 | embeds.reduce(
28 | (acc, [nm, cwi]) => acc.set(nm, mkElt(cwi)),
29 | new Maps having children. 38 | return
39 | } else if (children.length === 0) { 40 | return React.createElement(tag, attrs) 41 | } else { 42 | return React.createElement(tag, attrs, children) 43 | } 44 | } else if ('component' in html) { 45 | const [hash, export_, props, cs] = html.component 46 | const children = await Promise.all(cs.map(async html => await renderHtml(rs, pos, html))) 47 | const dynProps = {...props, pos} 48 | const mod = await importWidgetModule(rs, pos, hash) 49 | if (!(export_ in mod)) throw new Error(`Module '${hash}' does not export '${export_}'`) 50 | if (children.length === 0) { 51 | return React.createElement(mod[export_], dynProps) 52 | } else { 53 | return React.createElement(mod[export_], dynProps, children) 54 | } 55 | } else { 56 | return Unknown HTML variant: {JSON.stringify(html)} 57 | } 58 | } 59 | 60 | export default function HtmlDisplay({html} : {html: Html}): JSX.Element { 61 | const rs = useRpcSession() 62 | const pos = React.useContext(EnvPosContext)! 63 | const state = useAsyncPersistent(() => renderHtml(rs, pos, html), [rs, pos, html]) 64 | if (state.state === 'resolved') 65 | return state.value 66 | else if (state.state === 'rejected') 67 | return Error rendering HTML: {mapRpcError(state.error).message} 68 | return <> 69 | } 70 | -------------------------------------------------------------------------------- /widget/src/exprPresentation.tsx: -------------------------------------------------------------------------------- 1 | import * as React from 'react' 2 | import { RpcSessionAtPos, RpcPtr, Name, mapRpcError, useAsyncPersistent, 3 | useRpcSession} from '@leanprover/infoview' 4 | import HtmlDisplay, { Html } from './htmlDisplay' 5 | import InteractiveExpr from './interactiveExpr' 6 | 7 | type ExprWithCtx = RpcPtr<'ProofWidgets.ExprWithCtx'> 8 | 9 | interface ExprPresentationData { 10 | name: Name 11 | userName: string 12 | html: Html 13 | } 14 | 15 | async function getExprPresentations(rs: RpcSessionAtPos, expr: ExprWithCtx): 16 | Promise
56 | {selectionName !== 'none' &&
57 |
72 | } else
73 | return
55 |
58 | | none =>
59 |
60 | ` node messes up positioning
62 |
` node messes up positioning
87 |