- Common Lisp
I’m really going to put scheme and common lisp in the same category?
Gambit vs Chez vs Guile scheme. Me dunno Gerbil is a system on top of Gambit approximately similar to racket
(print "hello world") (print "~a foo" 'bar)
#lang racket (print "hello world")
raco pkg install minikanren
#lang racket (require minikanren) (run 1 (q) (fresh (x y z) (== x q) (== 3 y)))
http://io.livecode.ch/ more minikanren examples [implementing microkanren (https://www.youtube.com/watch?v=0FwIwewHC3o)
http://tca.github.io/veneer/examples/editor.html minikanren examples.
https://github.com/wilbowma/cur a curious dependently typed proof assistant
Mythical Macros tutorial https://soegaard.github.io/mythical-macros/
Macros and Languages in Racket book draft http://rmculpepper.github.io/malr/ 1
Racket Guide: Creating Languages https://docs.racket-lang.org/guide/languages.html
Racket Docs search for all languages: https://docs.racket-lang.org/search/index.html?q=H%3A
Rosette - should be a confluence of my interests. I feel like I want some kind of macro engine for smtlib. Perhaps it makes intermiedtae queries, perhaps not. stage0 would be “just” a macro expander for smtlib.
#lang rosette (define-symbolic b boolean?) (assert #t) (assume b) (verify b) (define-symbolic b boolean?)
Lisp-2 - seperate namespace for functions and vasriables -Common lisp Condition system lisp class system CLOS
https://letoverlambda.com/index.cl/guest/chap2.html let over lambda. Let in common lisp makes a ref cell?
Lisp in easy pieces
Hmm. make_gambit does this stuff? https://gitter.im/gambit/gambit?at=5bc7fb95435c2a518ec448d1
This final concatenation step is bizarre. Hmm wasn’t necessayr on minimal example in gitter above
% cat test.scm (println "hello!") % gsc/gsc -:=. -target js -exe test.scm % ./test hello!
tinylisp 99 lines of C. pretty cool https://news.ycombinator.com/item?id=32100035 - interrsting comment about generic multiple dispatch. Is there a subsumption indexing issue here?
https://github.com/nojb/ocs-ng ocaml scheme
Papers on writing virtual machines for scheme? 3 implementation models
“Let’s Build a Hygienic Macro Expander” by Matthew Flatt Macro scope. So de bruijn indices are a way of dealing with some of the troubles of binding forms. But here I think he’s saying that de bruijn indices are the wrong abstraction.
Scope sets Syntax objects are paired with scope sets. type syntax = Sexp.t * Int.Set.t
syntax_of_datum : Sexp.t -> syntax =
HUh that was an interesting trick. Use ref () and physical equality for gensym. Binding as Sets of Scopes Notes on a new model of macro expansion for Racket
https://ianthehenry.com/posts/janet-game/the-problem-with-macros/ interesting blog post cross stage persistence. How does one serialize a function? http://www.nhplace.com/kent/Papers/Technical-Issues.html why a lisp 2 i guess
https://turtleware.eu/ common lisp essay
https://www.cs.utah.edu/plt/publications/macromod.pdf composable and compileable macros - you want in whe?
Oleg of course. http://okmij.org/ftp/Scheme/
- Has an implementation of shift reset delimitted contianutations
- Making a pattern matcher might be kind of interesting exercise.
- making your own short circuiting “or” or other non call by value constructs. In some sense this is defining a new interpreter back into scheme?
- making your own binding forms or introducing variables into the environment
https://www.cs.utexas.edu/ftp/garbage/cs345/schintro-v14/schintro_toc.html - an intorudcition to scheme and it’s impllementation
https://ds26gte.github.io/tyscheme/index-Z-H-1.html teach yourself scheme in fixnum days
In particular the extneded examples section is kind of interesting https://www.scheme.com/tspl4/examples.html#./examples:h0
The scheme objects technique. Let bindings are mutable. Isn’t that nuts. Let’s you do all kinds of shenanigans that you could do in ocaml with refs, but would be unlikely to.
let make_counter () = let state = mk_ref 0 in fun () -> let state := !state + 1 in !state
amb is genuinely surprising. It isn’t even that it’s a macro. Its callcc that makes it possible call/cc for break statements.
continuations https://www.ps.uni-saarland.de/~duchier/python/continuations.html call/cc let’s you pretend you were writing in CPS the whole time.
- call/cc for break statements
- call/cc for coroutines
https://felleisen.org/matthias/7480-s21/lectures.html history of PL. interesting discussion of hygienic macros at the least https://www.sweetjs.org/ - hygienic macros
What is the deal.
https://github.com/namin/inc incremental compilter construction
Like livecode.io right clojurescript. But that’s clojure