Warning: this is an htmlized version!
The original is here, and
the conversion rules are here.
######
#
# E-scripts on the Lean theorem prover / proof assistant.
#
# Note 1: use the eev command (defined in eev.el) and the
# ee alias (in my .zshrc) to execute parts of this file.
# Executing this file as a whole makes no sense.
# An introduction to eev can be found here:
#
#   (find-eev-quick-intro)
#   http://angg.twu.net/eev-intros/find-eev-quick-intro.html
#
# Note 2: be VERY careful and make sure you understand what
# you're doing.
#
# Note 3: If you use a shell other than zsh things like |&
# and the for loops may not work.
#
# Note 4: I always run as root.
#
# Note 5: some parts are too old and don't work anymore. Some
# never worked.
#
# Note 6: the definitions for the find-xxxfile commands are on my
# .emacs.
#
# Note 7: if you see a strange command check my .zshrc -- it may
# be defined there as a function or an alias.
#
# Note 8: the sections without dates are always older than the
# sections with dates.
#
# This file is at <http://angg.twu.net/e/lean.e>
#           or at <http://angg.twu.net/e/lean.e.html>.
#        See also <http://angg.twu.net/emacs.html>,
#                 <http://angg.twu.net/.emacs[.html]>,
#                 <http://angg.twu.net/.zshrc[.html]>,
#                 <http://angg.twu.net/escripts.html>,
#             and <http://angg.twu.net/>.
#
#######



# «.lean4-mode-melpa»		(to "lean4-mode-melpa")
# «.lean4-mode-vc»		(to "lean4-mode-vc")
# «.feb2024»			(to "feb2024")
# «.zulip»			(to "zulip")
# «.elan»			(to "elan")
# «.install-2024»		(to "install-2024")
# «.lean4»			(to "lean4")
# «.lean4-git»			(to "lean4-git")
#   «.ee-rstdoc-:lean4»		(to "ee-rstdoc-:lean4")
#   «.:lean4»			(to ":lean4")
# «.lake»			(to "lake")
# «.lake-new-lake-build»	(to "lake-new-lake-build")
# «.lake-env»			(to "lake-env")
# «.lake-CLI»			(to "lake-CLI")
# «.lake-new-greeting»		(to "lake-new-greeting")
# «.lake-current-directory»	(to "lake-current-directory")
# «.cache-mathlib»		(to "cache-mathlib")
# «.lean4-mode»			(to "lean4-mode")
# «.lean-mode»			(to "lean-mode")
# «.lsp-server-exited-restart»	(to "lsp-server-exited-restart")
# «.lsp-yasnippet»		(to "lsp-yasnippet")
# «.mode-line»			(to "mode-line")
# «.topos»			(to "topos")
# «.diagram-chasing»		(to "diagram-chasing")
# «.prelude»			(to "prelude")
# «.rec_on»			(to "rec_on")
# «.alectryon»			(to "alectryon")
# «.nng4»			(to "nng4")
# «.lean4game»			(to "lean4game")
# «.natural-number-game»	(to "natural-number-game")
# «.real-number-game»		(to "real-number-game")
# «.set-theory-game»		(to "set-theory-game")
# «.mathsinlean»		(to "mathsinlean")
# «.:leanmaths»			(to ":leanmaths")
# «.mathsinlean-build»		(to "mathsinlean-build")
# «.mathsinlean-source»		(to "mathsinlean-source")
# «.mathzoo»			(to "mathzoo")
# «.mathlib»			(to "mathlib")
# «.mathlib4»			(to "mathlib4")
# «.mathlib4-greeting»		(to "mathlib4-greeting")
# «.mathlib-calculus»		(to "mathlib-calculus")
# «.tactics-list»		(to "tactics-list")
# «.tactics-in-ND»		(to "tactics-in-ND")
# «.vernacular»			(to "vernacular")
# «.fplean4»			(to "fplean4")
# «.5-manuals-tgz»		(to "5-manuals-tgz")
#
# «.3-essential»		(to "3-essential")
# «.3-essential-way-1»		(to "3-essential-way-1")
# «.3-essential-way-2»		(to "3-essential-way-2")
# «.3-essential-way-3»		(to "3-essential-way-3")
# «.abbrev»			(to "abbrev")
# «.addDecl»			(to "addDecl")
# «.animate-lean-proofs»	(to "animate-lean-proofs")
# «.anonymous»			(to "anonymous")
# «.antiquotation»		(to "antiquotation")
# «.Array»			(to "Array")
# «.assign»			(to "assign")
# «.attributes»			(to "attributes")
# «.axiom»			(to "axiom")
# «.backtick»			(to "backtick")
#   «.double-backtick»		(to "double-backtick")
# «.backtick-syntaxcat»		(to "backtick-syntaxcat")
# «.Bind»			(to "Bind")
# «.binop»			(to "binop")
# «.batteries»			(to "batteries")
# «.builtin_initialize»		(to "builtin_initialize")
#
# «.calc»			(to "calc")
# «.check»			(to "check")
# «.checksyntax»		(to "checksyntax")
# «.checksyntax-test»		(to "checksyntax-test")
# «.class»			(to "class")
# «.class-extends»		(to "class-extends")
# «.command»			(to "command")
# «.constant»			(to "constant")
# «.coercion»			(to "coercion")
# «.CommandElabM»		(to "CommandElabM")
# «.company»			(to "company")
# «.constructor»		(to "constructor")
# «.CoreM»			(to "CoreM")
#
# «.dbg_trace»			(to "dbg_trace")
# «.declare_syntax_cat»		(to "declare_syntax_cat")
# «.def»			(to "def")
# «.denoteArith»		(to "denoteArith")
# «.deriving»			(to "deriving")
# «.discard»			(to "discard")
# «.doc-comments»		(to "doc-comments")
# «.do-iteration»		(to "do-iteration")
# «.do-notation»		(to "do-notation")
# «.dotdot»			(to "dotdot")
# «.eglot»			(to "eglot")
# «.elab»			(to "elab")
# «.elabIMP»			(to "elabIMP")
# «.elab_rules»			(to "elab_rules")
# «.elab-term»			(to "elab-term")
# «.elab-type»			(to "elab-type")
# «.eldoc»			(to "eldoc")
# «.Environment»		(to "Environment")
# «.exceptions»			(to "exceptions")
# «.explicit-arguments»		(to "explicit-arguments")
#   «.implicit-arguments»	(to "implicit-arguments")
# «.exploring-data»		(to "exploring-data")
# «.exploring-data-2»		(to "exploring-data-2")
# «.export»			(to "export")
# «.Expr»			(to "Expr")
# «.extends»			(to "extends")
# «.extern»			(to "extern")
# «.extractFrom»		(to "extractFrom")
# «.eval»			(to "eval")
# «.example»			(to "example")
# «.feline»			(to "feline")
# «.Finset-comprehensions»	(to "Finset-comprehensions")
# «.FFI»			(to "FFI")
# «.FilePath»			(to "FilePath")
# «.FirstTokens»		(to "FirstTokens")
# «.fun»			(to "fun")
# «.Functor»			(to "Functor")
# «.getCurrNamespace»		(to "getCurrNamespace")
# «.guard_msgs»			(to "guard_msgs")
# «.guillemets»			(to "guillemets")
# «.HashMap»			(to "HashMap")
# «.have»			(to "have")
# «.heterogeneous»		(to "heterogeneous")
# «.Id.run»			(to "Id.run")
# «.if-let»			(to "if-let")
# «.import»			(to "import")
# «.import-problem»		(to "import-problem")
# «.indentation»		(to "indentation")
# «.inductive»			(to "inductive")
# «.inductive-Arith»		(to "inductive-Arith")
# «.inductive-Expr»		(to "inductive-Expr")
# «.inductive-List»		(to "inductive-List")
# «.inductive-N»		(to "inductive-N")
# «.inductive-Nat»		(to "inductive-Nat")
#   «.inductive-myNat»		(to "inductive-myNat")
# «.inductive-Option»		(to "inductive-Option")
# «.inductive-Syntax»		(to "inductive-Syntax")
# «.inferInstance»		(to "inferInstance")
# «.inferType»			(to "inferType")
# «.infix»			(to "infix")
# «.infixl»			(to "infixl")
# «.infixr»			(to "infixr")
# «.info-scp-mainModule»	(to "info-scp-mainModule")
# «.Inhabited»			(to "Inhabited")
# «.initialize»			(to "initialize")
# «.instance»			(to "instance")
# «.instance-implicits»		(to "instance-implicits")
# «.instance-Monad-List»	(to "instance-Monad-List")
# «.intercalate»		(to "intercalate")
# «.interpolatedStr»		(to "interpolatedStr")
# «.IO»				(to "IO")
# «.IO.print»			(to "IO.print")
# «.IO.println»			(to "IO.println")
# «.IO.Process.output»		(to "IO.Process.output")
# «.Lake.Load»			(to "Lake.Load")
# «.latin-cross»		(to "latin-cross")
# «.LawfulFunctor»		(to "LawfulFunctor")
# «.leading-dot-notation»	(to "leading-dot-notation")
# «.leading_parser»		(to "leading_parser")
# «.Lean.Parser.Category»	(to "Lean.Parser.Category")
# «.lean-type-theory»		(to "lean-type-theory")
# «.let»			(to "let")
# «.let_fun»			(to "let_fun")
# «.let-mut»			(to "let-mut")
# «.letterlike»			(to "letterlike")
# «.Linter»			(to "Linter")
# «.List»			(to "List")
# «.logInfo»			(to "logInfo")
# «.macro»			(to "macro")
# «.map»			(to "map")
# «.mapAddOneNil»		(to "mapAddOneNil")
# «.match»			(to "match")
# «.match-bar»			(to "match-bar")
# «.mdbook»			(to "mdbook")
# «.mdgen»			(to "mdgen")
# «.meta-if»			(to "meta-if")
# «.minted»			(to "minted")
# «.mkSyntaxQuotation»		(to "mkSyntaxQuotation")
# «.Monad»			(to "Monad")
# «.Monad-map»			(to "Monad-map")
# «.Monad-S»			(to "Monad-S")
# «.modules»			(to "modules")
# «.mutual»			(to "mutual")
# «.mydef»			(to "mydef")
# «.mySpecialCheck»		(to "mySpecialCheck")
# «.Name»			(to "Name")
# «.namespace»			(to "namespace")
#   «.section»			(to "section")
#   «.open»			(to "open")
# «.notation»			(to "notation")
# «.observation-study»		(to "observation-study")
# «.opaque»			(to "opaque")
# «.open»			(to "open")
# «.Options»			(to "Options")
# «.optParam»			(to "optParam")
# «.orelse»			(to "orelse")
# «.outParam»			(to "outParam")
# «.p123456»			(to "p123456")
# «.Partax»			(to "Partax")
# «.Partax-match_stx2»		(to "Partax-match_stx2")
# «.parse_term»			(to "parse_term")
# «.partial»			(to "partial")
# «.partial-mutual»		(to "partial-mutual")
# «.polymorphism»		(to "polymorphism")
# «.posOrNegThree»		(to "posOrNegThree")
# «.postulate»			(to "postulate")
# «.pp.notation»		(to "pp.notation")
# «.pp.universes»		(to "pp.universes")
# «.pratt-parser»		(to "pratt-parser")
# «.precedence»			(to "precedence")
# «.print»			(to "print")
# «.print-inductive»		(to "print-inductive")
# «.Prod»			(to "Prod")
# «.project»			(to "project")
# «.Pure»			(to "Pure")
# «.Range»			(to "Range")
# «.ReaderT»			(to "ReaderT")
# «.reduce»			(to "reduce")
# «.repl»			(to "repl")
# «.Repr»			(to "Repr")
# «.repr-type»			(to "repr-type")
# «.runActions»			(to "runActions")
# «.runCmd»			(to "runCmd")
# «.run_cmd»			(to "run_cmd")
# «.runParserCategory»		(to "runParserCategory")
# «.runTermElabM»		(to "runTermElabM")
# «.rw»				(to "rw")
# «.saveState»			(to "saveState")
# «.scoped-syntax»		(to "scoped-syntax")
# «.semi-output»		(to "semi-output")
# «.server»			(to "server")
# «.show»			(to "show")
# «.show-from-do»		(to "show-from-do")
# «.sleep1»			(to "sleep1")
# «.specialize»			(to "specialize")
# «.State»			(to "State")
# «.Std.Format»			(to "Std.Format")
# «.string-interpolation»	(to "string-interpolation")
# «.structure»			(to "structure")
# «.structures»			(to "structures")
# «.structure-like»		(to "structure-like")
# «.stx»			(to "stx")
# «.syntax-command»		(to "syntax-command")
# «.syntax-parser»		(to "syntax-parser")
# «.syntax-name»		(to "syntax-name")
# «.synth»			(to "synth")
# «.tactic_expand1»		(to "tactic_expand1")
# «.tagged-subgoals»		(to "tagged-subgoals")
# «.telescopes»			(to "telescopes")
# «.termination»		(to "termination")
# «.termParser»			(to "termParser")
# «.theorem»			(to "theorem")
# «.toolchains»			(to "toolchains")
# «.ToString»			(to "ToString")
# «.tpil-p38»			(to "tpil-p38")
# «.trace.Elab.command»		(to "trace.Elab.command")
# «.trace.Elab.info»		(to "trace.Elab.info")
# «.try-catch»			(to "try-catch")
# «.TSyntax»			(to "TSyntax")
# «.typeclass-search»		(to "typeclass-search")
# «.typeof»			(to "typeof")
# «.underscore»			(to "underscore")
# «.Unhygienic.run»		(to "Unhygienic.run")
# «.variable»			(to "variable")
# «.where»			(to "where")
# «.whnf»			(to "whnf")
#
# «.delaborator-diagram»	(to "delaborator-diagram")
# «.reference-manual»		(to "reference-manual")
#   «.:leanref»			(to ":leanref")
# «.metaprogramming»		(to "metaprogramming")
#   «.:leanmeta»		(to ":leanmeta")
# «.metaprogramming-book.yml»	(to "metaprogramming-book.yml")
# «.metaprogramming-toolchain»	(to "metaprogramming-toolchain")
# «.TermElabM»			(to "TermElabM")
# «.tpil»			(to "tpil")
# «.useandabuseoip»		(to "useandabuseoip")
# «.ullrichmp»			(to "ullrichmp")
# «.mechanics-of-proof»		(to "mechanics-of-proof")
# «.:mechprf»			(to ":mechprf")
# «.Colorized»			(to "Colorized")
# «.leandojo»			(to "leandojo")
# «.do-unchained»		(to "do-unchained")




https://leanprover.github.io/
https://leanprover.github.io/tutorial/
https://leanprover.github.io/download/debian78.html

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
# Dependencies
sudo apt-get install libstdc++-4.8-dev libgmp-dev libmpfr-dev liblua5.2-dev ninja-build
sudo dpkg -i /tmp/lean*.deb

# (find-status   "lean")
# (find-vldifile "lean.list")
# (find-udfile   "lean/")

# (find-sitelispfile "lean/")
# (find-sitelispfile "lean/lean-mode.el")
# (find-sitelispfile "lean/lean-mode.el" ";; Automatically use lean-mode for")
# (find-sitelispfile "lean/load-lean.el")

# (find-fline "/usr/lib/lean/")
# (find-fline "/usr/lib/lean/hott/")
# (find-fline "/usr/lib/lean/hott/book.md")
# (find-fline "/usr/lib/lean/library/")
# (find-fline "/usr/lib/lean/library/logic/logic.md")


https://leanprover.github.io/documentation/
http://leanprover.github.io/presentations/20150123_lean-mode/lean-mode.pdf
https://leanprover.github.io/tutorial/tutorial.pdf
https://leanprover.github.io/tutorial/quickref.pdf
https://github.com/leanprover/lean
https://github.com/leanprover/lean/blob/master/doc/lean/tutorial.org
https://github.com/leanprover/lean/blob/master/src/emacs/README.md


https://jiggerwit.wordpress.com/2018/09/18/a-review-of-the-lean-theorem-prover/ ***

https://xenaproject.wordpress.com/2020/02/09/lean-is-better-for-proper-maths-than-all-the-other-theorem-provers/
https://xenaproject.wordpress.com/2020/02/09/where-is-the-fashionable-mathematics/
https://xenaproject.wordpress.com/2020/04/30/the-invisible-map/
https://xenaproject.wordpress.com/2020/06/27/teaching-dependent-type-theory-to-4-year-olds-via-mathematics/amp/

https://xenaproject.wordpress.com/2021/01/21/formalising-mathematics-an-introduction/ pictures as eefective guides ***
https://xenaproject.wordpress.com/2021/04/18/induction-on-equality/




#####
#
# lean4-mode-melpa
# 2024mar10
#
#####

# «lean4-mode-melpa»  (to ".lean4-mode-melpa")
# (find-epackage-links 'lean4-mode "lean4mode" t)
# (find-epackages      'lean4-mode)
# (find-epackage       'lean4-mode)

# (package-refresh-contents)
# (package-install 'lean4-mode)
# (find-epackage   'lean4-mode)
# (package-delete (ee-package-desc 'lean4-mode))

# (code-c-d "lean4mode" "~/.emacs.d/elpa/lean4-mode/")
# (find-lean4modefile "")



#####
#
# lean4-mode-vc
# 2024mar10
#
#####

# «lean4-mode-vc»  (to ".lean4-mode-vc")
# (find-epackage-links 'lean4-mode "lean4mode" t)
# (find-epackage       'lean4-mode)
# (package-vc-install "https://github.com/leanprover-community/lean4-mode")
# (code-c-d "lean4mode" "~/.emacs.d/elpa/lean4-mode/")
# (find-lean4modefile "")
# (find-lean4modefile "README.md" "Trying It Out")
# https://github.com/leanprover-community/lean4-mode?tab=readme-ov-file#trying-it-out
# (find-ekeymapdescr lean4-mode-map "C-c C-k" "quail-show-key")

 C-c C-k      show the keystroke needed to input the symbol under the cursor
 C-c C-d      recompile & reload imports (`lean4-refresh-file-dependencies`)
 C-c C-x      execute Lean in stand-alone mode (`lean4-std-exe`)
 C-c C-p C-l  builds package with lake (`lean4-lake-build`)
 C-c C-i      toggle info view showing goals and errors at point (`lean4-toggle-info-buffer`)
 C-c ! n      flycheck: go to next error
 C-c ! p      flycheck: go to previous error

  →×αβ∧∨↔¬





#####
#
# feb2024
# 2024feb22
#
#####

# «feb2024»  (to ".feb2024")
# (find-es "emacs" "flycheck")
# (find-angg "LEAN/a.lean")

# (find-fline "~/.emacs.d/elpa/lean4-mode/")
# (find-fline "~/.emacs.d/elpa/lean4-mode/lean4-fringe.el" "(require 'lsp-mode)")

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
cd ~/.emacs.d/elpa/lean4-mode/
git pull

* (byte-recompile-directory "~/.emacs.d/elpa/lean4-mode/")


# Source file ‘/home/edrx/.emacs.d/elpa/lean4-mode/lean4-mode.el’ newer than byte-compiled file; using older file
# File mode specification error: (file-missing Cannot open load file No such file or directory ht)
# (find-efunctiondescr   'byte-compile-file)
# (find-efunction        'byte-compile-file)
# (find-elnode "Index" "* byte-compile-file:")
# (find-efunction-links 'byte-recompile-directory)


# (find-epackage-links 'spinner)
# (find-epackage-links 'ht)
# (find-epackage       'ht)
# (code-c-d "ht" "{d}")

https://github.com/Wilfred/ht.el




#####
#
# zulip
# 2023jun24
#
#####

# «zulip»  (to ".zulip")
# https://leanprover.zulipchat.com/




#####
#
# elan
# 2023jun22
#
#####

# «elan»  (to ".elan")
# «install-2024»  (to ".install-2024")
# (find-angg ".emacs" "lean4")
# https://leanprover-community.github.io/install/debian.html
# https://leanprover-community.github.io/install/debian_details.html
# https://github.com/leanprover/elan
# https://proofassistants.stackexchange.com/questions/2/how-do-i-install-lean-4
# (find-git-links "https://github.com/leanprover/elan" "elan")
# (code-c-d "elan" "~/usrc/elan/")
# (find-elanfile "")

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
# (find-fline "/tmp/elan-install/")
rm -Rv /tmp/elan-install/
mkdir  /tmp/elan-install/
cd     /tmp/elan-install/
curl https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh -sSf \
  | sh -s -- --default-toolchain leanprover/lean4:stable

# (find-fline "~/.profile")
# (find-fline "~/.zprofile")

Elan is installed now. Great!

To get started you need Elan's bin directory ($HOME/.elan/bin) in your PATH 
environment variable. Next time you log in this will be done automatically.

To configure your current shell run source $HOME/.elan/env


# (code-c-d "elan4lean" "~/.elan/toolchains/leanprover--lean4---stable/src/lean/")
# (find-elan4leanfile "")
# (find-sh "find ~/.elan/ | sort")
rm -Rfv ~/.elan/

elan
elan show
# elan default leanprover/lean4:stable
w lake
lake

# (find-fline "/home/edrx/.elan/bin/")

# Welcome to Lean!
# 
# This will download and install Elan, a tool for managing different Lean 
# versions used in packages you create or download. It will also install a 
# default version of Lean and its package manager, leanpkg, for editing files not
# belonging to any package.
# 
# It will add the leanpkg, lean, and elan commands to Elan's bin directory, 
# located at:
# 
#   /home/edrx/.elan/bin
# 
# This path will then be added to your PATH environment variable by modifying the
# profile files located at:
# 
#   /home/edrx/.profile
#   /home/edrx/.zprofile
# 
# You can uninstall at any time with elan self uninstall and these changes will 
# be reverted.
# 
# Current installation options:
# 
#      default toolchain: leanprover/lean4:nightly
#   modify PATH variable: yes
# 
# 1) Proceed with installation (default)
# 2) Customize installation
# 3) Cancel installation



* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
# rm -Rfv ~/usrc/elan/
cd      ~/usrc/
git clone https://github.com/leanprover/elan
cd      ~/usrc/elan/

# (code-c-d "elan" "~/usrc/elan/")
# (find-elanfile "")
# (find-elanfile "elan-init.sh")

# (find-fline "~/.elan/")
# (find-fline "~/.profile")
# (find-fline "~/.zprofile")



#####
#
# reinstall-2024
# 2024may16
#
#####

# «.reinstall-2024»	(to "reinstall-2024")
# «reinstall-2024»  (to ".reinstall-2024")

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
du -ch ~/.elan/
rm -Rv ~/.elan/




#####
#
# lean4
# 2023jun22
#
#####

# «lean4»      (to ".lean4")
# «lean4-git»  (to ".lean4-git")
# https://github.com/leanprover/lean4
# https://www.reddit.com/r/haskell/comments/z55hha/review_of_lean_4/

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
# rm -Rfv ~/bigsrc/lean4/
cd      ~/bigsrc/
git clone https://github.com/leanprover/lean4
cd      ~/bigsrc/lean4/

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
cd      ~/bigsrc/lean4/
git pull
git clean -dfx
git reset --hard
find * | sort > .files
wc              .files

export PAGER=cat
git branch --list -a
git for-each-ref
git log --oneline --graph --all -20

# (find-fline "~/bigsrc/")
# (find-fline "~/bigsrc/lean4/")
# (find-gitk  "~/bigsrc/lean4/")

# (code-c-d "lean4" "~/bigsrc/lean4/")
# (find-lean4sh "find * -type d | sort")
# (find-lean4sh "find * | sort | grep -i check")
# (find-lean4sh "find * | sort | grep -i notation")
# (find-lean4sh "find * | sort | grep -i synthesize")
# (find-lean4file "")
# (find-lean4file ".files")
# (find-lean4file "doc/")
# (find-lean4file "doc/setup.md")
# (find-lean4file "doc/quickstart.md")
# (find-lean4file "doc/quickstart.md" "lake init foo")
# (find-lean4file "doc/sections.md")
# (find-lean4file "doc/dev/mdbook.md")
# https://lean-lang.org/lean4/doc/dev/mdbook.html

Quickstart:        https://github.com/leanprover/lean4/blob/master/doc/quickstart.md
Walkthrough installation video:  https://www.youtube.com/watch?v=yZo6k48L0VY
Quick tour video:  https://youtu.be/zyXtbb_eYbY
Homepage:          https://leanprover.github.io
Theorem Proving Tutorial:        https://leanprover.github.io/theorem_proving_in_lean4/
Functional Programming in Lean:  https://leanprover.github.io/functional_programming_in_lean/
Manual:            https://leanprover.github.io/lean4/doc/
Release notes:     RELEASES.md
Examples:          https://leanprover.github.io/lean4/doc/examples.html
FAQ:               https://leanprover.github.io/lean4/doc/faq.html
Setting Up Lean:   https://leanprover.github.io/lean4/doc/setup.html

https://github.com/leanprover/lean4/blob/master/doc/setup.md#basic-setup

$ elan self update  # in case you haven't updated elan in a while
# download & activate latest Lean 4 stable release (https://github.com/leanprover/lean4/releases)
$ elan default leanprover/lean4:stable

elan self update
elan default leanprover/lean4:stable

# download & activate latest Lean 4 stable release (https://github.com/leanprover/lean4/releases)



#####
#
# ee-rstdoc-:lean4
# 2024may23
#
#####

# «ee-rstdoc-:lean4»  (to ".ee-rstdoc-:lean4")
# «:lean4»  (to ".:lean4")
# (find-angg ".emacs"         "ee-rstdoc-:lean4")
# (find-angg ".emacs.lean.el" "ee-rstdoc-:lean4")
# (find-wgetrecursive-links "https://lean-lang.org/lean4/doc/")
# (to "lean4-git")
# (find-code-rstdoc :lean4)
# (find-lean4doc  "whatIsLean")
# (find-lean4docw "whatIsLean")
# (find-lean4docr "whatIsLean.md")




#####
#
# lake
# 2024mar10
#
#####

# «lake»  (to ".lake")
# (find-angg ".emacs.papers" "fplean4")
# (find-angg ".emacs.papers" "fplean4" "75" "Starting a Project")
# (find-lean4doc  "setup#lake")
# (find-lean4docr "setup.md#lake")
# (find-fplean4doc  "hello-world/starting-a-project#first-steps")
# (find-fplean4docr "hello-world/starting-a-project" "## First steps")
# (find-fplean4docr "hello-world/starting-a-project" "`lake init` instead of `lake new`")

# Deprecated, merged into Lean4:
#   https://github.com/leanprover/lake
#   (find-git-links "https://github.com/leanprover/lake" "lake")
#   (code-c-d "lake" "~/usrc/lake/")
# See: (to "IO.Process.output")

# (find-lean4file "")
# (find-lean4sh "find * | sort")
# (find-lean4sh "find * | sort | grep -i lake")
# (find-lean4file "src/Lean/Util/LakePath.lean")
# (find-lean4file "src/lake/")
# (find-lean4file "src/lake/Lake.lean")
# (find-lean4file "src/lake/Lake/")
# (find-lean4file "src/lake/README.md")

# (find-lakefile "")
# (find-lakefile "README.md")
# (find-lakesh "find * | sort")




#####
#
# Testing lake with "lake new greeting"
# 2023jun25
#
#####

# «lake-new-greeting»  (to ".lake-new-greeting")
# (to "project")
# (to "modules")
# (to "mathlib4-greeting")
# (find-angg ".emacs.papers" "fplean4")
# (find-fplean4doc  "hello-world/starting-a-project")
# (find-fplean4docr "hello-world/starting-a-project")
# (find-fplean4docr "hello-world/starting-a-project" "lake new greeting")
# (find-fplean4page 75 "Starting a Project")
# (find-fplean4text 75 "Starting a Project")
# (find-fplean4page 76  "import «Greeting»")
# (find-fplean4text 76  "import «Greeting»")

# (code-c-d "grg" "/tmp/gr/greeting/")
# (find-grgfile "")
# (find-grgfile "lakefile.lean" "@[default_target]")
# (find-lean4prefile "lake/Lake/DSL/Attributes.lean" "initialize defaultTargetAttr")
# (to "initialize")

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
# (find-fline "/tmp/gr/")
rm -Rfv /tmp/greeting/
rm -Rfv /tmp/gr/
mkdir   /tmp/gr/
cd      /tmp/gr/
lake new greeting
cd      /tmp/gr/greeting/

# lean --run Main.lean
# lean --run Greeting.lean

find * | sort |  tee of0
lake build    |& tee olb
find * | sort |  tee of1
comm of0 of1

laf
find  build | sort
      build/bin/greeting
cp -v build/bin/greeting /tmp/greeting
cd /tmp/
./greeting

# (find-fline "/tmp/gr/greeting/")
# (find-fline "/tmp/gr/greeting/Main.lean")
# (find-fline "/tmp/gr/greeting/build/bin/")

w lake




#####
#
# Testing lake by running "lake new foo", "cd foo", and "lake build"
# 2024jun09
#
#####

# «lake-new-lake-build»  (to ".lake-new-lake-build")
lake-build lake build

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
# (find-fline "/tmp/testlake/")
rm -Rfv /tmp/testlake/
mkdir   /tmp/testlake/
cd      /tmp/testlake/
lake new foo
find    /tmp/testlake/ | sort

cd      /tmp/testlake/foo/
lake build   |& tee olb

** (find-sh "find /tmp/testlake/           | sort")
** (find-sh "find /tmp/testlake/foo/.lake/ | sort")
*  (code-c-d "foo"      "/tmp/testlake/foo/")
*  (code-c-d "foobuild" "/tmp/testlake/foo/.lake/build/")
** (find-foofile "")
** (find-foobuildfile "")
** (find-foosh      "find * .lake/ | sort")
** (find-foosh      "find *        | sort")
** (find-foobuildsh "find *        | sort")

      /tmp/testlake/foo/.lake/build/bin/foo
cp -v /tmp/testlake/foo/.lake/build/bin/foo /tmp/testlake/foo.bin
      /tmp/testlake/foo.bin

# (find-foofile "")
# (find-foofile "Main.lean")
# (find-foofile "Foo.lean")
# (find-foofile "Foo/")
# (find-foofile "Foo/Basic.lean")




#####
#
# lake-env
# 2024jun10
#
#####

# «lake-env»  (to ".lake-env")
# (to "import-problem")
# (find-sh "lake --help" "env <cmd> <args>")
# (find-sh "lake --help env")
# (find-lean4prefile "lake/Lake/CLI/Help.lean" "env <cmd> <args>")
# (find-lean4prefile "lake/Lake/CLI/Help.lean" "def helpEnv :=")




#####
#
# lake-CLI
# 2024jun09
#
#####

# «lake-CLI»  (to ".lake-CLI")
# (find-fplean4page 76 "@[default_target]")
# (find-fplean4text 76 "@[default_target]")
# (find-fplean4doc  "hello-world/starting-a-project")
# (find-fplean4docr "hello-world/starting-a-project" "@[default_target]")
# (find-fplean4docr "hello-world/starting-a-project" "@[default_target]" "To build a target that is not annotated with `@[default_target]`")

# (find-lean4prefile "lake/Lake/CLI/Main.lean" "def lakeLongOption :")
# (find-lean4prefile "lake/Lake/CLI/Main.lean" "def lakeCli :")







#####
#
# Making lake import files in the current directory
# 2024jun07
#
#####

# «lake-current-directory»  (to ".lake-current-directory")
# (to "import")
# (to "Colorized")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/Minimal.20setup.20for.20importing.20.2Elean.20files.20in.20the.20same.20director

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
rm -Rfv /tmp/test/
mkdir   /tmp/test/
cd      /tmp/test/

cat > A.lean <<'%%%'
def a := 42
#eval a
%%%

cat > B.lean <<'%%%'
import A
#eval a
%%%

cat > lakefile.lean <<'%%%'
import Lake
open   Lake DSL
package  A
lean_lib A
%%%

lean A.lean     ;# 42
lean B.lean     ;# error
lake build
find * .lake/ | sort
lean B.lean     ;# error

# (find-fline "/tmp/test/")
# (find-fline "/tmp/test/A.lean")
# (find-fline "/tmp/test/B.lean")
# (find-fline "/tmp/test/lakefile.lean")
# (find-fline "~/LuaTreeLean/")
# (find-fline "~/LuaTreeLean/lakefile.lean")

cd ~/LuaTreeLean/
lean Test1.lean





#####
#
# cache-mathlib
# 2023jun26
#
#####

# «cache-mathlib»  (to ".cache-mathlib")
# (find-fline "~/.cache/mathlib/")

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
du -c ~/.cache/mathlib/
find  ~/.cache/mathlib/
laf   ~/.cache/mathlib/




#####
#
# lean4-mode
# 2023jun22
#
#####

# «lean4-mode»  (to ".lean4-mode")
# https://github.com/leanprover/lean4-mode
# (find-es "emacs" "package-vc-install")
# (find-es "emacs" "lsp-mode")
# (package-vc-install "https://github.com/leanprover/lean4-mode")

# (find-epackage-links 'lean4-mode "lean4mode" t)
# (find-epackages      'lean4-mode)
# (find-epackage       'lean4-mode)
# (code-c-d "lean4mode" "~/.emacs.d/elpa/lean4-mode/")
# (find-lean4modefile "")
# (find-lean4modefile "README.md" "hovering")
# (find-lean4modefile "README.md" "C-c C-i" "toggle info view")
# (find-lean4modefile "lean4-input.el" "(defcustom lean4-input-inherit")






#####
#
# lean-mode
# 2021jul05
#
#####

# «lean-mode»  (to ".lean-mode")
# (find-epackages 'lean-mode)
# (find-epackage-links 'lean-mode)
# (find-epackage       'lean-mode)
# (code-c-d "leanmode" "~/.emacs.d/elpa/lean-mode-20210502.2049/")
# (find-leanmodefile "")
# (find-leanmodegrep "grep --color=auto -nH --null -e rootdir *.el")
# (find-efunction 'lean-get-rootdir)

https://leanprover.github.io/documentation/
https://leanprover.github.io/presentations/20150123_lean-mode/lean-mode.pdf
https://leanprover.github.io/tutorial/tutorial.pdf
https://leanprover.github.io/tutorial/quickref.pdf



#####
#
# mode-line
# 2024mar10
#
#####

# «mode-line»  (to ".mode-line")
# find-emodeline-links

("%e"
 mode-line-front-space

 (:propertize
  (""
   mode-line-mule-info
   mode-line-client
   mode-line-modified
   mode-line-remote
   mode-line-window-dedicated)
  display (min-width (6.0)))

 mode-line-frame-identification
 mode-line-buffer-identification
 "   "
 mode-line-position
 (project-mode-line project-mode-line-format)
 (vc-mode vc-mode)
 "  "
 mode-line-modes
 mode-line-misc-info
 mode-line-end-spaces)

# (find-evardescr 'mode-line-misc-info)
# (find-evariable 'mode-line-misc-info)

((which-function-mode (which-func-mode (which-func--use-mode-line ("" which-func-format " "))))
 (global-mode-string ("" global-mode-string)))








#####
#
# topos
# 2021jul05
#
#####

# «topos»  (to ".topos")
# https://github.com/b-mehta/topos
# (find-git-links "https://github.com/b-mehta/topos" "topos")
# (code-c-d "topos" "~/usrc/topos/")
# (find-toposfile "")
# (find-toposfile "README.md")
# (find-toposfile "src/")
# (find-toposfile "src/applications/")
# (find-toposfile "src/category/")



#####
#
# diagram-chasing
# 2021jul05
#
#####

# «diagram-chasing»  (to ".diagram-chasing")
# (find-books "__cats/__cats.el" "himmel")
# (find-himmeldiagchpage 19 "3.2. A formal proof of the four lemma")
# (find-himmeldiagchtext 19 "3.2. A formal proof of the four lemma")




#####
#
# prelude
# 2023jun29
#
#####

# «prelude»  (to ".prelude")
# (find-tpil4file "inductive_types.md" "prelude")
# (find-tpil4file "propositions_and_proofs.md" "Prelude.core")
# (find-lean4prefile "")
# (find-lean4prefile "")
# (find-lean4prefile "Init/")
# (find-lean4prefile "Init/Prelude.lean")
# (find-lean4prefile "Lean/")



#####
#
# rec_on
# 2023jul10
#
#####

# «rec_on»  (to ".rec_on")
# (find-tpinleanpage 89 "nat.rec_on")
# (find-tpinleantext 89 "nat.rec_on")
# (find-tpinleanpage 102 "weekday.rec_on (also generated automatically)")
# (find-tpinleantext 102 "weekday.rec_on (also generated automatically)")
# (find-tpinleanpage 103 "renaming option")
# (find-tpinleantext 103 "renaming option")

https://github.com/leanprover/theorem_proving_in_lean4/blob/master/inductive_types.md

inductive weekday : Type
| sunday : weekday
| monday : weekday
| tuesday : weekday
| wednesday : weekday
| thursday : weekday
| friday : weekday
| saturday : weekday

#check weekday.sunday
#check weekday.monday
#check weekday.rec
#check weekday.casesOn


weekday.casesOn.{u} {motive : weekday → Sort u}
  (t : weekday)
  (sunday : motive weekday.sunday)
  (monday : motive weekday.monday)
  (tuesday : motive weekday.tuesday)
  (wednesday : motive weekday.wednesday)
  (thursday : motive weekday.thursday)
  (friday : motive weekday.friday)
  (saturday : motive weekday.saturday) : motive t

weekday.rec.{u} {motive : weekday → Sort u}
  (sunday : motive weekday.sunday)
  (monday : motive weekday.monday)
  (tuesday : motive weekday.tuesday)
  (wednesday : motive weekday.wednesday)
  (thursday : motive weekday.thursday)
  (friday : motive weekday.friday)
  (saturday : motive weekday.saturday)
  (t : weekday) : motive t





@[reducible]

inductive mynat : Type
| zero : mynat
| succ : mynat → mynat

-- #check zero
#check mynat.zero

open mynat (renaming rec_on → rec_on)

def add (m n : mynat) : mynat :=
  mynat.rec_on n m (λ n add_m_n => succ add_m_n)

#check add
#check mynat
#check mynat.rec
#check mynat.rec_on

#check succ zero
#check add (succ zero) (succ (succ zero))

-- try it out
#reduce add (succ zero) (succ (succ zero))




#####
#
# alectryon
# 2024mar24
#
#####

