(contains-key :a {:v 1 :b 3 :a 3 :g 6})

100%

(contains-key :a {:v 1 :b 3 :a 3 :g 6})

✓ Published0🌍 Public

Last edited Apr 7, 2016

Created on Apr 7, 2016

This visualization demonstrates three recursive implementations of a `contains-key` function in Clojure, which checks whether a given key exists within a hashmap. The code defines the function variably using a loop with destructuring, sequential key comparison via `keys`, and a dissociative approach with `dissoc` and `nil` checks. It shows how different structural recursion patterns—through `recur` and `loop`—can solve the same lookup problem, relying on Clojure’s core sequence and map APIs, including `seq`, `first`, `rest`, and `empty?`.

AI-generated description

Similar vizzes

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

54% match

Loading thumbnail…

Gist 810577150f4b252e8faa69e7060bf3af

This example presents a Clojure visualization of a custom sorting algorithm called `sorting-sort`. The code defines two functions: `remove-one`, which removes a specified item from a list using `split-with` and `rest`, and `sorting-sort`, which iteratively finds the minimum value in an unsorted collection via `apply min`, removes it, and appends it to a sorted vector within a `loop`/`recur` construct. The visualization likely animates this selection-sort-like process, though no graphical library is shown; the gist contains only the algorithmic logic without any rendering or charting API.

66ewis

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

50% match

Loading thumbnail…

core.matrix clojure datasets

This example demonstrates how the Clojure library `core.matrix.dataset` structures tabular data, exposing three key attributes through map-like access. By treating the dataset as a map, it shows that the `keys` function returns `(:column-names :columns :shape)`, allowing direct retrieval of column headers, data content, and dimensions. The code uses `:column-names` to access the vector of column names `[:a :b]`, `:columns` to get the transposed data `[[1 2 3] [11 12 13]]`, and `:shape` to reveal the matrix size `[3 2]`. The dataset is initialized from a vector of Clojure maps, with the rendering shown as a formatted table. The example highlights the library’s API for inspecting structured data programmatically.

EEleonore9

49% match

Loading thumbnail…

Clojure thoughts and tips

This example illustrates Clojure’s multimethod polymorphism by defining a `full-moon-behavior` multimethod that dispatches on the `:were-type` key of a map. The code uses `defmulti` with a custom dispatching function and `defmethod` to attach behavior for `:wolf` and `:simmons` types, returning strings based on the creature’s name. Calling the multimethod with different maps, as shown, produces type-specific output. The example is drawn from a Clojure documentation gist, demonstrating dispatch logic without any external visualization libraries or data sources.

EEleonore9

48% match

Loading thumbnail…

Gist 23733

This example visualizes the distinction between local variables, instance variables, and block scoping in Ruby through a sequence of short code snippets. It shows how assignment semantics affect values across method calls and blocks, culminating in a Numeric class monkey-patch. The visualization likely renders each snippet as annotated code blocks with output values, using a custom layout or a library like D3.js to arrange the snippets and highlight variable bindings. The data originates from the gist’s source code, presented without external datasets, focusing on the logic of variable scope rather than numerical or spatial data.

DDylanFM

47% match

Loading thumbnail…

Gist 247783

This visualization uses a single file of JavaScript notes to map three inheritance patterns in Douglas Crockford’s code—pseudoclassical, prototypal, and functional—as a branching, node-link diagram. The code renders each pattern as a cluster of objects and functions, with edges showing prototype chains and constructor relationships. It relies on native JavaScript APIs like `Object.create` and constructor functions, while the layout is drawn on an HTML canvas without external libraries. The source is a gist by DylanFM, and the visual emphasizes the structural differences between the patterns by positioning them in separate columns.

DDylanFM

47% match

Loading thumbnail…

Advent of Code

This visualization demonstrates the redistribution of memory blocks in the "Advent of Code" Day 6 challenge, tracking how many redistribution cycles occur before a state repeats. The code uses XQuery 3.1 with recursive functions `local:zero-out-highest` and `local:add-blocks` to reallocate blocks from the highest-value bank across the array, while `local:calculate-state` records each state as a hyphen-separated string and stops when a duplicate state appears. The data source is a hardcoded sequence of 16 integers representing the initial memory banks, and the output is the integer count of iterations performed until repetition, rendered as plain text. No external visualization libraries are used; the example focuses purely on algorithmic state computation.

CCliffordAnderson

47% match