Gist b0f107f75c74641d68796a796f343bb5

100%

Gist b0f107f75c74641d68796a796f343bb5

✓ Published0🌍 Public

Last edited Nov 7, 2016

Created on Nov 7, 2016

This notebook demonstrates a Scheme interpreter’s evaluation process, showing how expressions like `(+ 1 2)` and `(+ 1 (* 2 3))` are recursively parsed and reduced. The code uses custom `Pair` and `nil` data structures from `scheme_primitives` and `scheme_reader`, with `scheme_eval` printing each subexpression’s representation and tracing symbol lookups, self-evaluation, and procedure application. Output cells display intermediate results, such as `Pair(3, nil)` after adding 1 and 2, alongside debug print statements that reveal the step-by-step evaluation order. The example highlights the interpreter’s handling of nested combinations and its error-checking via `check_procedure`.

AI-generated description

Similar vizzes

Loading thumbnail…

Elisp Evaluation Workshop

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.

DDarMontou

59% 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

57% match

Loading thumbnail…

Gist 0e59d1c2d63aaea35573

This example demonstrates benchmark-driven optimization of recursion schemes in Haskell, using the Criterion library’s `defaultMain`, `bgroup`, and `bench` functions to measure performance. The code defines catamorphisms (`ffold`), anamorphisms (`funfold`), hylomorphisms, and build functions (`fbuild`, `funbuild`), then applies them to natural numbers, lists, and trees. It highlights how `INLINE` pragmas and `RULES` for fusion (e.g., `ffold/fbuild`) improve execution speed, as shown in benchmarks like `lengthL`, `mapL`, and `depthT` over sample data structures.

FFranklin Chen

56% match

Loading thumbnail…

Gist 07c637765f8aad3f648d483be9e42cd8

This example demonstrates basic Python syntax and output within a Jupyter notebook, showing how simple print statements and expression evaluations behave. It highlights the classic floating-point precision issue where `0.1 + 0.2` does not equal `0.3`, and contrasts that with an epsilon-based comparison that returns `True`. The code also illustrates string handling with triple-quoted multiline strings and the difference between echoing a value and using `print()`. No external visualization libraries are used; the focus is purely on language fundamentals.

FFrieseWoudloper

55% match

Loading thumbnail…

Gist e3f5949ff1f99ab4126a

This notebook demonstrates Python string formatting through a series of interactive code cells. It shows how variables like `animal`, `verb`, and `noun` are assigned values and then inserted into template sentences using the `.format()` method from the Python standard library. The examples progress from simple variable printing with `print` statements to building sentences with placeholders like `{noun}` and `{verb}`, which are replaced with actual values, including numbers, demonstrating flexible substitution. The notebook uses standard Python 3 syntax and pandas for data handling, with matplotlib inline plotting enabled for visualization context.

Aakeshavan

54% match

Loading thumbnail…

Gist 312231

This example demonstrates how CoffeeScript files can be compiled and evaluated at runtime to run a suite of automated tests. It loads the CoffeeScript compiler along with supporting modules for rewriting, scope analysis, node parsing, and lexical analysis through custom `require` calls. Test files are discovered from the `../test/` directory using `system.files` with a wildcard pattern, and their contents are compiled with `CoffeeScript.compile` before being executed via `eval`. The code counts successful assertions through the `ok` and `throws` helper functions, then reports the total test count and execution time in seconds after processing all files.

TTBD

53% match

Loading thumbnail…

Gist b9e14cdd96682d931acd2ff1e0c5502e

This notebook demonstrates recursive tree algorithms implemented in Python, defining functions to square tree values, compute height, find maximum values, locate paths, prune branches, and generate hailstone sequences. The code uses a custom `tree` representation as nested lists, with helper functions like `root`, `branches`, and `is_leaf` to navigate the structure. Each algorithm follows a consistent pattern of processing the root, checking for leaf nodes, recursing over branches, and returning the final result. The examples illustrate functional decomposition and recursion for hierarchical data manipulation, with no external visualization libraries involved.

Aakeshavan

53% match

Loading thumbnail…

Gist b64124620bd851544b8e9e87b16370e8

This Jupyter notebook demonstrates how to define a curried `multiadder` function in Python, where `multiadder(n)` returns a chain of functions that each accept one argument and accumulate a sum. The code shows two implementations: a first pass using a dummy total variable, and a refined version that returns nested functions to handle the summation. Example calls like `multiadder(5)(1)(1)(1)(1)(1)` output `5`, and `multiadder(2)(4)(5)` returns `9`, illustrating the incremental function-returning behavior. The notebook uses standard Python 2 syntax, with code cells and Markdown explanations, and outputs results directly as text.

Aakeshavan

53% match