# «alectryon»  (to ".alectryon")
# (to "mdbook")
# https://github.com/cpitclaudel/alectryon
# https://github.com/Kha/alectryon
# https://proofassistants.stackexchange.com/questions/62/is-there-software-for-interfacing-lean-code-with-latex
# https://leanprover-community.github.io/archive/stream/270676-lean4/topic/Literate.20programming.20in.20Lean4.20.2F.20Lean4.20.2B.20Org.20mode.html




#####
#
# nng4
# 2023jun27 / 2024jun03
#
#####

# «nng4»  (to ".nng4")
# https://github.com/leanprover-community/NNG4
# (find-git-links "https://github.com/leanprover-community/NNG4" "NNG4")
# (code-c-d "NNG4" "~/usrc/NNG4/")
# (find-NNG4sh "find * | sort")
# (find-NNG4file "")
# (find-NNG4file "README.md")
# (find-NNG4file "README.md" "https://adam.math.hhu.de")
# (find-NNG4file "Game.lean")
# (find-NNG4file "lakefile.lean")


# Old:
# https://github.com/PatrickMassot/NNG4




#####
#
# lean4game
# 2024jun03
#
#####

# «lean4game»  (to ".lean4game")
# https://github.com/leanprover-community/lean4game
# (find-git-links "https://github.com/leanprover-community/lean4game" "lean4game")
# (code-c-d "lean4game" "~/usrc/lean4game/")
# (find-lean4gamefile "")
# (find-lean4gamefile "README.md")
# (find-lean4gamefile "doc/")
# (find-lean4gamefile "server/")
# (find-lean4gamesh "find * | sort")





#####
#
# natural-number-game
# 2021oct06
#
#####

# «natural-number-game»  (to ".natural-number-game")
# https://www.ma.imperial.ac.uk/~buzzard/xena/natural_number_game/
# https://www.ma.imperial.ac.uk/~buzzard/xena/natural_number_game/FAQ.html
# https://www.ma.imperial.ac.uk/~buzzard/xena/natural_number_game/FAQ.html#sourcecode
# https://github.com/ImperialCollegeLondon/natural_number_game
# https://github.com/mpedramfar/Lean-game-maker

# (find-git-links "https://github.com/ImperialCollegeLondon/natural_number_game" "nng")
# (find-git-links "https://github.com/mpedramfar/Lean-game-maker" "lgm")
# (code-c-d "nng" "~/usrc/natural_number_game/")
# (code-c-d "lgm" "~/usrc/Lean-game-maker/")

# (find-nngfile "")
# (find-nngfile "docs/technical.md")
# (find-nngfile "docs/technical.md" "tactic monad")
# (find-nngfile "src/tactic/")
# (find-nngfile "src/tactic/modded.lean")
# (find-nngfile "src/game/")
# (find-nngfile "src/game/world2/")
# (find-nngfile "src/game/world2/level1.lean")

# (find-lgmfile "")

https://www.ma.imperial.ac.uk/~buzzard/xena/
https://www.youtube.com/watch?v=9V1Xo1n_3Qw LftCM2020: Natural number game - Kevin Buzzard
https://xenaproject.wordpress.com/2019/10/24/chalkdust-and-the-natural-number-game/
https://xenaproject.wordpress.com/2019/11/12/the-natural-number-game-an-update/




#####
#
# real-number-game
# 2021oct17
#
#####

# «real-number-game»  (to ".real-number-game")
# https://github.com/ImperialCollegeLondon/real-number-game
# (find-git-links "https://github.com/ImperialCollegeLondon/real-number-game" "rng")
# (code-c-d "rng" "~/usrc/real-number-game/")
# (find-rngfile "")



#####
#
# set-theory-game
# 2024may17
#
#####

# «set-theory-game»  (to ".set-theory-game")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/Set.20theory.20game
# https://adam.math.hhu.de/
# https://adam.math.hhu.de/#/g/djvelleman/stg4




#####
#
# mathsinlean
# 2023jun24
#
#####

# «mathsinlean»  (to ".mathsinlean")
# «:leanmaths»                     (to ".:leanmaths")
# (find-angg ".emacs.lean.el" "ee-rstdoc-:leanmaths")
# (find-angg ".emacs.papers" "mathsinlean")
# https://leanprover-community.github.io/mathematics_in_lean/
# https://github.com/leanprover-community/mathematics_in_lean
# (find-wgetrecursive-links "https://leanprover-community.github.io/mathematics_in_lean/")
# https://github.com/avigad/mathematics_in_lean_source

# (find-git-links "https://github.com/leanprover-community/mathematics_in_lean" "mathsinlean")
# (code-c-d "mathsinlean" "~/bigsrc/mathematics_in_lean/")
# (find-mathsinleanfile "")
# (find-mathsinleanfile "lake-packages/")
# (find-mathsinleanfile "MIL/")
# (find-mathsinleanfile "MIL/C01_Introduction/")
# (find-mathsinleanfile "MIL/C01_Introduction/S02_Overview.lean")
# (find-mathsinleanpage)
# (find-mathsinleantext)
# (find-mathsinleanpage 5 "lake exe cache get")
# (find-mathsinleantext 5 "lake exe cache get")
# (find-mathsinleangrep "grep --color=auto -nRH --null -e constant *")

# (find-lean4mlifile "Mathlib/Util/AssertExists.lean" "elab \"assert_not_exists \"")

# file:///home/edrx/bigsrc/mathematics_in_lean/html/C01_Introduction.html





#####
#
# mathsinlean-build
# 2024may25
#
#####

# «mathsinlean-build»  (to ".mathsinlean-build")
# https://github.com/avigad/mathematics_in_lean_source
# (find-git-links "https://github.com/avigad/mathematics_in_lean_source" "mathsinleansrc")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/~.2F.2Eagda.2Fdefaults.20and.20~.2F.2Eagda.2Flibraries.2C.20but.20in.20Lean.3F
# (code-c-d "mathsinleansrc" "~/bigsrc/mathematics_in_lean_source/")
# (find-mathsinleansrcfile "")
# (find-mathsinleansrcfile "README.md")
# (find-mathsinleansrcfile "README.md" "lake exe cache get")
# (find-mathsinleansrcfile "lakefile.lean")
# (find-mathsinleansrcfile "lakefile.lean" "require mathlib from git")
# (find-mathsinleansrcsh "find * | sort")

* (eepitch-shell3)
* (eepitch-kill)
* (eepitch-shell3)
# (find-sh "du -ch ~/bigsrc/mathematics_in_lean/")

du -ch  ~/bigsrc/mathematics_in_lean_source/
rm -Rfv ~/bigsrc/mathematics_in_lean_source/
cd      ~/bigsrc/
git clone https://github.com/avigad/mathematics_in_lean_source
cd      ~/bigsrc/mathematics_in_lean_source/

find * | sort | tee .files0
lake exe cache get           |& tee olecg
find * | sort | tee .files1


Another basic question... now I have a full copy of mathlib4 in
~/bigsrc/mathlib4/, and I tried to run this:

rm -Rfv ~/bigsrc/mathematics_in_lean/
cd      ~/bigsrc/
git clone https://github.com/leanprover-community/mathematics_in_lean
cd      ~/bigsrc/mathematics_in_lean/
lake exe cache get

Apparently 1) this downloaded another full copy of mathlib4 in
~/bigsrc/mathematics_in_lean/lake-packages/mathlib/, and 2) if I
create a project and I put a like like this

require mathlib from git
"https://github.com/leanprover-community/mathlib4"@"master"

in its lakefile.lean it will also download another full copy of
mathlib4... is there a way to make these copies be shared?






# Error:

LSP :: Yasnippet is not installed, but `lsp-enable-snippet' is set to `t'. You must either install yasnippet, or disable snippet support.
LSP :: Connected to [lean4-lsp:187121/starting /home/edrx/bigsrc/mathematics_in_lean]. [2 times]
LSP :: Unable to autoconfigure company-mode. [2 times]
LSP :: lean4-lsp:187121 initialized successfully in folders: (/home/edrx/bigsrc/mathematics_in_lean)
LSP :: You can configure this warning with the `lsp-enable-file-watchers' and `lsp-file-watch-threshold' variables
LSP :: Unable to autoconfigure company-mode. [2 times]
info: [256/540] Building Aesop.Tree.UnsafeQueue
info: [315/794] Building Aesop.Search.Queue
info: [353/794] Building Mathlib.Data.ListM.Basic
info: [538/794] Building Mathlib.Algebra.Order.Group.Defs
error: external command `/home/edrx/.elan/toolchains/leanprover--lean4---nightly-2023-06-20/bin/lean` exited with code 139
`/home/edrx/.elan/toolchains/leanprover--lean4---nightly-2023-06-20/bin/lake print-paths Init Mathlib.Data.Nat.Basic Mathlib.Data.Nat.Parity Mathlib.Tactic` failed:

stderr:
info: [155/374] Building Qq.MetaM
info: [218/540] Building Std.Data.String.Lemmas
info: [256/540] Building Aesop.Tree.UnsafeQueue
info: [315/794] Building Aesop.Search.Queue
info: [353/794] Building Mathlib.Data.ListM.Basic
info: [538/794] Building Mathlib.Algebra.Order.Group.Defs
error: > LEAN_PATH=./lake-packages/proofwidgets/build/lib:./lake-packages/mathlib/build/lib:./build/lib:./lake-packages/Qq/build/lib:./lake-packages/aesop/build/lib:./lake-packages/std/build/lib LD_LIBRARY_PATH=./lake-packages/proofwidgets/build/lib:./lake-packages/mathlib/build/lib:./build/lib:./lake-packages/Qq/build/lib:./lake-packages/aesop/build/lib:./lake-packages/std/build/lib:./lake-packages/mathlib/build/lib /home/edrx/.elan/toolchains/leanprover--lean4---nightly-2023-06-20/bin/lean -DwarningAsError=true -Dpp.unicode.fun=true ./lake-packages/mathlib/././Mathlib/Algebra/Order/Group/Defs.lean -R ./lake-packages/mathlib/./. -o ./lake-packages/mathlib/build/lib/Mathlib/Algebra/Order/Group/Defs.olean -i ./lake-packages/mathlib/build/lib/Mathlib/Algebra/Order/Group/Defs.ilean -c ./lake-packages/mathlib/build/ir/Mathlib/Algebra/Order/Group/Defs.c
error: external command `/home/edrx/.elan/toolchains/leanprover--lean4---nightly-2023-06-20/bin/lean` exited with code 139
Mark set




#####
#
# mathsinlean-source
# 2024apr28
#
#####

# «mathsinlean-source»  (to ".mathsinlean-source")
# https://github.com/avigad/mathematics_in_lean_source
# https://leanprover-community.github.io/mathematics_in_lean/
# (find-git-links "https://github.com/avigad/mathematics_in_lean_source" "mathsinleansrc")
# (code-c-d "mathsinleansrc" "~/usrc/mathematics_in_lean_source/")
# (find-mathsinleansrcfile "")
# (find-mathsinleansrcfile "Makefile")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/Recommended.20ways.20to.20convert.20Lean4.20code.20to.20LaTeX.3F/near/435827430
# (find-es "pygments" "mypygments.sh")




#####
#
# mathzoo
# 2023jun24
#
#####

# «mathzoo»  (to ".mathzoo")
# https://github.com/leanprover-community/mathzoo
# (code-c-d "mathzoo" "~/usrc/mathzoo/")
# (find-mathzoofile "")
# (find-mathzoosh "find * | sort")



#####
#
# mathlib
# 2023jun24
#
#####

# «mathlib»  (to ".mathlib")
# https://github.com/leanprover-community/mathlib
# (find-git-links "https://github.com/leanprover-community/mathlib" "mathlib")

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
rm -Rfv ~/bigsrc/mathlib/
cd      ~/bigsrc/
git clone https://github.com/leanprover-community/mathlib
cd      ~/bigsrc/mathlib/

# (code-c-d "mathlib" "~/bigsrc/mathlib/")
# (find-mathlibfile "")
# (find-mathlibfile "README.md")

# https://leanprover-community.github.io/install/linux.html




#####
#
# mathlib4
# 2023jun24
#
#####

# «mathlib4»  (to ".mathlib4")
# https://github.com/leanprover-community/mathlib4
# (find-git-links "https://github.com/leanprover-community/mathlib4" "mathlib4")

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
rm -Rfv ~/bigsrc/mathlib4/
cd      ~/bigsrc/
git clone https://github.com/leanprover-community/mathlib4
cd      ~/bigsrc/mathlib4/

cd      ~/bigsrc/mathlib4/
lake exe cache get

cd      ~/bigsrc/mathlib4/
git clean -dfx
git pull

elan self update
lake build   |& tee olb

# (code-c-d "mathlib4" "~/bigsrc/mathlib4/")
# (find-mathlib4file "")
# (find-mathlib4sh "find * | sort")
# (find-mathlib4file "README.md")
# (find-mathlib4file "README.md" "lean_exe")
# (find-mathlib4file "README.md" "elan self update")
# (find-mathlib4file "README.md" "lake build")
# (find-mathlib4file "" "lake")
# (find-mathlib4file "lake-manifest.json")
# (find-mathlib4file "lakefile.lean")
# (find-mathlib4file "olb")

# (find-mathlib4file "lakefile.lean" "package mathlib where")

# (find-mathlib4file "Mathlib/Data/Set/")
# (find-mathlib4file "Mathlib/Data/Set/Basic.lean")




#####
#
# mathlib4-greeting
# 2023jun26
#
#####

# «mathlib4-greeting»  (to ".mathlib4-greeting")
# (to "lake-new-greeting")
# (find-mathlib4file "README.md" "require mathlib from git")

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
rm -Rfv /tmp/gr/
mkdir   /tmp/gr/
cd      /tmp/gr/
lake new greeting
cd      /tmp/gr/greeting/

lake build
lake update
lake build

# (find-fline "/tmp/gr/greeting/")




#####
#
# mathlib-calculus
# 2022jul03
#
#####

# «mathlib-calculus»  (to ".mathlib-calculus")
# https://github.com/leanprover-community/mathlib
# https://leanprover-community.github.io/mathlib_docs/
# https://leanprover-community.github.io/mathlib_docs/analysis/calculus/deriv.html
# https://leanprover-community.github.io/get_started.html

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
# rm -Rfv ~/usrc/mathlib/
cd      ~/usrc/
git clone https://github.com/leanprover-community/mathlib
git clone git@github.com:leanprover-community/mathematics_in_lean.git
cd      ~/usrc/mathlib/
cd      ~/usrc/mathlib/


In a terminal, navigate to the folder where you want to put a copy of
the repository, and type git clone

git@github.com:leanprover-community/mathematics_in_lean.git

to fetch
it from github.

Navigate to mathematics_in_lean, and execute lake exe cache get to
fetch a compiled version of the library, mathlib.

Type code . to open the folder in VS Code. Alternatively, you can run
VS Code and choose Open Folder from the File menu. Be sure to open the
folder mathematics_in_lean, not any other folder.



;; <leanmathlib>
;; "The Lean Mathematical Library"
;; https://arxiv.org/abs/1910.09336
;; https://arxiv.org/pdf/1910.09336.pdf
(code-pdf-page "leanmathlib" "$S/https/arxiv.org/pdf/1910.09336.pdf")
(code-pdf-text "leanmathlib" "$S/https/arxiv.org/pdf/1910.09336.pdf")
;; (find-leanmathlibpage)
;; (find-leanmathlibtext)


# (find-anggsh "find . -mtime 0 | sort")
# (find-fline "~/.config/Code/")
# (find-fline "~/.local/pipx/logs/")
# (find-fline "~/.elan/")
# (find-fline "~/.local/pipx/")
# (find-fline "~/.mathlib/")
# (find-fline "~/.mathlib/url")
# (find-fline "~/.vscode/")



#####
#
# Server lean4-lsp:nnnn exited (...) Do you want to restart it?
# 2024may21
#
#####

# «lsp-server-exited-restart»  (to ".lsp-server-exited-restart")
# (find-elpafile "lsp-mode/lsp-mode.el" "Server %s exited")
# (find-lean4modefile "")

# Server lean4-lsp:nnnn exited (check corresponding stderr
# buffer for details). Do you want to restart it? (y or n)

LSP :: Connected to [lean4-lsp:250842/starting /tmp].
LSP :: Connected to [lean4-lsp:250961/starting /home/edrx/.elan/toolchains/leanprover--lean4---stable/src/lean].
LSP :: lean4-lsp:250842 initialized successfully in folders: (/tmp)
LSP :: lean4-lsp:250961 initialized successfully in folders: (/home/edrx/.elan/toolchains/leanprover--lean4---stable/src/lean)



#####
#
# lsp-yasnippet
# 2024may21
#
#####

# «lsp-yasnippet»  (to ".lsp-yasnippet")
LSP :: Yasnippet is not installed, but `lsp-enable-snippet' is set to `t'. You must either install yasnippet, or disable snippet support.
LSP :: Yasnippet is not installed, but `lsp-enable-snippet' is set to `t'. You must either install yasnippet, or disable snippet support.



#####
#
# tactics-list
# 2024may17
#
#####

# «tactics-list»  (to ".tactics-list")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/Lean.204.20tactics.20list




#####
#
# tactics-in-ND
# 2021oct14
#
#####

# «tactics-in-ND»  (to ".tactics-in-ND")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/Natural.20Deduction/near/257611457
# https://leanprover-community.github.io/mathlib_docs/tactic/explode.html#tactic.explode



#####
#
# vernacular
# 2021dec16
#
#####

# «vernacular»  (to ".vernacular")
# https://mathoverflow.net/questions/376839/what-makes-dependent-type-theory-more-suitable-than-set-theory-for-proof-assista
# https://www.youtube.com/watch?v=Dp-mQ3HxgDE#t=1h0m0s



#####
#
# fplean4
# 2023jun02
#
#####

# «fplean4»  (to ".fplean4")
# (find-angg ".emacs.lean.el" "ee-rstdoc-:fplean4")
# (find-angg ".emacs.papers" "fplean4")
# https://news.ycombinator.com/item?id=36107796 Functional Programming in Lean – a book on using Lean 4 to write programs (leanprover.github.io)
# https://leanprover.github.io/functional_programming_in_lean/
# https://leanprover.github.io/functional_programming_in_lean/print.html
# (find-fplean4page)
# (find-fplean4text)

https://lean-lang.org/functional_programming_in_lean/

https://leanprover.zulipchat.com/#narrow/stream/113488-general/topic/FPIL.20and.20TPIL.20with.20internal.20tables.20of.20contents.3F


# (find-wgetrecursive-links "https://lean-lang.org/functional_programming_in_lean/")
# (to "lean4-git")
# (find-code-rstdoc :lean4)




#####
#
# Local copies of the main 5 manuals, in a single .tgz
# 2024jul07
#
#####

# «5-manuals-tgz»  (to ".5-manuals-tgz")
# (find-angg ".emacs.templates" "find-leanwgetr-links")
# (find-code-leandocpdf 'ee-leandoc-:fplean4)
# (find-code-leandocpdf 'ee-leandoc-:lean4)
# (find-code-leandocpdf 'ee-leandoc-:leanmeta)
# (find-code-leandocpdf 'ee-leandoc-:tclean4)
# (find-code-leandocpdf 'ee-leandoc-:tpil4)
# (find-leandocprep-links 'ee-leandoc-:fplean4)
# (find-leandocprep-links 'ee-leandoc-:lean4)
# (find-leandocprep-links 'ee-leandoc-:leanmeta)
# (find-leandocprep-links 'ee-leandoc-:tclean4)
# (find-leandocprep-links 'ee-leandoc-:tpil4)
# (find-efunction 'find-wgetrecursive-links)

* (setenv "TMPS" "/tmp/snarf")

# (find-leanwgetr-links "lean-lang.org/functional_programming_in_lean/")
# (find-leanwgetr-links "lean-lang.org/lean4/doc/")
# (find-leanwgetr-links "leanprover-community.github.io/lean4-metaprogramming-book/")
# (find-leanwgetr-links "ammkrn.github.io/type_checking_in_lean4/")
# (find-leanwgetr-links "lean-lang.org/theorem_proving_in_lean4/")

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
cd /tmp/snarf/ && tar -cvzf /tmp/2024-lean4-oficina-manuais.tgz https/
laf /tmp/2024-lean4-oficina-manuais.tgz

cd /tmp/
rm -v /tmp/2024-lean4-oficina-manuais.tgz
wget -N http://anggtwu.net/tmp/2024-lean4-oficina-manuais.tgz

# (find-fline "/tmp/2024-lean4-oficina-manuais.tgz")

echo $S

 (eepitch-shell)
 (eepitch-kill)
 (eepitch-shell)
cd /tmp/
wget -N http://anggtwu.net/tmp/2024-lean4-oficina-manuais.tgz
# (find-fline   "/tmp/2024-lean4-oficina-manuais.tgz")
tar -C $S/ -xvzf /tmp/2024-lean4-oficina-manuais.tgz

# (find-cp-angg-links "2024-lean4-oficina-manuais.tgz" "/tmp/" "tmp/")







#####
#
# 3 essential commands and their syntax sugars
# 2024jun07
#
#####

# «3-essential»  (to ".3-essential")
# (to "elab_rules")
# (find-leanmetadoc  "main/02_overview#3-essential-commands-and-their-syntax-sugars")
# (find-leanmetadocr "main/02_overview.lean" "## 3 essential commands and their syntax sugars")
# (find-leanmetapage  9 "3 essential commands and their syntax sugars")
# (find-leanmetatext  9 "3 essential commands and their syntax sugars")
# (find-leanmetapage 11 "This image is not supposed")
# (find-leanmetatext 11 "This image is not supposed")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open Lean Elab Command

