Skip to main content
SimilarExport ZIP
100%

Swift class constants are mutable within the initialiser

✓ Published0🌍 Public
CColinEberhardt
Last edited Dec 3, 2014
Created on Dec 3, 2014

This example demonstrates that Swift class constants, declared with `let`, can be assigned multiple times within the initialiser, despite being immutable elsewhere. The code defines a `Bar` class with an uninitialized `myConstant` field, then sets it to 77 and 45 before calling `super.init()`, and finally reassigns it to 55 after that call. A `doSomething()` method shows that further mutation outside the initialiser is prohibited. The example is a raw Swift source file from a gist, run as a standalone script.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 54292

This example demonstrates how Ruby’s `instance_variable_set` and `instance_variable_get` can dynamically alter and read an instance variable defined on a class, using a module-scoped `@foo` that starts as `"bar"` and is changed to `"changed"` via a nested class method. The code defines a `What` module containing `@foo` and a `Whatever` class whose `change_foo` method mutates that variable, then prints its initial and updated values using `p`. The output, shown as comments (`# >> "bar"` and `# >> "changed"`), confirms the state change. No external libraries or rendering APIs are used; the example relies solely on Ruby’s core object model and metaprogramming features.

DDylanFM
50% match
Loading thumbnail…

Javascript Variables- const

This example demonstrates JavaScript's `const` keyword by attempting to reassign a constant variable, which triggers a runtime error. The page displays the text "Hello HTML" prominently with a font size of 13em, styled via CSS. The HTML structure includes a script tag where a `const` variable named `hotel` is initialized to 'Royal' and then reassigned to 'Rainbow', illustrating that constant variables cannot be changed. No external libraries are used; the example relies solely on native HTML, CSS, and JavaScript to showcase this fundamental language behavior.

NNita
46% match
Loading thumbnail…

random test. # I wanted to try and flush the string before it dies. note that ruby only has a finalizer , it does not have a destructor. I could have use ObjectSpace.define_finalizer self, proc {persist} and use GC.start at the command line to run the garbage collector however it would be after destroying an instance object.

This example demonstrates a Ruby class called `PersistentString` that extends the built-in `String` class, showing how to add persistence and utility methods while retaining core string behavior. The code shows what the class does—such as saving data to files, checking palindromes, and reading/appending file contents—before explaining how it works, using instance methods like `persist` and class methods like `read_to` and `append_to`, with error handling via `STDERR.puts`. It relies on standard Ruby APIs like `File.open`, `File.exist?`, and `STDOUT.puts`, and the example uses interactive console sessions (e.g., `2.0.0-p247 :004 >`) to illustrate usage. The data source is user-provided strings, and the rendering approach is file-based output, not visual.

66ewis
44% 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
44% match
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
44% match
Loading thumbnail…

Gist 49850

This example demonstrates how to dynamically add instance methods to a Ruby class at runtime using `class_eval` and `define_method`. The code defines a `fun` method that takes a class, a method name, and a block, then injects the block as a new instance method on that class. Specifically, it adds a `world` method to the `String` class, which returns the string `"#{self} world"`. The final line calls `"Hello".world` and outputs `"Hello world"`, showing how the injected method operates on any string instance. The example relies purely on Ruby's core reflection and metaprogramming APIs, with no external libraries or data sources involved.

DDylanFM
41% match
Loading thumbnail…

Gist 75454

This example demonstrates string manipulation utilities in Objective-C, converting camelCase or mixed-case strings into either underscore-separated or dash-separated formats. The code defines an NSString category with `underscore` and `dasherize` methods, which internally call a private `normalizeWith:` method that iterates over each character, detects uppercase letters and existing delimiters, and inserts the chosen separator while preserving the original text. The implementation uses NSCharacterSet, NSMutableString, and unichar APIs to perform character-by-character processing, ultimately returning a lowercase version of the transformed string.

CCaged
41% match
Loading thumbnail…

Swift Structs to Decode Gists API

This example shows Swift structs that decode the GitHub Gists API response for a user's public gists, modeling the `Gist`, `File`, and `Owner` objects with their nested properties. It uses the `Codable` protocol and a `JSONDecoder` with an ISO 8601 date strategy to parse the JSON from `https://api.github.com/users/kevingutowski/gists`, mapping snake_case API fields like `forks_url` to camelCase Swift properties via `CodingKeys`. The code also demonstrates decoding the dynamic `files` dictionary using `GenericCodingKeys` to handle arbitrary filenames.

KKevinGutowski
39% match