Skip to main content
SimilarExport ZIP
100%

Gist b7643abc7d460e1673981d3f41bb9b40

✓ Published0🌍 Public
MMoximillian
Last edited Jun 11, 2018
Created on Jun 7, 2018

This example demonstrates a Swift language extension that optimizes the `reversed()` operation on lazy collections. It defines a `ReversedCollectionProtocol` for bidirectional collections, and an extension that lets reversing a lazy reversed collection return a lazy representation of the original, avoiding unnecessary materialization. The code uses Swift generics and associated types (`Elements.Base`) to express this optimization, and notes a fallback using parametrized extensions for Swift versions prior to 4.2.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 3908cc252b823e449510

This example demonstrates a Swift extension that removes duplicate elements from an array of strings, converting the initial list containing repeated values like "P" and "C" into a unique sequence. The custom `unique()` method uses the standard library’s `reduce` function alongside a generic `contains` check to build a filtered result. The code explicitly converts each element to a generic type `T` and appends it only if it is not already present. The final output, printed via `println()`, shows the deduplicated array in its original order, preserving the first occurrence of each string.

CColinEberhardt
58% match
Loading thumbnail…

Journey into PAT-land

This example shows a programmer’s repeated attempts to create a unified interface for dequeuing reusable cells across UITableView and UICollectionView in Swift, using protocols with associated types and generics. The code illustrates the progression from a simple protocol that fails to preserve type information, through generic and PAT-based approaches, to a final multiprotocol solution incorporating a parent protocol and Self-typed static methods. It highlights the Swift compiler’s constraints, such as lack of parametrized extensions and existential casting limitations, while referencing ProtoKit, UITableView, UICollectionView, and IndexPath.

MMoximillian
55% match
Loading thumbnail…

Swift protocol and extensions for adding support to closures in UIKit classes. Extension support for UIButton, UIGestureRecognizer, UIBarButtonItem etc. Swift 3.0.

This example demonstrates a Swift protocol that adds closure-based event handling to UIKit classes, replacing traditional target-action patterns. Code extensions for UIButton, UIPageControl, UIGestureRecognizer, and UIBarButtonItem use the Closurable protocol to wrap callbacks in a ClosureContainer object, stored via objc_setAssociatedObject. The container exposes an @objc selector that invokes the stored closure, allowing UIKit to call the handler dynamically. The code pairs each UI component’s standard addTarget or initializer with custom convenience methods, keeping the call site concise. No external libraries are required; the implementation relies solely on Swift 3.0 and the Objective-C runtime.

MMoximillian
51% match
Loading thumbnail…

A demonstration of Swift sequences

This example demonstrates Swift sequences by pairing odd and even Fibonacci numbers, then skipping the first two pairs before printing the next two results. The code defines custom Fibonacci sequences, uses the `filter` function to generate separate odd and even number streams, and combines them with `Zip2`. A `skip(n:)` extension on `SequenceOf` filters out leading elements, while `GeneratorOf` lazily produces values. The output logs each generated Fibonacci number and the skipped pairs, showing how sequence composition and lazy evaluation work together in Swift.

CColinEberhardt
51% match
Loading thumbnail…

Snap! custom block to reverse a list

This example shows a Snap! custom block that reverses a list, reporting the reversed list as its output. The block first determines the list’s length and creates an empty list for the result. It then uses a `doUntil` loop that, while the length is not zero, appends the item at the current index to the result and decrements the length. The code relies on Snap! list primitives such as `reportListLength`, `reportListItem`, and `doAddToList`, with the original list passed in as an argument.

CCliffordAnderson
50% match
Loading thumbnail…

An eventing mechanism for Swift

This example demonstrates an eventing mechanism for Swift, showing how to create type-safe events with multiple handlers and automatic cleanup. It defines an `Event<T>` class that manages a collection of handler wrappers, allowing observers to subscribe and unsubscribe dynamically. The implementation uses the `Disposable` protocol for tear-down logic and the `Invocable` private protocol to abstract handler invocation, with `EventHandlerWrapper` holding a weak reference to the target to prevent retain cycles. The code highlights Swift’s protocol-oriented and generics features, as well as curried instance methods, to build a reusable notification system without relying on external libraries.

CColinEberhardt
50% match
Loading thumbnail…

Example of how init/func behaves in protocols and protocol extensions

This example demonstrates how Swift handles `init` and `func` declarations in protocols versus protocol extensions. It defines two similar protocol pairs—one where `P1` declares both members, and another where `P2` is empty and relies entirely on its extension—to show that a struct’s own implementations always take precedence over those in the extension. The code creates instances of `S1` and `S2` and calls their methods, printing "S1 init"/"S1 func" and "S2 init"/"S2 func" respectively, proving that the extension’s fallback implementations are never invoked when the struct provides its own.

MMoximillian
49% match
Loading thumbnail…

Function for reversing the bits in a 32bit number

The example demonstrates a custom function that reverses the order of bits in a 32-bit unsigned integer, a common low-level operation used in bit manipulation. It shows the step-by-step isolation and recombination of individual bytes (b0 through b3) before reversing the bits within each byte. The code relies on Power Query’s `Number.BitwiseAnd`, `Number.BitwiseShiftRight`, `Number.BitwiseShiftLeft`, and `Number.BitwiseOr` functions to mask, shift, and reassemble the bytes. A helper `reverse` function is implied for per-byte bit reversal, though not defined here. The visualization itself is a code snippet, not a graphical chart, highlighting the algorithmic logic rather than data representation.

HHugoberry
49% match