Shared via Rust Playground

100%

Shared via Rust Playground

✓ Published0🌍 Public

Last edited Nov 15, 2015

Created on Nov 15, 2015

This example demonstrates how multiple threads can safely share and mutate a counter using Rust’s concurrency primitives. It shows the `Arc<Mutex<Toaster>>` pattern, where an atomic mutex lock protects the `count` field from race conditions. The code spawns three threads via `thread::spawn`, each cloning the `Arc` handle and acquiring the lock with `toaster.lock().unwrap()` before incrementing the count. The output prints each thread’s index, which is assigned from the prior value of `count` before incrementing. The example uses the standard library’s `std::sync::{Arc, Mutex}` and `std::thread` APIs, with no external data source or rendering—purely console output.

AI-generated description

Similar vizzes

Loading thumbnail…

Shared via Rust Playground

This example simulates a concurrent breakfast scenario using Rust's standard library. It shows how multiple attendee threads send bagels through channels to a single toaster thread, which toasts them and returns them via acknowledgment channels. The visualization highlights thread synchronization and message passing with `std::thread::spawn`, `std::sync::mpsc::channel`, and channel send/receive operations. The code prints toasting progress and final consumption messages, illustrating the choreography of concurrent tasks through inter-thread communication. No external libraries or data sources are used; the rendering is purely textual output from the console.

FFranklin Chen

77% match

Loading thumbnail…

JS Bin

This example demonstrates a live counter that updates every second, displaying the number of elapsed seconds in the browser and the console. It uses RxJS’s `Observable.timer` to emit sequential integers, which are mapped to formatted strings. The resulting data stream is subscribed to by two effects: a DOM effect that writes the text into a `#app` container, and a console effect that logs each message. The code separates the main data stream from its side effects, following a simple functional reactive programming pattern.

JJaxonDvl

49% match

Loading thumbnail…

Gist 10288187

This example demonstrates the importance of bounds checking in C++ vector access. It uses the `std::vector` class and its `.at()` method, which throws an exception when the given index is out of range, in contrast to the unchecked `[]` operator. A loop iterates from zero to four over a vector containing three integers, triggering an out-of-range error that is caught by an `exception` handler. The code also shows a custom destructor message when a `Foo` object, managed via `make_shared`, is cleaned up.

FFranklin Chen

48% match

Loading thumbnail…

Elm Counter Example

This example demonstrates a minimal interactive counter interface built with Elm. It displays a numeric value alongside two buttons, one for incrementing and one for decrementing the count. The implementation uses Elm’s `beginnerProgram` from `Html.App` to manage the application state, with `Html` and `Html.Events` for rendering and handling `onClick` events. The `update` function directly modifies the integer model based on `Increment` and `Decrement` messages. The code relies on Elm’s static typing and pure functions, with no external JavaScript libraries, illustrating Elm’s built-in reactive model and view loop.

CCliffordAnderson

48% match

Loading thumbnail…

Knuth/McIlroy word count task using Haskell

This example demonstrates a word-frequency analysis task using Haskell, showing how to compute and display the most common words from standard input. It chains data transformations through a pipeline: converting text to lowercase, replacing non-letter characters with newlines, splitting into words, and tallying counts with a hash map. The code relies on `Data.HashMap.Strict` for efficient key-value aggregation via `HashMap.fromListWith`, and uses `Data.List` for sorting and taking the top *n* results. The final output lists each word with its count, sorted in descending order of frequency. The example highlights functional composition and lazy evaluation in a concise, read-backwards data-flow style.

FFranklin Chen

47% match

Loading thumbnail…

Simple Unidirectional Data Flow

This example demonstrates a simple unidirectional data flow pattern, using a counter that increments on button click. The current count is displayed in the DOM, and each click dispatches an INCREMENT action to a reducer function, which returns a new state object. The updated state is then passed to a render function that updates the text content of the counter element. The code uses vanilla JavaScript, with plain DOM methods like `getElementById` and `addEventListener` to handle interaction and rendering.

MMark D. Clements

47% match

Loading thumbnail…

Counter

A counter app shows a large numeric count that increases or decreases via two buttons, styled with large typography and a simple layout. It demonstrates the d3-component library for defining reusable components like `countDisplay`, `buttonPanel`, and `button`, while managing state with Redux. The top-level `app` component composes these pieces, and renders update on store subscriptions. The example bridges D3 v4's component pattern with Redux's reducer and dispatch flow.

CCurran Kelleher

47% match

Loading thumbnail…

Gist dc33dbae2a8fee3d6c026c07e216dc5a

This example shows a JavaScript function called `copyMachine` that duplicates an array’s contents a given number of times. The code uses a `while` loop and the spread operator `[...arr]` to append copies of the original array to itself, then stores the result in `newArr`. It demonstrates array mutation and reassignment within a loop, logging the final duplicated array to the console via `console.log`. The function handles a numeric `num` parameter, decrementing it until the loop ends, and returns the expanded array. No external libraries or visualization APIs are used; it is plain JavaScript array manipulation.

MMistyBlunch

47% match