Intro to Spec

100%

✓ Published0🌍 Public

Last edited Sep 13, 2016

Created on Sep 13, 2016

This example demonstrates how Clojure.spec validates and destructures user input through compositional specs. It shows the progression from simple predicates for phone numbers and email addresses to complex nested specs that combine user names with optional contact information. The code uses `s/def`, `s/cat`, `s/alt`, and `s/valid?` to define and test data shapes, while `s/explain` and `s/conform` provide debugging output. A final `add-new-user` function uses these specs for runtime argument validation, with the source data defined as Clojure vectors in a Gist.

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

56% match

Loading thumbnail…

Gist 578871

This example shows a Gist titled "Gist 578871" that integrates RSpec mocking and Authlogic into a Cucumber testing environment. It demonstrates how to configure RSpec's mock framework within Cucumber steps by explicitly setting up and tearing down mocks around each scenario. The code loads supporting files like `support.rb`, which requires `cucumber/rspec/doubles` and `rspec/core`, and uses `RSpec::Mocks::setup`, `verify`, and `teardown` in `Before` and `After` hooks. It also activates Authlogic’s test mode and resets `Sham` data. The rendering approach is code-based, not visual, focusing on test configuration.

DDylanFM

50% match

Loading thumbnail…

Svelte Testing

This example demonstrates a simple interactive arithmetic calculator built with Svelte. Two numeric input fields are bound to variables `a` and `b` using Svelte’s `bind:value` directive, and the sum is displayed in a paragraph. The UI is styled via a global CSS rule in the HTML file. The visualization shows how Svelte’s declarative syntax integrates into a page, though the README notes that style output is not yet fully instantiated in this early VizHub integration. The code relies on the Svelte component model and basic HTML input elements.

CCurran Kelleher

49% match

Loading thumbnail…

Gist 7d6a7404e99051bb7d2f36c61f0113ae

This example demonstrates functional programming techniques in JavaScript, including currying, composition, and generator functions. It shows how currying enables partial application, as seen with the `sum` function and reusable helpers like `getName` and `mapUserNames`. The code uses `compose` with `reduceRight` to chain array transformations, filtering user names by length. It also illustrates generator behavior with `next(true)` to control iteration completion. The data is a hardcoded array of user objects, and output is logged to the console via `console.log`.

IIliaIdakiev

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

47% match

Loading thumbnail…

Example of point-free style

This example demonstrates how to compose functions in a point-free style using Haskell’s `Control.Category` operator `(>>>)`. The code defines a `matches` function that checks whether a given string equals an `Option`’s name prefixed with `"--"`, without explicitly mentioning the arguments. It shows the data flow by chaining `name`, `("--" ++)`, and `(==)` together, making the logic declarative. The example uses a custom `Option` data type and a sample `helpOption` to test the matching with `"--help"`. The source is a gist by FranklinChen, illustrating readable point-free composition in a functional programming context.

FFranklin Chen

47% match

Loading thumbnail…

Gist 6b70052296ccf0ebf338143509429d64

This example simulates a simplified Facebook-like social network in Ruby, using a `User` class to model profiles, friendships, and wall posts. The code defines methods for adding friends and posting content to another user’s wall, checking friendship status before allowing a post, and initializing two user objects with sample data. It uses the `pry` debugging library via `binding.pry` to pause execution and allow interactive inspection of the state, with no graphical output or external visualization library.

JJastor11

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

47% match