Elisp Evaluation Workshop

100%

Elisp Evaluation Workshop

✓ Published0🌍 Public

Last edited Jul 4, 2019

Created on Jul 3, 2019

This interactive Emacs Lisp evaluation workshop demonstrates how the language evaluates different forms, from self-evaluating objects like numbers and strings to symbol indirection and function invocation. The buffer pairs source code with explanatory comments, encouraging exploration through `eval-print-last-sexp` bindings like `C-j`. It covers function calls, special forms, macros, quoting, and backquoting, using APIs such as `symbol-function`, `fset`, `funcall`, and `apply`. The example exposes runtime errors, like the wrong-type-argument from `apply`, and includes a commented-out infinite loop, making evaluation behavior concrete and testable.

AI-generated description

Similar vizzes

Loading thumbnail…

Emacs Debugging Workshop

This visualization demonstrates the Emacs debugging workflow through a series of instrumented Lisp examples, showing how the built-in debugger and Edebug interact with source buffers, stack frames, and invocation messages. The buffer uses `lisp-interaction-mode` and defines key bindings for `eval-print-last-sexp`, while examples trigger `debug-on-variable-change`, `debug-on-message`, and `debug-on-error` to pause execution. The code also exercises Edebug’s stepping, tracing via `edebug-trace`, and conditional breaks through `edebug` calls, relying on standard Emacs Lisp functions like `(debug)`, `toggle-debug-on-quit`, and `with-output-to-temp-buffer` to produce backtraces and evaluation control. The source text itself serves as the data, with the rendering being the interactive debugging session.

DDarMontou

73% match

Loading thumbnail…

Eval example

This example demonstrates how to dynamically generate and execute XQuery code at runtime, using the `xquery:eval` function to apply a chosen string function to book titles from an XML collection. The code first iterates over `fn:collection("books")/record/Title` to retrieve each title, then constructs a string expression that calls the external `fn:upper-case` function, passing the current title as a variable. It explicitly shows the use of the XQuery 3.1 standard, the `map` constructor for passing external variables, and the `declare variable $title external` declaration to inject the title into the evaluated expression. The example highlights dynamic code generation within a database query context, with the rendering limited to the function’s output.

CCliffordAnderson

54% match

Loading thumbnail…

Gist ec627b32670dd31f4028

This example demonstrates a modular approach to building and testing effectful programs using the free monad pattern in Scala. It defines a `Free` monad to sequence interactions like console prompts and authentication checks, with interpreters separating execution from logic. The code uses type classes `Monad`, natural transformations (`~>`), and coproducts to compose independent algebras (`Interact` and `Auth`). It shows both a production interpreter (`Console`) and a pure test interpreter (`TestConsole`) that returns output lists from a static input map, highlighting how to decouple I/O from program structure.

FFranklin Chen

50% match

Loading thumbnail…

Clojure thoughts and tips

The example shows a Clojure gist that clarifies the distinct behaviors of the standard functions `comp` and `juxt` through commented code and live map calls. It first demonstrates `juxt` with `map`, `name`, and `str/capitalize` to produce pairs like `["name" ":name"]`, then examines `comp` to reveal its right-to-left application order, correcting an initial misuse. The code uses Clojure core APIs such as `clojure.core/comp`, `clojure.core/juxt`, `map`, and `str/capitalize` directly in the REPL. The source is a gist authored by Eleonore9, with rendering limited to text output from the function calls.

EEleonore9

50% match

Loading thumbnail…

Coding Adelante: Challenges

This example shows a progression of coding challenges for learning JavaScript, starting with basic functions and building up to object-oriented programming. The gist presents a series of exercises that ask the reader to implement functions like `hello`, `multiply`, `sum`, `isEven`, and `isDivisible`, each with sample inputs and expected outputs shown in commented code. The visible API is plain JavaScript, using console output via `console.log` and standard function declarations. The examples gradually introduce arrays, conditional logic, and higher-order patterns, with the source being a single Markdown file from a gist. The rendering approach is purely text-based, with code blocks and comments that illustrate function behavior without any graphical or external library dependencies.

HHerbCaudill

48% match

Loading thumbnail…

Gist 0e5ae22a48dcab9747f0fed6d90e4749

This example stages a dialogue about two approaches to learning a software library: mastering the API for rapid development versus studying the source code for deep, long-term flexibility. The code examines the trade-offs between quick delivery and the ability to extend or debug a library, using a conversational format to compare the benefit of immediate working results with the empowerment of understanding the underlying mechanics. It ultimately suggests a combined strategy, starting with the API and gradually moving into the internals as needs evolve. No external data or rendering libraries, such as d3 or Three.js, are present in the code.

深深度碎片

48% match

Loading thumbnail…

Time R Function Calls

This example demonstrates two R functions for timing the execution of arbitrary code: `time.call` evaluates an expression using `evalq` and prints the elapsed time via `proc.time`, while `time.call.q` times pre-quoted expressions passed to `eval`. It also shows how to combine `time.call.q` with the `magrittr` pipe operator (`%>%`) to wrap a quoted assignment in a readable, one-line pipeline. The code uses base R functions only, with no external visualization libraries or datasets.

LLeeMendelowitz

48% match

Loading thumbnail…

Gist 49850

This example demonstrates how to dynamically add instance methods to a Ruby class at runtime using `class_eval` and `define_method`. The code defines a `fun` method that takes a class, a method name, and a block, then injects the block as a new instance method on that class. Specifically, it adds a `world` method to the `String` class, which returns the string `"#{self} world"`. The final line calls `"Hello".world` and outputs `"Hello world"`, showing how the injected method operates on any string instance. The example relies purely on Ruby's core reflection and metaprogramming APIs, with no external libraries or data sources involved.

DDylanFM

48% match