syntax (name := default_h) "#help" str : command
@[command_elab  default_h]
def helpElab : CommandElab := fun stx =>
  match stx with
  | `(#help "#explode") => logInfo "Message 1"
  | _ => Elab.throwUnsupportedSyntax

elab_rules : command
  | `(#help "#explode") => logInfo "Message 2"

elab "#help " x:str : command =>
  match x with
  | `("#explode")       => logInfo "Message 3"
  | _ => Elab.throwUnsupportedSyntax

#help "#explode"


syntax (name := shortcut_h) "#h" str : command

@[macro shortcut_h]
def helpMacro : Macro := fun stx =>
  match stx with
  | `(#h $x:str) => `(#help $x)
  | _ => Macro.throwUnsupported

macro_rules
  | `(#h $x:str) => `(#help $x)

macro "#h" x:str : command =>
  `(#help $x)

#h "#explode"

-- end



#####
#
# 3-essential-way-1
# 2024jun11
#
#####

# «3-essential-way-1»  (to ".3-essential-way-1")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open Lean Elab Command

syntax (name := default_h) "#help" str : command
@[command_elab  default_h]
def helpElab : CommandElab := fun stx =>
  match stx with
  | `(#help "#explode") => logInfo "Message 1"
  | _ => Elab.throwUnsupportedSyntax

syntax (name := shortcut_h) "#h" str : command
@[macro         shortcut_h]
def helpMacro : Macro := fun stx =>
  match stx with
  | `(#h $x:str) => `(#help $x)
  | _ => Macro.throwUnsupported

#help "#explode"
#h    "#explode"

-- end




#####
#
# 3-essential-way-2
# 2024jun11
#
#####

# «3-essential-way-2»  (to ".3-essential-way-2")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open Lean Elab Command

syntax "#help" str : command
elab_rules : command
  | `(#help "#explode") => logInfo "Message 2"

syntax "#h" str : command
macro_rules
  | `(#h $x:str) => `(#help $x)

#help "#explode"
#h    "#explode"

-- end




#####
#
# 3-essential-way-3
# 2024jun11
#
#####

# «3-essential-way-3»  (to ".3-essential-way-3")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open Lean Elab Command

elab "#help " x:str : command =>
  match x with
  | `("#explode")       => logInfo "Message 3"
  | _ => Elab.throwUnsupportedSyntax

macro "#h" x:str : command =>
  `(#help $x)

#help "#explode"
#h    "#explode"

elab "#minihelp " x:str : command => logInfo x
#minihelp "bla"

-- end






#####
#
# abbrev
# 2024may17
#
#####

# «abbrev»  (to ".abbrev")
# (find-lean4prefile "Init/Prelude.lean" "abbrev MacroM :=")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'abbrev' *")
# (find-fplean4page 17 "using abbrev instead of def")
# (find-fplean4text 17 "using abbrev instead of def")
# (find-fplean4page 17 "abbrev N : Type := Nat")
# (find-fplean4text 17 "abbrev N : Type := Nat")
# (find-fplean4doc "getting-to-know/functions-and-definitions#messages-you-may-meet")
# (find-lean4prefile "Lean/Parser/Command.lean" "def «abbrev\ »         := leading_parser")

# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

abbrev N  := Nat
abbrev Ns := List Nat

#check (2 : N)
#check (2 : N) + (3 : Int)
#eval  (2 : N) + (3 : Int)
#check [1,2]
#check ([1,2] : List Nat)
#check ([1,2] : Ns)         -- ?

  #check                Nat
  def    Nat2 : Type := Nat
  def    Nat3        := Nat
  abbrev Nat4        := Nat
  #check Nat2
  #check Nat3
  #check Nat4
  #print Nat2
  #print Nat3
  #print Nat4

  #check  (42 : Nat)
  #check ((42 : Nat) : Nat2)
  #check  (42        : Nat2) -- err

-- end



#####
#
# addDecl
# 2024jun23
#
#####

# «addDecl»  (to ".addDecl")
# (to "example")
# https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/name.20for.20syntax.20category.20of.20.60notation.60.2C.20.60namespace.60.2C.20.60def.60.2E.2E
# (find-lean-links "addDecl")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'addDecl' *")

Internally, def, inductive, etc elaborate the syntax tree, and then
use the “addDecl” function to add the actual declaration to the
Environment.

And example doesn't create a declaration at all!
Nonetheless, it is part of the declaration syntax.
(It actually does create a declaration. It just then discards it via withoutModifyingEnv).




#####
#
# animate-lean-proofs
# 2024jun28
#
#####

# «animate-lean-proofs»  (to ".animate-lean-proofs")
# https://github.com/dwrensha/animate-lean-proofs
# https://leanprover.zulipchat.com/#narrow/stream/113488-general/topic/animating.20Lean.20proofs.20in.20Blender.3A.20a.20video.20and.20github.20repo/near/447306235
# (find-git-links "https://github.com/dwrensha/animate-lean-proofs" "alp")
# (code-c-d "alp" "~/usrc/animate-lean-proofs/")
# (find-alpfile "")
# (find-alpfile "Chess.lean")
# (find-alpfile "README.md" "ke exe Animate Input/NNG.lean")
# (find-SUBS     "mathologer-calculus-easy.lua")
# (find-SUBSfile "mathologer-calculus-easy.lua" "17:12")

# (find-telegachat "617713850#234083" "Bruno Macedo")

  (eepitch-vterm)
cd ~/clones/
git clone https://github.com/dwrensha/animate-lean-proofs
cd animate-lean-proofs
(code-c-d "alp" "~/clones/animate-lean-proofs")
;; (find-alpfile "animate_proof.py")
;; (find-alpfile "animate_proof.py" 0 '(swiper "json"))
;; (find-alpgrep "grep -ne json animate_proof.py")
;; (find-alpfile "animate_proof.py" "parser.add_argument(\"file\"")







#####
#
# anonymous
# 2024mar23
#
#####

# «anonymous»  (to ".anonymous")
# (to "partial-mutual")
# (find-tpil4page 29 "anonymous constructor")
# (find-tpil4text 29 "anonymous constructor")
# (find-tpil4page 33 "anonymous constructor")
# (find-tpil4text 33 "anonymous constructor")
# (find-fplean4page 202 "anonymous angle-bracket notation")
# (find-fplean4text 202 "anonymous angle-bracket notation")
# (find-tpil4doc  "propositions_and_proofs#conjunction")
# (find-tpil4docr "propositions_and_proofs" "### Conjunction")
# (find-tpil4docr "propositions_and_proofs" "anonymous constructor")
# (find-fplean4doc "functor-applicative-monad/inheritance")
# (find-fplean4doc "functor-applicative-monad/inheritance" "anonymous angle-bracket")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

structure  A where s : String deriving Repr
def   a1 : A := ⟨"foo"⟩
#eval a1
#eval a1.s

-- end




#####
#
# antiquotation
# 2024jun12
#
#####

# «antiquotation»  (to ".antiquotation")
# (to "match")
# (to "fun")
# (find-lean4prefile "Init/Prelude.lean" "an antiquotation `$id:ident`")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'antiquotation' *")
# (find-leanmetadoc  "main/06_macros#syntax-quotations")
# (find-leanmetadoc  "main/06_macros#the-basics")
# (find-leanmetadocr "main/06_macros" "### The basics")
# (find-leanmetapage 63 "Syntax Quotations")
# (find-leanmetatext 63 "Syntax Quotations")
# (find-leanmetapage 64 "If we use the antiquotation syntax")
# (find-leanmetatext 64 "If we use the antiquotation syntax")





#####
#
# Array
# 2024may31
#
#####

# «Array»  (to ".Array")
# (find-lean4doc "array")
# (find-lean4prefile "Init/Prelude.lean" "structure Array (α : Type u) where")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

def a := [0, 1, 2]
def b := List.toArray a
def c := Array.toList b
#check b
#check c
#eval b
#eval c

-- end




#####
#
# assign
# 2024may28
#
#####

# «assign»  (to ".assign")
# (to "do-notation")
# (find-lean-links "assign")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'assign' *")
# (find-lean4prefile "Lean/Elab/Do.lean" "x := x + 1")
# (find-leanmetadoc  "main/04_metam#basic-operations")
# (find-leanmetadocr "main/04_metam" "### Basic Operations")
# (find-leanmetadocr "main/04_metam" "Metavariables are initially unassigned. To assign them, use")
# (find-fplean4doc "monad-transformers/do#mutable-variables")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open Lean Lean.Expr Lean.Meta

#eval show MetaM Unit from do
  -- Create two fresh metavariables of type `Nat`.
  let mvar1 ← mkFreshExprMVar (Expr.const ``Nat []) (userName := `mvar1)
  let mvar2 ← mkFreshExprMVar (Expr.const ``Nat []) (userName := `mvar2)
  -- Create a fresh metavariable of type `Nat → Nat`. The `mkArrow` function
  -- creates a function type.
  let mvar3 ← mkFreshExprMVar (← mkArrow (.const ``Nat []) (.const ``Nat []))
    (userName := `mvar3)

  -- Define a helper function that prints each metavariable.
  let printMVars : MetaM Unit := do
    IO.println s!"  meta1: {← instantiateMVars mvar1}"
    IO.println s!"  meta2: {← instantiateMVars mvar2}"
    IO.println s!"  meta3: {← instantiateMVars mvar3}"

  IO.println "Initially, all metavariables are unassigned:"
  printMVars

  -- Assign `mvar1 : Nat := ?mvar3 ?mvar2`.
  mvar1.mvarId!.assign (.app mvar3 mvar2)
  IO.println "After assigning mvar1:"
  printMVars

  -- Assign `mvar2 : Nat := 0`.
  mvar2.mvarId!.assign (.const ``Nat.zero [])
  IO.println "After assigning mvar2:"
  printMVars

  -- Assign `mvar3 : Nat → Nat := Nat.succ`.
  mvar3.mvarId!.assign (.const ``Nat.succ [])
  IO.println "After assigning mvar3:"
  printMVars
-- Initially, all metavariables are unassigned:
--   meta1: ?_uniq.1
--   meta2: ?_uniq.2
--   meta3: ?_uniq.3
-- After assigning mvar1:
--   meta1: ?_uniq.3 ?_uniq.2
--   meta2: ?_uniq.2
--   meta3: ?_uniq.3
-- After assigning mvar2:
--   meta1: ?_uniq.3 Nat.zero
--   meta2: Nat.zero
--   meta3: ?_uniq.3
-- After assigning mvar3:
--   meta1: Nat.succ Nat.zero
--   meta2: Nat.zero
--   meta3: Nat.succ

-- end





#####
#
# @[...]
# 2024may18
#
#####

# «attributes»  (to ".attributes")
# (find-lean-links "attribute")
# (find-leanmetadocrgrep "grep --color=auto -niRH --null -e 'attribute' *")
# (find-tpil4grep    "grep --color=auto -niRH --null -e 'attribute' *.md")
# (find-tpil4file "interacting_with_lean.md" "Attributes")
# (find-tpil4page  85 "6.4. Attributes")
# (find-tpil4text  85      "Attributes")
# (find-tpil4doc  "interacting_with_lean#attributes")
# (find-tpil4docr "interacting_with_lean" "Attributes")
# (find-lean4pregrep "grep --color=auto -niRH --null -e '\"@\\[\"' *")
# (find-lean4pregrep "grep --color=auto -niRH --null -e 'attributes' *")
# (find-lean4pregrep "grep --color=auto -niRH --null -e 'attributes' * | grep -a optional")
# (find-lean4pregrep "grep --color=auto -niRH --null -e 'elabDeclAttrs' *")
# (find-lean4pregrep "grep --color=auto -niRH --null -e 'mkDefViewOfDef' *")
# (find-lean4prefile "Init/Notation.lean" "`attr` is a builtin syntax category for attributes.")
# (find-lean4prefile "Init/Notation.lean" "def attr : Category := {}")
# (find-lean4prefile "Lean/Elab/Attributes.lean" "Format.bracket \"@[\"")
# (find-lean4prefile "Lean/Elab/Attributes.lean" "leading_parser \"@[\" >> sepBy1 attrInstance")
# (find-lean4prefile "Lean/Elab/Attributes.lean" "-- leading_parser \"@[\"")
# (find-lean4prefile "Lean/Elab/DeclModifiers.lean")
# (find-lean4prefile "Lean/Parser/Term.lean" "def attributes")
# (find-lean4prefile "Lean/Parser/Syntax.lean" "@[builtin_command_parser] def «macro\ »")
# (find-lean4prefile "Lean/Parser/Syntax.lean" "@[builtin_command_parser] def «elab_rules\ »")
# (find-lean4prefile "Lean/Parser/Syntax.lean" "@[builtin_command_parser] def «elab\ »")
# (find-lean4prefile "Lean/Parser/Command.lean" "def declModifiers (inline : Bool) := leading_parser")
# (find-lean4prefile "Lean/Elab/DefView.lean" "leading_parser \"def \" >> declId >> optDeclSig")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/Using.20custom.20.60Repr.60.20of.20inductive.20type/near/447554048 mini database



#####
#
# axiom
# 2023jun24
#
#####

# «axiom»  (to ".axiom")
# (to "postulate")
# (find-lean-links "axiom")
# (find-tpil4doc  "propositions_and_proofs")
# (find-tpil4doc  "propositions_and_proofs#propositions-as-types")
# (find-tpil4docr "propositions_and_proofs" "Propositions as Types")
# (find-tpil4docr "propositions_and_proofs" "An \"axiom\" would be")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'axiom' *")
# (find-lean4file "doc/declarations.md" "axiom c : α")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\"axiom \"' *")
# (find-lean4doc  "declarations")
# (find-lean4docr "declarations.md")
# (find-lean4doc "")
# (find-es "agda" "postulates")

# (find-tpil4page 26 "the axiom declaration")
# (find-tpil4text 26 "the axiom declaration")



#####
#
# backtick
# 2024mar29
#
#####

# «backtick»  (to ".backtick")
# «double-backtick»  (to ".double-backtick")
# (to "exploring-data")
# (find-leanmetatext  1 "Constructing Expressions")
# (find-leanmetapage 18 "Constructing Expressions")
# (find-leanmetatext 18 "Constructing Expressions")
# (find-leanmetapage 54 "Constructing new Syntax")
# (find-leanmetatext 54 "Constructing new Syntax")
# (find-leanmetapage 55 "Matching on Syntax")
# (find-leanmetatext 55 "Matching on Syntax")
# (find-leanmetapage 69 "%$tk")
# (find-leanmetatext 69 "%$tk")

# (find-leanmetadoc  "main/03_expressions#constructing-expressions")
# (find-leanmetadocr "main/03_expressions" "## Constructing Expressions")
# (find-leanmetadoc  "main/05_syntax#constructing-new-syntax")
# (find-leanmetadocr "main/05_syntax" "### Constructing new `Syntax`")
# (find-leanmetadocr "main/05_syntax.lean" "is the syntax of `Nat.add 1 1`")
# (find-leanmetadoc  "main/05_syntax#matching-on-syntax")
# (find-leanmetadocr "main/05_syntax" "### Matching on `Syntax`")
# (find-leanmetadocr "main/05_syntax" "`(Nat.add $x $y)")
# (find-lean-links "backtick")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\"`(\"' *")
# (find-angg "LEAN/syntax.lean" "mini-project")
# (find-lean4prefile "Init/Prelude.lean" "`Lean.Meta.whnf")
# (find-lean4prefile "Lean/Elab/Syntax.lean" "private def declareSyntaxCatQuotParser" "`(")
# (find-lean4prefile "Lean/Parser/Term.lean" "@[builtin_term_parser] def dynamicQuot" "`(")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open   Lean
open   Nat
def   z₁ := Expr.const  `zero []
#eval z₁ -- Lean.Expr.const `zero []
def   z₂ := Expr.const ``zero []
#eval z₂ -- Lean.Expr.const `Nat.zero []

#check   zero
#check  `zero
#check ``zero
#check  `(zero)

-- end



#####
#
# backtick-syntaxcat
# 2024jun08
#
#####

# «backtick-syntaxcat»  (to ".backtick-syntaxcat")
# (to "denoteArith")
# (to "info-scp-mainModule")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open   Lean

declare_syntax_cat syntaxA
declare_syntax_cat syntaxB

syntax num                  : syntaxA
syntax "[B: " syntaxA " :]" : syntaxB
syntax "[A: " syntaxB " :]" : syntaxA

#check `(             42)
#check `(syntaxA|     42)
#check `(syntaxB| [B: 42:])

-- end





#####
#
# Bind
# 2024may23
#
#####

# «Bind»  (to ".Bind")
# (to "do-notation")
# (find-es "lean" "instance-Monad-List")
# (find-lean-links ">>=")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '>>=' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\" >>= \"' *")
# (find-lean4prefile "Init/Notation.lean" "infixl:55  \" >>= \" => Bind.bind")
# (find-lean4prefile "Init/Prelude.lean" "class Bind (m : Type u → Type v) where")
# (find-lean4prefile "Init/Prelude.lean" "export Bind (bind)")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

def main2 : IO UInt32 := do
 IO.println "hello"
 IO.println "world"
 return 0

def main3 : IO UInt32 :=
  bind (IO.println "hello") (fun _ =>
  bind (IO.println "world") (fun _ =>
  pure 0))

#check            IO.println
#check            IO.println "hello"
#check Bind.bind (IO.println "hello")
#check Bind.bind
#print main2
set_option pp.notation false in
#print main2
#print bind
#print pure

#check (inferInstance : Bind IO)
#check (inferInstance : Pure IO)

-- end




#####
#
# binop%
# 2024jun12
#
#####

# «binop»  (to ".binop")
# (to "precedence")
# (find-lean4prefile "Init/Notation.lean" "macro_rules | `($x + $y)   => `(binop% HAdd.hAdd $x $y)")
# (find-lean4prefile "Lean/Elab/Extra.lean" "`binop% f a b` elaborates `f a b` as")





#####
#
# batteries
# 2024jun12
#
#####

# «batteries»  (to ".batteries")
# https://github.com/leanprover-community/batteries
# (find-git-links "https://github.com/leanprover-community/batteries" "batteries")
# (code-c-d "batteries" "~/usrc/batteries/")
# (find-batteriessh "find * | sort")
# (find-batteriessh "find * .lake/ | sort")
# (find-batteriessh "find * .lake/ | sort | grep '\\.lean$'")
# (find-batteriesfile "")

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
cd      ~/usrc/batteries/

lake -R -Kdoc=on update
lake -R -Kdoc=on build Batteries:docs
...
> ls build/doc/index.html
build/doc/index.html






#####
#
# builtin_initialize
# 2024may18
#
#####

# «builtin_initialize»  (to ".builtin_initialize")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'builtin_command' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'builtin_command_elab' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'builtin_command_parser' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'builtin_initialize' *")
# (find-lean4pregrep "grep --color=auto -niRH --null -e 'register' * | grep -ia attribute")
# (find-lean4prefile "Init.lean")
# (find-lean4prefile "Init/Prelude.lean")
# (find-lean4prefile "Lean/Parser/Syntax.lean" "registerBuiltinParserAttribute `builtin_syntax_parser")

# (find-lean4file "")
# (find-lean4file ".files")
# (find-lean4sh "du -ch")



#####
#
# calc
# 2024apr06
#
#####

# «calc»  (to ".calc")
# https://leanprover-community.github.io/extras/calc.html
# (find-tpil4page 45 "Calculational Proofs")
# (find-tpil4text 45 "Calculational Proofs")
# (find-tpil4page 45 "with the keyword calc")
# (find-tpil4text 45 "with the keyword calc")
# (find-tpil4file "quantifiers_and_equality.md")
# (find-tpil4file "quantifiers_and_equality.md" "Calculational Proofs")
# (find-lean-links "calc")
# (find-lean-links "Calc")
# (find-lean4presh "find * | sort")
# (find-lean4presh "find * | sort | grep Calc")




#####
#
# #check
# 2024may18
#
#####

# «check»  (to ".check")
# (to "scoped-syntax")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '#check' *")
# (find-fplean4page 12 "#eval (1 + 2 : Nat)")
# (find-fplean4text 12 "#eval (1 + 2 : Nat)")
# (find-fplean4page 13 "#check (1 - 2 : Int)")
# (find-fplean4text 13 "#check (1 - 2 : Int)")
# (find-fplean4page 15 "#check add1")
# (find-fplean4text 15 "#check add1")
# (find-fplean4page 15 "#check (add1)")
# (find-fplean4text 15 "#check (add1)")
# (find-fplean4page 54 "#check fun (x : Int) => x + 1")
# (find-fplean4text 54 "#check fun (x : Int) => x + 1")
# (find-fplean4page 55 "(· + 1)")
# (find-fplean4text 55 "(· + 1)")
# (find-lean4file "doc/functions.md")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

#check  1
#check  1 : Int    -- bad
#check (1 : Int)   -- good
#check   Nat
#check   Nat -> Nat
#check ((Nat -> Nat) : Type)
#check ( Nat -> Nat  : Type)

#check   fun  x        => x + 1
#check   fun (x : Nat) => x + 1
#check ((fun (x : Nat) => x + 1) : (Nat -> Nat))
#check                   (· + 1)
#check                  ((· + 1) : (Nat -> Nat))

-- end

# (find-fplean4doc  "type-classes/polymorphism#checking-polymorphic-functions-types")
# (find-fplean4docr "type-classes/polymorphism#checking-polymorphic-functions-types")
# (find-fplean4page 111 "Checking Polymorphic Functions' Types")
# (find-fplean4text 111 "Checking Polymorphic Functions' Types")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

#check (IO.println)
#check @IO.println
#check   do Lean.logInfo "a"
#check @(do Lean.logInfo "a")

-- end

# (find-lean-links "check")
# (find-lean-links ">>")
# (find-fplean4page 13 "use #check instead of #eval")
# (find-fplean4text 13 "use #check instead of #eval")
# (find-fplean4page 51 "#check 14")
# (find-fplean4text 51 "#check 14")
# (find-fplean4page 52 "#check (14 : Int)")
# (find-fplean4text 52 "#check (14 : Int)")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'check' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '#check' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '<|>' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'namespace Command' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'builtin_command_parser' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'elaboration function for' *")
# (find-lean4prefile "Lean/Parser/Command.lean" "@[builtin_command_parser] def check")
# (find-lean4prefile "Lean/Parser/Command.lean" "\"#check \" >> termParser")




#####
#
# #checksyntax
# 2024may15
#
#####

# «checksyntax»  (to ".checksyntax")
# (find-leanmetadoc  "main/05_syntax#free-form-syntax-declarations")
# (find-leanmetadocw "main/05_syntax#free-form-syntax-declarations")
# (find-leanmetadocr "main/05_syntax" "### Free form syntax declarations")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'elaboration function for' *")
# (find-lean4prefile "Lean/Elab/Command.lean" "elaboration function for")
# (find-lean4prefile "Lean/Elab/Term.lean" "elaboration function for")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/How.20do.20I.20write.20a.20.22.23check_syntax.22.3F/near/438919441

Hi all,

I'm taking far too long to do this myself, so I decided to ask...

In the section "Free form syntax declarations" of the metaprogramming
book there's an example - inside "namespace Playground2" - in which
the command "#check_failure ⊥ OR (⊤ AND ⊥)" fails with the error
"elaboration function for 'Playground2.term_OR_' has not been
implemented". I only found that error message in two places in the
source:

here in Lean/Elab/Command.lean, and
here in Lean/Elab/Term.lean,

but lots of things happen before that error message...

How do I write a variant of #check or #check_failure - let me call
that variant "#check_syntax" - that parses the rest of the line like
#check or #check_failure, i.e., like this,

@[builtin_command_parser] def check := leading_parser "#check " >> termParser

but that does not try to elaborate the result of "termParser"? I would
like it to just print the resulting Syntax object...

---

Neat! If I run this,

#check `(42 + "foo")

then the output is:

do
  let info ← Lean.MonadRef.mkInfoFromRefPos
  let scp ← Lean.getCurrMacroScope
  let mainModule ← Lean.getMainModule
  pure
      {
        raw :=
          Lean.Syntax.node3 info `term_+_ (Lean.Syntax.node1 info `num (Lean.Syntax.atom info "42"))
            (Lean.Syntax.atom info "+")
            (Lean.Syntax.node1 info `str (Lean.Syntax.atom info "\"foo\"")) } : ?m.233 (Lean.TSyntax `term) (lsp)

I would still like to learn how to write a new command that works as
the first half of #check, but that helps!



If anyone else is reading this, here is a version that is trivial to run:

import Lean.Elab.Command

namespace Playground2

scoped syntax "⊥" : term
scoped syntax "⊤" : term
scoped syntax:40 term " OR " term : term
scoped syntax:50 term " AND " term : term

elab "#check_syntax " t:term : command => do Lean.logInfo m!"{t}"
elab "#check_syntax " t:term : command => do Lean.logInfo m!"{repr t.raw}"

#check_syntax ⊥ OR (⊤ AND ⊥)

end Playground2

The definition of "#check_syntax" that holds is the last one - to
change its behavior, reorder the "elab" lines.




#####
#
# checksyntax-test
# 2024may16
#
#####

# «checksyntax-test»  (to ".checksyntax-test")
# (to "TSyntax")
# (to "command")
# (to "interpolatedStr")
# (to "mkSyntaxQuotation")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean.Elab.Command
elab "#check_syntax " t:term : command => do Lean.logInfo m!"{t}"
elab "#check_syntax " t:term : command => do Lean.logInfo m!"{repr t.raw}"
elab "#check_syntax " t:term : command => do Lean.logInfo (repr t.raw)
#check_syntax 42 + "foo"
#check `(42 + "foo")

-- end




#####
#
# class
# 2024may23
#
#####

# «class»  (to ".class")
# (to "typeclass-search")
# (to "export")
# (to "extends")
# (find-fplean4doc "type-classes")
# (find-fplean4doc "type-classes/pos#classes-and-instances")
# (find-fplean4page 101 "Overloading and Type Classes")
# (find-fplean4text 101 "Overloading and Type Classes")
# (find-fplean4page 104 "Classes and Instances")
# (find-fplean4text 104 "Classes and Instances")
# (find-leanrefdoc "lean-lang.org/lean4/doc/typeclass#type-classes")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

class Foo (α : Type) where plic : α → String
class Bar (α : Type) where plic : α → String

instance : Foo String where plic := fun _ => "(str)"
instance : Foo Bool   where plic := fun _ => "(bool)"
instance : Bar String where plic := fun _ => "|str|"
instance : Bar Bool   where plic := fun _ => "|bool|"

#eval Foo.plic "a"
#eval Foo.plic true
#eval Bar.plic "a"
#eval Bar.plic true

-- export Foo (plic)
export Bar (plic)

#check plic
#eval  plic "a"
#eval  plic true

-- end





#####
#
# class-extends
# 2024may23
#
#####

# «class-extends»  (to ".class-extends")
# (find-fplean4page 217 "definition of Applicative that extends Functor")
# (find-fplean4text 217 "definition of Applicative that extends Functor")
# (find-fplean4page 218 "EXPR1 ={ REASON }= EXPR2")
# (find-fplean4text 218 "EXPR1 ={ REASON }= EXPR2")
# (find-lean-links "extends")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'extends' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\" extends \"' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'class Monad' * | grep -a extends")
# (find-lean4prefile "Init/Prelude.lean" "class Monad" "extends Applicative m, Bind m")
# (find-lean4prefile "Init/Prelude.lean" "class Applicative" "extends Functor f, Pure f, Seq f, SeqLeft f, SeqRight f")
# (find-lean4prefile "Init/Prelude.lean" "class Functor ")
# (find-lean4prefile "Init/Prelude.lean" "class Pure ")
# (find-lean4prefile "Init/Prelude.lean" "class Seq ")
# (find-lean4prefile "Init/Prelude.lean" "class SeqLeft ")
# (find-lean4prefile "Init/Prelude.lean" "class SeqRight ")
# (find-lean4prefile "Init/Prelude.lean" "class Bind ")

# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

instance : Monad List where
  pure := List.pure
  bind := List.bind

#check List.pure
#check List.bind
#check List.map
#check List.seq   -- err

-- end




#####
#
# command
# 2024may12
#
#####

# «command»  (to ".command")
# (to "checksyntax-test")
# (to "elab-term")
# (find-lean4prefile "Init/Notation.lean" "def command : Category := {}")
# (find-leanmetadoc  "main/01_intro#building-a-command")
# (find-leanmetapage 3 "Building a command")
# (find-leanmetatext 3 "Building a command")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean.Elab.Command
elab "#check_syntax " t:term : command => do Lean.logInfo m!"{t}"
#check_syntax 42 + "foo"

-- end





#####
#
# constant
# 2023jun24
#
#####

# «constant»  (to ".constant")
# (find-lean4pregrep "grep --color=auto -nRH --null -e constant *")
# (find-lean4grep "grep --color=auto -nRH --null -e constant doc/*")
# (find-lean4file "doc/funabst.md" "constant f : Nat → Nat")
# (find-lean4file "doc/typeobjs.md" "constant α : Type")
# (find-lean4file "doc/")
# (find-tpinleanpage 11 "constant m : nat")
# (find-tpinleantext 11 "constant m : nat")

# (find-tpinleanpage (+ 6 5) "2.1 Simple Type Theory")
# (find-tpinleantext (+ 6 5) "2.1 Simple Type Theory")
# (find-lean4file "doc/simptypes.md" "Simple Type Theory")
# (find-lean4file "doc/simptypes.md" "The ``constant`` command")

# (find-lean4file "doc/SUMMARY.md" "# Language Manual")
# (find-lean4file "doc/SUMMARY.md" "[Theorem Proving in Lean](./tpil.md)")
# (find-lean4docr "SUMMARY.md" "<!--   - [Function Abstraction and Evaluation](./funabst.md) -->")
# (find-lean4file "doc/tpil.md")

# (find-tpil4doc "introduction")
# (find-tpil4docrfile "")
# (find-tpil4docrgrep "grep --color=auto -nH --null -e constant *")

# (find-fline "~/bigsrc/lean4/doc/funabst.md")
~/bigsrc/lean4/doc/funabst.md
constant f : Nat → String
# (find-lean4docr "SUMMARY.md" "funabst.md")
# (find-lean4docr "funabst.md")




#####
#
# def
# 2024mar09
#
#####

# «def»  (to ".def")
# (to "addDecl")
# (find-fplean4page 15 "def maximum (n : Nat) (k : Nat) : Nat :=")
# (find-fplean4text 15 "def maximum (n : Nat) (k : Nat) : Nat :=")
# (find-tpil4page 11 "Definitions")
# (find-tpil4text 11 "Definitions")
# (find-tpil4-links "Definitions")
# (find-tpil4file "dependent_type_theory.md" "## Definitions")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\"def \"' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'mkDefViewOfDef' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'mkDefView' *")
# (find-lean4prefile "Lean/Elab/DefView.lean" "def mkDefViewOfDef")
# (find-lean4prefile "Lean/Elab/DefView.lean" "-- leading_parser \"def \" >> declId >>")
# (find-lean4prefile "Lean/Elab/DefView.lean" "else if declKind == ``Parser.Command.def then")
# (find-lean4prefile "Lean/Elab/DeclModifiers.lean" "structure Modifiers where")
# (find-lean4prefile "Lean/Elab/DeclModifiers.lean" "attrs           : Array Attribute := #[]")

# (find-lean4pregrep "grep --color=auto -nRH --null -e 'invalid syntax node kind' *")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

def add0                     : Nat := 4
def add1 (n : Nat)           : Nat := n + 1
def add2 (n : Nat) (m : Nat) : Nat := n + m
def add3 (n : Nat) (m : Nat) : Nat :=

#eval add0
#eval add1 7
#eval add2 3 4
#eval add3 3 4

def add4  (a b : Nat) : Nat := a+b
def add5 :       Nat  → Nat := id
def add6 : Nat → Nat  → Nat := fun a b => a+b
def add7 : (x : Nat) → Nat  → Nat := fun a b => a+b

-- end







#####
#
# coercion
# 2024may19
#
#####

# «coercion»  (to ".coercion")
# (to "heterogeneous")
# (to "structure")
# (find-fplean4doc "type-classes/pos#overloaded-addition")
# (find-fplean4doc "type-classes/coercion")
# (find-lean-links "instance : Coe")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'instance : Coe' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '@\\[coe\\]' *")
# (find-lean4prefile "Init/Coe.lean")
# (find-lean4prefile "Lean/Meta/CoeAttr.lean" "to delaborate coercion functions as `↑`")
# (find-lean4prefile "Init/Notation.lean" "syntax (name := Attr.coe) \"coe\" : attr")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

#check (2 : Nat) + (3 : Int)    -- ↑2 + 3 : Int

structure A where n : Nat deriving Repr
structure B where n : Nat deriving Repr
instance : Coe A B where coe a := ⟨a.n * 10⟩
#eval  (⟨4⟩ : A)
#eval  (⟨5⟩ : B)
#eval ((⟨6⟩ : A) : B)

-- end




#####
#
# CommandElabM
# 2024may18
#
#####

# «CommandElabM»  (to ".CommandElabM")
# (to "run_cmd")
# (find-lean-links "CommandElabM")
# (find-leanmetadocrgrep "grep --color=auto -nRH --null -e 'CommandElabM' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'CommandElabM' *")
# (find-lean4prefile "Init/Notation.lean" "#eval show CommandElabM Unit from do doSeq")
# (find-lean4prefile "Lean/Elab/Command.lean" "abbrev CommandElabM := CommandElabCoreM Exception")

# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean.Elab.Command
#check CommandElabM

-- end





#####
#
# company
# 2024may07
#
#####

# «company»  (to ".company")
# (find-es "emacs" "company")
# (find-companyfile "company-capf.el")




#####
#
# constructor
# 2024jun30
#
#####

# «constructor»  (to ".constructor")
# (find-lean4docgrep    "grep --color=auto -niH --null -e 'constructor' print.txt")
# (find-fplean4docgrep  "grep --color=auto -niH --null -e 'constructor' print.txt")
# (find-leanmetadocgrep "grep --color=auto -niH --null -e 'constructor' print.txt")
# (find-tclean4docgrep  "grep --color=auto -niH --null -e 'constructor' print.txt")
# (find-tpil4docgrep    "grep --color=auto -niH --null -e 'constructor' print.txt")
# (fpl "constructor")
# (ldl "constructor")
# (lml "constructor")
# (tcl "constructor")
# (tpl "constructor")
# (find-books "__comp/__comp.el" "dybjer")
# (find-books "__logic/__logic.el" "martin-lof")





#####
#
# CoreM
# 2024may17
#
#####

# «CoreM»  (to ".CoreM")
# (find-leanmetadoc  "main/04_metam")
# (find-leanmetadocw "main/04_metam")
# (find-leanmetadocr "main/04_metam")
# (find-leanmetadocr "main/04_metam" "`CoreM` gives access to the *environment*")
# (find-lean4prefile "Lean/CoreM.lean" "structure Context where")
# (find-lean4prefile "Lean/CoreM.lean" "structure Context where" "currNamespace")
# (find-lean4prefile "Lean/CoreM.lean" "instance : MonadResolveName CoreM where")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'CoreM' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'getCurrNamespace' *")
# (find-lean4prefile "Init/Prelude.lean" "def getCurrNamespace")




#####
#
# dbg_trace
# 2024may27
#
#####

# «dbg_trace»  (to ".dbg_trace")
# (to "eldoc")
# (find-leanmetapage 14 "Printing Messages")
# (find-leanmetatext 14 "Printing Messages")
# (find-leanmetadoc  "main/02_overview#printing-messages")
# (find-leanmetadocr "main/02_overview" "### Printing Messages")
# (find-lean-links "dbg_trace")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'dbg_trace' *")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean

elab "traces" : tactic => do
  let array := List.replicate 2 (List.range 3)
  Lean.logInfo m!"logInfo: {array}"
  dbg_trace  f!"dbg_trace: {array}"

example : True := by -- `example` is underlined in blue, outputting:
                     -- dbg_trace: [[0, 1, 2], [0, 1, 2]]
  traces -- now `traces` is underlined in blue, outputting
         -- logInfo: [[0, 1, 2], [0, 1, 2]]
  trivial

-- end




#####
#
# declare_syntax_cat
# 2024jun08
#
#####

# «declare_syntax_cat»  (to ".declare_syntax_cat")
# (to "Lean.Parser.Category")
# (to "macro_rules")
# (to "TSyntax")
# (find-leanmetadoc  "main/01_intro#building-a-dsl-and-a-syntax-for-it")
# (find-leanmetadocr "main/01_intro" "### Building a DSL and a syntax for it")
# (find-leanmetadocr "main/01_intro" "declare_syntax_cat arith")
# (find-leanmetapage 5 "declare_syntax_cat")
# (find-leanmetatext 5 "declare_syntax_cat")
# (find-leanmetadoc  "main/05_syntax")
# (find-leanmetadocr "main/05_syntax" "you will have to use `` `(category| ...)``")
# (find-lean-links "declare_syntax_cat")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'declare_syntax_cat' *")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")


-- end





#####
#
# denoteArith
# 2024jun08
#
#####

# «denoteArith»  (to ".denoteArith")
# (to "backtick-syntaxcat")
# (find-leanmetadocr "main/05_syntax.lean#mini-project")
# (find-leanmetadocr "main/05_syntax.lean" "### Mini Project")
# (find-leanmetadocr "main/05_syntax.lean" "partial def denoteArith : TSyntax `arith → Nat")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open   Lean

declare_syntax_cat arith

syntax num : arith
syntax arith "-" arith : arith
syntax arith "+" arith : arith
syntax "(" arith ")" : arith

partial def denoteArith : TSyntax `arith → Nat
  | `(arith| $x:num) => x.getNat
  | `(arith| $x:arith + $y:arith) => denoteArith x + denoteArith y
  | `(arith| $x:arith - $y:arith) => denoteArith x - denoteArith y
  | `(arith| ($x:arith)) => denoteArith x
  | _ => 0

def test : Elab.TermElabM Nat := do
  let stx ← `(arith| (12 + 2) - 4)
  pure (denoteArith stx)

#eval test -- 10

-- end





#####
#
# deriving
# 2024may31
#
#####

# «deriving»  (to ".deriving")
# (to "synth")
# (find-lean-links "deriving")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'deriving' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'deriving instance' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'deriving instance Repr' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\"deriving \"' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'optDeriving' *")
# (find-lean4prefile "Lean/Elab/Deriving/Basic.lean" "@[builtin_command_elab «deriving»]")
# (find-lean4prefile "Lean/Elab/Deriving/Repr.lean")
# (find-lean4prefile "Lean/Parser/Command.lean" "def optDeriving      := leading_parser")
# (find-lean4prefile "Lean/Parser/Command.lean" "@[builtin_command_parser] def «deriving»")
# (find-lean4prefile "Init/Meta.lean" "deriving instance Repr for Syntax")




#####
#
# discard
# 2024may12
#
#####

# «discard»  (to ".discard")
# (find-leanmetadoc  "main/01_intro#building-a-command")
# (find-leanmetadocr "main/01_intro" "### Building a command")
# (find-lean4prefile "Init/Control/Basic.lean" "def Functor.discard")



#####
#
# doc-comments
# 2024may29
#
#####

# «doc-comments»  (to ".doc-comments")
# (to "eldoc")
# (find-leanrefdoc "lexical_structure#doc-comments")
# (find-lean4prefile "Lean/Parser/Term.lean" "a \"documentation comment\" like `/-- foo -/`")




#####
#
# do-iteration
# 2024may24
#
#####

# «do-iteration»  (to ".do-iteration")
# (to "Id.run")
# (find-lean-links  "range")
# (find-lean4doc  "do#iteration")
# (find-lean4docr "do.md" "## Iteration")
# (find-lean4docr "do.md" "[:x] is notation for the range [0, x)")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\\[:' *")
# (find-lean4prefile "Init/Core.lean" "inductive DoResultPRBC ")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

def sum (xs : Array Nat) : IO Nat := do
  let mut s := 0
  for x in xs do { IO.println s!"x:{x}"; s:=s+x }
  return s

def sum' (xs : Array Nat) : Nat := Id.run <| do
  let mut s := 0
  for x in xs do s:=s+x
  return s

def sumEven (xs : Array Nat) : IO Nat := do
  let mut s := 0
  for x in xs do if x%2==0 then { IO.println s!"x:{x}"; s:=s+x }
  return s

#eval sum     #[1, 2, 3]
#eval sum'    #[1, 2, 3]
#eval sumEven #[1, 2, 3, 6]

-- end




#####
#
# do notation
# 2024mar23
#
#####

# «do-notation»  (to ".do-notation")
# (find-es "lean" "instance-Monad-List")
# (to "runActions")
# (to "let-mut")
# (to "Monad")
# (to "Bind")
# (to "sleep1")
# (to "pp.notation")
# (find-lean4doc  "do")
# (find-lean4doc  "do#the-do-notation")
# (find-lean4docr "do.md" "# The `do` notation")
# (find-lean4docrfile "do.md")
# (find-fplean4page 66 "Combining IO Actions")
# (find-fplean4text 66 "Combining IO Actions")
# (find-fplean4page 67 "let bindings in do use a left arrow")
# (find-fplean4text 67 "let bindings in do use a left arrow")
# (find-fplean4page 85 "left arrow immediately" "under parentheses")
# (find-fplean4text 85 "left arrow immediately" "under parentheses")
# (find-fplean4page 85 "(← IO.getStdout)")
# (find-fplean4text 85 "(← IO.getStdout)")
# (find-fplean4page 90 "do Notation")
# (find-fplean4text 90 "do Notation")
# (find-fplean4doc "hello-world/running-a-program#combining-io-actions")
# (find-fplean4doc "monads/do")
# (find-fplean4doc "monad-transformers/do")
# (find-fplean4doc "monad-transformers/do#single-branched-if")
# (find-fplean4doc "monad-transformers/do#early-return")
# (find-fplean4doc "monad-transformers/do#loops")
# (find-fplean4doc "monad-transformers/do#stopping-iteration")
# (find-fplean4doc "monad-transformers/do#mutable-variables")
# (find-fplean4doc "monad-transformers/do#what-counts-as-a-do-block")
# (find-fplean4doc "monad-transformers/conveniences#infinite-loops")
# (find-fplean4doc "monad-transformers/conveniences#while-loops")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\"do \"' *")
# (find-lean4prefile "Lean/Elab/Do.lean")
# (find-lean4prefile "Lean/Parser/Do.lean")
# (find-lean4prefile "Init/Prelude.lean" "the type `m Unit` represents an action")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

instance : Monad List where
  pure := List.pure
  bind := List.bind

def foo := do let a ← [0, 1]; let b ← [a+1, a+2]; return (a,b)

set_option pp.notation false in
#print foo

def main2 : IO UInt32 := do
 IO.println "hello"
 IO.println "world"
 return 0

def main3 : IO UInt32 :=
  bind (IO.println "hello") (fun _ =>
  bind (IO.println "world") (fun _ =>
  pure 0))

#check IO.println "hello"
#print main2
set_option pp.notation false in
#print main2
#print bind
#print pure

#check (inferInstance : Bind IO)
#check (inferInstance : Pure IO)

#check do return 42
#check do let _ := 42
#check do let _ ← IO.getStdin
#check do let _ ← IO.getStdin; let _ ← IO.getStdin
#check do let a ← IO.getStdin; let b ← IO.getStdin; return [a,b]

#check do
  let stdin <- IO.getStdin

-- end



#####
#
# " .. "
# 2024jun20
#
#####

# «dotdot»  (to ".dotdot")
# (find-lean4pregrep "grep --color=auto -nRH --null -e ' \\.\\. ' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e ' \\.\\. ' * | grep -a '{'")
# (find-lean4prefile "Lean/Meta/InferType.lean" "| .bvar .. ")
# (find-lean4prefile "Init/System/IO.lean" "| .ok { type := .symlink, .. } =>")
# (find-lean4prefile "Lean/Server/CodeActions/Attr.lean" "let { env, opts, .. } ← read")




#####
#
# eglot
# 2024jun20
#
#####

# «eglot»  (to ".eglot")
# https://codeberg.org/mekeor/nael
# https://github.com/bustercopley/lean4-mode




#####
#
# elab
# 2024mar30
#
#####

# «elab»  (to ".elab")
# (find-leanmetadoc  "main/01_intro#building-a-command")
# (find-leanmetadocw "main/01_intro#building-a-command")
# (find-leanmetadocr "main/01_intro" "elab \"#assertType \"")
# (find-leanmetadocr "main/01_intro" "inductive Arith : Type where")
# (find-leanmetadocrgrep "grep --color=auto -nH --null -e '^elab ' main/*")
# (find-lean4prefile "Init/Notation.lean" "`f $ x` means the same as the same as `f x`")
# (find-lean4prefile "Lean/Elab/SyntheticMVars.lean" "def synthesizeSyntheticMVarsNoPostponing")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

elab "#assertType " termStx:term " : " typeStx:term : command =>
  open Lean Lean.Elab Command Term in
  liftTermElabM
    try
      let tp ← elabType typeStx
      discard $ elabTermEnsuringType termStx tp
      synthesizeSyntheticMVarsNoPostponing
      logInfo "success"
    catch | _ => throwError "failure"

-- /-- info: success -/
-- #guard_msgs in --#
-- #assertType 5  : Nat

/-- error: failure -/
#guard_msgs in --#
#assertType [] : Nat

#check Lean.Elab.Command.liftTermElabM
#check Lean.Elab.Term.elabType
#check Lean.Elab.Term.elabTermEnsuringType
#check Functor.discard

-- end

‘
’: unknown constant 'Lean.Elab.Command.CommandElab'
‘
’: unknown constant 'Lean.Elab.throwUnsupportedSyntax'
Company: An error occurred in post-command
Company: frontend company-pseudo-tooltip-unless-just-one-frontend error "Company: backend company-capf error "Args out of range: #<buffer a.lean>, 754, 13" with args (match Unit)" on command post-command
Making completion list... [2 times]
Saving file /tmp/a.lean...
Wrote /tmp/a.lean
unexpected token '#assertType'; expected '#guard_msgs', 'abbrev', 'add_decl_doc', 'axiom', 'binder_predicate', 'builtin_initialize', 'builtin_simproc', 'builtin_simproc_decl', 'class', 'declare_config_elab', 'declare_simp_like_tactic', 'declare_syntax_cat', 'def', 'elab', 'elab_rules', 'example', 'inductive', 'infix', 'infixl', 'infixr', 'initialize', 'instance', 'macro', 'macro_rules', 'notation', 'opaque', 'postfix', 'prefix', 'register_builtin_option', 'register_label_attr', 'register_option', 'register_simp_attr', 'simproc', 'simproc_decl', 'structure', 'syntax', 'theorem' or 'unif_hint'


synthesizeSyntheticMVarsNoPostponing




#####
#
# elabIMP
# 2024jun19
#
#####

# «elabIMP»  (to ".elabIMP")
# (find-leanmetadoc  "main/08_dsls")
# (find-leanmetadocr "main/08_dsls")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open   Lean Elab Meta

inductive IMPLit
  | nat  : Nat  → IMPLit
  | bool : Bool → IMPLit
inductive IMPUnOp
  | not
inductive IMPBinOp
  | and | add | less
inductive IMPExpr
  | lit : IMPLit → IMPExpr
  | var : String → IMPExpr
  | un  : IMPUnOp → IMPExpr → IMPExpr
  | bin : IMPBinOp → IMPExpr → IMPExpr → IMPExpr
inductive IMPProgram
  | Skip   : IMPProgram
  | Assign : String → IMPExpr → IMPProgram
  | Seq    : IMPProgram → IMPProgram → IMPProgram
  | If     : IMPExpr → IMPProgram → IMPProgram → IMPProgram
  | While  : IMPExpr → IMPProgram → IMPProgram

declare_syntax_cat imp_lit
syntax num       : imp_lit
syntax "true"    : imp_lit
syntax "false"   : imp_lit

def elabIMPLit : Syntax → MetaM Expr
  | `(imp_lit| $n:num) => mkAppM ``IMPLit.nat  #[mkNatLit n.getNat]
  | `(imp_lit| true  ) => mkAppM ``IMPLit.bool #[.const ``Bool.true []]
  | `(imp_lit| false ) => mkAppM ``IMPLit.bool #[.const ``Bool.false []]
  | _ => throwUnsupportedSyntax

elab "test_elabIMPLit " l:imp_lit : term => elabIMPLit l

#reduce test_elabIMPLit 4     -- IMPLit.nat 4
#reduce test_elabIMPLit true  -- IMPLit.bool true
#reduce test_elabIMPLit false -- IMPLit.bool true

declare_syntax_cat imp_unop
syntax "not"     : imp_unop

def elabIMPUnOp : Syntax → MetaM Expr
  | `(imp_unop| not) => return .const ``IMPUnOp.not []
  | _ => throwUnsupportedSyntax

declare_syntax_cat imp_binop
syntax "+"       : imp_binop
syntax "and"     : imp_binop
syntax "<"       : imp_binop

def elabIMPBinOp : Syntax → MetaM Expr
  | `(imp_binop| +)   => return .const ``IMPBinOp.add []
  | `(imp_binop| and) => return .const ``IMPBinOp.and []
  | `(imp_binop| <)   => return .const ``IMPBinOp.less []
  | _ => throwUnsupportedSyntax

declare_syntax_cat                   imp_expr
syntax imp_lit                     : imp_expr
syntax ident                       : imp_expr
syntax imp_unop imp_expr           : imp_expr
syntax imp_expr imp_binop imp_expr : imp_expr

syntax "(" imp_expr ")" : imp_expr

partial def elabIMPExpr : Syntax → MetaM Expr
  | `(imp_expr| $l:imp_lit) => do
    let l ← elabIMPLit l
    mkAppM ``IMPExpr.lit #[l]
  -- `mkStrLit` creates an `Expr` from a `String`
  | `(imp_expr| $i:ident) => mkAppM ``IMPExpr.var #[mkStrLit i.getId.toString]
  | `(imp_expr| $b:imp_unop $e:imp_expr) => do
    let b ← elabIMPUnOp b
    let e ← elabIMPExpr e -- recurse!
    mkAppM ``IMPExpr.un #[b, e]
  | `(imp_expr| $l:imp_expr $b:imp_binop $r:imp_expr) => do
    let l ← elabIMPExpr l -- recurse!
    let r ← elabIMPExpr r -- recurse!
    let b ← elabIMPBinOp b
    mkAppM ``IMPExpr.bin #[b, l, r]
  | `(imp_expr| ($e:imp_expr)) => elabIMPExpr e
  | _ => throwUnsupportedSyntax

elab "test_elabIMPExpr " e:imp_expr : term => elabIMPExpr e

#reduce test_elabIMPExpr a
#reduce test_elabIMPExpr a + 5
#reduce test_elabIMPExpr 1 + true

declare_syntax_cat           imp_program
syntax "skip"              : imp_program
syntax ident ":=" imp_expr : imp_program

syntax imp_program ";;" imp_program : imp_program

syntax "if" imp_expr "then" imp_program "else" imp_program "fi" : imp_program
syntax "while" imp_expr "do" imp_program "od" : imp_program

partial def elabIMPProgram : Syntax → MetaM Expr
  | `(imp_program| skip) => return .const ``IMPProgram.Skip []
  | `(imp_program| $i:ident := $e:imp_expr) => do
    let i : Expr := mkStrLit i.getId.toString
    let e ← elabIMPExpr e
    mkAppM ``IMPProgram.Assign #[i, e]
  | `(imp_program| $p₁:imp_program ;; $p₂:imp_program) => do
    let p₁ ← elabIMPProgram p₁
    let p₂ ← elabIMPProgram p₂
    mkAppM ``IMPProgram.Seq #[p₁, p₂]
  | `(imp_program| if $e:imp_expr then $pT:imp_program else $pF:imp_program fi) => do
    let e ← elabIMPExpr e
    let pT ← elabIMPProgram pT
    let pF ← elabIMPProgram pF
    mkAppM ``IMPProgram.If #[e, pT, pF]
  | `(imp_program| while $e:imp_expr do $pT:imp_program od) => do
    let e ← elabIMPExpr e
    let pT ← elabIMPProgram pT
    mkAppM ``IMPProgram.While #[e, pT]
  | _ => throwUnsupportedSyntax

elab ">>" p:imp_program "<<" : term => elabIMPProgram p

#reduce >>
a := 5;;
if not a and 3 < 4 then
  c := 5
else
  a := a + 1
fi;;
b := 10
<<

-- end




#####
#
# elab_rules
# 2024jun08
#
#####

# «elab_rules»  (to ".elab_rules")
# (to "3-essential")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'elab_rules' *")
https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/Widgets.20not.20displaying.20on.20some.20terms/near/434371640
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open   Lean

syntax "#help"   str : command
elab_rules           : command
  |   `(#help $s:str) => logInfo ("[h " ++ s ++ " h]")
#help         "BLAM"

syntax "[: "  term " :]" : term
elab_rules               : term
  |   `([: $t:term   :]) => do Elab.Term.elabTerm t none
#eval   [: 42        :]

-- end




#####
#
# elab-term
# 2024jun15
#
#####

# «elab-term»  (to ".elab-term")
# (to "command")
# (to "mapAddOneNil")
# (find-leanmetapage 11 "or any other syntax category")
# (find-leanmetatext 11 "or any other syntax category")
# (find-leanmetapage 11 "TermElab stands for Syntax → Option Expr →")
# (find-leanmetatext 11 "TermElab stands for Syntax → Option Expr →")
# (find-leanmetapage 20 "def mapAddOneNil : Expr :=")
# (find-leanmetatext 20 "def mapAddOneNil : Expr :=")
# (find-leanmetapage 20 "we can turn our Expr into a" "Lean term")
# (find-leanmetatext 20 "we can turn our Expr into a" "Lean term")
# (find-lean4prefile "Lean/Elab/Term.lean" "abbrev TermElab  := Syntax → Option Expr →")
# (find-lean4prefile "Lean/Elab/ElabRules.lean" "def elabElabRulesAux")
# (find-lean4prefile "Lean/Elab/ElabRules.lean" "def elabElabRulesAux" "if catName == `term")
# (find-lean4prefile "Lean/Elab/ElabRules.lean" "def elabElabRulesAux" "if catName == `command")
# (find-lean4prefile "Lean/Elab/ElabRules.lean" "def elabElabRulesAux" "if catName == `tactic")
# (find-lean4prefile "Lean/Elab/ElabRules.lean" "unsupported syntax category")
# (find-lean4gitgrep "grep --color=auto -nRH --null -e command_elab *")
# (find-lean4gitgrep "grep --color=auto -nRH --null -e term_elab *")

# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open   Lean

def nat1 : Expr := .const ``Nat   []
--                        ------  ------------
--                        : Name  : List Level
--                 ---------------------------
--                 : Expr

elab "nat2" : term => return (.const ``Nat   []          )
--                                   ------  ------------
--                                   : Name  : List Level
--                            ---------------------------
--                            : Expr
--                    -----------------------------------
--                    : m Expr
--                    -----------------------------------
--                    : TermElabM Expr

#check nat1
#check nat2
#check (3 : nat2)

#check TermElab

#check                            (.const ``Nat []  :           Expr)
elab "nat2"  : term    =>  return (.const ``Nat [])
elab "nat2"  : term    => (return (.const ``Nat []) : TermElabM Expr)
elab "say42" : command =>  logInfo "42"
elab "say42" : command => (logInfo "42" : CommandElabM Unit)
say42

declare_syntax_cat catB
elab "foo" : catB => 42  -- unsupported syntax category 'catB'

-- end









#####
#
# The type of the function in an elab
# 2024jun12
#
#####

# «elab-type»  (to ".elab-type")
# (to "repr-type")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open Lean Elab Command

elab "#withstring " x:str : command =>
  match x with
  | `("a") => logInfo x
  | `("b") => do { logInfo x; logInfo (repr x) }
  | `("c") => do { logInfo x; logInfo (repr x.raw) }
  | _ => Elab.throwUnsupportedSyntax

#withstring "a"
#withstring "b"
#withstring "c"

#check fun x => match x with | `("a") => 42 | _ => 42
#check fun x => match x with | _ => 42
#check fun x => match x with | _ => logInfo x
-- #check fun x =>
-- #check fun (x : Syntax) =>
#check fun (x : TSyntax `str) =>
  match x with
  | `("a") => logInfo x
  | `("b") => do { logInfo x; logInfo (repr x) }
  | `("c") => do { logInfo x; logInfo (repr x.raw) }
  | _ => Elab.throwUnsupportedSyntax

-- end




#####
#
# eldoc
# 2024may27
#
#####

# «eldoc»  (to ".eldoc")
# (to "doc-comments")
# (to "dbg_trace")
# (find-es "emacs" "eldoc-mode")





#####
#
# Environment
# 2024may18
#
#####

# «Environment»  (to ".Environment")
# (find-lean-links "Environment")
# (find-lean4prefile "Lean/CoreM.lean" "structure State where")



#####
#
# exceptions
# 2024may25
#
#####

# «exceptions»  (to ".exceptions")
# (to "try-catch")
# (find-lean-links "Except")
# (find-fplean4page 154 "Propagating Error Messages")
# (find-fplean4text 154 "Propagating Error Messages")
# (find-fplean4page 254 "Failure with OptionT")
# (find-fplean4text 254 "Failure with OptionT")
# (find-fplean4page 258 "Exceptions")
# (find-fplean4text 258 "Exceptions")
# (find-fplean4page 260 "Type Classes for Exceptions")
# (find-fplean4text 260 "Type Classes for Exceptions")
# (find-fplean4doc "monad-transformers/transformers#failure-with-optiont")
# (find-fplean4doc "monad-transformers/transformers#exceptions")
# (find-fplean4doc "monad-transformers/transformers#type-classes-for-exceptions")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'Except' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'MonadExcept' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\\[MonadExcept ' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'class MonadExcept' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e ' Except ' *")
# (find-lean4prefile "Init/Prelude.lean" "inductive Except")
# (find-lean4prefile "Init/Prelude.lean" "An implementation of Haskell's [`MonadError`] class")
# (find-lean4prefile "Init/Prelude.lean" "class MonadExceptOf ")
# (find-lean4prefile "Init/Prelude.lean" "class MonadExcept ")
# (find-lean4prefile "Init/Control/Except.lean")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

inductive Err where
  | divByZero
  | notANumber : String → Err

def asNumber [Monad m] [MonadExcept Err m] (s : String) : m Int :=
  match s.toInt? with
  | none => throw (.notANumber s)
  | some i => pure i

def divBackend [Monad m] [MonadExcept Err m] (n k : Int) : m Int :=
  if k == 0 then
    throw .divByZero
  else pure (n / k)

def divFrontend [Monad m] [MonadExcept Err m] (n k : String) : m String :=
  try
    pure (toString (← divBackend (← asNumber n) (← asNumber k)))
  catch
    | .divByZero => pure "Division by zero!"
    | .notANumber s => pure s!"Not a number: \"{s}\""

-- end






#####
#
# At sign
# 2024mar15
#
#####

# «explicit-arguments»  (to ".explicit-arguments")
# «implicit-arguments»  (to ".implicit-arguments")
# (to "optParam")
# (find-lean-links "@")
# (find-tpil4doc  "dependent_type_theory")
# (find-tpil4doc  "dependent_type_theory#implicit-arguments")
# (find-tpil4docr "dependent_type_theory" "Implicit Arguments")
# (find-tpil4docr "dependent_type_theory" "@foo" "with all the arguments" "made explicit")
# (find-fplean4doc "getting-to-know/polymorphism")
# (find-fplean4doc "getting-to-know/polymorphism#implicit-arguments")
# (find-fplean4doc "getting-to-know/conveniences#automatic-implicit-arguments")
# (find-fplean4page 38 "Implicit Arguments")
# (find-fplean4text 38 "Implicit Arguments")
# (find-fplean4page 39 "#check List.length (α := Int)")
# (find-fplean4text 39 "#check List.length (α := Int)")
# (find-fplean4page 48 "Automatic Implicit Arguments")
# (find-fplean4text 48 "Automatic Implicit Arguments")
# (find-lean4pregrep "grep --color=auto -nRH --null -e ' @' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\"@\"' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '@' * | grep -ai explicit")
# (find-lean4prefile "Lean/Elab/App.lean" "`explicit = true` when notation `@` is used")
# (find-fplean4doc "type-classes/polymorphism#checking-polymorphic-functions-types")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

#check List.length
#check List.length (α := Int)
#check bind

instance : Monad List where
  pure := List.pure
  bind := List.bind

inductive A where |a1:A |a2:A deriving Repr
inductive B where |b1:B |b2:B deriving Repr
open A B

#check Bind.bind
#check bind
#check bind (m := List)
#check bind (m := List) (α := A)
#check bind (m := List) (α := A) (β := B)
#check bind (α := A) (m := List) (β := B)

def myfst : {A:Type} → {B:Type} → A×B → A := fun (a,b) => a

#eval myfst                          ("a",2)
#eval myfst (A := String) (B := Nat) ("a",2)
#eval myfst (A := String)            ("a",2)
#eval myfst               (B := Nat) ("a",2)

#check myfst
#check myfst (A := String)
#check myfst               (B := Nat)
#check myfst (A := String) (B := Nat)

-- end




#####
#
# exploring-data
# 2024may25
#
#####

# «exploring-data»  (to ".exploring-data")
# (to "extractFrom")
# (to "getCurrNamespace")
# (to "backtick")
# (to "match-bar")
# (find-fline "~/TH/eev-lean4.blogme" "exploring-data")
# (find-fline "~/LOGS/2024may25.haskell")
# (find-fline "~/LOGS/2024may25.haskell" "let (Just x) = Nothing in length [x, x, x]")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/Tools.20for.20exploring.20data.20structures.3F
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

open Lean
#check Syntax
#check Syntax.mkNumLit
#check Syntax.mkNumLit "1"
#eval  Syntax.mkNumLit "1"
#check        mkAtom
#check        mkAtom "+"
#eval         mkAtom "+"
#check                           []
#check                          #[]
#check               `«term_+_»
#check        mkNode
#check        mkNode `«term_+_»
#check        mkNode `«term_+_» #[]
#eval         mkNode `«term_+_» #[]

def my1      := Syntax.mkNumLit "1"
def myadd    := mkIdent `Nat.add
def myplus   := `«term_+_»
def myadd11  := Syntax.mkApp myadd #[my1, my1]
def myplus11 := mkNode myplus #[my1, mkAtom "+", my1]

#eval  myadd11
#eval  Syntax.mkApp (mkIdent `Nat.add) #[Syntax.mkNumLit "1", Syntax.mkNumLit "1"]
#eval  mkNode `«term_+_» #[Syntax.mkNumLit "1", mkAtom "+", Syntax.mkNumLit "1"]
#eval  myplus11
#check myplus11
#check myplus11.raw
#eval  myplus11.raw

def Syntax.foo : Syntax → String
  | .missing              => "(m)"
  | .node  info kind args => "(n)"
  | .atom  info val       => "(a)"
  | .ident info rawVal val preresolved => "i"

def Name.foo : Name → String
  | .anonymous   => "(anon)"
  | .str pre str => str
  | .num pre i   => "num" ++ Name.foo pre

#eval            myplus
#eval            myplus11
#eval            myplus11.raw
#eval Syntax.foo myplus11.raw

#check Name
#check  myplus
#check Name.foo myplus
#eval  Name.foo myplus
#eval   myplus
#eval   myplus.str
#eval toString myplus
#eval repr myplus

macro "extractFrom " input:term " => " pat:term " => " result:term : term =>
  `(match ($input) with
     | some ($pat) => some ($result)
     | _ => none)

def a := some myadd11
#eval a
#check a
#check Syntax.node
def b := extractFrom a => Syntax.node info kind args => info  -- err

-- end



#####
#
# exploring-data-2
# 2024may26
#
#####

# «exploring-data-2»  (to ".exploring-data-2")
# (to "macro")
# (to "inductive-Option")
# (find-lean-links "matchAlt")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'matchAlt' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\" matchAlt \"' *")
# (find-lean4prefile "Lean/Parser/Term.lean" "def matchAlt ")
# (find-lean4prefile "Lean/Parser/Term.lean" "def matchAlts ")
# (find-lean4prefile "Lean/Expr.lean" "def mvarId! : Expr → MVarId")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

inductive N where
  | z         : N
  | s (n : N) : N
  deriving Repr

def c  := N.s (N.s N.z)

def b1 := match some c with
  | some (N.s x) => some x
  | _ => none

macro "extractFrom " input:term " => " pat:term " => " result:term : term =>
  `(match ($input) with
     | some ($pat) => some ($result)
     | _ => none)

def b2 := extractFrom some c => N.s x => x

#check b1
#eval  b1
#check b2
#eval  b2

#eval  extractFrom some (N.s N.z) => N.s x => x
#eval  extractFrom some      N.z  => N.s x => x

-- end









#####
#
# export
# 2024may23
#
#####

# «export»  (to ".export")
# (to "class")
# (find-lean-links "export")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'export' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\"export \"' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '«export»' *")
# (find-lean4prefile "Init/Prelude.lean" "export Decidable (isTrue isFalse decide)")
# (find-lean4prefile "Lean/Elab/BuiltinCommand.lean" "@[builtin_command_elab «export»] def elabExport")
# (find-fplean4page 252 "doesn't need to be written with the type class name before it")
# (find-fplean4text 252 "doesn't need to be written with the type class name before it")
# https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Naming.20convention/near/323311235
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

class      ToLuaTree (α : Type) where toLuaTree : α → String
instance : ToLuaTree String     where toLuaTree str := q str
instance : ToLuaTree Int        where toLuaTree n   := toString n
instance : ToLuaTree Nat        where toLuaTree n   := toString n

#check ToLuaTree.toLuaTree
#check ToLuaTree.toLuaTree ("ab" : String)
#check ToLuaTree.toLuaTree  "ab"

export ToLuaTree (toLuaTree)

#check toLuaTree "ab"
#check toLuaTree 42

namespace A def x := 37  end A
namespace B export A (x) end B
-- #check   x -- err: unknown identifier
   #check B.x -- A.x : Nat

-- end




#####
#
# Expr
# 2024jun02
#
#####

# «Expr»  (to ".Expr")
# (find-lean4prefile "Lean/Expr.lean" "inductive Expr where")
# (find-lean4prefile "Lean/Expr.lean" "def ctorName : Expr → String")
# (find-lean4prefile "Lean/Expr.lean" "def ctorName : Expr → String" "| forallE .. =>")
# (find-lean4prefile "Lean/Expr.lean" "However, expressions sent to the kernel should not")
# (find-lean4prefile "Lean/Expr.lean" "contain metavariables.")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\" \\.\\. \"' *")
# (find-leanmetadoc  "main/03_expressions")
# (find-leanmetadocr "main/03_expressions")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open   Lean
#check Expr

-- end





#####
#
# extends
# 2024jun01
#
#####

# «extends»  (to ".extends")
# (to "class")
# (to "Monad")
# (find-lean-links "extends")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

class Ca  (α : Type)              where ma : String
class Cb  (α : Type)              where mb : String
class Cbc (α : Type) extends Cb α where mc : String
inductive A where | a : A
instance : Ca  A where ma := "Ca.ma A"
instance : Cbc A where mb := "Cb.mb A"; mc := "Cbc.mc B"
#eval  Ca.ma  A
#eval  Cb.mb  A
#eval  Cbc.mc A

-- end






#####
#
# extern
# 2024mar23
#
#####

# «extern»  (to ".extern")
# (find-lean4prefile "Init/System/IO.lean" "@[extern \"lean_get_stdin\"] opaque getStdin")
# (find-lean4grep "grep --color=auto -nRH --null -e lean_get_stdin *")
# (find-lean4file "stage0/src/runtime/io.cpp" "lean_get_stdin")




#####
#
# extractFrom
# 2024may26
#
#####

# «extractFrom»  (to ".extractFrom")
# (to "exploring-data")
# (find-leanmetadoc  "main/06_macros#the-basics")
# (find-leanmetadocr "main/06_macros" "### The basics")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

macro "extractFrom " input:term " => " pat:term " => " result:term : term =>
  `(match ($input) with
     | some ($pat) => some ($result)
     | _ => none)

inductive N where
  | z         : N
  | s (n : N) : N
  deriving Repr

#eval                   (N.s N.z)
#eval              some (N.s N.z)
#eval  extractFrom some (N.s N.z) => N.s x => x
#eval  extractFrom some      N.z  => N.s x => x
#eval  extractFrom none           => N.s x => x

-- end






#####
#
# #eval
# 2024mar09
#
#####

# «eval»  (to ".eval")
# (find-fplean4page 12 "#eval (1 + 2 : Nat)")
# (find-fplean4text 12 "#eval (1 + 2 : Nat)")
# (find-fplean4page 88 "Running IO Actions With #eval")
# (find-fplean4text 88 "Running IO Actions With #eval")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'eval' *")
# (find-lean4pregrep "grep --color=auto -nwRH --null -e 'eval' *")
# (find-lean4pregrep "grep --color=auto -nwRH --null -e 'elabEval' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '#eval' *")
# (find-lean4prefile "Lean/Parser/Command.lean" "@[builtin_command_parser] def eval" "\"#eval \"")
# (find-lean4prefile "Lean/Elab/BuiltinCommand.lean" "@[builtin_command_elab «eval»,")
# (find-lean4prefile "Lean/Elab/BuiltinCommand.lean" "unsafe def elabEvalUnsafe : CommandElab")
# (find-lean4docrgrep "grep --color=auto -nRH --null -e '#eval' *")




#####
#
# example
# 2024mar11
#
#####

# «example»  (to ".example")
# (to "metaprogramming")
# (to "addDecl")
# (find-angg ".emacs.papers" "tpil4" "The example command")
# (find-tpil4page 29 "The example command")
# (find-tpil4text 29 "The example command")
# (find-lean4pregrep "grep --color=auto -nRH --null -e example *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e Parser.Command *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e Lean.Parser *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e Lean.Parser.Command *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e withoutModifyingEnv *")
# (find-lean4prefile "Lean/Elab/DefView.lean" "def | theorem | example | opaque | abbrev")
# (find-lean4prefile "Lean/Elab/DeclarationRange.lean" "Parser.Command.«example»")
# https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/name.20for.20syntax.20category.20of.20.60notation.60.2C.20.60namespace.60.2C.20.60def.60.2E.2E/near/446373495
# ^ "(It actually does create a declaration. It just then discards it via withoutModifyingEnv)."
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

variable (p q : Prop)

example (hp : p) (hq : q) : p ∧ q := And.intro hp hq

example (_ : Int)       := 42
example (_ : Int) : Int := 42

variable (P Q R : Prop)
variable {P Q R : Prop}
variable {p : P}
variable {q : Q}

example     (p : P) (q : Q) : P ∧ Q := And.intro p q
#check  fun (p : P) (q : Q)         => And.intro p q
#check (fun (p : P) (q : Q)         => And.intro p q : P → Q → P ∧ Q)

-- end




#####
#
# feline
# 2024jun20
#
#####

# «feline»  (to ".feline")
# (find-fplean4page 79 "Worked Example: cat")
# (find-fplean4text 79 "Worked Example: cat")
# (find-fplean4doc  "hello-world/cat")
# (find-fplean4docr "hello-world/cat")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

def bufsize : USize := 20 * 1024

partial def dump (stream : IO.FS.Stream) : IO Unit := do
  let buf ← stream.read bufsize
  if buf.isEmpty then
    pure ()
  else
    let stdout ← IO.getStdout
    stdout.write buf
    dump stream

#check Stream

def fileStream (filename : System.FilePath) : IO (Option IO.FS.Stream) := do
  let fileExists ← filename.pathExists
  if not fileExists then
    let stderr ← IO.getStderr
    stderr.putStrLn s!"File not found: {filename}"
    pure none
  else
    let handle ← IO.FS.Handle.mk filename IO.FS.Mode.read
    pure (some (IO.FS.Stream.ofHandle handle))

def process (exitCode : UInt32) (args : List String) : IO UInt32 := do
  match args with
  | [] => pure exitCode
  | "-" :: args =>
    let stdin ← IO.getStdin
    dump stdin
    process exitCode args
  | filename :: args =>
    let stream ← fileStream ⟨filename⟩
    match stream with
    | none =>
      process 1 args
    | some stream =>
      dump stream
      process exitCode args

def main (args : List String) : IO UInt32 :=
  match args with
  | [] => process 0 ["-"]
  | _ =>  process 0 args


-- end




#####
#
# Finset-comprehensions
# 2024jun29
#
#####

# «Finset-comprehensions»  (to ".Finset-comprehensions")
# https://github.com/leanprover-community/mathlib4/pull/11582
# (find-sh "locate -i finset")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

#check Data.Finset.Basic

-- end




#####
#
# FFI
# 2024jun20
#
#####

# «FFI»  (to ".FFI")
# (find-sh "locate -i lean4/src | grep -i ffi")
# (find-lean4file "src/lake/examples/ffi/")
# (find-lean4file "src/Lean/Compiler/FFI.lean")
# (find-lean4page 121 "@[extern \"foreign_function\"]")
# (find-lean4text 121 "@[extern \"foreign_function\"]")
# (find-lean4page 153 "Foreign Function Interface")
# (find-lean4text 153 "Foreign Function Interface")
# (find-lean4doc "dev/ffi")



#####
#
# FilePath
# 2024jun15
#
#####

# «FilePath»  (to ".FilePath")
# (find-lean4prefile "Init/System/FilePath.lean")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
#check System.FilePath
#eval  (.mk "a" / "b.lean" : System.FilePath)

-- end





#####
#
# FirstTokens
# 2024may17
#
#####

# «FirstTokens»  (to ".FirstTokens")
# (to "leading_parser")
# (find-lean4pregrep "grep --color=auto -niRH --null -e 'firsttokens' *")
# (find-lean4prefile "Lean/Parser/Types.lean" "inductive FirstTokens where")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import    Lean.Parser.Term
import    Lean.Parser.Types
namespace Lean.Parser
def foo := leading_parser "foo "
#print   foo
#check   foo
#check   foo.info
#check   foo.info.firstTokens
#eval    foo.info.firstTokens
def a := foo.info.firstTokens
def b := FirstTokens.tokens ["$", "bar"]
#check a
#eval  a
#print a
#print b

namespace Types
#check FirstTokens
#check FirstTokens.epsilon
#eval  FirstTokens.epsilon
#check  ("a" : Token)
#check [("a" : Token), ("b" : Token)]
#check FirstTokens.tokens [("a" : Token), ("b" : Token)]
#check FirstTokens.tokens ["a", "b"]

#eval  foo.info.firstTokens

-- end






#####
#
# fun
# 2024mar22
#
#####

# «fun»  (to ".fun")
# (find-lean4doc  "functions")
# (find-lean4docr "functions.md")
# (find-tpil4doc)
# (find-tpil4doc  "dependent_type_theory")
# (find-tpil4doc  "dependent_type_theory#function-abstraction-and-evaluation")
# (find-tpil4docr "dependent_type_theory" "## Function Abstraction and Evaluation")
# (find-tpil4docr "dependent_type_theory" "`fun` (or `λ`)")
# (find-tpil4doc  "propositions_and_proofs")
# (find-tpil4doc  "propositions_and_proofs#propositions-as-types")
# (find-tpil4docr "propositions_and_proofs" "Propositions as Types")
# (find-tpil4docr "propositions_and_proofs" "``(fun x => t) s`` and ``t[s/x]``")
# (find-fplean4page 54 "Anonymous Functions")
# (find-fplean4text 54 "Anonymous Functions")
# (find-fplean4page 55 "centered dot")
# (find-fplean4text 55 "centered dot")
# (find-lean4prefile "Lean/Parser/Term.lean" "@[builtin_term_parser] def «fun»")
# (find-lean4prefile "Lean/Elab/Binders.lean" "@[builtin_term_elab «fun»]")
# (find-lean4prefile "Lean/Parser/Basic.lean" "def unicodeSymbol")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

#check fun  x        => x + 1
#check fun (x : Int) => x + 1
#check fun {α : Type} (x : α) => x

#check fun  x y                => x + y
#check fun (x : Int)  y        => x + y
#check fun (x : Int) (y : Int) => x + y
#check fun (x y : Int)         => x + y

#check (fun  x y               => x + y : Int → Int → Int)
#check  42
#check (42 : Int)

-- end




#####
#
# Functor
# 2024jun17
#
#####

# «Functor»  (to ".Functor")
# (to "LawfulFunctor")
# (find-lean4prefile "Init/Prelude.lean" "class Functor (f : Type u → Type v)")
# (find-books "__comp/__comp.el" "haskell-hutton")
# (find-books "__comp/__comp.el" "haskell-hutton" "182" "12.1     Functors")
# (find-lean-links "Functor")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'Functor' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'Functor' * | grep -a extends")
# (find-lean4pregrep "grep --color=auto -nRHw --null -e 'Functor' * | grep -a instance")

class Functor (f : Type → Type) : Type where map : {α β : Type} → (α → β) → f α → f β




#####
#
# getCurrNamespace
# 2024may18
#
#####

# «getCurrNamespace»  (to ".getCurrNamespace")
# (to "where")
# (to "run_cmd")
# (to "exploring-data")
# (find-lean-links "getCurrNamespace")
# (find-lean4prefile "Init/Prelude.lean" "def getCurrNamespace : MacroM Name := do")
# (find-THfile "eev-lean4.blogme" "getCurrNamespace")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
namespace Foo
run_cmd Lean.logInfo (← Lean.getCurrNamespace)

-- end



#####
#
# #guard_msgs
# 2024jun02
#
#####

# «guard_msgs»  (to ".guard_msgs")
# (find-lean4prefile "Lean/Elab/GuardMsgs.lean" "`#guard_msgs` command for testing commands")
# (find-leanmetadoc  "main/01_intro#building-a-command")
# (find-leanmetadocr "main/01_intro" "### Building a command")
# (find-leanmetadocr "main/01_intro" "### Building a command" "#guard_msgs")




#####
#
# guillemets
# 2024mar23
#
#####

# «guillemets»  (to ".guillemets")
# (find-fplean4page 76 "guillemets around a name")
# (find-fplean4text 76 "guillemets around a name")
# (find-lean4prefile "Lean/Parser/Extra.lean" "disallowed characters in identifiers")



#####
#
# HashMap
# 2024jun13
#
#####

# «HashMap»  (to ".HashMap")
# (find-lean4presh "find * | sort")
# (find-lean4presh "find * | sort | grep -i hash")
# (find-lean4presh "find * | sort | grep -i hash | grep build")
# (find-lean4presh "find * | sort | grep -i hash | grep -v build")
# (find-lean4prefile "Lean/Data/HashMap.lean")
# (find-lean4prefile "Lean/Data/HashMap.lean" "def ofList (l : List (α × β)) : HashMap α β :=")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/How.20to.20use.20a.20hashmap.3F
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
/-!
A very quick tutorial for using `HashMap`s
-/

open Lean

/-- using `HashMap.empty` and `HashMap.insert` -/
def myHM : HashMap Nat String := HashMap.empty
  |>.insert 1 "one"
  |>.insert 2 "two"
  |>.insert 3 "three"

--  the above is just for "clean" formatting: you could also write
--  `def myHM1 : HashMap Nat String := ((HashMap.empty.insert 1 "one").insert 2 "two").insert 3 "three"`

-- Now also `HashMap.find?` and `HashMap.contains`
#eval myHM.find? 1  -- `some "one"`
#eval myHM.find? 4  -- `none`
#eval myHM.contains 1  -- `true`
#eval myHM.contains 4  -- `false`

-- to print a HashMap, convert it to a `List` or an `Array`
#eval IO.println myHM.toArray -- #[(1, one), (2, two), (3, three)]
#eval IO.println myHM.toList  -- [(3, three), (2, two), (1, one)]

-- end



import Lean.Data.HashMap
open Lean.HashMap

def a := [("one", 1), ("two", 2)]
#check a
#eval ofList a   -- err





#####
#
# have
# 2024apr30
#
#####

# «have»  (to ".have")
# (find-lean-links "have")
# (find-angg ".emacs.papers" "tpil4")
# (find-tpil4file "propositions_and_proofs.md" "the ``have`` construct")
# (find-tpil4page  33 "3.4. Introducing Auxiliary Subgoals")
# (find-tpil4text  33      "Introducing Auxiliary Subgoals")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'have' *")
# (find-lean4prefile "Lean/Elab/Do.lean" "def getDoHaveVars (doHave : Syntax)")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

variable (P Q : Prop)

example (paq : P ∧ Q) : Q ∧ P :=
  have p : P := paq.left
  have q : Q := paq.right
  show Q ∧ P from And.intro q p

-- end





#####
#
# heterogeneous
# 2024may19
#
#####

# «heterogeneous»  (to ".heterogeneous")
# (to "coercion")
# (find-lean4pregrep "grep --color=auto -nRH --null -e Nat * | grep -a Int")
# (find-lean4pregrep "grep --color=auto -nRH --null -e Nat * | grep -a Int | grep -a Coe")
# (find-lean4pregrep "grep --color=auto -nRH --null -e ofNat *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\" + \"' *")
# (find-lean4pregrep "grep --color=auto -niRH --null -e 'HAdd' *")
# (find-lean4pregrep "grep --color=auto -niRH --null -e 'hAdd' *")
# (find-lean4pregrep "grep --color=auto -niRH --null -e 'heterogeneous' *")
# (find-lean4prefile "Init/Notation.lean" "@[inherit_doc] infixl:65 \" + \"   => HAdd.hAdd")
# (find-lean4prefile "Init/Prelude.lean" "heterogeneous addition")
# (find-lean4prefile "Init/Prelude.lean" "instance [Add α] : HAdd α α α where")
# (find-lean4prefile "Init/Prelude.lean" "class OfNat (α : Type u) (_ : Nat) where")
# (find-lean4prefile "Init/Coe.lean" "# Coercion")
# (find-lean4prefile "Init/Coe.lean" "instance : Coe Nat Int := ⟨Int.ofNat⟩")
# (find-fplean4page 105 "Overloaded Addition")
# (find-fplean4text 105 "Overloaded Addition")
# (find-fplean4doc "type-classes/pos#overloaded-addition")
# (find-fplean4doc "type-classes/coercion")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

#check (2 : Nat) + (3 : Int)    -- ↑2 + 3 : Int

-- end




#####
#
# Id.run
# 2024may21
#
#####

# «Id.run»  (to ".Id.run")
# (to "Monad-S")
# (to "run_cmd")
# (to "show-from-do")
# (to "do-for-in")
# invalid `do` notation, expected type is not a monad application
# You can use the `do` notation in pure code by writing `Id.run do`
# instead of `do`, where `Id` is the identity monad. (lsp)

# (find-fplean4doc "monads/class#the-identity-monad")

# (find-lean-links "Id.run")
# (find-lean4prefile "Lean/Elab/Do.lean" "`do` notation in pure code by writing `Id.run do`")
# (find-lean4prefile "Init/Control/Id.lean" "protected def run (x : Id α) : α := x")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'Id.run' *")

# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

#check                      do return 42
#check show Nat from        do return 42  -- err
#check               Id.run do return 42
#check show Nat from Id.run do return 42

instance : Monad List  where
  pure := List.pure
  bind := List.bind

#check show List Nat from                  [2, 3]
#check show List Nat from        do return [2, 3]  -- err
#check show List Nat from Id.run do return [2, 3]

-- end



#####
#
# if-let
# 2024may25
#
#####

# «if-let»  (to ".if-let")
# (find-fplean4page 57 "if let")
# (find-fplean4text 57 "if let")
# (find-fplean4page 271 "Single-Branched if")
# (find-fplean4text 271 "Single-Branched if")
# (find-fplean4doc "getting-to-know/conveniences#if-let")
# (find-fplean4doc "monad-transformers/do#single-branched-if")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

inductive B where    -- binary tree
  | n (n : Nat)       : B
  | b (l : B) (r : B) : B

def foo (b : B) : Option Nat :=
  if let B.b bl _ := b then
    if let B.b _ blr := bl then
      if let B.n blrn := blr then
        some blrn
      else none
    else none
  else none

#check     B.b (.b (.n 1) (.n 2)) (.n 3)
#eval foo (B.b (.b (.n 1) (.n 2)) (.n 3))

-- end




#####
#
# import
# 2024mar31
#
#####

# «import»  (to ".import")
# (to "lake-current-directory")
# (to "namespace")
# (to "modules")
# (find-lean-links "import")
# (find-fplean4page 76 "The import line")
# (find-fplean4text 76 "The import line")
# (find-fplean4page 77 "Libraries and Imports")
# (find-fplean4text 77 "Libraries and Imports")
# (find-fplean4page 77 "decoupled from the namespace hierarchy")
# (find-fplean4text 77 "decoupled from the namespace hierarchy")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'import' *")
# (find-leanrefdoc "using_lean#import-resolution")
# (find-fplean4doc "hello-world/starting-a-project")
# (find-fplean4doc "hello-world/starting-a-project#first-steps")
# (find-fplean4doc "hello-world/starting-a-project#lakefiles")
# (find-fplean4doc "hello-world/starting-a-project#libraries-and-imports")
# (find-fplean4doc "hello-world/starting-a-project#libraries-and-imports" "decoupled")



#####
#
# import-problem
# 2024jun09
#
#####

# «import-problem»  (to ".import-problem")
# (find-TH "eev-lean4" "import")
# (to "lake-env")
# (to "server")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/Need.20help.20to.20debug.20an.20import.20-.20and.20maybe.20a.20lakefile

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
rm -Rfv /tmp/import-test/

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
rm -Rfv /tmp/import-test/
mkdir   /tmp/import-test/
cd      /tmp/import-test/

cat > A.lean <<'%%%'
  def a := "42"
  #eval a
%%%
cat > B.lean <<'%%%'
  -- (lsp-describe-session)
  import A
  #eval a
  def main : IO Unit := IO.println s!"Hello {a}"
%%%
cat > lakefile.lean <<'%%%'
  import Lake
  open   Lake DSL
  package A
  @[default_target] lean_lib A
  @[default_target] lean_exe b { root := `B } 
%%%

 lake build            ;# ok
.lake/build/bin/b      ;# ok
lean A.lean            ;# ok
lean B.lean            ;# unknown package 'A'
lake env lean B.lean   ;# ok
lake env

find * .lake/ | sort

# (find-fline "/tmp/import-test/")
# (find-fline "/tmp/import-test/A.lean")
# (find-fline "/tmp/import-test/B.lean")

# (code-c-d "importtest" "/tmp/import-test/")
# (find-importtestfile "")
# (find-importtestfile "A.lean")
# (find-importtestfile "B.lean")
# (find-importtestsh "find * .lake/ | sort")







#####
#
# indentation
# 2024mar09
#
#####

# «indentation»  (to ".indentation")
# (to "let")
# (find-fplean4-links "semicolon")
# (find-fplean4page 88 "This version uses only whitespace-sensitive layout")
# (find-fplean4text 88 "This version uses only whitespace-sensitive layout")

# (find-fplean4doc  "getting-to-know/conveniences#local-definitions")
# (find-fplean4docr "getting-to-know/conveniences" "## Local Definitions")
# (find-fplean4docr "getting-to-know/conveniences" "## Local Definitions" "semicolon")

# (find-fplean4page 87 "Flexible Layouts for do")
# (find-fplean4text 87 "Flexible Layouts for do")
# (find-fplean4page 87 "all of the following programs are equivalent")
# (find-fplean4text 87 "all of the following programs are equivalent")
# (find-fplean4doc  "hello-world/conveniences#flexible-layouts-for-do")
# (find-fplean4docr "hello-world/conveniences" "## Flexible Layouts for `do`")
# (find-fplean4docr "hello-world/conveniences" "## Flexible Layouts for `do`" "semicolon")
# (find-fplean4docr "hello-world/conveniences" "all of the following programs are equivalent")
# (find-fplean4file "examples/Examples/Cat.lean" "book declaration {{{ helloOne }}}")

(find-lean4prefile "Lean/Parser/Command.lean" "def structFields " "manyIndent")





#####
#
# inductive
# 2024mar23
#
#####

# «inductive»  (to ".inductive")
# (to "mutual")
# (to "structure")
# (find-fplean4page 26 "inductive Bool where")
# (find-fplean4text 26 "inductive Bool where")
# (find-fplean4page 58 "Positional Structure Arguments")
# (find-fplean4text 58 "Positional Structure Arguments")
# (find-fplean4page 129 "inductive BinTree")
# (find-fplean4text 129 "inductive BinTree")
# (find-lean4prefile "Lean/Elab/Declaration.lean" "leading_parser \"inductive \"")
# (find-lean4presh "find * | sort | grep -i inductive")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

-- end






#####
#
# inductive-Arith
# 2024may12
#
#####

# «inductive-Arith»  (to ".inductive-Arith")
# (to "p123456")
# (find-leanmetadoc  "main/01_intro#building-a-dsl-and-a-syntax-for-it")
# (find-leanmetadocr "main/01_intro" "### Building a DSL and a syntax for it")
# (find-lean4prefile "Lean/Parser/Syntax.lean" "declare_syntax_cat")
# (find-lean4prefile "Lean/Parser/Syntax.lean" "def catBehavior :=")
# (find-lean4prefile "Lean/Elab/Syntax.lean"     "@[builtin_command_elab «syntax»]")
# (find-lean4prefile "Lean/Elab/MacroRules.lean" "@[builtin_command_elab «macro_rules»]")
# (find-lean4prefile "Lean/Parser/Syntax.lean" "@[builtin_command_parser] def «syntax»")
# (find-lean4prefile "Lean/Parser/Syntax.lean" "@[builtin_command_parser] def «macro_rules»")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

inductive Arith : Type where
  | add : Arith → Arith → Arith -- e + f
  | mul : Arith → Arith → Arith -- e * f
  | nat : Nat → Arith           -- constant
  | var : String → Arith        -- variable

declare_syntax_cat arith
syntax num                        : arith -- nat for Arith.nat
syntax str                        : arith -- strings for Arith.var
syntax:50 arith:50 " + " arith:51 : arith -- Arith.add
syntax:60 arith:60 " * " arith:61 : arith -- Arith.mul
syntax " ( " arith " ) "          : arith -- bracketed expressions

syntax " <. " arith " .> " : term

macro_rules
  | `(<. $s:str .>)              => `(Arith.var $s)
  | `(<. $num:num .>)            => `(Arith.nat $num)
  | `(<. $x:arith + $y:arith .>) => `(Arith.add <. $x .> <. $y .>)
  | `(<. $x:arith * $y:arith .>) => `(Arith.mul <. $x .> <. $y .>)
  | `(<. ( $x ) .>)              => `( <. $x .> )

#check <. "x" * "y" .>
#check <. "x" + "y" .>
#check <. "x" + 20 .>
#check <. "x" + "y" * "z" .> -- precedence
#check <. "x" * "y" + "z" .> -- precedence
#check <. ("x" + "y") * "z" .> -- brackets

-- end


#check <. ("x"      +       20) *    "z"   .>
           --------   --------    --------
              str        num        str
           --------   --------    
           arith:50   arith:51
           -------------------
                arith:50
          ---------------------
                arith          
          ---------------------   --------
                arith:60          arith:61
           -------------------------------
                      arith:60
       --------------------------------------
                    term



#####
#
# inductive-Expr
# 2024may12
#
#####

# «inductive-Expr»  (to ".inductive-Expr")
# (find-leanmetadoc  "main/03_expressions")
# (find-leanmetadocr "main/03_expressions")
# https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/Creating.20Expr.20objects




#####
#
# inductive-List
# 2024may13
#
#####

# «inductive-List»  (to ".inductive-List")
# (find-fplean4page 37 "inductive List")
# (find-fplean4text 37 "inductive List")
# (find-lean4prefile "Init/Prelude.lean" "inductive List")
# (find-lean4prefile "Init/Data/List/Basic.lean" "syntax \"[\"")
# (find-lean4prefile "Init/Notation.lean" "@[inherit_doc] infixr:67 \" :: \" => List.cons")



#####
#
# inductive-N
# 2024may30
#
#####

# «inductive-N»  (to ".inductive-N")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

inductive N where
  | z         : N
  | s (n : N) : N
  deriving Repr

def   ssz_a  := N.s (N.s N.z)
#eval ssz_a

open N
def   ssz_b := s (s z)
#eval ssz_b

-- end




#####
#
# inductive-Nat
# 2024may13
#
#####

# «inductive-Nat»    (to ".inductive-Nat")
# «inductive-myNat»  (to ".inductive-myNat")
# (find-fplean4page 27 "inductive Nat")
# (find-fplean4text 27 "inductive Nat")
# (find-fplean4page 31 "def plus")
# (find-fplean4text 31 "def plus")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

inductive myNat where
  | zero             : myNat
  | succ (n : myNat) : myNat

def my1 := myNat.succ myNat.zero

def my23 := match my1 with
  | myNat.zero   => 2
  | myNat.succ _ => 3

def myIncomplete := match my1 with
  | myNat.zero   => 42

-- end





#####
#
# inductive-Option
# 2024may15
#
#####

# «inductive-Option»  (to ".inductive-Option")
# (find-fplean4page 40 "inductive Option")
# (find-fplean4text 40 "inductive Option")
# (find-fplean4page 40 "def List.head?")
# (find-fplean4text 40 "def List.head?")
# (find-fplean4doc "getting-to-know/polymorphism#more-built-in-datatypes")
# (find-fplean4doc "getting-to-know/polymorphism#option")
# (find-fplean4doc "monads/arithmetic#evaluating-expressions")
# (find-lean4prefile "Init/Prelude.lean" "inductive Option ")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

#check List.head?

def List.myhead? {α : Type} (xs : List α) : Option α :=
  match xs with
  | [] => none
  | y :: _ => some y

#eval [].myhead?
#eval [].myhead? (α := Int)
#eval ([] : List Int).myhead?

-- end





#####
#
# inductive-Syntax
# 2024may15
#
#####

# «inductive-Syntax»  (to ".inductive-Syntax")
# (find-lean-links "Syntax")
# (find-leanmetadocrfile "main/01_intro.lean" "Concrete Syntax Tree, Lean's `Syntax` type")
# (find-leanmetadocrgrep "grep --color=auto -nRH --null -e 'Syntax' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'Syntax' *")
# (find-lean4pregrep "grep --color=auto -nRHw --null -e 'Syntax' *")
# (find-lean4prefile "Lean/Syntax.lean")
# (find-lean4prefile "Init/Prelude.lean" "inductive Syntax where")
# (find-lean4prefile "Init/Prelude.lean" "inductive SourceInfo where")
# (find-leanmetadoc  "extra/03_pretty-printing")
# (find-leanmetatext 1 "let stx : Syntax")
# (find-leanmetapage 47 "let stx : Syntax")
# (find-leanmetatext 47 "let stx : Syntax")
# (find-leanmetapage 54 "Operating on Syntax")
# (find-leanmetatext 54 "Operating on Syntax")
# (find-leanmetapage 55 "Matching on Syntax")
# (find-leanmetatext 55 "Matching on Syntax")
# (find-leanmetadoc  "main/04_metam#exercises" "let stx : Syntax")
# (find-leanmetadocr "main/04_metam#exercises" "let stx : Syntax")
# (find-leanmetadoc  "main/05_syntax")
# (find-leanmetadoc  "main/05_syntax#operating-on-syntax")
# (find-leanmetadocr "main/05_syntax" "## Operating on Syntax")
# (find-leanmetadoc  "main/05_syntax#matching-on-syntax")
# (find-leanmetadocr "main/05_syntax" "### Matching on `Syntax`")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

-- end



#####
#
# inferInstance
# 2024may23
#
#####

# «inferInstance»  (to ".inferInstance")
# (to "Inhabited")
# (find-lean4prefile "Init/Prelude.lean" "#check (inferInstance : Inhabited Nat)")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

#check (inferInstance : Inhabited Nat) -- Inhabited Nat
def foo : Inhabited (Nat × Nat) := inferInstance
example : foo.default = (default, default) := rfl

-- end



#####
#
# inferType
# 2024jun12
#
#####

# «inferType»  (to ".inferType")
# (to "runTermElabM")
# (to "repr-type")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/Is.20there.20a.20variant.20of.20repr.20that.20.22prints.20the.20type.22.3F
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean

open Lean Elab Command Meta

elab "#my_check " t:term : command => do
  runTermElabM fun _ => do -- go into term elaboration mode after processing any `variables` commands
    let e ← Term.elabTermAndSynthesize t none -- elaborate `t` and run all elaboration tasks to completion
    let eTy ← inferType e --  compute the type of `e`
    logInfo m!"{e} : {eTy}" -- log a MessageData with `e` and `eTy` embedded into it

#my_check "s"
-- "s" : String

-- end






#####
#
# infix
# 2024mar11
#
#####

# «infix»   (to ".infix")
# «infixl»  (to ".infixl")
# «infixr»  (to ".infixr")
# (find-fplean4page 153 "Infix Operators")
# (find-fplean4text 153 "Infix Operators")
# (find-fplean4page 153 "infixl:55 \" ~~> \" => andThen")
# (find-fplean4text 153 "infixl:55 \" ~~> \" => andThen")

# (find-leanmetadocr "main/05_syntax" "infixl:60 \" ⊕ \" => fun l r => (!l && r) || (l && !r)")

# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

inductive myNat where
  | zero             : myNat
  | succ (n : myNat) : myNat

def my1 := myNat.succ myNat.zero

def my23 := match my1 with
  | myNat.zero   => 2
  | myNat.succ _ => 3

def myIncomplete := match my1 with
  | myNat.zero   => 42

-- end



#####
#
# info-scp-mainModule
# 2024jun08
#
#####

# «info-scp-mainModule»  (to ".info-scp-mainModule")
# (to "mkSyntaxQuotation")
# (to "backtick-syntaxcat")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
#check Lean.Elab.Term.Quotation.mkSyntaxQuotation
open   Lean.Elab.Term.Quotation
#check mkSyntaxQuotation

#check mkSyntaxQuotation
#check  `(42 + "foo")
#check (`(42 + "foo") : Lean.MacroM                  (Lean.TSyntax `term))

-- end






#####
#
# Inhabited
# 2024may23
#
#####

# «Inhabited»  (to ".Inhabited")
# (to "inferInstance")
# (find-lean4page 83 "inhabited and non empty")
# (find-lean4text 83 "inhabited and non empty")
# (find-lean4prefile "Init/Prelude.lean" "class Inhabited (α : Sort u) where")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'Inhabited' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'inhabited and' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'instance : Inhabited' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'deriving Inhabited' *")
# (find-lean4prefile "Lean/Elab/PreDefinition/MkInhabitant.lean" "inhabited and non empty")

failed to compile partial definition 'toLTree_Syntax', failed to show
that type is inhabited and non empty




#####
#
# initialize
# 2024may29
#
#####

# «initialize»  (to ".initialize")
# (to "lake-new-greeting")
# (find-lean-links "initialize")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'initialize' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'initialize' * | grep -aw initialize")
# (find-lean4prefile "Lean/Elab/Declaration.lean" "@[builtin_macro Lean.Parser.Command.«initialize»]")
# (find-lean4prefile "Lean/Parser/Command.lean" "@[builtin_command_parser] def «initialize» :=")
# (find-lean4prefile "Lean/Environment.lean" "are declared using the `initialize` command")





#####
#
# instance
# 2024mar14
#
#####

# «instance»  (to ".instance")
# (to "class")
# (to "Repr")
# (to "instance-Monad-List")
# (find-fplean4doc  "index")
# (find-fplean4doc "type-classes/pos#classes-and-instances")
# (find-fplean4doc "type-classes/pos#classes-and-instances")
# (find-fplean4page 104 "Classes and Instances")
# (find-fplean4text 104 "Classes and Instances")
# (find-fplean4page 104 "instance : Plus Nat where")
# (find-fplean4text 104 "instance : Plus Nat where")

# (find-tpil4doc  "type_classes")
# (find-tpil4docr "type_classes")
# (find-tpil4doc  "type_classes#chaining-instances")
# (find-tpil4docr "type_classes" "## Chaining Instances")
# (find-tpil4page 157 "Type Classes")
# (find-tpil4text 157 "Type Classes")
# (find-tpil4page 160 "Chaining Instances")
# (find-tpil4text 160 "Chaining Instances")

# (find-lean4doc  "typeclass")
# (find-lean4docr "typeclass.md")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'instance' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'instance \\[' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'instance :' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'instance' * | grep -a Repr")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'instance' * | grep -a Command")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'Command.instance' *")
# (find-lean4prefile "Lean/Parser/Command.lean" "@[builtin_command_parser] def declaration :=")
# (find-lean4prefile "Lean/Parser/Command.lean" "def «instance\ »       := leading_parser")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

-- end





#####
#
# instance-implicits
# 2024jun12
#
#####

# «instance-implicits»  (to ".instance-implicits")
# (to "Options")
# (find-fplean4page 112 "in square brackets are called instance implicits")
# (find-fplean4text 112 "in square brackets are called instance implicits")
# (find-lean4pregrep "grep --color=auto -niRH --null -e 'instance' * | grep -ai implicit")
# (find-lean4pregrep "grep --color=auto -niRH --null -e 'instance \\[' *")
# (find-lean4prefile "Lean/Log.lean" "variable [Monad m] [MonadLog m] [AddMessageContext m]")
# (find-lean4prefile "Lean/PrettyPrinter/Delaborator/Options.lean" "pp.instances")
# (find-lean4prefile "Init/Control/State.lean" "instance [Alternative m] : Alternative (StateT σ m) wh")
# (find-lean4prefile "Lean/Parser/Term.lean" "An instance binder `[A]` or `[x : A]`")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

def foo1 [Monad m] [MonadState σ m] (a : Nat) : m Nat := show m Nat from do return a
def foo2 [Monad m] [MonadState σ m] (a : Nat) : m Nat :=                 do return a

def foo3 [i1 : Monad m] [i2 : MonadState σ m] (a : Nat) : m Nat := do
  let xxxxxxxx := 42
  let b ← get
  -- let c ← bind
--return _
  return a

#check foo1
#check foo2

-- end
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open   Lean
#check logInfo
#check logInfo "a"

set_option pp.all true  in
#check logInfo "a"
set_option pp.all false in
#check logInfo "a"
set_option pp.beta true  in
#check logInfo "a"
set_option pp.beta false in
#check logInfo "a"
set_option pp.coercions true  in
#check logInfo "a"
set_option pp.coercions false in
#check logInfo "a"
set_option pp.deepTerms true  in
#check logInfo "a"
set_option pp.deepTerms false in
#check logInfo "a"
set_option pp.deepTerms.threshold true  in
#check logInfo "a"
set_option pp.deepTerms.threshold false in
#check logInfo "a"
set_option pp.explicit true  in
#check logInfo "a"
set_option pp.explicit false in
#check logInfo "a"
set_option pp.fullNames true  in
#check logInfo "a"
set_option pp.fullNames false in
#check logInfo "a"
set_option pp.funBinderTypes true  in
#check logInfo "a"
set_option pp.funBinderTypes false in
#check logInfo "a"
set_option pp.instanceTypes true  in
#check logInfo "a"
set_option pp.instanceTypes false in
#check logInfo "a"
set_option pp.instances true  in
#check logInfo "a"
set_option pp.instances false in
#check logInfo "a"
set_option pp.instantiateMVars true  in
#check logInfo "a"
set_option pp.instantiateMVars false in
#check logInfo "a"
set_option pp.letVarTypes true  in
#check logInfo "a"
set_option pp.letVarTypes false in
#check logInfo "a"
set_option pp.match true  in
#check logInfo "a"
set_option pp.match false in
#check logInfo "a"
set_option pp.motives.all true  in
#check logInfo "a"
set_option pp.motives.all false in
#check logInfo "a"
set_option pp.motives.nonConst true  in
#check logInfo "a"
set_option pp.motives.nonConst false in
#check logInfo "a"
set_option pp.motives.pi true  in
#check logInfo "a"
set_option pp.motives.pi false in
#check logInfo "a"
set_option pp.natLit true  in
#check logInfo "a"
set_option pp.natLit false in
#check logInfo "a"
set_option pp.notation true  in
#check logInfo "a"
set_option pp.notation false in
#check logInfo "a"
set_option pp.numericTypes true  in
#check logInfo "a"
set_option pp.numericTypes false in
#check logInfo "a"
set_option pp.piBinderTypes true  in
#check logInfo "a"
set_option pp.piBinderTypes false in
#check logInfo "a"
set_option pp.privateNames true  in
#check logInfo "a"
set_option pp.privateNames false in
#check logInfo "a"
set_option pp.proofs true  in
#check logInfo "a"
set_option pp.proofs false in
#check logInfo "a"
set_option pp.proofs.threshold true  in
#check logInfo "a"
set_option pp.proofs.threshold false in
#check logInfo "a"
set_option pp.proofs.withType true  in
#check logInfo "a"
set_option pp.proofs.withType false in
#check logInfo "a"
set_option pp.safeShadowing true  in
#check logInfo "a"
set_option pp.safeShadowing false in
#check logInfo "a"
set_option pp.structureInstanceTypes true  in
#check logInfo "a"
set_option pp.structureInstanceTypes false in
#check logInfo "a"
set_option pp.structureInstances true  in
#check logInfo "a"
set_option pp.structureInstances false in
#check logInfo "a"
set_option pp.structureProjections true  in
#check logInfo "a"
set_option pp.structureProjections false in
#check logInfo "a"
set_option pp.tagAppFns true  in
#check logInfo "a"
set_option pp.tagAppFns false in
#check logInfo "a"
set_option pp.unicode.fun true  in
#check logInfo "a"
set_option pp.unicode.fun false in
#check logInfo "a"
set_option pp.universes true  in
#check logInfo "a"
set_option pp.universes false in
#check logInfo "a"

-- end





#####
#
# instance : Monad List
# 2024may18
#
#####

# «instance-Monad-List»  (to ".instance-Monad-List")
# (to "instance")
# (2024tinsp 2 "instance-Monad-List")
# (2024tinsa   "instance-Monad-List")
# (find-es "haskell" "list-comprehensions")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'instance' * | grep -a Monad")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'instance' * | grep -a List")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'instance' * | grep -a Monad | grep -a List")
# (find-lean4doc  "monads/monads.lean#example-using-list")
# (find-lean4docr "monads/monads.lean" "## Example using List")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

instance : Monad List where
  pure := List.pure
  bind := List.bind

inductive A where |a1:A |a2:A deriving Repr
inductive B where |b1:B |b2:B deriving Repr
open A B
#eval do let a←[a1,a2]; let b←[b1,b2]; return (a,b)
#eval bind [a1,a2]  fun a   => bind [b1,b2]  fun b   => pure (a  ,b  )
--         --------     ---         --------     ---          --- ---
--         : List A     : A         : List B     : B          : A : B
--                                                           ---------
--                                                           : A×B
--                                                      --------------
--                                                      : List A×B
--                                           --------------------------
--                                           : B → List A×B
--                             ----------------------------------------
--                             : List A×B
--                  ---------------------------------------------------
--                  : A → List A×B
--     ----------------------------------------------------------------
--     : List A×B

def foo := do let a←[a1,a2]; let b←[b1,b2]; return (a,b)

set_option pp.all true in
#print foo

#check Bind.bind

-- end




#####
#
# intercalate
# 2024jul12
#
#####

# «intercalate»  (to ".intercalate")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

open   String
#check intercalate
#eval  intercalate "," ["a", "b", "c"]

-- end





#####
#
# interpolatedStr
# 2024may16
#
#####

# «interpolatedStr»  (to ".interpolatedStr")
# (to "string-interpolation")
# (to "checksyntax-test")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 's!' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'interpolatedStr' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'syntax:max \"s!\"' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'syntax:max \"m!\"' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'syntax:max \"f!\"' *")
# (find-lean4prefile "Lean/Parser/StrInterpolation.lean")
# (find-lean4prefile "Init/Data/ToString/Macro.lean" "syntax:max \"s!\"")
# (find-lean4prefile "Lean/Message.lean"             "syntax:max \"m!\"")
# (find-lean4prefile "Init/Data/Format/Macro.lean"   "syntax:max \"f!\"")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

#check m!"a{2+3}b"
#check s!"a{2+3}b"
#check f!"a{2+3}b"

-- end






#####
#
# IO
# 2024jun01
#
#####

# «IO»  (to ".IO")
# (find-lean4prefile "Init/System/IO.lean" "abbrev IO : Type → Type := EIO Error")
# (find-lean4prefile "Init/System/IO.lean" "def EIO (ε : Type) : Type → Type :=")
# (find-lean4prefile "Init/System/IO.lean" "instance : Monad (EIO ε) :=")
# (find-lean4prefile "Init/System/IOError.lean" "inductive IO.Error where")
# (find-lean4prefile "Init/Prelude.lean" "def EStateM (ε σ α : Type u) := σ → Result ε σ α")




#####
#
# IO.print and IO.println
# 2024mar22
#
#####

# «IO.print»    (to ".IO.print")
# «IO.println»  (to ".IO.println")
# (find-fplean4page 106 "IO.println")
# (find-fplean4text 106 "IO.println")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

#eval               "foo\nbar\n"
#eval    IO.println "foo\nbar\n"
#eval do IO.println "foo\nbar\n"
#eval do IO.print   "foo\nbar\n"

-- end






#####
#
# IO.Process.output
# 2024mar11
#
#####

# «IO.Process.output»  (to ".IO.Process.output")
# (find-angg "LEAN/luatree2.lean")
# (find-lean4prefile "Init/System/IO.lean" "Run process to completion")
# (find-lean4prefile "lake/Lake/Config/InstallPath.lean")
# (find-lean4prefile "lake/Lake/Config/InstallPath.lean" "let out ← IO.Process.output {")
# (find-lean4pregrep "grep --color=auto -nirH --null -e pipe *")
# (find-lean4pregrep "grep --color=auto -nirH --null -e Process.Stdio.piped *")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/IO.2EProcess.2Eoutput.20with.20stdin.20being.20a.20string.3F

# (find-lean4prefile "")


IO.Process.output with stdin being a string?

Hi all! How do I tell IO.Process.output to run with its stdin being
(piped from) a string? Or, more precisely: how do I write a function
"tac" that receives a string, pipes it through /usr/bin/tac, and
returns the output? Apparently the "def findLeanSysroot?" in
Lake/Config/InstallPath.lean is a good starting point, and I would
need to use IO.Process.Stdio.piped somewhere - but I am a newbie and
I'm struggling with the details...

Note: I mentioned tac above just to discuss a minimal example, but my
real objective is to use this thing here - luatree.lua - to draw 2D
trees in ASCII art... here's a screenshot:

https://github.com/leanprover/lean4/blob/master/src/lake/Lake/Config/InstallPath.lean#L121
http://anggtwu.net/eev-maxima.html#luatree



#####
#
# Lake.Load
# 2024jun21
#
#####

# «Lake.Load»  (to ".Lake.Load")
# (find-lean4prefile "lake/Lake/Load/Main.lean" "no previous manifest, creating one from scratch")
# (find-lean4prefile "lake/Lake/Load/Main.lean" "Load a `Workspace` for a Lake package by elaborating")
# (find-lean4prefile "lake/lakefile.lean" "supportInterpreter := true")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lake
import Lake.Load
#check Lake.logWarning
#check Lake.loadWorkspaceRoot
#check Lake.loadDepsFromEnv

-- end



#####
#
# latin-cross
# 2024apr20
#
#####

# «latin-cross»  (to ".latin-cross")
# (find-lean-links "✝")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '✝' *")
# (find-lean4prefile "Init/Meta.lean" "s.contains '✝' || s == \"_inaccessible\"")
# (find-lean4prefile "Lean/Hygiene.lean" "name.appendAfter \"✝\"")



#####
#
# LawfulFunctor
# 2024jun01
#
#####

# «LawfulFunctor»  (to ".LawfulFunctor")
# (to "Functor")
# (find-lean-links "LawfulFunctor")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'LawfulFunctor' *")
# (find-lean4prefile "Init/Prelude.lean" "only the operations and not" "laws (see `LawfulFunctor`)")
# (find-lean4prefile "Init/Control/Lawful.lean" "class LawfulFunctor")
# (find-lean4docr "monads/laws.lean#life-without-laws")




#####
#
# leading-dot-notation
# 2024may23
#
#####

# «leading-dot-notation»  (to ".leading-dot-notation")
# (find-fplean4page 194 "Leading Dot Notation")
# (find-fplean4text 194 "Leading Dot Notation")
# (find-fplean4doc "monads/conveniences#leading-dot-notation")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

inductive N where
  | z         : N
  | s (n : N) : N

set_option trace.Elab.command true in
def N.tostr : N → String
  | .z   => "z"
  | .s n => "s" ++ N.tostr n

#check  N.s N.z
#eval  (N.s N.z).tostr

-- end




#####
#
# leading_parser
# 2024mar27
#
#####

# «leading_parser»  (to ".leading_parser")
# (to "FirstTokens")
# (to "synth")
# (find-lean-links "leading_parser")
# (find-lean4grep    "grep --color=auto -nRH --null -e leading_parser *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'leading_parser' *")
# (find-lean4prefile "Lean/Elab/BuiltinNotation.lean" "invalid `leading_parser` macros")
# (find-lean4prefile "Lean/Elab/BuiltinNotation.lean" "@[builtin_term_elab «leading_parser»]")
# (find-lean4prefile "Lean/Parser/Syntax.lean" "def «precedence\ » := leading_parser")
# (find-lean4prefile "Lean/Parser/Term.lean" "def «fun» := leading_parser:maxPrec")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/Leading.20parser/near/431690866 yz, 2024apr06
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/leading_parser.3F/near/438403571 me, 2024may13
# (find-lean4pregrep "grep --color=auto -niRH --null -e 'firsttokens' *")
# (find-lean4prefile "Lean/Parser/Types.lean" "inductive FirstTokens where")
# (find-lean4prefile "Lean/Parser/Types.lean" "def toStr : FirstTokens → String")
-- (ee-copy-rest-3 nil "-- end" "/tmp/a.lean")

import Lean
import Lean.Parser.Term
import Lean.Parser.Command
#print Lean.Parser.Command.visibility
namespace Lean
namespace Parser
def foo := leading_parser "foo "
#check foo
#check foo.info
#check foo.info.firstTokens
#eval  foo.info.firstTokens

#print foo
/-
def Lean.Parser.foo : Parser :=
withCache `Lean.Parser.foo
  (withAntiquot (mkAntiquot "foo" `Lean.Parser.foo true) (leadingNode `Lean.Parser.foo 1024 (symbol "bar ")))
-/

namespace Lean.Parser.Term
#check instBinder
#print instBinder
#check `(command|
  def instBinder := ppGroup <| leading_parser
    "[" >> withoutPosition (optIdent >> termParser) >> "]"
)

-- end

Kyle Miller: Usually it's

  ">> becomes space and f x y z becomes f(x, y, z)"

though sometimes the parser name for syntax can be a little different.

There are also transformations like many p becomes p* and many1 p
becomes p+, among some others.




#####
#
# Lean.Parser.Category
# 2024jun12
#
#####

# «Lean.Parser.Category»  (to ".Lean.Parser.Category")
# (to "declare_syntax_cat")
# (find-lean4pregrep "grep --color=auto -nRH --null -e ': Category := {}' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'declare_syntax_cat' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'antiquotation' *")






#####
#
# Mário Carneiro: The Type Theory of Lean
# 2024may07
#
#####

# «lean-type-theory»  (to ".lean-type-theory")
# (find-angg ".emacs.papers" "leanttmain")
# (find-angg ".emacs.papers" "leanttslides")
# https://github.com/digama0/lean-type-theory
# https://github.com/digama0/lean-type-theory/releases/download/v1.0/main.pdf
# https://github.com/digama0/lean-type-theory/releases/download/v1.0/slides.pdf
# https://github.com/digama0/lean-type-theory/archive/refs/tags/v1.0.tar.gz
# https://www.youtube.com/watch?v=3sKrSNhSxik
# (find-youtubedl-links "/sda5/videos/" nil "3sKrSNhSxik" nil "{stem}")
# (find-youtubedl-links "/sda5/videos/" "The_Type_Theory_of_Lean" "3sKrSNhSxik" ".mkv" "leantt")
# (code-video "leanttvideo" "/sda5/videos/The_Type_Theory_of_Lean-3sKrSNhSxik.mkv")
# (find-leanttvideo "0:00")

# (find-git-links "https://github.com/digama0/lean-type-theory" "leantt")
# (code-c-d "leantt" "~/usrc/lean-type-theory/")
# (find-leanttfile "")

(code-pdf-page  "leanttmain" "$S/https/github.com/digama0/lean-type-theory/releases/download/v1.0/main.pdf")
(code-pdf-text8 "leanttmain" "$S/https/github.com/digama0/lean-type-theory/releases/download/v1.0/main.pdf")
;; (find-leanttmainpage)
;; (find-leanttmaintext)
;; (find-leanttmainpage 8 "2.5   Definitions")
;; (find-leanttmaintext 8 "2.5   Definitions")
;; (find-leanttmainpage 9 "telescope")
;; (find-leanttmaintext 9 "telescope")

(code-pdf-page  "leanttslides" "$S/https/github.com/digama0/lean-type-theory/releases/download/v1.0/slides.pdf")
(code-pdf-text8 "leanttslides" "$S/https/github.com/digama0/lean-type-theory/releases/download/v1.0/slides.pdf")
;; (find-leanttslidespage)
;; (find-leanttslidestext)

https://leanprover.zulipchat.com/#narrow/stream/113488-general/topic/Lean.20in.20the.20wild/near/296059360






#####
#
# let
# 2024mar09
#
#####

# «let»  (to ".let")
# (to "indentation")
# (find-fplean4page 50 "let unzipped")
# (find-fplean4text 50 "let unzipped")
# (find-fplean4page 50 "let rec")
# (find-fplean4text 50 "let rec")
# (find-fplean4page 67 "definition using :=")
# (find-fplean4text 67 "definition using :=")
# (find-fplean4page 67 "let bindings in do use a left arrow")
# (find-fplean4text 67 "let bindings in do use a left arrow")
# (find-leanmetadoc  "main/03_expressions#expressions")
# (find-leanmetadocr "main/03_expressions" "letE n t v b")
# (find-fplean4doc "getting-to-know/conveniences#local-definitions")
# (find-fplean4page 49 "Local Definitions")
# (find-fplean4text 49 "Local Definitions")

# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

def abc : List Nat :=
  let a : Nat := 2
  let b : Nat := 10*a
  let c : Nat := 10*b
  [a,b,c]

#eval abc

def de : List Nat := let d : Nat := 3; let e : Nat := 10*d; [d,e]
#eval de

-- end




#####
#
# let_fun
# 2024jun02
#
#####

# «let_fun»  (to ".let_fun")
# (find-lean4prefile "Init/Prelude.lean" "@[irreducible] def letFun")
# (find-lean4pregrep "grep --color=auto -nRHw --null -e 'let' * | grep -aw fun")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

def       sq1        (x : Nat) := x*x
def       sq2 := fun (x : Nat) => x*x
#eval let sq3 := fun (x : Nat) => x*x; sq3 5
#eval let sq4 := fun  x        => x*x; sq4 5

-- end




#####
#
# let mut
# 2024may30
#
#####

# «let-mut»  (to ".let-mut")
# (to "do-notation")
# (to "do-unchained")
# (find-fplean4doc "monad-transformers/do#mutable-variables")
# (find-fplean4doc "monad-transformers/do#what-counts-as-a-do-block")
# https://www.reddit.com/r/haskell/comments/z55hha/review_of_lean_4/
# https://lean-lang.org/papers/do.pdf
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

def two1 : Nat := Id.run do
  let mut x := 0
  x := x + 1
  x := x + 1
  return x

def two2 : Nat :=
  let block : StateT Nat Id Nat := do
    modify (· + 1)
    modify (· + 1)
    return (← get)
  let (result, _finalState) := block 0
  result

-- end







#####
#
# letterlike
# 2024apr06
#
#####

# «letterlike»  (to ".letterlike")
# (find-lean-links "unicode")
# (find-lean-links "letterlike")
# (find-lean4doc)
# (find-lean4doc      "lexical_structure")
# (find-lean4docrfile "lexical_structure.md")
# (find-lean4docrfile "lexical_structure.md" "letterlike_symbols")
# (find-lean4docrfile "SUMMARY.md" "<!-- - [Lexical Structure](./lexical_structure.md) -->")
# (find-lean4prefile "Init/Meta.lean" "def isLetterLike (c : Char) : Bool :=")
# (find-lean-links "letterlike_symbols")
# (find-lean-links "letterlike")
# (find-lean4pregrep "grep --color=auto -niRH --null -e 'unicode' *")
# (find-lean4pregrep "grep --color=auto -niRH --null -e 'letterlike' *")




#####
#
# Linter
# 2024jun21
#
#####

# «Linter»  (to ".Linter")
# (find-lean4prefile "Init/Prelude.lean" "set_option linter.missingDocs true")
# (find-lean4prefile "Lean/Linter/UnusedVariables.lean")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

set_option linter.unusedVariables false

def foo3 [i1 : Monad m] [i2 : MonadState σ m]
         (a : Nat) : m Nat := do
  let xxxxxxxx := 42
  let b ← get
  return a

-- end




#####
#
# List
# 2024jun26
#
#####

# «List»  (to ".List")
# (find-fplean4page 36 "Linked Lists")
# (find-fplean4text 36 "Linked Lists")





#####
#
# logInfo
# 2024may18
#
#####

# «logInfo»  (to ".logInfo")
# (find-lean-links "logInfo")
# (find-es "lean" "metaprogramming")
# (find-leanmetadocrfile "")
# (find-leanmetadocrsh "find * | sort")
# (find-leanmetadocrgrep "grep --color=auto -nRH --null -e 'logInfo' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'logInfo' *")
# (find-leanmetadoc  "main/01_intro")
# (find-leanmetadoc  "main/01_intro#building-a-command")
# (find-leanmetadocr "main/01_intro" "### Building a command")
# (find-leanmetadocr "main/01_intro" "### Building a command" "`logInfo` to output \"success\"")
# (find-lean4prefile "Lean/Log.lean" "def logInfo")



#####
#
# Macro and macro
# 2024may26
#
#####

# «macro»  (to ".macro")
# (to "extractFrom")
# (to "exploring-data-2")
# (find-leanmetadoc  "main/01_intro#introducing-notation-defining-new-syntax")
# (find-leanmetadocr "main/01_intro" "### Introducing notation (defining new syntax)")
# (find-leanmetadoc  "main/06_macros")
# (find-leanmetadocr "main/06_macros" "@[macro lxor] def lxorImpl2 : Macro")
# (find-leanmetadoc  "main/06_macros#simplifying-macro-declaration")

# (find-lean4prefile "Init/Prelude.lean" "namespace Macro")
# (find-lean4prefile "Init/Prelude.lean" "abbrev Macro := Syntax → MacroM Syntax")
# (find-lean4prefile "lake/Lake/DSL/Script.lean" "@[macro scriptDecl]")

# (find-lean-links "macro")
# (find-leanmetadocrgrep "grep --color=auto -nRH --null -e 'macro' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'macro' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\" macro \"' *")
# (find-lean4pregrep "grep --color=auto -nRHw --null -e 'Macro' *")
# (find-lean4pregrep "grep --color=auto -nRHw --null -e 'Macro' Init/Prelude.lean")
# (find-lean4pregrep "grep --color=auto -nRHw --null -e 'macro' *")

# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean

macro x:ident ":" t:term " ↦ " y:term : term => do
  `(fun $x : $t => $y)

#eval (x : Nat ↦ x + 2) 2 -- 4

macro x:ident " ↦ " y:term : term => do
  `(fun $x  => $y)

#eval (x ↦  x + 2) 2 -- 4

-- end



#####
#
# map
# 2024jun01
#
#####

# «map»  (to ".map")
# (find-lean4prefile "Init/Prelude.lean")
# (find-lean4prefile "Init/Prelude.lean" "class Monad")
# (find-lean4prefile "Init/Prelude.lean" "class Monad" "map      f x :=")
# (find-lean4prefile "Init/Prelude.lean" "class Applicative")
# (find-lean4prefile "Init/Prelude.lean" "class Applicative" "map      :=")
# (find-lean4prefile "Init/Prelude.lean" "class Functor")
# (find-lean4prefile "Init/Prelude.lean" "class Functor" "map :")




#####
#
# mapAddOneNil
# 2024may28
#
#####

# «mapAddOneNil»  (to ".mapAddOneNil")
# (to "elab-term")
# (find-leanmetapage 20 "def mapAddOneNil : Expr :=")
# (find-leanmetatext 20 "def mapAddOneNil : Expr :=")
# (find-leanmetadoc  "main/03_expressions#constructing-expressions")
# (find-leanmetadocr "main/03_expressions" "## Constructing Expressions")
# (find-leanmetadocr "main/03_expressions" "mapAddOneNil")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open Lean
open Nat

def nat : Expr := .const ``Nat []

def addOne : Expr :=
  .lam `x nat
    (mkAppN (.const ``Nat.add []) #[.bvar 0, mkNatLit 1])
    BinderInfo.default

def mapAddOneNil : Expr :=
  mkAppN (.const ``List.map [levelOne, levelOne])
    #[nat, nat, addOne, .app (.const ``List.nil [levelOne]) nat]

#check           mapAddOneNil
#check do return mapAddOneNil

elab "mapAddOneNil" : term => return mapAddOneNil

#check  mapAddOneNil
set_option pp.universes true in
set_option pp.explicit true in
#check  mapAddOneNil
#reduce mapAddOneNil

-- end





#####
#
# match
# 2024mar10
#
#####

# «match»  (to ".match")
# (to "antiquotation")
# (find-angg ".emacs.papers" "fplean4" "28" "Pattern Matching")
# (find-angg ".emacs.papers" "fplean4" "57" "if let")
# (find-leanmetapage 16 "what about match statements")
# (find-leanmetatext 16 "what about match statements")
# (find-fplean4page 28 "Pattern Matching")
# (find-fplean4text 28 "Pattern Matching")
# (find-fplean4page 57 "if let")
# (find-fplean4text 57 "if let")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'match \"' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'match' * | grep -a with")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'match' * | grep -a with | grep -a pat")
# (find-lean4prefile "Lean/Elab/Match.lean" "-- leading_parser \"match \" >>")
# (find-lean4prefile "Lean/Elab/Match.lean" "we don't know the type of `p` yet")
# (find-lean4prefile "Init/Notation.lean" "`(match $d:term with | $pat => $t | _ => $e)")

#eval match 2 with | 0 => true | (n + 1) => false
#eval match 2 with | 0 => true | (_ + 1) => false
#eval match 2 with
        | 0       => true
        | (_ + 1) => false




#####
#
# Abbreviation for match/with: "a sequence of `| pat => expr`"
# 2024may19
#
#####

# «match-bar»  (to ".match-bar")
# (to "Expr")
# (to "Expr" "| forallE .. =>")
# (find-lean4prefile "Lean/Parser/Command.lean" "")
# (find-lean4prefile "Lean/Parser/Command.lean" "a sequence of `| pat => expr`")
# (find-tpil4doc "induction_and_recursion#pattern-matching")
# (find-leanmetadoc  "main/05_syntax#matching-on-syntax")
# (find-leanmetadocr "main/05_syntax" "### Matching on `Syntax`")
# (find-leanmetadocr "main/05_syntax" "def isAdd11 : Syntax → Bool")
# (find-leanmetadoc  "main/03_expressions#constructing-expressions")
# (find-leanmetadocr "main/03_expressions" "## Constructing Expressions")
# (find-leanmetadocr "main/03_expressions" "| n, m =>")
# (find-fplean4doc "monads/conveniences#or-patterns")
# (find-fline "~/TH/eev-lean4.blogme" "match-bar")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open   Lean

def isAdd11 : Syntax → Bool
  | `(Nat.add 1 1) => true
  | _ => false

#eval isAdd11 (Syntax.mkApp (mkIdent `Nat.add) #[Syntax.mkNumLit "1", Syntax.mkNumLit "1"]) -- true
#eval isAdd11 (Syntax.mkApp (mkIdent `Nat.add) #[mkIdent `foo, Syntax.mkNumLit "1"]) -- false

-- end
-- (ee-copy-rest-3 nil "-- end" "/tmp/L/a.lean")

inductive N where
  | z         : N
  | s (n : N) : N

def foo1 : N → Bool
  | N.z   => true
  | N.s _ => false

def foo2 : N → Bool := (match · with
  | N.z   => true
  | N.s _ => false)

def foo3 (n : N) : Bool := match n with
  | N.z   => true
  | N.s _ => false

  def bar1    : N  → Bool                  | .z => true | .s _ => false
  def bar2    : N  → Bool := (match · with | .z => true | .s _ => false)
--def bar3    : N  → Bool :=  match · with | .z => true | .s _ => false  -- err
  def bar4 (n : N) : Bool :=  match n with | .z => true | .s _ => false

-- end




#####
#
# mdbook
# 2024may22
#
#####

# «mdbook»  (to ".mdbook")
# (to "alectryon")
# (find-es "nix")
# https://lean-lang.org/lean4/doc/dev/mdbook.html
# (find-lean4doc  "dev/mdbook")
# (find-lean4doc  "dev/mdbook#using-nix")
# (find-lean4docr "dev/mdbook" "### Using Nix")

Type Checking in Lean 4
-----------------------

This is a book about Lean 4's kernel and implementing external type
checkers; it's built with mdBook.

A hosted copy can be found at
https://ammkrn.github.io/type_checking_in_lean4/

Users can build and view the book locally in their browser by
[installing
mdbook](https://rust-lang.github.io/mdBook/guide/installation.html)
and running:

```bash
mdbook watch --open  # opens the output in `out/` in your default browser
```




#####
#
# mdgen
# 2024may22
#
#####

# «mdgen»  (to ".mdgen")
# (to "metaprogramming")
# https://github.com/Seasawher/mdgen
# (find-git-links "https://github.com/Seasawher/mdgen" "mdgen")
# (code-c-d "mdgen" "~/usrc/mdgen/")
# (find-mdgenfile "")
# (find-mdgenfile "README.md")
# (find-mdgenfile "Mdgen/")
# (find-mdgenfile "Mdgen/ConvertToMd.lean")
# (find-mdgenfile "Test/Src/First.lean")
# (find-mdgenfile "lakefile.lean")
# (find-mdgenfile "lakefile.lean" "/-- run test by `lake test` -/")
# (find-mdgengrep "grep --color=auto -niRH --null -e html *")
# (find-mdgengrep "grep --color=auto -niRH --null -e minted *")
# (find-mdgengrep "grep --color=auto -niRH --null -e pygments *")

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
rm -Rfv ~/usrc/mdgen/
cd      ~/usrc/
git clone https://github.com/Seasawher/mdgen
cd      ~/usrc/mdgen/

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
cd      ~/usrc/mdgen/
git clean -dfx
touch .timestamp
sleep 1

lake test   |& tee olt

# (find-mdgensh "find . -newer .timestamp | sort")
# (find-mdgenfile "Test/Out/")
# (find-mdgenfile "Test/Out/First.md")
# (find-mdgenfile "Test/Out/Second/")
# (find-mdgenfile "Test/Out/Second/Second.md")



#####
#
# meta if
# 2024jun21
#
#####

# «meta-if»  (to ".meta-if")
# (find-lean4prefile "lake/Lake/DSL/Meta.lean" "meta if <c:term> then <a:command> else <b:command>")
# (find-lean-links "meta if")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'meta if' *")




#####
#
# minted
# 2024apr28
#
#####

# «minted»  (to ".minted")
# https://lean-lang.org/lean4/doc/syntax_highlight_in_latex.html
# (find-lean4doc "syntax_highlight_in_latex")
# (find-esgrep "grep --color=auto -nH --null -e minted *.e")




#####
#
# mkSyntaxQuotation
# 2024jun02
#
#####

# «mkSyntaxQuotation»  (to ".mkSyntaxQuotation")
# (to "info-scp-mainModule")
# (to "TSyntax")
# (to "checksyntax-test")
# (find-lean4pregrep "grep --color=auto -nwRH --null -e 'mkSyntaxQuotation' *")
# (find-lean4pregrep "grep --color=auto -nwRH --null -e 'MonadQuotation' *")
# (find-lean4pregrep "grep --color=auto -nwRH --null -e 'MonadQuotation' * | grep -a instance")
# (find-lean4prefile "Lean/Elab/Quotation.lean" "def mkSyntaxQuotation")
# (find-leanmetadoc  "main/06_macros")
# (find-leanmetadocr "main/06_macros")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean.Elab.Command
open   Lean.Elab.Term.Quotation
#check mkSyntaxQuotation

elab "#check_syntax " t:term : command => do Lean.logInfo m!"{t}"
elab "#check_syntax " t:term : command => do Lean.logInfo m!"{repr t.raw}"
elab "#check_syntax " t:term : command => do Lean.logInfo (repr t.raw)
#check_syntax 42 + "foo"

#check    `(42 + "foo")
#check   (`(42 + "foo") : Lean.MacroM                  (Lean.TSyntax `term))
#check   (`(42 + "foo") : Lean.PrettyPrinter.UnexpandM (Lean.TSyntax `term))
def a := (`(42 + "foo") : Lean.MacroM                  (Lean.TSyntax `term))
def b := (`(42 + "foo") : Lean.PrettyPrinter.UnexpandM (Lean.TSyntax `term))

#check `(#h $x:str)
#check `(#help $x)

-- end

do
  let info ← Lean.MonadRef.mkInfoFromRefPos
  let scp ← Lean.getCurrMacroScope
  let mainModule ← Lean.getMainModule
  pure
      {
        raw :=
          Lean.Syntax.node3 info `term_+_ (Lean.Syntax.node1 info `num (Lean.Syntax.atom info "42"))
            (Lean.Syntax.atom info "+")
            (Lean.Syntax.node1 info `str (Lean.Syntax.atom info "\"foo\"")) }
              : ?m.1206 (Lean.TSyntax `term) (lsp)






#####
#
# Monad
# 2024mar24
#
#####

# «Monad»  (to ".Monad")
# (to "do-notation")
# (to "extends")
# (find-lean4prefile "Init/Prelude.lean" "class Bind")
# (find-lean4prefile "Init/Prelude.lean" "class Pure")
# (find-lean4prefile "Init/Prelude.lean" "class Functor")
# (find-lean4prefile "Init/Prelude.lean" "class Applicative")
# (find-lean4prefile "Init/Prelude.lean" "class Monad")
# (find-lean4prefile "Init/Prelude.lean" "class Monad" "extends Applicative")

# (find-lean4doc "monads/intro")
# (find-lean4doc "monads/functors.lean")
# (find-lean4doc "monads/applicatives.lean")
# (find-lean4doc "monads/monads.lean")
# (find-lean4doc "monads/readers.lean")
# (find-lean4doc "monads/states.lean")
# (find-lean4doc "monads/except.lean")
# (find-lean4doc "monads/transformers.lean")
# (find-lean4doc "monads/laws.lean")

# (find-fplean4page 71 "def twice (action : IO Unit) : IO Unit")
# (find-fplean4text 71 "def twice (action : IO Unit) : IO Unit")
# (find-fplean4page 79 "Worked Example: cat")
# (find-fplean4text 79 "Worked Example: cat")
# (find-fplean4page 164 "The Monad Type Class")
# (find-fplean4text 164 "The Monad Type Class")
# (find-fplean4page 165 "General Monad Operations")
# (find-fplean4text 165 "General Monad Operations")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

#check Monad

-- end




#####
#
# Monad-map
# 2024jun12
#
#####

# «Monad-map»  (to ".Monad-map")
# (find-fplean4doc "monad-transformers/transformers#lifting")
# https://github.com/leanprover-community/mathlib4/wiki/Monad-map

A solid arrow upwards from A to B means "when in the A Monad, anything
in B can be called directly", i.e. there is a lift from B to A. (If
this arrow is labeled, you must call that function to do so.)

A dotted line downwards from B to A means that you can call a function
(possibly with some extra arguments, such as initial state) to run B
inside A. Note that many of these functions have apostrophe variants
(e.g. TermElabM.run and TermElabM.run'): run typically returns the
final state of the monad that we're running inside the other monad
along with the actual return value, whereas run' simply discards it.

This diagram is ordered from bottom to top, with simpler monads at the
bottom and more complex ones at the top. As such, lifts go up, and
run-like functions go down.

# (find-fline "~/tmp/monad-map.png")
# (xz         "~/tmp/monad-map.png")

Note that IO and EIO are taken to each other by the functions IO.toEIO
and EIO.toIO, neither of which is a lift, so in this case, the
top-to-bottom directionality of dotted lines isn't meaningful.

Many application-specific monads are defined in terms of monad
transformers on top of typical metaprogramming monads; for example, in
addition to SimpM, we have SimpAll.M, and many others. Instead of
having dedicated functions to run in the monad they're defined on top
of, many of these simply use the function given by the monad
transformer, e.g. StateRefT'.run for SimpM to return to the MetaM
monad. SimpM is given here as an example.

Note that runTermElabM and liftTermElabM both turn a TermElabM into a
CommmandElabM (and neither is a MonadLift). The difference is that
runTermElabM allows the TermElabM computation to act on any scoped
free variables (introduced by the variable command), whereas
liftTermElabM doesn't. As a mnemonic: the run lets us specify some
part of the "initial state" for the monad computation (like e.g.
StateT.run), whereas the lift (as usual) doesn't.

# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open   Lean

#check Lean.Elab.Tactic.TacticM
#check Lean.Elab.Term.TermElabM
#check Lean.Meta.MetaM
#check Lean.CoreM
#check EIO
#check IO
#check Lean.Server.RequestM
#check Lean.PrettyPrinter.Delaborator.DelabM
#check BaseIO
#check Lean.Elab.Command.CommandElabM
#check Lean.Meta.Simp.SimpM
#check Lean.Elab.Frontend.FrontendM
-- end




#####
#
# Monad S
# 2024jun22
#
#####

# «Monad-S»  (to ".Monad-S")
# (to "Id.run")
# (to "outParam")
# (find-lean-links "MonadState")
# (find-lean-links "must be an inductive type")
# (find-lean4pregrep "grep --color=auto -nRH  --null -e 'MonadState' *")
# (find-lean4pregrep "grep --color=auto -nRHw --null -e 'MonadState' *")
# (find-lean4pregrep "grep --color=auto -nRH  --null -e 'Monad' * | grep instance")
# (find-lean4pregrep "grep --color=auto -nRH  --null -e 'Pure' * | grep instance")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

universe u
universe v

def S (α : Type) : Type := String × α

instance : Monad S where
  pure o    := ⟨"", o⟩
  bind sa f := ⟨sa.fst, (f (sa.snd)).snd⟩
--bind sa f := f (sa.snd)

#check show S Nat from do return 42
#eval  show S Nat from do return 42
#eval  show IO Nat from do return 42

#check List.pure
#check List.bind
#check List.pure Nat
#check List.pure 42

-- end



# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

universe u
universe v

def S (α : Type u) : Type u := String × α   -- "S" stands for both "State" and "String"

instance : Monad S where
  pure o := ⟨"", o⟩
  bind {α : Type u} {β : Type u}
       (sa : S α) (f : α → S β) : S β :=    -- or just: bind sa f := ...
    let state := sa.fst
    let a     := sa.snd
    ⟨state, (f a).snd⟩

#check                   do return 42
#check show S Nat from   do return 42
#eval  show S Nat from   do return 42

-- end

# (find-lean-links "MonadStateOf")




# (find-lean4prefile "Init/Prelude.lean" "class MonadState ")
# (find-lean4prefile "Init/Prelude.lean" "class MonadStateOf ")




#####
#
# modules
# 2024may29
#
#####

# «modules»  (to ".modules")
# (to "import")

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
rm -Rv   /tmp/MA*
mkdir -p /tmp/MA/MB/MC/

# (ee-copy-rest-3 nil "-- end" "/tmp/MA.lean")
def a := 42
-- end

# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")
import MA
#check a
-- end




#####
#
# mutual
# 2024jun05
#
#####

# «mutual»  (to ".mutual")
# (to "inductive")
# (to "partial-mutual")
# (find-fplean4doc  "dependent-types/universe-pattern")
# (find-fplean4docr "dependent-types/universe-pattern" "in a `mutual` block")
# (find-fline "~/usrc/fp-lean/examples/Examples/DependentTypes/Finite.lean" "-- ANCHOR: MutualStart")
# (find-fplean4file "examples/Examples/DependentTypes/Finite.lean" "-- ANCHOR: MutualStart")
# (find-lean4prefile "Lean/Declaration.lean" "The kernel compiles (mutual) inductive declarations")

# (find-lean-links "inductive")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'inductive' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'inductive fam' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'mutual inductive' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'mutually inductive' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'mutual' *")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

mutual
  inductive A where
    | a0         : A
    | a1 (b : B) : A

  inductive B where
    | b0         : B
    | b1 (a : A) : B
end

mutual
  def A.foo : A → String
    | A.a0   => "a0"
    | A.a1 b => "a1_" ++ (B.foo b)

  def B.foo : B → String
    | B.b0   => "b0"
    | B.b1 a => "b1_" ++ (A.foo a)
end

#check        B.b1 (A.a1 B.b0)
#check B.foo (B.b1 (A.a1 B.b0))
#eval  B.foo (B.b1 (A.a1 B.b0))

-- end




#####
#
# mydef
# 2024jun27
#
#####

# «mydef»  (to ".mydef")
# (to "Unhygienic.run")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean

open Lean Elab Command
def mydef (name : Name) (stx : TSyntax `term) : CommandElabM Unit := do
  elabCommand (← `(command| def $(mkIdent name) := $stx))

run_cmd
  let stx ← `(fun a => a+2)
  Lean.logInfo m!"{stx}"
  Lean.logInfo m!"{repr stx}"
  mydef `bla stx

#eval (bla 1)
#eval repr (bla 1)

-- end

note that your original #eval bla fails because the resulting expression has type Nat -> Nat

you can #print bla if you want to see that it was defined as intended




#####
#
# mySpecialCheck
# 2024may24
#
#####

# «mySpecialCheck»  (to ".mySpecialCheck")
# (to "TermElabM")
# (find-leanmetadoc  "main/07_elaboration")
# (find-leanmetadocr "main/07_elaboration")
# (find-leanmetadocr "main/07_elaboration" "mySpecialCheck")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open   Lean Elab Command Term Meta

elab "#check" "mycheck" : command => do logInfo "Got ya!"

@[command_elab Lean.Parser.Command.check] def mySpecialCheck : CommandElab := fun stx => do
  if let some str := stx[1].isStrLit? then
    logInfo s!"Specially elaborated string literal!: {str} : String"
  else
    throwUnsupportedSyntax

#check mycheck -- Got ya!
#check "Hello" -- Specially elaborated string literal!: Hello : String
#check Nat.add -- Nat.add : Nat → Nat → Nat

-- end



#####
#
# Name
# 2024jun20
#
#####

# «Name»  (to ".Name")
# (find-lean4prefile "Init/Prelude.lean" "inductive Name where")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'Command.instance' *")
# (find-leanmetapage 110 "let name := mkIdent $ Name.mkSimple str")
# (find-leanmetatext 110 "let name := mkIdent $ Name.mkSimple str")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open   Lean
#check Name
#check Name.mkSimple
#check Name.mkNum
#check  ``Lean.Parser.Command.instance
#check       ``Parser.Command.instance
def name1 := ``Parser.Command.instance
def name2 := Name.mkNum name1 42
def name3 := Name.mkNum "foo" 42
#eval name1
#eval name2
#eval name3

def f1 : Name → String
  | .anonymous                       => ".anonymous"
  | .str (pre : Name) (str : String) => s!".str ({f1 pre}) ({str})"
  | .num (pre : Name) (i : Nat)      => s!".num ({f1 pre}) ({i})"

def f2 : Name → String
  | .anonymous                  => ".anonymous"
  | .str _ (str : String)       => str
  | .num (pre : Name) (i : Nat) => s!".num ({f2 pre}) ({i})"

#eval f1 name1
#eval f1 name2
#eval f1 name3
#eval f2 name1
#eval f2 name2
#eval f2 name3

-- end




#####
#
# namespace
# 2024mar15
#
#####

# «namespace»  (to ".namespace")
# «section»    (to ".section")
# (to "import")
# (to "open")
# (find-lean-links "namespace")
# (find-angg ".emacs.papers" "tpil4" "15" "2.7. Namespaces")
# (find-angg ".emacs.papers" "tpil4" "83" "6.3. More on Namespaces")
# (find-tpil4page  15 "2.7. Namespaces")
# (find-tpil4text  15      "Namespaces")
# (find-tpil4page  16      "The open command")
# (find-tpil4text  16      "The open command")
# (find-tpil4page  83 "6.3. More on Namespaces")
# (find-tpil4text  83      "More on Namespaces")
# (find-tpil4page 167 "open scoped <namespace>")
# (find-tpil4text 167 "open scoped <namespace>")
# (find-tpil4file "dependent_type_theory.md" "# Namespaces")
# (find-tpil4file "interacting_with_lean.md" "More on Namespaces")
# (find-lean4prefile "Lean/Elab/BuiltinCommand.lean" "only `S` and `K` under `Combinator.Calculus`")

# (find-lean4doc "sections")
# (find-lean4doc "namespaces")
# (find-lean4doc "tour#functions-and-namespaces")
# (find-lean4docrfile "namespaces.md" "# Namespaces")
# (find-lean4docrfile "tour.md" "# Functions and Namespaces")

# (find-angg ".emacs.papers" "fplean4" "56" "Namespaces")
# (find-fplean4page 56 "Namespaces")
# (find-fplean4text 56 "Namespaces")

# (find-lean4pregrep "grep --color=auto -nRH --null -e '`namespace`' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '`open`' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '`section`' *")
# (find-lean4prefile "Lean/Elab/BuiltinCommand.lean" "The `open` command")

# (find-tpil4file "type_classes.md" "open scoped <namespace>")
# (find-lean4prefile "Lean/Elab/BuiltinTerm.lean" "@[builtin_term_elab «open\ »]")
# (find-lean4prefile "Lean/Elab/BuiltinCommand.lean" "@[builtin_command_elab «namespace»]")
# (find-lean4prefile "Lean/Elab/BuiltinCommand.lean" "@[builtin_command_elab «section»]")
# (find-lean4prefile "Lean/Elab/BuiltinCommand.lean" "@[builtin_command_elab «open\ »]")
# (find-lean4prefile "Lean/Parser/Command.lean" "@[builtin_command_parser] def «namespace»")
# (find-lean4prefile "Lean/Parser/Command.lean" "@[builtin_command_parser] def «section»")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\"namespace \"' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\"section \"'   *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\"open \"'      *")

# (find-lean4prefile "Lean/Parser/Extra.lean" "possibly with namespaces")
# (find-lean4prefile "Lean/Parser/Term.lean" "(appending the current namespaces)")
# (find-lean4prefile "Lean/ResolveName.lean" "namespace ResolveName")
# (find-lean4prefile "Lean/Server/Completion.lean" "Search namespaces")
# (find-lean4prefile "Lean/Environment.lean" "Environment extension for tracking all `namespace`")

# (find-lean-links "registerNamespace")
# (find-lean-links "namespace")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'registerNamespace' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'builtin_command_elab' *")
# (find-lean4prefile "Lean/Elab/BuiltinCommand.lean" "@[builtin_command_elab «namespace»]")


# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

namespace A
  namespace B
    def c := 42
  end B
end A

#check A.B.c

namespace A
  #check A.B.c
  #check   B.c
end A

namespace A.B
  #check A.B.c
  #check   B.c
  #check     c
end A.B

namespace A
  namespace B
    #check A.B.c
    #check   B.c
    #check     c
  end B
end A

--#check c
open A.B
#check c

-- end

# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

namespace A
  def c := "Ac"
end A
namespace B
  def c := "Bc"
end B

#eval A.c
#eval B.c
open A
#eval c
open B
#eval c  -- err: ambiguous

-- end






#####
#
# notation
# 2024mar28
#
#####

# «notation»  (to ".notation")
# (find-lean-links "notation")
# (find-tpil4grep "grep --color=auto -nH --null -e 'notation' *.md")
# (find-tpil4file "interacting_with_lean.md" "notation ``≤`` to the `isPrefix` relation")
# (find-tpil4file "interacting_with_lean.md" "notation:65 lhs:65 \" + \" rhs:66")
# (find-tpil4file "tactics.md" "The notation ``←t``")
# (find-tpil4file "type_classes.md" "how the notation `a*b` is defined in Lean")
# (find-lean4docgrep "grep --color=auto -nRH --null -e 'notation' *")
# (find-leanmetadocrgrep "grep --color=auto -nRH --null -e 'notation' *")
# (find-lean4prefile "Init/Notation.lean" "\" ∧ \"")
# (find-lean4prefile "Lean/Parser/Syntax.lean" "@[builtin_command_parser] def «notation\ »")
# (find-leanmetadoc  "main/03_expressions#constructing-expressions" "double backticks")
# (find-leanmetadoc  "main/05_syntax")
# (find-leanmetadoc  "main/05_syntax#free-form-syntax-declarations")
# (find-leanmetadoc  "main/05_syntax#free-form-syntax-declarations" "scoped syntax")
# (find-leanmetadocr "main/05_syntax" "### Free form syntax declarations")
# (find-leanmetadocr "main/05_syntax" "`command`, this is the category for top-level commands")
# (find-leanmetadoc  "main/05_syntax#declaration-helpers")
# (find-leanmetadocr "main/05_syntax" "### Declaration helpers")
# (find-leanmetadocr "main/05_syntax" "notation:65 lhs:65 \" ~ \" rhs:65 => (lhs - rhs)")




#####
#
# observation-study
# 2024jun28
#
#####

# «observation-study»  (to ".observation-study")
# https://leanprover.zulipchat.com/#narrow/stream/113488-general/topic/Seeking.20Lean.20users.20for.20an.20observation.20study
# https://www.youtube.com/watch?v=5GkisJ0OImg Alex Kontorovich
# https://www.youtube.com/channel/UC2brkQoKuPv0ep7FkfEGPgQ Bolton Bailey






#####
#
# opaque
# 2024jun03
#
#####

# «opaque»  (to ".opaque")
# (to "partial")



#####
#
# open
# 2024jun14
#
#####

# «open»  (to ".open")
# (to "namespace")
# (find-tpil4page  16 "The open command")
# (find-tpil4text  16 "The open command")
# (find-tpil4page 167 "open scoped <namespace>")
# (find-tpil4text 167 "open scoped <namespace>")




#####
#
# Options
# 2024jun02
#
#####

# «Options»  (to ".Options")
# (to "instance-implicits")
# (to "pp.universes")
# (to "trace.Elab.command")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'pp.notation' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'pp.universes' *")
# (find-lean4prefile "Lean/PrettyPrinter/Delaborator/Options.lean" "pp.notation : Bool := {")
# (find-lean4prefile "Lean/PrettyPrinter/Delaborator/Options.lean" "pp.universes : Bool := {")
# (find-lean4prefile "Lean/PrettyPrinter/Delaborator/Options.lean" "pp.explicit : Bool := {")
# (find-lean4prefile "Lean/PrettyPrinter/Delaborator/Options.lean" "pp.instances")
# (find-lean4doc  "monads/monads.lean#basic-monad-example")
# (find-lean4docr "monads/monads.lean#basic-monad-example")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

-- end




#####
#
# optParam
# 2024jun30
#
#####

# «optParam»  (to ".optParam")
# (to "implicit-arguments")
# (find-leanbook-links 'fplean4 "optParam")
# https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/Optional.20implicit.20argument
# (find-lean4prefile "Lean/Parser/Term.lean" "def explicitBinder (requireType := false) ")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'optParam' *")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

def f1 (a : Nat      ) (b : Nat     ) : Nat := a+b
def f2 (a : Nat := 20) (b : Nat := 3) : Nat := a+b
def f3 (a       := 20) (b       := 3) : Nat := a+b
#check  f1
#check  f2
#check  f3
#check @f2
#check @f3

#eval f1 40 5            -- 45
#eval f2 40 5            -- 45
#eval f2 (a:=40) (b:=5)  -- 45
#eval f2 (b:=5) (a:=40)  -- 45
#eval f2     (b:=5)      -- 25
#eval f2

#check `(command| def f2 (a : Nat := 20) (b : Nat := 3) : Nat := a+b) 

-- end





#####
#
# <|>, a.k.a. orelse
# 2024may15
#
#####

# «orelse»  (to ".orelse")
# (find-lean4prefile "Init/Notation.lean" "`p1 <|> p2` is shorthand for `orelse(p1, p2)`")
# (find-lean4prefile "Init/Notation.lean" "`(stx| $p₁ <|> $p₂) => `(stx| orelse($p₁, $p₂))")



#####
#
# outParam
# 2024jun22
#
#####

# «outParam»  (to ".outParam")
# (find-lean4pregrep "grep --color=auto -niRH  --null -e 'outparam' *")
# (find-lean4pregrep "grep --color=auto -niRHw --null -e 'outparam' *")
# (find-lean4prefile "Init/Prelude.lean" "class Membership (α : outParam (Type u)) (γ : Type v)")
# (find-fplean4page 117 "declared with the outParam modifier:")
# (find-fplean4text 117 "declared with the outParam modifier:")
# (find-fplean4page 123 "class GetElem (coll : Type) (idx : Type) (item : outParam Type)")
# (find-fplean4text 123 "class GetElem (coll : Type) (idx : Type) (item : outParam Type)")
# (find-fplean4page 148 "(indicated by an outParam modifier)")
# (find-fplean4text 148 "(indicated by an outParam modifier)")
# (find-fplean4page 251 "class MonadReader (ρ : outParam (Type u))")
# (find-fplean4text 251 "class MonadReader (ρ : outParam (Type u))")
# (find-fplean4page 252 "Just as in MonadReader , the environment ρ is an outParam .")
# (find-fplean4text 252 "Just as in MonadReader , the environment ρ is an outParam .")

# (find-lean4pregrep "grep --color=auto -niRHw --null -e 'optparam' *")





#####
#
# p123456
# 2024jun09
#
#####

# «p123456»  (to ".p123456")
# (to "inductive-Arith")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

inductive A where
  | n     (n : Nat) : A
  | minus (b c : A) : A
  | pow   (b c : A) : A
  deriving Repr

def paren : A → String
  | .n n       => toString n
  | .minus b c => "(" ++ paren b ++ "-" ++ paren c ++ ")"
  | .pow   b c => "(" ++ paren b ++ "^" ++ paren c ++ ")"

def p123    : A := A.minus (A.minus (A.n 1) (A.n 2)) (A.n 3)
def p456    : A := A.pow (A.n 4) (A.pow (A.n 5) (A.n 6))
def p123456 : A := A.minus p123 p456

#eval paren p123456   --> "(((1-2)-3)-(4^(5^6)))"

declare_syntax_cat catA

syntax num                      : catA
syntax:50 catA:50 " - " catA:51 : catA
syntax:70 catA:71 " ^ " catA:70 : catA
syntax "[: " catA " :]"         : term

macro_rules | `([: $n:num :]) => `(A.n ($n))
macro_rules | `([: $b:catA - $c:catA :]) => `(A.minus ([: $b :]) ([: $c :]))
macro_rules | `([: $b:catA ^ $c:catA :]) => `(A.pow   ([: $b :]) ([: $c :]))

#check      [: 1 - 2 - 3 - 4 ^ 5 ^ 6 :]
#eval paren [: 1 - 2 - 3 - 4 ^ 5 ^ 6 :]   --> "(((1-2)-3)-(4^(5^6)))"

-- end




#####
#
# Partax
# 2024jun14
#
#####

# «Partax»  (to ".Partax")
# https://github.com/tydeu/lean4-partax
# (find-git-links "https://github.com/tydeu/lean4-partax" "partax")
# (code-c-d "partax" "~/usrc/lean4-partax/")
# (find-partaxfile "")
# (find-partaxfile "README.md")
# (find-partaxfile "tests/lcompile.lean" "#match_stx term term | 2 + 2 = 4")
# (find-partaxfile "Partax/Test/Basic.lean" "@[scoped command_parser] def matchStx :=")
# (find-partaxfile "Partax/Test/Basic.lean" "@[macro matchStx] def expandMatchStx")
# https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/Introducing.20Partax.2C.20the.20Parser.20Compiler/near/379967441

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
rm -Rfv  ~/usrc/lean4-partax/
mkdir -p ~/usrc/
cd       ~/usrc/
git clone https://github.com/tydeu/lean4-partax
cd       ~/usrc/lean4-partax/

git clean -dfx
git reset --hard
time ./test.sh      2>&1 | tee ot     ;# takes a few minutes

# (find-file "~/usrc/lean4-partax/tests/lcompile.lean")


# (ee-copy-rest-3m nil "-- end" (ee-partaxfile "a.lean"))
import Lean
import Partax
open scoped Partax
open Lean Elab Command
compile_parser Lean.Parser.Term.attributes => attrs -- with CompileConfig.lParse
#eval attrs.run' "@[instance high, inline]" -- TSyntax `Lean.Parser.Term.attributes
-- end

# (ee-copy-rest-3m nil "-- end" (ee-partaxfile "a.lean"))

import Lean
import Partax

open scoped Partax

compile_parser Lean.Parser.Term.attributes => attrs -- with CompileConfig.lParse
#eval attrs.run' "@[instance high, inline]" -- TSyntax `Lean.Parser.Term.attributes

compile_parser_category prio -- with CompileConfig.lParse
#eval prio.run' "default + default" -- TSyntax `prio

open Lean Elab Command in -- 2000
#eval liftMacroM (m := CommandElabM) do
  match prio.run' "default + default" with
  | .ok stx => evalPrio stx
  | .error e => Macro.throwError e

-- end



#####
#
# #match_stx2
# 2024jun16
#
#####

# «Partax-match_stx2»  (to ".Partax-match_stx2")
# (code-c-d "partax" "~/usrc/lean4-partax/")
# (find-partaxfile "")
# (find-partaxfile "README.md")
# (find-partaxfile "tests/lcompile.lean" "#match_stx term term | 2 + 2 = 4")
# (find-partaxfile "Partax/Test/Basic.lean" "@[scoped command_parser] def matchStx :=")
# (find-partaxfile "Partax/Test/Basic.lean" "@[macro matchStx] def expandMatchStx")
# (ee-copy-rest-3m nil "-- end" (ee-partaxfile "a.lean"))

import Partax.Test.Basic
open   Partax.Test
#check expandMatchStx

open Lean
open Parser
namespace MyTests

@[scoped command_parser] def matchStx2 := leading_parser
  "#match_stx2 " >> ident >> termParser >> " | " >> parserOfStack 2

@[macro matchStx2] def expandMatchStx : Macro := fun matchStx => do
  let stx := matchStx[4]
  let some src := stx.updateTrailing "".toSubstring |>.reprint
    | Macro.throwError "cannot reprint syntax"
  let p : Ident := ⟨matchStx[2]⟩
  let test ← `((matchStxFn · $(quoteSyntax stx)))
  `(#eval $(p).run' $(quote src) >>= $test)

#match_stx2 term term | 2 + 2 = 4
-- def_from_match_stx a224 := term term | 2 + 2 = 4
-- #eval a224

end MyTests

-- end




#####
#
# #parse_term
# 2024jun15
#
#####

# «parse_term»  (to ".parse_term")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/.E2.9C.94.20How.20to.20test.20a.20syntax
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

elab "#parse_term " _t:term : command => pure ()
#parse_term 2 + 2

-- end






#####
#
# partial
# 2024mar23
#
#####

# «partial»  (to ".partial")
# (to "Inhabited")
# (to "termination")
# (to "opaque")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'partial' *")
# (find-fplean4page 80 "The dump function is declared partial")
# (find-fplean4text 80 "The dump function is declared partial")
# (find-fplean4doc "hello-world/cat#streams")
# (find-leanmetadoc  "main/02_overview#type-correctness")
# (find-leanmetadocr "main/02_overview" "### Type correctness" "use the `partial` keyword")
# (find-lean4prefile "Lean/Declaration.lean" "inductive DefinitionSafety where")
# (find-lean4prefile "Lean/Declaration.lean" "inductive Declaration where")
# (find-lean4prefile "Lean/Declaration.lean" "| opaqueDecl")
# (find-lean4prefile "Lean/Declaration.lean" "| mutualDefnDecl")
# (find-lean4prefile "Lean/Elab/MutualDef.lean")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

def bufsize : USize := 20 * 1024

partial def dump (stream : IO.FS.Stream) : IO Unit := do
  let buf ← stream.read bufsize
  if buf.isEmpty then
    pure ()
  else
    let stdout ← IO.getStdout
    stdout.write buf
    dump stream

#print dump  -- opaque

-- end




#####
#
# partial-mutual - "This trick is useful if you need mutual recursion among your instances"
# 2024jun04
#
#####

# «partial-mutual»  (to ".partial-mutual")
# (to "mutual")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/.22failed.20to.20synthesize.20instance.20ToLuaTree.20Name.22.20inside.20.22insta/near/441936047

partial def toLuaTreeName (name : Name) : String :=
  let _ : ToLuaTree Name := ⟨toLuaTreeName⟩
  match name with
  | .anonymous   => "(.anon)"
  | .str pre str => zconcat ".str" [toLuaTree pre, q str]
  | .num pre i   => "(.n)"

instance : ToLuaTree Name := ⟨toLuaTreeName⟩

# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")


-- end






#####
#
# polymorphism
# 2024may19
#
#####

# «polymorphism»  (to ".polymorphism")
# (find-angg ".emacs.papers" "fplean4")
# (find-fplean4page 34 "Polymorphism")
# (find-fplean4text 34 "Polymorphism")



#####
#
# posOrNegThree
# 2024may23
#
#####

# «posOrNegThree»  (to ".posOrNegThree")
# (find-fplean4page 36 "def posOrNegThree")
# (find-fplean4text 36 "def posOrNegThree")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

inductive Sign where
  | pos
  | neg

def posOrNegThree (s : Sign) : match s with
  | Sign.pos => Nat
  | Sign.neg => Int := match s with
    | Sign.pos => (3 : Nat)
    | Sign.neg => (-3 : Int)

#eval posOrNegThree Sign.pos
#eval posOrNegThree Sign.neg

-- end



#####
#
# postulate
# 2024may20
#
#####

# «postulate»  (to ".postulate")
# (to "axiom")
# (find-THfile "eev-lean4.blogme" "question-postulate")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/How.20do.20I.20translate.20Agda's.20.22postulate.22.20to.20Lean.3F/near/439561780
# (find-es "agda" "postulates")



#####
#
# pp.notation
# 2024jun02
#
#####

# «pp.notation»  (to ".pp.notation")
# (to "Options")
# (to "sleep1")




#####
#
# pp.universes
# 2024may28
#
#####

# «pp.universes»  (to ".pp.universes")
# (to "Options")
# (find-leanmetapage 18 "set_option pp.universes true in")
# (find-leanmetatext 18 "set_option pp.universes true in")
# (find-leanmetadocr "main/03_expressions" "set_option pp.universes true in")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

#check @List.map

set_option pp.universes true in
#check @List.map

-- end





#####
#
# Pratt parser
# 2024mar27
#
#####

# «pratt-parser»  (to ".pratt-parser")
# (to "ullrichmp")
# (find-es "pratt")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'pratt' *")
# (find-lean4prefile "Lean/Parser/Basic.lean" "def prattParser")
# (find-lean4docrfile "metaprogramming-arith.md" "(a:60 + b:61):60 + c")




#####
#
# precedence
# 2024jun12
#
#####

# «precedence»  (to ".precedence")
# (to "binop")
# (find-leanmetapage 5 "the" "higher the number, the tighter the binding")
# (find-leanmetatext 5 "the" "higher the number, the tighter the binding")
# (find-lean4prefile "Init/Notation.lean" "@[inherit_doc] infixl:65 \" + \"   => HAdd.hAdd")
# (find-lean4prefile "Init/Notation.lean" "macro_rules | `($x + $y)   => `(binop% HAdd.hAdd $x $y)")




#####
#
# #print
# 2024mar11
#
#####

# «print»  (to ".print")
# (find-fplean4page 190 "#print Nat")
# (find-fplean4text 190 "#print Nat")
# (find-fplean4page 191 "#print IO.Error")
# (find-fplean4text 191 "#print IO.Error")
# (find-tpil4grep "grep --color=auto -nH --null -e '#print' *.md")
# (find-tpinleanpage (+ 6 89) "6.8 Displaying Information")
# (find-tpinleantext (+ 6 89) "6.8 Displaying Information")
# (find-lean4prefile "Lean/Parser/Command.lean" "@[builtin_command_parser] def print")
# (find-lean4prefile "Lean/Elab/Print.lean" "@[builtin_command_elab «print\ »] def elabPrint :")
# (find-lean4prefile "Lean/Elab/Print.lean" "private def printIdCore (id : Name) :")
# (find-lean-links "print")
# (find-lean-links "#print")
# (find-lean-links "printAxioms")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'print' * | grep -a command")

# (to "leading_parser")
Repr doesn't have anything to do with #print. What #print does is
pretty print a declaration, whose value is an Expr.

-- Old:
#print definition                      :   display   definition
#print inductive                       :   display   an inductive type and its constructors
#print notation                        :   display   all notation
#print notation <tokens>               :   display   notation using any of the tokens
#print axioms                          :   display   assumed axioms
#print options                         :   display   options set by user
#print prefix <namespace>              :   display   all declarations in the namespace
#print classes                         :   display   all classes
#print instances <class name>          :   display   all instances of the given class
#print fields <structure>              :   display   all fields of a structure



#####
#
# #print inductive
# 2024jun20
#
#####

# «print-inductive»  (to ".print-inductive")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '#print' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'Command.print' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'number of parameters' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'printInduct' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\" \\.\\. \"' *")
# (find-lean4prefile "Lean/Elab/Print.lean" "@[builtin_command_elab «print\ »]")
# (find-lean4prefile "Lean/Elab/Print.lean" "private def printInduct")
# (find-lean4prefile "Lean/Elab/Print.lean" "printInduct id us numParams t ctors u")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open   Lean
open   Nat
#print Nat
#print Expr
#print Expr.const
#check Expr.const

-- end

 a.lean    36   1 info            inductive Lean.Expr : Type
 number of parameters: 0
 constructors:
 Lean.Expr.bvar : Nat → Expr
 Lean.Expr.fvar : FVarId → Expr
 Lean.Expr.mvar : MVarId → Expr
 Lean.Expr.sort : Level → Expr
 Lean.Expr.const : Name → List Level → Expr
 Lean.Expr.app : Expr → Expr → Expr
 Lean.Expr.lam : Name → Expr → Expr → BinderInfo → Expr
 Lean.Expr.forallE : Name → Expr → Expr → BinderInfo → Expr
 Lean.Expr.letE : Name → Expr → Expr → Expr → Bool → Expr
 Lean.Expr.lit : Literal → Expr
 Lean.Expr.mdata : MData → Expr → Expr
 Lean.Expr.proj : Name → Nat → Expr → Expr (lsp)





#####
#
# Prod
# 2024jun13
#
#####

# «Prod»  (to ".Prod")
# (find-fplean4page 42 "Prod")
# (find-fplean4text 42 "Prod")
# (find-fplean4doc "getting-to-know/polymorphism#prod")
# (find-tpil4page 106 "structure Prod")
# (find-tpil4text 106 "structure Prod")
# (find-lean4prefile "Init/Prelude.lean" "structure Prod (α : Type u) (β : Type v) where")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")



-- end





#####
#
# project
# 2024may29
#
#####

# «project»  (to ".project")
# (to "lake-new-greeting")
# (find-fplean4doc "hello-world/starting-a-project")
# (find-leanrefdoc "using_lean#id3" "1.3.2. Multi-file Projects")




#####
#
# Pure
# 2024jun22
#
#####

# «Pure»  (to ".Pure")
# (find-lean4prefile "Init/Prelude.lean" "class Pure (f : Type u → Type v) where")




#####
#
# Range
# 2024may24
#
#####

# «Range»  (to ".Range")
# (find-lean4prefile "Init/Data/Range.lean" "[i:j]")
# (find-lean4prefile "Init/Data/Range.lean" "structure Range where")
# (find-lean4prefile "Init/Data/Range.lean" "  start : Nat := 0")
# (find-lean4prefile "Init/Core.lean" "inductive ForInStep ")
# (find-lean4prefile "Init/Core.lean" ""class ForIn ")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

#check [:(5:Nat)]
#check [:5]
#check [:(5:Int)] -- err

-- end





#####
#
# ReaderT
# 2024may21
#
#####

# «ReaderT»  (to ".ReaderT")
# (to "run_cmd")
# (find-lean4prefile "Lean/Elab/Command.lean" "abbrev CommandElabCoreM (ε) := ReaderT Context")
# (find-lean4prefile "Init/Prelude.lean" "def ReaderT")
# (find-fplean4page 250 "Adding a Reader to Any Monad")
# (find-fplean4text 250 "Adding a Reader to Any Monad")
# (find-fplean4page 254 "A Monad Construction Kit")
# (find-fplean4text 254 "A Monad Construction Kit")
# (find-fplean4doc "monads/arithmetic#custom-environments")
# (find-fplean4doc "monads/arithmetic#readers-with-failure")
# (find-fplean4doc "monads/arithmetic#readers-with-failure")




#####
#
# #reduce
# 2024may28
#
#####

# «reduce»  (to ".reduce")
# (to "whnf")
# (find-leanmetadoc  "main/04_metam")
# (find-leanmetadoc  "main/04_metam#full-normalisation")
# (find-leanmetadocr "main/04_metam" "### Full Normalisation")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

inductive A where |a1 |a2 deriving Repr
inductive B where |b1 |b2 deriving Repr
open A B
#check a1

def f : A → B  |a1=>b2 |a2=>b1
#check  f a1
#eval   f a1
#print  f
#reduce f
#reduce f a1

-- end
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open Lean Lean.Expr Lean.Meta

def someNumber : Nat := (· + 2) $ 3
#eval Expr.const ``someNumber []
#eval reduce (Expr.const ``someNumber [])
#reduce someNumber

def traceConstWithTransparency (md : TransparencyMode) (c : Name) :
    MetaM Format := do
  ppExpr (← withTransparency md $ reduce (.const c []))

@[irreducible] def irreducibleDef : Nat      := 1
def                defaultDef     : Nat      := irreducibleDef + 1
abbrev             reducibleDef   : Nat      := defaultDef + 1

#eval traceConstWithTransparency .reducible ``reducibleDef

set_option pp.explicit true
#eval traceConstWithTransparency .reducible ``reducibleDef
#eval traceConstWithTransparency .instances ``reducibleDef
#eval traceConstWithTransparency .default ``reducibleDef
#eval traceConstWithTransparency .all ``reducibleDef

-- end



#####
#
# repl
# 2024jun09
#
#####

# «repl»  (to ".repl")
# https://github.com/leanprover-community/repl
# https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/How.20to.20interface.20with.20Lean.20from.20another.20language.3F
# https://leanprover.zulipchat.com/#narrow/stream/113488-general/topic/lean4_jupyter.3A.20A.20Lean.204.20Jupyter.20kernel.20via.20repl



#####
#
# Repr and ToString
# 2024mar24
#
#####

# «Repr»  (to ".Repr")
# (to "structure")
# (to "instance")
# (to "inductive-Nat")
# (to "synth")
# (find-fplean4page 19 "deriving Repr")
# (find-fplean4text 19 "deriving Repr")

# (find-lean-links "Repr")
# (find-lean4presh "find * | sort")
# (find-lean4presh "find * | sort | grep Repr")
# (find-lean4prefile "Init/Data/Repr.lean")
# (find-lean4prefile "Init/Data/Repr.lean" "def List.repr")
# (find-lean4prefile "Lean/Elab/Deriving/Repr.lean")

# (find-lean4prefile "Lean/Elab/BuiltinCommand.lean" "recall that any type implementing")
# (find-lean4prefile "Lean/Elab/Deriving/Repr.lean" "def mkReprInstanceHandler")
# (find-lean4prefile "Lean/MonadEnv.lean"  "def isInductive")
# (find-lean4prefile "Lean/Structure.lean" "def getStructureFields")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'mkRepr' *")

# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")
set_option trace.Elab.command true

inductive myNat where
  | zero             : myNat
  | succ (n : myNat) : myNat
  deriving Repr

def my1 := myNat.succ myNat.zero
#check my1
#print my1
#eval  my1
#eval  repr my1
#check repr my1
-- #print repr my1
#check Std.Format
#synth Repr myNat
#print instReprMyNat

-- end




#####
#
# Is there a variant of repr that "prints the type"?
# 2024jun11
#
#####

# «repr-type»  (to ".repr-type")
# (to "runTermElabM")
# (to "inferType")
# (to "elab-type")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/Is.20there.20a.20variant.20of.20repr.20that.20.22prints.20the.20type.22.3F/near/444131617

Is there a variant of repr that "prints the type"?

I wrote my first DSL a few days ago - here
https://github.com/edrx/LuaTreeLean , screenshot
http://anggtwu.net/LuaTreeLean/screenshot.png - and I'm in a stage in
which I still have to decompose each example in the Metaprogramming
book into 10 smaller snippets to understand what is going on in it...
and this looks like a good way to explore (specific) Syntax/TSyntax
objects:

# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open Lean Elab Command

elab "#withstring " x:str : command =>
  match x with
  | `("a") => logInfo x
  | `("b") => do { logInfo x; logInfo (repr x) }
  | `("c") => do { logInfo x; logInfo (repr x.raw) }
  | _ => Elab.throwUnsupportedSyntax

#withstring "a"
#withstring "b"
#withstring "c"

-- end

I know that repr o converts o to its repr as a string, and #check o
prints o and its type - but #check is a command, so it has access to
the current context...

Is there a function that receives an object o and returns its type
converted to a string?





#####
#
# runActions
# 2024jun01
#
#####

# «runActions»  (to ".runActions")
# (to "do-notation")
# (find-fplean4doc "hello-world/running-a-program#combining-io-actions")
# (find-fplean4page 66 "Combining IO Actions")
# (find-fplean4text 66 "Combining IO Actions")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

def getoutput (cmd : String) (args : Array String) : IO String := do
  let out ← IO.Process.output { cmd := cmd, args := args }
  return out.stdout

def now    := getoutput "date" #["+%S"]
def sleep1 := getoutput "sleep" #["1"]

#eval now
#eval sleep1
#eval Unit.unit

#eval now
#eval sleep1
#eval now
#eval Unit.unit
#check ()

-- end






#####
#
# runCmd
# 2024may18
#
#####

# «runCmd»  (to ".runCmd")
# «run_cmd»  (to ".run_cmd")
# (to "show-from-do")
# (to "CommandElabM")
# (to "ReaderT")
# (find-lean-links "runcmd")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'runCmd' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'executes code in' *")
# (find-lean4prefile "Lean/Elab/BuiltinCommand.lean" "@[builtin_command_elab runCmd]")
# (find-lean4prefile "Init/Notation.lean" "The `run_cmd doSeq` command executes code in")
# (find-lean4prefile "Init/Notation.lean" "syntax (name := runCmd) \"run_cmd \" doSeq : command")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/run_cmd.2C.20monads.2C.20and.20tests.20for.20their.20methods/near/442408599
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
import Lean.Elab.Command
open   Lean.Elab.Command
open   Lean
-- set_option trace.Elab.command true
namespace Foo
run_cmd                                 logInfo (← getCurrNamespace)
#eval show  CommandElabM Unit  from  do logInfo (← getCurrNamespace)
#eval show (CommandElabM Unit) from (do logInfo (← getCurrNamespace))
#check                               do logInfo (← getCurrNamespace)
#check                                  logInfo
#check                                             getCurrNamespace
#check      CommandElabM Unit
#check      CommandElabM

#check AddMessageContext
#check MessageData
#check MonadLog
#check MonadOptions
#check logInfo

run_cmd do
  let stx <- `(fun {α β} [BEq α] (ab : α×β) => let (a,_) := ab; a==a)
  -- process stx
  Lean.logInfo m!"{stx}"

-- end




#####
#
# runParserCategory
# 2024jun12
#
#####

# «runParserCategory»  (to ".runParserCategory")
# https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/Simple.20parsing.2Belaboration.20with.20metaprogramming
# https://leanprover.zulipchat.com/#narrow/stream/217875-Is-there-code-for-X.3F/topic/.E2.9C.94.20.60unfold.60.20tactic.20only.20accepts.20an.20identifier.2E/near/448078065
# https://leanprover.zulipchat.com/#narrow/search/runparsercategory
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean

inductive MyType
| a : MyType -> MyType
| b : MyType -> MyType
| c : MyType
deriving Inhabited, BEq, Repr

open Lean Elab

unsafe def stringToMyType (string : String) : TermElabM (Option MyType) := do
  let e ← getEnv
  let .ok syn := Parser.runParserCategory e `term string | return none
  logInfo syn
  -- we could elab here, but its not needed
  -- let expr ← Term.elabTerm syn (some (.const `MyType []))
  -- logInfo expr

  let out ← Term.evalTerm MyType (.const `MyType []) syn
  logInfo (repr out)
  return out

#eval MyType.a (.b (.a (.a .c)))
#eval stringToMyType "MyType.a (.b (.a (.a .c)))"

-- end






#####
#
# runTermElabM
# 2024jun12
#
#####

# «runTermElabM»  (to ".runTermElabM")
# (to "inferType")
# (to "repr-type")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/Is.20there.20a.20variant.20of.20repr.20that.20.22prints.20the.20type.22.3F/near/444131617
# (find-lean4prefile "Lean/Elab/Command.lean" "def runTermElabM")
# (find-lean4prefile "Lean/Elab/SyntheticMVars.lean" "def elabTermAndSynthesize")
# (find-lean4prefile "Lean/Elab/SyntheticMVars.lean" "partial def synthesizeSyntheticMVars")
# (find-lean4prefile "Lean/Meta/Basic.lean" "@[extern 6 \"lean_infer_type\"] opaque inferType")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open   Lean Elab Command Meta

elab "#my_check1 " t:term : command => do
  runTermElabM fun _ => do
    let e1 ← Term.elabTermAndSynthesize t none
    let eTy1 ← inferType e1
    logInfo m!"{e1} : {eTy1}"

elab "#my_check2 " t:term : command => do
  runTermElabM fun _ => do
    let e2 ← Term.elabTerm t none
    Term.synthesizeSyntheticMVars (mayPostpone := false) (ignoreStuckTC := true)
    let eTy2 ← inferType e2
    logInfo m!"{e2} : {eTy2}"

#my_check1 "s"
--#my_check1 do logInfo "foo"
#my_check2   do logInfo "foo"

-- end







#####
#
# rw
# 2024mar14
#
#####

# «rw»  (to ".rw")
# (find-lean4rc1file "Init/Tactics.lean" "macro (name := rwSeq) \"rw\"")
# (find-mathsinleanpage 9 "2.1 Calculating")
# (find-mathsinleantext 9 "2.1 Calculating")
# (find-mathsinleanpage 9 "2.1 Calculating" "tactic rw")
# (find-mathsinleantext 9 "2.1 Calculating" "tactic rw")
# (find-leanmathsdoc "C02_Basics#calculating")
# (find-mathsinleanfile "MIL/C02_Basics/S01_Calculating.lean")



#####
#
# saveState
# 2024jun08
#
#####

# «saveState»  (to ".saveState")
# (find-leanmetadoc  "main/04_metam#backtracking")
# (find-leanmetadocr "main/04_metam" "## Backtracking")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open   Lean

def tryM (x : MetaM Unit) : MetaM Unit := do
  let s ← saveState
  try
    x
  catch _ =>
    restoreState s

-- end






#####
#
# scoped-syntax
# 2024may15
#
#####

# «scoped-syntax»  (to ".scoped-syntax")
# (to "check")
# (find-leanmetadoc  "main/05_syntax#free-form-syntax-declarations")
# (find-leanmetadocw "main/05_syntax#free-form-syntax-declarations")
# (find-leanmetadocr "main/05_syntax" "### Free form syntax declarations")
# (find-leanmetadocr "main/05_syntax" "namespace Playground2")
# (find-lean4prefile "Lean/Elab/Term.lean" "elaboration function for '{k}' has not been implemented")
# (find-lean4prefile "Lean/Elab/Command.lean" "elaboration function for '{k}' has not been implemented")



#####
#
# semi-output
# 2024jun22
#
#####

# «semi-output»  (to ".semi-output")
# (find-lean4prefile "Init/Prelude.lean" "Gadget for marking semi output parameters")



#####
#
# server
# 2024jun01
#
#####

# «server»  (to ".server")
# (to "import-problem")
# (to "trace.Elab.info")
# (find-lean4prefile "Lean/Server.lean")
# (find-lean4prefile "Lean/Server/")
# (find-lean4prefile "Lean/Server/Completion.lean" "Search namespaces")
# (find-lean4prefile "Lean/Server/README.md")
# (find-lean4prefile "Lean/Server/README.md" "cannot import a `.lean` file without compiling it first")
# (find-lean4prefile "Lean/Server/README.md" "lake setup-file")
# (find-lean4prefile "Lean/Server/README.md" "set_option trace.Elab.info true")




#####
#
# show
# 2024mar22
#
#####

# «show»  (to ".show")
# (to "from-do")
# (find-lean-links "show")
# (find-tpil4file "propositions_and_proofs.md" "show p from hp")
# (find-tpil4page 25 "show p from hp")
# (find-tpil4text 25 "show p from hp")
# (find-lean4prefile "Init/Prelude.lean" "`show T' from e` is sugar for")
# (find-lean4prefile "Init/Tactics.lean" "`show t` finds the first goal")

# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")
#check show Int from 42
#check show Nat from 42
-- end

# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")
set_option trace.Elab.command true

variable {P : Prop}
variable {Q : Prop}
theorem t1 : P → Q → P :=
  fun p : P =>
  fun q : Q =>
  show P from p

theorem t1 : P → Q → P := fun p : P => fun q : Q => show P from p

theorem t0 : P → P := fun p : P => show P from p

theorem t0a : P → P := fun p : P => show P from p
theorem t0b : P → P := fun p : P =>             p

#check fun p : P => show P from p

#check show Int from 42

#check fun p : P => show P from p
#check fun p : P =>             p
#check show Int from 42

-- end



#####
#
# show ... from do ...
# 2024may21
#
#####

# «show-from-do»  (to ".show-from-do")
# (to "Id.run")
# (to "show")
# (find-lean4prefile "Init/Prelude.lean" "`show T' from e` is sugar for")
# (find-lean-links "from do")
# (find-lean-links "from")
# (find-leanmetadocrgrep "grep --color=auto -nRH --null -e 'from do' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'from do' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\"from \"' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\" from \"' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e from * | grep -a do")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '«from\ »' *")
# (find-leanmetadoc  "main/04_metam#basic-operations")
# (find-leanmetadocr "main/04_metam" "### Basic Operations")
# (find-leanmetadocr "main/04_metam" "### Basic Operations" "#eval show MetaM Unit from do")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

instance : Monad List  where
  pure := List.pure
  bind := List.bind

#check                    do return 42   -- _ : ?m   Nat
#check show IO   Nat from do return 42   -- _ : IO   Nat
#check show List Nat from do return 42   -- _ : List Nat
#check show List Int from do return 42   -- _ : List Int

-- end





#####
#
# sleep1 and friends
# 2024jun02
#
#####

# «sleep1»  (to ".sleep1")
# (to "do-notation")
# (to "pp.notation")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

def getoutput  (cmd : String) (args : List String) : IO String := do
  let out ← IO.Process.output { cmd := cmd, args := args.toArray }
  return out.stdout

def getoutput0 (cmd : String) (args : List String) : IO Unit   := do
  let _   ← IO.Process.output { cmd := cmd, args := args.toArray }
  return

def duplicate (str : String) : IO String := getoutput  "echo"  [str, str]
def seconds                  : IO String := getoutput  "date"  ["+%S"]
def sleep1                   : IO Unit   := getoutput0 "sleep" ["1"]

#eval  getoutput "echo" ["a", "b"]
#eval  duplicate "abc"
#eval  seconds
#check sleep1

#eval do IO.println (← seconds)

def ss := do
  let a ← seconds
  sleep1
  let b ← seconds
  return a++b

#check ss
#eval  ss
#print ss
set_option pp.notation false in
#print ss

-- end



#####
#
# specialize
# 2024jun01
#
#####

# «specialize»  (to ".specialize")
# (find-lean-links "specialize")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'specialize' *")



#####
#
# State
# 2024jun22
#
#####

# «State»  (to ".State")
# (find-es "haskell" "wikibook")
# https://en.wikibooks.org/wiki/Haskell/Understanding_monads/State
# (find-lean4prefile "Init/Control/State.lean" "instance : Monad (StateT σ m) where")
# (find-lean-links "State")
# (find-fplean4doc "monad-transformers/transformers#state")
# (find-fplean4page 262 "def StateT ")
# (find-fplean4text 262 "def StateT ")
# (find-lean4prefile "Init/Prelude.lean" "class MonadState ")
# (find-lean4prefile "Init/Control/State.lean" "def StateT ")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

structure LetterCounts where
  vowels : Nat
  consonants : Nat
deriving Repr

inductive Err where
  | notALetter : Char → Err
deriving Repr

def vowels :=
  let lowerVowels := "aeiuoy"
  lowerVowels ++ lowerVowels.map (·.toUpper)

def consonants :=
  let lowerConsonants := "bcdfghjklmnpqrstvwxz"
  lowerConsonants ++ lowerConsonants.map (·.toUpper )

def countLetters (str : String) : StateT LetterCounts (Except Err) Unit :=
  let rec loop (chars : List Char) := do
    match chars with
    | [] => pure ()
    | c :: cs =>
      let st ← get
      let st' ←
        if c.isAlpha then
          if vowels.contains c then
            pure {st with vowels := st.vowels + 1}
          else if consonants.contains c then
            pure {st with consonants := st.consonants + 1}
          else -- modified or non-English letter
            pure st
        else throw (.notALetter c)
      set st'
      loop cs
  loop str.toList

-- end



# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

#check StateM
#check StateM Nat
#check StateM Nat Nat
#check StateT
#check StateT Nat
#check StateT Nat List
#check StateT Nat List Nat

#check StateT.get
#check StateT.bind

#check      StateM
#check      StateM Nat
#check      StateM Nat Nat
#check show StateM Nat Nat from do return 42
#check show StateM Nat Nat from do return (← get)

-- end






#####
#
# Std.Format
# 2024may17
#
#####

# «Std.Format»  (to ".Std.Format")
# (to "coercion")
# (find-lean4prefile "Init/Data/Format/Basic.lean" "inductive Format")
# (find-lean4prefile "Init/Data/Format/Basic.lean" "Wadler's" "A Prettier Printer")
# (find-lean4prefile "Init/Data/Format/Basic.lean" "instance : Coe String Format := ⟨text⟩")
# (find-lean4prefile "Init/Data/Format/Basic.lean" "class ToFormat (α : Type u) where")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Init.Data.Format
#check Std.Format.isEmpty
#check Std.Format.paren
open   Std.Format
open   Std

#check Format
#check line
#check text
#check        text "ab"
#check paren (text "ab")
#check ( "ab" : Format)
#check (("ab" : String) : Format)
#eval paren "ab"

#eval nest 2 <| "."   ++ align true  ++ "a" ++ line ++ "b"
#eval nest 2 <| "..." ++ align true  ++ "a" ++ line ++ "b"
#eval nest 2 <| "..." ++ align false ++ "a" ++ line ++ "b"   -- ?
#eval nest 4 <| "..." ++ align true  ++ "a" ++ line ++ "b"

def pile : (List Format) → Format
  | []           => ""
  | [item]       => item
  | item :: rest => item ++ line ++ pile rest

def zpile (head : String) (fmts : List Format) :=
  nest (1 + String.length head) <| head ++ align true ++ (pile fmts)

#eval  pile       ["b", "c"]
#eval zpile "a"   ["b", "c"]
#eval zpile "aaa" ["b", "c"]
#eval zpile "aaa" ["b", "c", zpile "d" ["e", "f"]]

-- end





#####
#
# s!"str" and m!"str"
# 2024mar23
#
#####

# «string-interpolation»  (to ".string-interpolation")
# (to "interpolatedStr")
# (find-fplean4page 59 "String Interpolation")
# (find-fplean4text 59 "String Interpolation")
# (find-fplean4page 106 "when a value occurs in an interpolated string")
# (find-fplean4text 106 "when a value occurs in an interpolated string")
# (find-fplean4doc "getting-to-know/conveniences")
# (find-fplean4doc "getting-to-know/conveniences#string-interpolation")
# (find-fplean4doc "type-classes/pos#conversion-to-strings")
# (find-fplean4doc "type-classes/pos#conversion-to-strings" "in an interpolated string")




#####
#
# structures
# 2023jun24
#
#####

# «structure»  (to ".structure")
# «structures»  (to ".structures")
# (to "inductive")
# (to "coercion")
# (to "Repr")
# (find-fplean4page 18 "Structures")
# (find-fplean4text 18 "Structures")
# (find-fplean4page 20 "structure Point3D where")
# (find-fplean4text 20 "structure Point3D where")
# (find-fplean4page 23 "To override a structure's constructor name" "two colons")
# (find-fplean4text 23 "To override a structure's constructor name" "two colons")
# (find-fplean4page 24 "The function Point.modifyBoth")
# (find-fplean4text 24 "The function Point.modifyBoth")
# (find-fplean4doc "getting-to-know/structures")
# (find-fplean4doc "getting-to-know/structures#updating-structures")

# (find-tpil4page 106 "structure Prod")
# (find-tpil4text 106 "structure Prod")
# (find-tpil4page 152 "Declaring Structures")
# (find-tpil4text 152 "Declaring Structures")
# (find-tpil4doc  "inductive_types#constructors-with-arguments")
# (find-tpil4docr "inductive_types" "Constructors with Arguments")
# (find-tpil4docr "inductive_types" "structure Prod")
# (find-tpil4doc  "structures_and_records")
# (find-tpil4doc  "structures_and_records#declaring-structures")
# (find-tpil4docr "structures_and_records" "Declaring Structures")

# (find-lean4prefile "Lean/Elab/Structure.lean" "Recall that the `structure command syntax is")
# (find-lean-links "structFields")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'structFields' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\" structFields \"' *")
# (find-lean4prefile "Lean/Parser/Command.lean" "def structFields ")

# (find-anggfile "LEAN/structures1.lean")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

structure S1 where
  a : Nat
  b : Nat
structure S2 where
  mymk ::
  a : Nat
  b : Nat
structure S3 where         (a : Nat)   (b : Nat)
structure S4 where   mk :: (a : Nat)   (b : Nat)
structure S5 where mymk :: (a : Nat)   (b : Nat)
#print S1
#print S2
#print S3
#print S4
#print S5

inductive I1 where | mk :       Nat  →      Nat  → I1
inductive I2 where | mk :  (a : Nat) → (b : Nat) → I2
inductive I3 where | mk    (a : Nat)   (b : Nat) : I3
inductive I4 where | mk    (a : Nat)   (b : Nat)
inductive I5 where | mk    (a           b : Nat)
#print I1
#print I2
#print I3
#print I4
#print I5

#check I1.mk
#check I5.mk

-- end
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

structure Point where
  x : Float
  y : Float
deriving Repr

def     p45 : Point := { x := 4, y := 5 }
#eval   p45
#eval { p45 with y := 6 }

#check Point.mk
#check Point.x
#check Point.y

structure Point3D where
  x : Float
  y : Float
  z : Float
deriving Repr

def origin3D : Point3D := { x := 0.0, y := 0.0, z := 0.0 }

--#check { x := 0.0, y := 0.0 }           -- err
#check  ({ x := 0.0, y := 0.0 } : Point)
#check   { x := 0.0, y := 0.0   : Point}

-- end




#####
#
# structure-like
# 2024jun02
#
#####

# «structure-like»  (to ".structure-like")
# (find-lean4prefile "Lean/Expr.lean" "must be an structure-like inductive type. That is")



#####
#
# stx
# 2024jun13
#
#####

# «stx»  (to ".stx")
# (find-lean4prefile "Init/Notation.lean" "  | `(stx| $p +) => `(stx| many1($p))")





#####
#
# syntax (command)
# 2024jun08
#
#####

# «syntax-command»  (to ".syntax-command")
# (find-leanmetadoc  "main/05_syntax#free-form-syntax-declarations")
# (find-leanmetadocr "main/05_syntax" "### Free form syntax declarations")
# (find-leanmetadocr "main/05_syntax"   "add a new" "syntax rule to an already existing")
# (find-leanmetadocr "main/05_syntax"   "syntax \"[Bool|\" boolean_expr \"]\" : term")
# (find-leanmetadoc  "main/05_syntax#constructing-new-syntax")
# (find-leanmetadocr "main/05_syntax" "### Constructing new `Syntax`")
# (find-leanmetadoc  "main/05_syntax#matching-on-syntax")
# (find-leanmetadocr "main/05_syntax" "### Matching on `Syntax`")
# (find-leanmetadoc  "main/05_syntax#typed-syntax")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

#check Lean.Parser.Category
#print Lean.Parser.Category
#check Lean.Parser.Category.boolean_expr
declare_syntax_cat          boolean_expr
#check Lean.Parser.Category.boolean_expr

syntax "⊥" : boolean_expr
syntax "⊤" : boolean_expr
syntax:40 boolean_expr " OR "  boolean_expr : boolean_expr
syntax:50 boolean_expr " AND " boolean_expr : boolean_expr

syntax "[Bool|" boolean_expr "]" : term
#check_failure [Bool| ⊥ AND ⊤]

syntax binOne     := "O"
syntax binZero    := "Z"
syntax binDigit   := binZero <|> binOne
syntax binNumber  := binDigit,+
syntax binNumber' := binDigit,*
syntax "emptyBin(" binNumber' ")" : term
#check_failure emptyBin()

syntax "binCompact(" ("Z" <|> "O"),+ ")" : term
#check_failure binCompact(Z, O, Z, Z, O)

syntax "binDoc(" (str ";")? binNumber ")" : term
#check_failure binDoc(Z, O, Z, Z, O)
#check_failure binDoc("mycomment"; Z, O, Z, Z, O)

open Lean

def isAdd11 : Syntax → Bool
  | `(Nat.add 1 1) => true
  | _ => false

def isAdd : Syntax → Option (Syntax × Syntax)
  | `(Nat.add $x $y) => some (x, y)
  | _ => none

#eval isAdd11 (Syntax.mkApp (mkIdent `Nat.add) #[Syntax.mkNumLit "1", Syntax.mkNumLit "1"])
#eval isAdd11 (Syntax.mkApp (mkIdent `Nat.add) #[mkIdent `foo,        Syntax.mkNumLit "1"])
#eval isAdd   (Syntax.mkApp (mkIdent `Nat.add) #[Syntax.mkNumLit "1", Syntax.mkNumLit "1"])
#eval isAdd   (Syntax.mkApp (mkIdent `Nat.add) #[mkIdent `foo,        Syntax.mkNumLit "1"])
#eval isAdd   (Syntax.mkApp (mkIdent `Nat.add) #[mkIdent `foo])

-- end







#####
#
# syntax (parser)
# 2024may23
#
#####

# «syntax-parser»  (to ".syntax-parser")
# (find-lean-links "syntax")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'syntax' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\"syntax \"' *")
# (find-lean4prefile "Lean/Parser/Syntax.lean" "@[builtin_command_parser] def «syntax»")




#####
#
# syntax (name := bla) ...
# 2024may23
#
#####

# «syntax-name»  (to ".syntax-name")
# (find-lean-links "syntax")
# (find-leanmetadoc  "main/02_overview#3-essential-commands-and-their-syntax-sugars")
# (find-leanmetadocr "main/02_overview" "## 3 essential commands and their syntax sugars")
# (find-leanmetadoc  "main/05_syntax")
# (find-leanmetadocr "main/05_syntax")
# (find-leanmetadoc  "main/07_elaboration")
# (find-leanmetadocr "main/07_elaboration")
# (find-lean4pregrep "grep --color=auto -nRH --null -e syntax * | grep -a name")
# (find-leanmetadocrgrep "grep --color=auto -nRH --null -e 'syntax (name' *")
# (find-lean4prefile "Lean/Parser/Syntax.lean" "@[builtin_command_parser] def «syntax»")
# (find-lean4prefile "Lean/Parser/Syntax.lean" "def namedName := leading_parser")
# (find-lean4prefile "Lean/Elab/Command.lean" "abbrev CommandElab")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open Lean Elab Command

syntax (name := xxx) "red"   : command
syntax (name := yyy) "green" : command
syntax (name := zzz) "blue"  : command

@[macro xxx]        def redMacro   : Macro := λ stx => match stx with | _ => `(green)
@[macro yyy]        def greenMacro : Macro := λ stx => match stx with | _ => `(blue)
@[command_elab zzz] def blueElab   : CommandElab := λ _ => Lean.logInfo "finally, blue!"

red  -- finally, blue!

-- end




#####
#
# #synth
# 2024may31
#
#####

# «synth»  (to ".synth")
# (to "leading_parser")
# (to "Repr")
# (to "deriving")
# (find-lean-links "#synth")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/leading_parser.3F
# (find-lean4prefile "Lean/Parser/Command.lean" "@[builtin_command_parser] def synth")
# (find-lean4prefile "Lean/Elab/BuiltinCommand.lean" "@[builtin_command_elab «synth\ »] def elabSynth")
# (find-lean4pregrep "grep --color=auto -nRHw --null -e 'synth' *")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

set_option trace.Elab.command true

inductive myNat where
  | zero             : myNat
  | succ (n : myNat) : myNat
  deriving Repr

#synth Repr myNat
#print instReprMyNat

-- end




#####
#
# #tactic_expand1
# 2024jun23
#
#####

# «tactic_expand1»  (to ".tactic_expand1")
# https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/.E2.9C.94.20see.20result.20of.20tactic.20macro/near/446310888
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open   Lean

elab "#tactic_expand1 " t:tactic : command => do
  let some t ← Elab.liftMacroM <| Lean.Macro.expandMacro? t | logInfo m!"Not a macro"
  logInfo m!"{t}"

#tactic_expand1 exists 1
-- (refine ⟨1, ?_⟩; try trivial)

-- end




#####
#
# tagged-subgoals
# 2024apr30
#
#####

# «tagged-subgoals»  (to ".tagged-subgoals")
# (find-tpil4page  55 "5. Tactics")
# (find-tpil4text  55    "Tactics")
# (find-tpil4page  57    "tagged the first subgoal as left")
# (find-tpil4text  57    "tagged the first subgoal as left")
# (find-tpil4doc  "tactics#entering-tactic-mode")
# (find-tpil4docr "tactics" "Entering Tactic Mode")
# (find-tpil4docr "tactics" "Entering Tactic Mode" "tagged the first subgoal as")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

variable (P Q R : Prop)
variable {P Q R : Prop}
variable {p : P}
variable {q : Q}

example    (p : P) (q : Q) : P ∧ Q := And.intro p q
#check fun (p : P) (q : Q)         => And.intro p q

-- end







#####
#
# telescopes
# 2024apr27
#
#####

# «telescopes»  (to ".telescopes")
# (find-angg "LEAN/telescopes1.lean")
# (find-leanmetadoc  "main/04_metam#deconstructing-expressions")
# (find-leanmetadocr "main/04_metam" "### Deconstructing Expressions")
# (find-leanmetadocr "main/04_metam" "forallTelescope")
# (find-lean-links "telescope")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'telescope' *")
# (find-lean4pregrep "grep --color=auto -niRH --null -e 'telescope' *")
# (find-lean4pregrep "grep --color=auto -niRH --null -e 'foralltelescope' *")




#####
#
# termination
# 2024jun06
#
#####

# «termination»  (to ".termination")
# (to "partial")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'failed to show' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'fail to show' *")
# (find-fplean4page 31 "fail to show termination for")
# (find-fplean4text 31 "fail to show termination for")
# (find-fplean4-links "termination")
# (find-fplean4docrgrep "grep --color=auto -nRH --null -e 'termination' *")
# (find-fplean4docrgrep "grep --color=auto -nRH --null -e 'termination_by' *")
# (find-fplean4doc  "programs-proofs/summary")
# (find-fplean4doc  "programs-proofs/summary#proving-termination")
# (find-fplean4docr "programs-proofs/summary" "## Proving Termination")
# (find-fplean4docr "programs-proofs/summary" "## Proving Termination" "A good way")

"A good way to write recursive functions is to begin by declaring them
`partial` and debugging them with testing until they return the right
answers. Then, `partial` can be removed and replaced with a
`termination_by` clause."

fail to show termination for
  LuaTree.toLua
with errors
structural recursion cannot be used

failed to prove termination, possible solutions:
  - Use `have`-expressions to prove the remaining goals
  - Use `termination_by` to specify a different well-founded relation
  - Use `decreasing_by` to specify your own tactic for discharging this kind of goal




#####
#
# termParser
# 2024may15
#
#####

# «termParser»  (to ".termParser")
# (find-lean4prefile "Lean/Parser/Basic.lean" "def termParser")
# (find-lean4prefile "Lean/Parser/Basic.lean" "def termParser (prec : Nat := 0) : Parser :=")
# (find-lean4prefile "Lean/Parser/Basic.lean" "def categoryParser")




#####
#
# theorem
# 2024mar27
#
#####

# «theorem»  (to ".theorem")
# (find-fplean4doc "props-proofs-indexing#propositions-and-proofs")
# (find-fplean4doc "props-proofs-indexing#propositions-and-proofs" "theorem keyword instead of def")
# (find-tpil4doc  "propositions_and_proofs")
# (find-tpil4doc  "propositions_and_proofs#working-with-propositions-as-types")
# (find-tpil4docr "propositions_and_proofs" "Working with Propositions as Types")
# (find-tpil4docr "propositions_and_proofs" "``theorem`` command")
# (find-tpil4page 25 "the theorem command")
# (find-tpil4text 25 "the theorem command")
# (find-lean4prefile "Init/Tactics.lean" "This simp theorem")
# (find-lean4prefile "Lean/Meta/Tactic/Simp/SimpCongrTheorems.lean" "with the `congr` attribute")
# (find-lean4prefile "Lean/Elab/DefView.lean" "leading_parser \"theorem \"")
# (find-lean4prefile "Lean/Elab/Declaration.lean" "Lean.Parser.Command.theorem")
# (find-lean4prefile "Lean/Elab/Tactic/Simp.lean" "using the simp theorems collected in `ctx`")
# (find-lean4prefile "Lean/Parser/Command.lean" "def «theorem\ »")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/Explain.20induction.20in.20baby-steps.2E/near/447627480
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

variable (P Q R : Prop)
variable {P Q R : Prop}

theorem t1a : P → P := fun p : P =>             p
theorem t1b : P → P := fun p : P => show P from p
theorem t1c               (p : P)      : P   := p

#print t1a           -- p → q → p
#print t1b           -- p → q → p
#print t1c           -- p → q → p

theorem ta (p : P) (q : Q) : P ∧ Q := And.intro p q
example    (p : P) (q : Q) : P ∧ Q := And.intro p q
#check fun (p : P) (q : Q)         => And.intro p q
#check fun (p : P) (q : Q)         =>
  let paq := And.intro p q
  paq

-- end





#####
#
# toolchains
# 2024may12
#
#####

# «toolchains»  (to ".toolchains")
# (to "metaprogramming-toolchain")
# (find-fline "~/.elan/toolchains/")
# (code-c-d "elantoolchains" "~/.elan/toolchains/")
# (find-elantoolchainsfile "")
# (find-elantoolchainssh "du -ch")
# https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/Update.20toolchain



#####
#
# ToString
# 2024may22
#
#####

# «ToString»  (to ".ToString")
# (to "match-bar")
# (find-fplean4page 106 "ToString")
# (find-fplean4text 106 "ToString")
# (find-fplean4doc "type-classes/pos#conversion-to-strings")
# (find-lean4presh "find * | sort | grep -i tostring")
# (find-lean4prefile "Init/Data/ToString.lean")
# (find-lean4prefile "Init/Data/ToString/Basic.lean")
# (find-lean4prefile "Init/Data/ToString/Macro.lean")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

#check toString  42
#eval  toString  42
#check toString "42"
#eval  toString "42"

inductive N where
  | z         : N
  | s (n : N) : N
  deriving Repr

open N

#check s (s z)
#eval  s (s z)

def N.tos
  | z   => "z"
  | s n => "s" ++ n.tos

#check (s (s z)).tos
#eval  (s (s z)).tos

instance : ToString N := ⟨N.tos⟩

#check toString (s (s z))
#eval  toString (s (s z))

-- end




#####
#
# TPiL: exercises on p.38
# 2024jun22
#
#####

# «tpil-p38»  (to ".tpil-p38")
# (find-tpil4doc "propositions_and_proofs#examples-of-propositional-validities")
# (find-tpil4page 37 "Exercises" "Prove the following identities")
# (find-tpil4text 37 "Exercises" "Prove the following identities")
# (find-tpil4page 38 "-- commutativity of ∧ and ∨")
# (find-tpil4text 38 "-- commutativity of ∧ and ∨")
# (find-tpil4page 38 "example : p ∧ q ↔ q ∧ p := sorry")
# (find-tpil4text 38 "example : p ∧ q ↔ q ∧ p := sorry")
# (find-lean4prefile "Init/Core.lean" "structure Iff")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '↔' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\" ↔ \"' *")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

variable (P Q R : Prop)

-- commutativity of ∧ and ∨
theorem tc1 : P ∧ Q ↔ Q ∧ P := sorry
theorem tc2 : P ∨ Q ↔ Q ∨ P := sorry

-- associativity of ∧ and ∨
theorem ta1 : (P ∧ Q) ∧ R ↔ P ∧ (Q ∧ R) := sorry
theorem ta2 : (P ∨ Q) ∨ R ↔ P ∨ (Q ∨ R) := sorry

-- distributivity
theorem td1 : P ∧ (Q ∨ R) ↔ (P ∧ Q) ∨ (P ∧ R) := sorry
theorem td2 : P ∨ (Q ∧ R) ↔ (P ∨ Q) ∧ (P ∨ R) := sorry

-- other properties
theorem top1 : (P → (Q → R)) ↔ (P ∧ Q → R) := sorry
theorem top2 : ((P ∨ Q) → R) ↔ (P → R) ∧ (Q → R) := sorry
theorem top3 : ¬(P ∨ Q) ↔ ¬P ∧ ¬Q := sorry
theorem top4 : ¬P ∨ ¬Q → ¬(P ∧ Q) := sorry
theorem top5 : ¬(P ∧ ¬P) := sorry
theorem top6 : P ∧ ¬Q → ¬(P → Q) := sorry
theorem top7 : ¬P → (P → Q) := sorry
theorem top8 : (¬P ∨ Q) → (P → Q) := sorry
theorem top9 : P ∨ false ↔ P := sorry
theorem top10 : P ∧ False ↔ False := sorry
theorem top11 : (P → Q) → (¬Q → ¬P) := sorry

-- end
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

variable (P Q R : Prop)

theorem tc1 : P ∧ Q ↔ Q ∧ P :=
  let a : P ∧ Q → Q ∧ P :=
    fun b : P ∧ Q =>
      let c : P := b.1
      let d : Q := b.2
      let e : Q ∧ P := ⟨d,c⟩
      e
  let f : Q ∧ P → P ∧ Q :=
    fun g : Q ∧ P =>
      let h : Q := g.1 
      let i : P := g.2
      let j : P ∧ Q := ⟨i,h⟩
      j
  ⟨a,f⟩

#print  tc1
#reduce tc1

-- end






#####
#
# trace.Elab.command
# 2024jun08
#
#####

# «trace.Elab.command»  (to ".trace.Elab.command")
# (find-esgrep "grep --color=auto -niH --null -e trace.Elab.command lean.e")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

set_option trace.Elab.command true in
declare_syntax_cat ltsyntax

-- end

# (find-lean-links "trace")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'trace' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\" trace \"' *")




#####
#
# trace.Elab.info
# 2024jun10
#
#####

# «trace.Elab.info»  (to ".trace.Elab.info")
# (to "server")






#####
#
# try-catch
# 2024may12
#
#####

# «try-catch»  (to ".try-catch")
# (to "exceptions")
# (find-leanmetadoc  "main/01_intro#building-a-command")
# (find-leanmetadocr "main/01_intro" "### Building a command")
# (find-lean4prefile "Lean/CoreM.lean" "try-catch")
# (find-lean4prefile "Lean/Elab/Do.lean" "def doTry :=")
# (find-lean4pregrep "grep --color=auto -nRH --null -e catch *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'catch \"' *")
# (find-fplean4doc )
# (find-fplean4page 261 "def divFrontend")
# (find-fplean4text 261 "def divFrontend")
# (find-fplean4doc "monad-transformers/transformers#type-classes-for-exceptions")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

def ab [Monad m] [MonadExcept Nat m] : m String :=
  try          pure "a"
  catch | _ => pure "b"

#print ab

-- end





#####
#
# TSyntax
# 2024jun02
#
#####

# «TSyntax»  (to ".TSyntax")
# (to "checksyntax-test")
# (to "mkSyntaxQuotation")
# (find-lean4prefile "Init/Prelude.lean" "structure TSyntax")
# (find-leanmetagrep "grep --color=auto -nRH --null -e TSyntax *")
# (find-leanmetadoc  "main/05_syntax")
# (find-leanmetadocr "main/05_syntax")
# (find-leanmetadoc  "main/06_macros")
# (find-leanmetadocr "main/06_macros")
# (find-leanmetadoc  "main/07_elaboration")
# (find-leanmetadocr "main/07_elaboration")
# (find-leanmetadoc  "extra/03_pretty-printing")
# (find-leanmetadocr "extra/03_pretty-printing")
# (find-lean4pregrep "grep --color=auto -nwRH --null -e 'mainModule' *")
# (find-lean4pregrep "grep --color=auto -nwRH --null -e 'addMacroScope' *")
# (find-lean4pregrep "grep --color=auto -nwRH --null -e 'mkInfoFromRefPos' *")
# (find-lean4pregrep "grep --color=auto -nwRH --null -e 'TSyntax' * | grep -a instance")
# (find-lean4prefile "Init/Prelude.lean" "pure (Lean.addMacroScope mainModule n scp)")
# (find-lean4prefile "Init/Prelude.lean" "@[inline] def MonadQuotation.addMacroScope")
# (find-lean4prefile "Lean/Elab/Quotation.lean" "def stxQuot.expand (stx : Syntax) : TermElabM Syntax")
# (find-lean4prefile "Lean/Elab/Quotation.lean" "def mkSyntaxQuotation")
# (find-lean4prefile "Lean/Elab/Quotation.lean" "def mkSyntaxQuotation" "@TSyntax.mk")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

#check Lean.MonadRef.mkInfoFromRefPos
#check Lean.getCurrMacroScope
#check Lean.getMainModule
#check Lean.Syntax.atom
#check Lean.Syntax.node1
#check Lean.Syntax.node3
#check Lean.TSyntax

import Lean
open Lean Elab Command

#check                            TSyntax.mk
#check                            TSyntax.mk Syntax.missing
#check    show TSyntax `term from TSyntax.mk Syntax.missing
def ts := show TSyntax `term from TSyntax.mk Syntax.missing
#check ts
#eval  ts
#eval  ts.raw

def foo1                        (ts : TSyntax ks) : Nat := 42
def foo2 {ks : SyntaxNodeKinds} (ts : TSyntax ks) : Nat := 42
def foo3 {ks : SyntaxNodeKinds} (ts : TSyntax ks) : SyntaxNodeKinds := ks
def foo4 {ks : SyntaxNodeKinds} (ts : TSyntax ks) : Syntax := ts.raw

#check @foo1
#check @foo2
#eval  foo1 ts
#eval  foo3 ts
#eval  foo4 ts

elab "#withstring " x:str : command =>
  match x with
  | `("a")       => logInfo x
  | `("b")       => do { logInfo x; logInfo (repr x) }
  | `("c")       => do { logInfo x; logInfo (repr x.raw) }
  | _ => Elab.throwUnsupportedSyntax

#withstring "a"
#withstring "b"
#withstring "c"

def c := Lean.Syntax.node
 (Lean.SourceInfo.none)
 `str
  #[Lean.Syntax.atom
  (Lean.SourceInfo.original "".toSubstring { byteIdx := 317 } "\n\n".toSubstring { byteIdx := 320 })
  "\"c\""]

-- end




#####
#
# typeclass-search
# 2024jun22
#
#####

# «typeclass-search»  (to ".typeclass-search")
# (to "class")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/How.20does.20Lean.20.22synthesize.22.20a.20.22get.22.20inside.20a.20.22do.22.3F
# (find-lean4pregrep "grep --color=auto -niRH --null -e 'typeclass' *")
# (find-lean4pregrep "grep --color=auto -niRH --null -e 'typeclass search' *")
# (find-lean4pregrep "grep --color=auto -niRH --null -e 'typeclass inference' *")
# (find-lean4page 19 "typeclass resolution procedure")
# (find-lean4text 19 "typeclass resolution procedure")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

class Cla (α : Type) where met : String

instance : Cla String where met := "(string)"
instance : Cla Bool   where met := "(bool)"
instance : Cla Nat    where met := "(nat)"
instance : Cla Int    where met := "(int)"

def foo {α : Type} [inst : Cla α] (_ : α) : String := inst.met

#eval foo true
#eval foo   42
#eval foo (-42)
#eval foo "abc"

-- end
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

set_option linter.unusedVariables false

def foo1 [Monad m] [MonadState σ m]
         (a : Nat) : m Nat := do
  let xxxxxxxx := "--delimiter--"
  let b ← get      -- ok
  return a

def foo2 [Monad m] -- [MonadState σ m]
         (a : Nat) : m Nat := do
  let xxxxxxxx := "--delimiter--"
  let b ← get      -- error: failed to synthesize...
  return a

def foo3 [inst1 : Monad m] [inst2 : MonadState σ m]
         (a : Nat) : m Nat := do
  let xxxxxxxx := "--delimiter--"
  let b ← get      -- ok
  let c ← inst2.get -- same as b
  return _

-- end




#####
#
# typeof
# 2024may05
#
#####

# «typeof»  (to ".typeof")
# (find-lean-links "typeof")
# (find-lean4pregrep "grep --color=auto -niRH --null -e 'typeof' *")

def foo1 {A : _} (a : A) := a
def foo2 {A : _} (_ : A) := A
#check foo1 42
#check foo2 42





#####
#
# underscore
# 2024apr06
#
#####

# «underscore»  (to ".underscore")
# (find-tpil4page 36 "you can use an underscore _")
# (find-tpil4text 36 "you can use an underscore _")
# (find-tpil4page 21 "holes")
# (find-tpil4text 21 "holes")
# (find-tpil4page 87 "replaced by @t _")
# (find-tpil4text 87 "replaced by @t _")
# (find-tpil4page 87 "unicode brackets")
# (find-tpil4text 87 "unicode brackets")
# (find-tpil4doc  "propositions_and_proofs#examples-of-propositional-validities")
# (find-tpil4docr "propositions_and_proofs" "Examples of Propositional Validities")
# (find-tpil4docr "propositions_and_proofs" "you can use" "an underscore ``_``")
# (find-lean4grep "grep --color=auto -nRH --null -e 'synthesize placeholder' *")
# (find-lean4file "src/Lean/Elab/Term.lean" "synthesize placeholder")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

variable (P Q R : Prop)
theorem triv1 (p : P) : P := p
theorem triv2 («.P» : P) : P := «.P»
theorem triv3 («.P» : P) («P→Q» : P → Q) : Q := _
theorem triv4 («.P» : P) («P→Q» : P → Q) : Q := «P→Q» _
theorem triv5 («.P» : P) («P→Q» : P → Q) : Q := «P→Q» «.P»

-- end




#####
#
# Unhygienic.run
# 2024jun27
#
#####

# «Unhygienic.run»  (to ".Unhygienic.run")
# (to "mydef")
# (find-luatreeleanfile "ToPrettier1.lean")
# (find-lean4prefile "Lean/Hygiene.lean" "protected def run")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open   Lean
def stx := Unhygienic.run `(fun {α β} [BEq α] (ab : α×β) => let (a,_) := ab; a==a)
#eval IO.print stx
#eval IO.print (repr stx)

-- end





#####
#
# variable
# 2024mar15
#
#####

# «variable»  (to ".variable")
# (find-lean-links "the ``variable`` command")
# (find-tpil4doc  "dependent_type_theory")
# (find-tpil4doc  "dependent_type_theory#variables-and-sections")
# (find-tpil4docr "dependent_type_theory" "# Variables and Sections")
# (find-tpil4docr "dependent_type_theory" "the ``variable`` command")
# (find-tpil4doc  "dependent_type_theory#implicit-arguments")
# (find-tpil4docr "dependent_type_theory" "Implicit Arguments")
# (find-tpil4docr "dependent_type_theory" "can also be specified as implicit")
# (find-tpil4doc  "propositions_and_proofs")
# (find-tpil4doc  "propositions_and_proofs#disjunction")
# (find-tpil4docr "propositions_and_proofs" "### Disjunction")
# (find-tpil4docr "propositions_and_proofs" "variable (p q r : Prop)")
# (find-tpil4docr "propositions_and_proofs" "variable {p : Prop}")
# (find-lean4doc      "sections")
# (find-lean4docrfile "sections.md" "``variable``")
# (find-lean4docrfile "sections.md" "``section``")
# (find-lean4prefile "Lean/Parser/Command.lean" "@[builtin_command_parser] def «variable»")
# (find-lean4prefile "Lean/Meta/ExprTraverse.lean" "variable {M} [Monad M] [MonadLiftT MetaM M]")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/I.20accidentally.20proved.202.3D3



#####
#
# #where
# 2024may18
#
#####

# «where»  (to ".where")
# (to "getCurrNamespace")
# (find-lean-links "#where")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '#where' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e 'where' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '«where»' *")
# (find-lean4pregrep "grep --color=auto -nRH --null -e '\" #where \"' *")
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/A.20command.20that.20prints.20the.20current.20namespace.3F/near/439330480
# (find-sh "lean")
# (find-sh "lean --version")
# (find-lean4prefile "")




#####
#
# whnf
# 2024may28
#
#####

# «whnf»  (to ".whnf")
# (to "reduce")
# (find-leanmetadoc  "main/04_metam#weak-head-normalisation")
# (find-leanmetadocr "main/04_metam" "### Weak Head Normalisation")
# (ee-copy-rest-3m nil "-- end" "/tmp/L/a.lean")

import Lean
open Lean Lean.Expr Lean.Meta

open Lean.Elab.Term in
def whnf' (e : TermElabM Syntax) : TermElabM Format := do
  let e ← elabTermAndSynthesize (← e) none
  ppExpr (← whnf e)

#eval whnf' `(List.cons 1 [])
#eval whnf' `(List.cons (1 + 1) [])
#eval withTransparency .reducible $ whnf' `(List.append [1] [2])
#eval whnf' `(λ x : Nat => x)
#eval whnf' `(∀ x, x > 0)
#eval whnf' `(Type 3)
#eval whnf' `((15 : Nat))
#eval whnf' `(List.append [1])
#eval whnf' `((λ x y : Nat => x + y) 1)
#eval whnf' `(let x : Nat := 1; x)

def matchAndReducing (e : Expr) : MetaM (Option (Expr × Expr)) := do
  match ← whnf e with
  | (.app (.app (.const ``And _) P) Q) => return some (P, Q)
  | _ => return none

def matchAndReducing₂ (e : Expr) : MetaM (Option (Expr × Expr × Expr)) := do
  match ← whnf e with
  | (.app (.app (.const ``And _) P) e') =>
    match ← whnf e' with
    | (.app (.app (.const ``And _) Q) R) => return some (P, Q, R)
    | _ => return none
  | _ => return none

-- end






#####
#
# delaborator-diagram
# 2024mar10
#
#####

# «delaborator-diagram»  (to ".delaborator-diagram")
# https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Pretty-printing.20of.20sums/near/355279588
# https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Pretty-printing.20of.20sums/near/355262783
#
# String ---(parser)---> Syntax ---(elaborator)---> Expr ---(delaborator)---> Syntax ---(formatter)---> String
#
#         parser           elaborator         delaborator           formatter
# String --------> Syntax ------------> Expr -------------> Syntax -----------> String







#####
#
# reference-manual
# 2024mar09
#
#####

# «reference-manual»  (to ".reference-manual")
# «:leanref»                       (to ".:leanref")
# (find-angg ".emacs.lean.el" "ee-rstdoc-:leanref")
# https://leanprover.github.io/reference/
# (find-leanrefdoc  "using_lean#using-lean-with-emacs")
# (find-leanrefdocw "using_lean#using-lean-with-emacs")
# (find-leanrefdocw "declarations")

# (code-c-d "leanrefdoc" "$S/https/leanprover.github.io/reference/")
# (find-leanrefdocfile "")
# (find-leanrefdocfile "_sources/")

# (find-leanrefdocfile "")
# https://leanprover.github.io/reference/lean_reference.pdf
(code-pdf-page "leanref" "$S/https/leanprover.github.io/reference/lean_reference.pdf")
(code-pdf-text "leanref" "$S/https/leanprover.github.io/reference/lean_reference.pdf")
;; (find-leanrefpage)
;; (find-leanreftext)




#####
#
# metaprogramming
# 2024mar09
#
#####

# «metaprogramming»  (to ".metaprogramming")
# «:leanmeta»              (to ".:leanmeta")
# (find-angg ".emacs"         "ee-rstdoc-:leanmeta")
# (find-angg ".emacs.lean.el" "ee-rstdoc-:leanmeta")
# (to "mySpecialCheck")
# (to "mdgen")
# (find-es "minted")
# (find-lean4-intro "1. `find-wgetrecursive-links'")
# https://leanprover-community.github.io/lean4-metaprogramming-book/md/

# https://github.com/leanprover-community/
# https://github.com/leanprover-community/lean4-metaprogramming-book
# (find-git-links "https://github.com/leanprover-community/lean4-metaprogramming-book" "leanmeta")
# (code-c-d "leanmeta" "~/usrc/lean4-metaprogramming-book/")
# (find-leanmetafile "")
# (find-leanmetash "find * | sort")
# (find-leanmetash "cd lean; find * | sort")
# (find-leanmetafile "lean/main/01_intro.lean")

# (find-wgetrecursive-links "https://leanprover-community.github.io/lean4-metaprogramming-book/")
# (find-leanmetadoc)
# (find-leanmetadoc  "main/06_macros")
# (find-leanmetadoc  "main/03_expressions")

# (find-leanmetadocrfile "main/07_elaboration.lean")

# (find-leanmetadoc  "main/01_intro")
# (find-leanmetadoc  "main/01_intro#book-structure")
# (find-leanmetadoc  "main/01_intro#building-a-command")
# (find-leanmetadocr "main/01_intro#building-a-command")
# (find-leanmetadoc  "main/02_overview")
# (find-leanmetadoc  "main/03_expressions")
# (find-leanmetadoc  "main/04_metam")
# (find-leanmetadoc  "main/04_metam#full-normalisation")
# (find-leanmetadoc  "main/04_metam#constructing-expressions")
# (find-leanmetadocr "main/04_metam#constructing-expressions")
# (find-leanmetadocw "main/04_metam#constructing-expressions")
# (find-leanmetadoc  "main/04_metam#deconstructing-expressions")
# (find-leanmetadoc  "main/05_syntax")
# (find-leanmetadoc  "main/06_macros")
# (find-leanmetadoc  "main/07_elaboration")
# (find-leanmetadocr "main/07_elaboration" "### Giving meaning to commands" "MonadEnv")
# (find-leanmetadoc  "main/08_dsls")
# (find-leanmetadoc  "main/09_tactics")
# (find-leanmetadoc  "main/10_cheat-sheet")

# (find-git-links "https://github.com/leanprover-community/lean4-metaprogramming-book" "leanmeta")

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
rm -Rfv ~/usrc/lean4-metaprogramming-book/
cd      ~/usrc/
git clone https://github.com/leanprover-community/lean4-metaprogramming-book
cd      ~/usrc/lean4-metaprogramming-book/

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
cd      ~/usrc/lean4-metaprogramming-book/
git clean -dfx
git pull

lake exe cache get
lake exe cache get!

lake exe mdgen lean md
lake exe mdgen lean md

lake build lean4-metaprogramming-book |& tee olb
lake build lean4-metaprogramming-book md |& tee olb

# (code-c-d "leanmeta" "~/usrc/lean4-metaprogramming-book/")
# (find-leanmetafile "")
# (find-leanmetafile "md/")
# (find-leanmetafile "pygments/")
# (find-leanmetafile "lakefile.lean")
# (find-leanmetafile "olb")
# (find-leanmetash "find * | sort")
# (find-leanmetash "find .lake | sort")
# (find-leanmetash "find .lake * | sort")
# (find-leanmetash "find .lake * | rev | sort | rev")
# (find-leanmetafile ".lake/packages/std/")
# (find-leanmetagrep "grep --color=auto -niRH --null -e pdf * .lake")
# (find-leanmetagrep "grep --color=auto -niRH --null -e mdgen * .lake")
# (find-leanmetagrep "grep --color=auto -niRH --null -e 'lake exe' * .lake")
# (find-leanmetagrep "grep --color=auto -niRH --null -e pygments * .lake")
# (find-leanmetafile ".lake/packages/mdgen/")
# (find-leanmetafile ".lake/packages/mdgen/README.md")
# (find-leanmetafile ".lake/packages/mdgen/README.md" "lake exe mdgen <input_dir> <output_dir>")



#####
#
# metaprogramming-book.yml
# 2024may28
#
#####

# «metaprogramming-book.yml»  (to ".metaprogramming-book.yml")
# (find-leanmetafile ".github/workflows/book.yml")




#####
#
# metaprogramming-toolchain
# 2024may26
#
#####

# «metaprogramming-toolchain»  (to ".metaprogramming-toolchain")
# https://leanprover-community.github.io/install/project.html#working-on-an-existing-project

# (to "toolchains")
# (find-leanmetafile "")
# (find-leanmetafile "lake-manifest.json")
# (find-leanmetafile "lake-manifest.json" "inputRev")
# (find-leanmetafile "lake-manifest.json" "inputRev" "v4.7.0")
# (find-leanmetafile "lakefile.lean")
# (find-leanmetafile "lakefile.lean" "require std from git")
# (find-leanmetafile "lakefile.lean" "require std from git" "v4.7.0")
# (find-leanmetafile "lean-toolchain")
# (find-leanmetafile "lean-toolchain" "leanprover/lean4:v4.7.0")





#####
#
# TermElabM
# 2024may25
#
#####

# «TermElabM»  (to ".TermElabM")
# (to "mySpecialCheck")
# (find-leanmetadocr "main/07_elaboration" "`TermElabM` is basically an upgrade of")







#####
#
# Theorem Proving in Lean 4
# 2024may19
#
#####

# «tpil»  (to ".tpil")
# (find-angg ".emacs" "ee-rstdoc-:tpil4")
# (find-angg ".emacs.lean.el" "ee-rstdoc-:tpil4")
# https://lean-lang.org/theorem_proving_in_lean4/title_page.html
# https://github.com/leanprover/theorem_proving_in_lean4
# (find-wgetrecursive-links "https://lean-lang.org/theorem_proving_in_lean4/")
# (find-git-links "https://github.com/leanprover/theorem_proving_in_lean4" "tpil")
# (code-c-d "tpil" "~/usrc/theorem_proving_in_lean4/")
# (find-tpilfile "")




#####
#
# useandabuseoip
# 2024may25
#
#####

# «useandabuseoip»  (to ".useandabuseoip")
# (find-psne-arxiv-links "https://arxiv.org/pdf/2202.01629v3.pdf" "useandabuseoip")

;; <useandabuseoip>
;; https://arxiv.org/abs/2202.01629v3
;; https://arxiv.org/pdf/2202.01629v3.pdf
;; Anne Baanen: "Use and abuse of instance parameters in the Lean mathematical library"
(code-pdf-page "useandabuseoip" "$S/https/arxiv.org/pdf/2202.01629v3.pdf")
(code-pdf-text "useandabuseoip" "$S/https/arxiv.org/pdf/2202.01629v3.pdf")
;; (find-useandabuseoippage)
;; (find-useandabuseoiptext)





#####
#
# Sebastian Ullrich: Lean Together 2021 - Metaprogramming in Lean 4
# 2024mar11
#
#####

# «ullrichmp»  (to ".ullrichmp")
# (to "pratt-parser")
# (find-angg ".emacs.lean.el" "lt2021leo")
# (find-angg ".emacs.lean.el" "lt2021leom")

https://www.researchgate.net/scientific-contributions/Sebastian-Ullrich-2132232638
https://leanprover-community.github.io/papers.html
https://leanprover-community.github.io/lt2021/
https://leanprover-community.github.io/lt2021/schedule.html ***
https://leanprover-community.github.io/lt2021/slides/leo-LT2021.pdf
https://leanprover-community.github.io/lt2021/slides/leo-LT2021-meta.pdf
https://leanprover-community.github.io/lt2021/slides/sebastian-lean4-parsers-macros.pdf
https://leanprover-community.github.io/lt2021/slides/sebastian-An-Overview-of-Lean-4-Demo.pdf
https://leanprover-community.github.io/lt2021/slides/gihan-exlean_2021.pdf
https://leanprover-community.github.io/lt2021/slides/thomas-LT2021-Galois-Theory.pdf

# (find-youtubedl-links "/sda5/videos/" "Lean_Together_2021_-_Metaprogramming_in_Lean_4" "hxQ1vvhYN_U" ".webm" "lt2021sebastianleo")


# (code-video "ullrichmpvideo" "/sda5/videos/Lean_Together_2021_-_Metaprogramming_in_Lean_4-hxQ1vvhYN_U.webm")
# (find-ullrichmpvideo "0:00")
# (find-ullrichmpvideo "6:50" "notation")
# (find-ullrichmpvideo "8:45" "trace.Elab.command")
# (find-ullrichmpvideo "9:30" "for the next command")
# (find-ullrichmpvideo "12:00" "longest parse wins")
# (find-ullrichmpvideo "26:45" "crosses")

(code-pdf-page "ullrichmp" "$S/https/leanprover-community.github.io/lt2021/slides/sebastian-lean4-parsers-macros.pdf")
(code-pdf-text "ullrichmp" "$S/https/leanprover-community.github.io/lt2021/slides/sebastian-lean4-parsers-macros.pdf")
;; (find-ullrichmppage)
;; (find-ullrichmptext)
# (find-ullrichmppage 5 "notation:80 lhs \" ^ \" rhs:80 =>")
# (find-ullrichmptext 5 "notation:80 lhs \" ^ \" rhs:80 =>")
# (find-ullrichmppage 13 "precedence (Pratt) parser")
# (find-ullrichmptext 13 "precedence (Pratt) parser")

1-2-3


# (find-leanmetadoc "md/main/05_syntax#declaration-helpers" "longest parse")



#####
#
# mechanics-of-proof
# 2024jun01
#
#####

# «mechanics-of-proof»  (to ".mechanics-of-proof")
# «:mechprf»                       (to ".:mechprf")
# (find-angg ".emacs.lean.el" "ee-rstdoc-:mechprf")
# https://hrmacbeth.github.io/math2001/
# (find-git-links "https://github.com/hrmacbeth/math2001" "mechprf")
# (code-c-d "mechprf" "~/usrc/math2001/")
# (find-mechprffile "")
# (find-mechprffile "README.md")
# (find-mechprffile "Library/")
# (find-mechprffile "Math2001/")

# (find-mechprfdoc      "01_Proofs_by_Calculation")
# (find-mechprfdocw     "01_Proofs_by_Calculation")
# (find-mechprfdocrfile "01_Proofs_by_Calculation/")




#####
#
# Colorized
# 2024jun04
#
#####

# «Colorized»  (to ".Colorized")
# (to "lake-current-directory")
# (find-telegachat  "@leanlangbr#520" "lakefile current directory")
# https://github.com/axiomed
# https://github.com/axiomed/Colorized.lean
# https://github.com/algebraic-sofia?tab=repositories
# https://github.com/edrx
# (find-git-links "https://github.com/axiomed/Colorized.lean" "colorized")
# (code-c-d "colorized" "~/usrc/Colorized.lean/")
# (find-colorizedfile "")

* (eepitch-shell)
* (eepitch-kill)
* (eepitch-shell)
rm -Rfv ~/usrc/Colorized.lean/
cd      ~/usrc/
git clone https://github.com/axiomed/Colorized.lean
cd      ~/usrc/Colorized.lean/
# lake exe example
# lake exe example

# (find-colorizedfile "")
# (find-colorizedfile "lakefile.lean")
# (find-colorizedfile "Example.lean")
# (find-colorizedfile "Colorized.lean")





#####
#
# leandojo
# 2024jun07
#
#####

# «leandojo»  (to ".leandojo")
# https://leandojo.readthedocs.io/en/latest/user-guide.html#traced-repos




#####
#
# `do' Unchained: Embracing Local Imperativity in a Purely Functional Language
# 2024jun14
#
#####

# «do-unchained»  (to ".do-unchained")
# (to "let-mut")

;; https://lean-lang.org/papers/do.pdf
;; `do' Unchained: Embracing Local Imperativity in a Purely Functional Language (Functional Pearl)
;; SEBASTIAN ULLRICH, Karlsruhe Institute of Technology, Germany
;; LEONARDO DE MOURA, Microsoft Research, USA
;; (find-fline "$S/https/lean-lang.org/papers/")
(code-pdf-page  "dounchained" "$S/https/lean-lang.org/papers/do.pdf")
(code-pdf-text8 "dounchained" "$S/https/lean-lang.org/papers/do.pdf")
;; (find-dounchainedpage)
;; (find-dounchainedtext)





















stdout.putStrLn


# (find-fplean4page 76 "import «Greeting»")
# (find-fplean4text 76 "import «Greeting»")



https://leanprover-community.github.io/lean4-metaprogramming-book/md/main/01_intro.html#introducing-notation-defining-new-syntax





https://lovettsoftware.com/NaturalNumbers/PropositionWorld.lean.html

Proposition world.

A Proposition is a true/false statement, like 2 + 2 = 4 or 2 + 2 = 5.
Just like we can have concrete sets in Lean like mynat, and abstract
sets called things like X, we can also have concrete propositions like
2 + 2 = 5 and abstract propositions called things like P.

Mathematicians are very good at conflating a theorem with its proof.
They might say "now use theorem 12 and we're done". What they really
mean is "now use the proof of theorem 12..." (i.e. the fact that we
proved it already). Particularly problematic is the fact that
mathematicians use the word Proposition to mean "a relatively
straightforward statement which is true" and computer scientists use
it to mean "a statement of arbitrary complexity, which might be true
or false". Computer scientists are far more careful about
distinguishing between a proposition and a proof. For example: x + 0 =
x is a proposition, and add_zero x is its proof. The convention we'll
use is capital letters for propositions and small letters for proofs.


https://www.ma.imperial.ac.uk/~buzzard/xena/natural_number_game/FAQ.html
https://github.com/ImperialCollegeLondon/natural_number_game
https://github.com/mpedramfar/Lean-game-maker






https://xenaproject.wordpress.com/2021/06/05/half-a-year-of-the-liquid-tensor-experiment-amazing-developments/
Picking a basis and then pretending you didn’t

https://github.com/leanprover-community/leanprover-community.github.io/blob/newsite/data/zulip.md

https://leanprover.zulipchat.com/#narrow/stream/113488-general/topic/Calling.20lean.20from.20command.20line


https://www.ma.imperial.ac.uk/~buzzard/xena/natural_number_game/
https://www.microsoft.com/en-us/research/uploads/prod/2020/11/perceus-tr-v1.pdf

(find-books "__comp/__comp.el" "colton")

https://leanprover.github.io/reference/
https://leanprover.github.io/reference/using_lean.html#using-lean-with-emacs
https://lawrencecpaulson.github.io/2023/01/18/Sqrt2_irrational.html
https://news.ycombinator.com/item?id=34437735 Formalising a new proof that the square root of two is irrational (lawrencecpaulson.github.io) ***
https://news.ycombinator.com/item?id=35511152 What I've Learned About Formal Methods in Half a Year (jakob.space)

;; <schemesinlean>
;; https://arxiv.org/abs/2101.02602
;; https://arxiv.org/pdf/2101.02602.pdf
(code-pdf-page "schemesinlean" "$S/https/arxiv.org/pdf/2101.02602.pdf")
(code-pdf-text "schemesinlean" "$S/https/arxiv.org/pdf/2101.02602.pdf")
;; (find-schemesinleanpage)
;; (find-schemesinleantext)

https://proofassistants.stackexchange.com/questions/2153/type-theory-lean-3-to-lean-4

;; <ullrichmhm>
;; https://arxiv.org/abs/2001.10490
;; https://arxiv.org/pdf/2001.10490.pdf
;; Ullrich/Moura: "Beyond Notations: Hygienic Macro Expansion for Theorem Proving Languages"
(code-pdf-page "ullrichmhm" "$S/https/arxiv.org/pdf/2001.10490.pdf")
(code-pdf-text "ullrichmhm" "$S/https/arxiv.org/pdf/2001.10490.pdf")
;; (find-ullrichmhmpage)
;; (find-ullrichmhmtext)
# (find-ullrichmhmpage 13 "token antiquotation %$x")
# (find-ullrichmhmtext 13 "token antiquotation %$x")

;; <leanteach2020>
;; https://github.com/vaibhavkarve/leanteach2020
;; https://vaibhavkarve.github.io/leanteach_report.pdf
;; https://wiki.illinois.edu/wiki/display/LT2020/LeanTeach+2020+Home
;; Dolcos/Kong/Zhao/Phillips/Karve: "Interactive Theorem Proving in Lean"
(code-pdf-page "leanteach2020" "$S/https/vaibhavkarve.github.io/leanteach_report.pdf")
(code-pdf-text "leanteach2020" "$S/https/vaibhavkarve.github.io/leanteach_report.pdf")
(code-c-d      "leanteach2020"      "~/usrc/leanteach2020/")
(code-video    "leanteach2020video" "~/usrc/leanteach2020/igl_talk.mp4")
;; (find-leanteach2020page)
;; (find-leanteach2020text)

# (find-git-links "https://github.com/vaibhavkarve/leanteach2020" "leanteach2020")
# (find-leanteach2020file "")
# (find-leanteach2020video)
# (find-leanteach2020video "0:00")

https://pp.ipd.kit.edu/person.php?id=144 Dr.-Ing. Sebastian Ullrich
https://www.math.uni-bonn.de/ag/logik/events/MLPTT/Ullrich_lean.pdf Embedding Languages into Lean 4

;; <ullrichemb>
;; https://www.math.uni-bonn.de/ag/logik/events/MLPTT/Ullrich_lean.pdf
;; (find-fline "$S/https/www.math.uni-bonn.de/ag/logik/events/MLPTT/")
(code-pdf-page "ullrichemb" "$S/https/www.math.uni-bonn.de/ag/logik/events/MLPTT/Ullrich_lean.pdf")
(code-pdf-text "ullrichemb" "$S/https/www.math.uni-bonn.de/ag/logik/events/MLPTT/Ullrich_lean.pdf")
;; (find-ullrichembpage)
;; (find-ullrichembtext)
# (find-ullrichembpage 20 "ParserContext =")
# (find-ullrichembtext 20 "ParserContext =")

https://leanprover.github.io/presentations/20181012_MSR/#/4
https://leanprover-community.github.io/lt2021/slides/sebastian-An-Overview-of-Lean-4-Demo.pdf




https://jiggerwit.wordpress.com/2018/09/18/a-review-of-the-lean-theorem-prover/ elaborator
https://jiggerwit.wordpress.com/2019/06/20/an-argument-for-controlled-natural-languages-in-mathematics/

https://leanprover.github.io/papers/lean4.pdf



https://leanprover-community.github.io/archive/stream/270676-lean4/topic/Metaprogramming.20tutorial.html

https://github.com/leanprover-community/quote4

https://leanprover-community.github.io/undergrad.html
https://leanprover-community.github.io/mathlib4_docs/Mathlib/Analysis/NormedSpace/Exponential.html#NormedSpace.exp
https://leanprover-community.github.io/mathlib-overview.html
https://leanprover-community.github.io/mathlib4_docs/Mathlib/CategoryTheory/Yoneda.html#CategoryTheory.yoneda
https://leanprover-community.github.io/theories/category_theory.html
https://github.com/ImperialCollegeLondon/formalising-mathematics-2024
https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Project.20idea.3A.20linking.20MathLib.20to.20math.20books
https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/idiom.20for.20using.20calc.20to.20rewrite.20the.20goal

https://github.com/leanprover-community/lean4-samples/blob/main/RubiksCube/README.md
https://lean-lang.org/lean4/doc/examples/widgets.lean.html
https://github.com/leanprover-community/lean4-samples/blob/main/ListComprehension/README.md
https://github.com/leanprover-community/lean4-samples/blob/main/GuessMyNumber/README.md

https://florisvandoorn.com/ HOTT in Lean

(find-lean4prefile "Init/Prelude.lean" "triangle")

https://github.com/kmill
https://github.com/kmill/lean4-raytracer
https://github.com/kmill/LeanTeX
https://github.com/kmill/glimpse_of_lean
https://github.com/kmill/leanprover-community.github.io
https://github.com/kmill/tutorials
https://leanprover-community.github.io/archive/stream/270676-lean4/topic/getting.20started.20with.20Lean.204.html
https://kmill.github.io/cv/cv.pdf

https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/Creating.20Expr.20objects/near/438922814




@_**Eduardo Ochs|381195** [said](https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/leading_parser.3F/near/439313997):
````quote
Now about the output of "`#print foo`": wow and thanks! It works here, but I think that I need to understand other things before understanding that... and my guess is that would be a good idea to start by understand how "`deriving Repr`" works in a simple case. I tried this,

```
inductive myNat where
  | zero             : myNat
  | succ (n : myNat) : myNat
  deriving Repr

def my1 := myNat.succ myNat.zero
#check my1
#eval  my1
#print my1
#check repr my1
#eval  repr my1
#print repr my1
#check Std.Format
```

and then:

1) the method "`repr`" for the type `myNat` is not in a super-obvious place, like in `myNat.repr`,

2) the output of "`#check repr my1`" is "`repr my1 : Std.Format`", and I don't have test snippets (yet) for the class [Std.Format](https://github.com/leanprover/lean4/blob/master/src/Init/Data/Format/Basic.lean),

3) but I read some parts of the source starting by "[mkReprInstanceHandler](https://github.com/leanprover/lean4/blob/master/src/Lean/Elab/Deriving/Repr.lean#L118)" and I found references to "[isInductive](https://github.com/leanprover/lean4/blob/master/src/Lean/MonadEnv.lean#L27)" and "[getStructureFields](https://github.com/leanprover/lean4/blob/master/src/Lean/Structure.lean#L79)" - they look very useful, can we start by them? If yes, question: how do I call "`isInductive`" and "`getStructureFields`" on the "`myNat`" or on the "`my1`" of the example above?

Thanks in advance!
````




https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/leading_parser.3F/near/439313997



How to use getStructureFields
Hi all! How can I use [getStructureFields](https://github.com/leanprover/lean4/blob/master/src/Lean/Structure.lean#L79) to obtain the fields of a structure? Or, to be more concrete, how can I use it to obtain the fields of myNat after running this?

```
inductive myNat where
  | zero             : myNat
  | succ (n : myNat) : myNat
  deriving Repr

def my1 := myNat.succ myNat.zero
#check my1
#eval  my1
#print my1
```

NOTE: the question above is similar to one that I asked in a [thread about leading_parser](https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/leading_parser.3F), and it may be related to [this thread](https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/How.20do.20I.20write.20a.20.22.23check_syntax.22.3F/near/438953824), in which 

showed me this example of how to write a command...

```
import Lean.Elab.Command
elab "#check_syntax " t:term : command => do Lean.logInfo m!"{repr t.raw}"
#check_syntax 42 + "foo"
```

https://leanprover.zulipchat.com/#narrow/stream/116395-maths/topic/Proving.20extentionality.20for.20category.20structure.20with.207.20entries
https://www.ma.imperial.ac.uk/~buzzard/xena/pdfs/BuzzardICM2022talk.pdf
https://gilkalai.wordpress.com/2022/07/17/icm-2022-kevin-buzzard-the-rise-of-formalism-in-mathematics/
https://alectryon-paper.github.io/bench/books/proof-by-reflection.html

# Clément Pit-Claudel: "Untangling mechanized proofs"
# https://dl.acm.org/doi/10.1145/3426425.3426940 
# https://dl.acm.org/doi/pdf/10.1145/3426425.3426940

https://leanprover.zulipchat.com/#narrow/stream/113488-general/topic/writing.20simple.20parsers Parsec
https://news.ycombinator.com/item?id=34456573 Lean – Theorem Prover (leanprover.github.io)

;; <ochigame>
;; https://arxiv.org/abs/2309.11457v1
;; https://arxiv.org/abs/2309.11457v1.pdf
(code-pdf-page "ochigame" "$S/https/arxiv.org/abs/2309.11457v1.pdf")
(code-pdf-text "ochigame" "$S/https/arxiv.org/abs/2309.11457v1.pdf")
;; (find-ochigamepage)
;; (find-ochigametext)

https://mathstodon.xyz/@tao/111208692505811257 Terence Tao and the NNG
https://fredrikj.net/blog/2022/04/things-i-would-like-to-see-in-a-computer-algebra-system/#section7

Lean phrasebook:
https://docs.google.com/spreadsheets/d/1Gsn5al4hlpNc_xKoXdU6XGmMyLiX4q-LFesFVsMlANo/edit#gid=854838157

https://media.ccc.de/v/gpn22-483-intro-to-lean-4-a-language-at-the-intersection-of-programming-and-mathematics
https://lean-fro.org/about/roadmap/

https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/.E2.9C.94.20Lean4.20equivalent.20of.20library_search.20and.20suggest
https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/.E2.9C.94.20Discussion.3A.20Making.20Your.20Lean.20Code.20More.20Readable focusing dot

# Kyle Miller, 2024jun12 - Here's the sort of mental model I have for Lean's type system:
# https://leanprover.zulipchat.com/#narrow/stream/113489-new-members/topic/.E2.9C.94.20Type.20and.20Type*/near/444063991

https://github.com/PatrickMassot/GlimpseOfLean

Proof Visualization for the Lean 4 theorem prover
https://pp.ipd.kit.edu/uploads/publikationen/b%C3%BClow22bachelorarbeit.pdf 

https://blog.codeminer42.com/exploring-lean4/ Sofia
https://github.com/orgs/axiomed/repositories
https://github.com/axiomed/Http.lean
https://kmicinski.com/cis352-f23/assets/slides/types.pdf




#  Local Variables:
#  coding:           utf-8-unix
#  End: