| import Foundation | |
| enum FinderColor: Int { | |
| case noColor = 0 | |
| case grey = 1 | |
| case green = 2 | |
| case purple = 3 | |
| case blue = 4 | |
| case yellow = 5 | |
| case red = 6 |
| import type { V2_HtmlMetaDescriptor, V2_MetaFunction } from "@remix-run/node"; | |
| export const mergeMeta = ( | |
| overrideFn: V2_MetaFunction, | |
| appendFn?: V2_MetaFunction, | |
| ): V2_MetaFunction => { | |
| return arg => { | |
| // get meta from parent routes | |
| let mergedMeta = arg.matches.reduce((acc, match) => { | |
| return acc.concat(match.meta || []); |
Remix Deferred is currently implemented on top of React's Suspense model but is not limited to React. This will be a quick dive into how "promise over the wire" is accomplished.
It isn't rocket science, but a quick recap of how frameworks such as react do SSR:
As Swift evolves, it gains new language features and capabilities. There are different categories of features: some fill in gaps, taking existing syntax that is not permitted and giving it a semantics that fit well with the existing language, with features like conditional conformance or allowing existential values for protocols with Self or associated type requirements. Others introduce new capabilities or paradigms to the language, such as the addition of concurrency or comprehensive reflection.
There is another large category of language features that provide syntactic sugar to eliminate common boilerplate, taking something that can be written out in long-form and making it more concise. Such features don't technically add any expressive power to the language, because you can always write the long-form version, but their effect can be transformational if it enables use cases that would otherwise have been unwieldy. The synthesis of Codable conformances, for ex
A lot of StackOverflow answers for dealing with things in SwiftUI sometimes being positioned not how you want (for example) understandably solve it with a magic number to put something where they want.
The downside of this is that it likely only works at the default Dynamic Type size, so anyone with larger or smaller text settings (for accessibility reasons, for instance) will likely have a layout that doesn't look as optimized (for instance, if you assume 24.0 is a good number based on the default .large size, if they have their phone set to accessibilityExtraExtraExtraLarge, 24.0 will likely be way too small).
So here's a quick helper extension that simply scales a number based on the Dynamic Type size, so that 24.0 will increase and decrease with the user's Dynamic Type setting.
// Extending BinaryFloatingPoint so that this ext
| // | |
| // Shell.swift | |
| // | |
| // Created by Tanner Bennett on 6/25/22. | |
| // Copyright Tanner Bennett (c) 2022 | |
| // | |
| import Foundation | |
| extension StringProtocol { |
| extension Sequence { | |
| func asyncMap<T>(_ transform: @escaping (Element) async -> T) async -> [T] { | |
| return await withTaskGroup(of: T.self) { group in | |
| var transformedElements = [T]() | |
| for element in self { | |
| group.addTask { | |
| return await transform(element) | |
| } | |
| } |
| // I learned about `#if canImport(module, _version: x.y)` from Tony Allevato: | |
| // https://forums.swift.org/t/pitch-sdk-conditional-code/52642/4 | |
| // | |
| // Does this work reliably? I have no idea! | |
| // I have only done some quick experiments in a playground. | |
| // | |
| // The Foundation version in Xcode 14.0b1 is: | |
| // - in iOS's Foundation.swiftinterface: 1932.104 | |
| // - in macOS's Foundation.swiftinterface: 1932.401 | |
| // |
| // A heterogeneous dictionary with strong types in Swift, https://oleb.net/2022/heterogeneous-dictionary/ | |
| // Ole Begemann, April 2022 | |
| /// A key in a `HeterogeneousDictionary`. | |
| public protocol HeterogeneousDictionaryKey { | |
| /// The "namespace" the key belongs to. Every `HeterogeneousDictionary` has its associated domain, | |
| /// and only keys belonging to that domain can be stored in the dictionary. | |
| associatedtype Domain | |
| /// The type of the values that can be stored under this key in the dictionary. | |
| associatedtype Value |
| class ViewController: UIViewController { | |
| override func viewDidLoad() { | |
| super.viewDidLoad() | |
| Task { | |
| // 1️⃣❓ UIViewController is in a MainActor context, so this Task | |
| // will inherit that, so the following pretend expensive call will | |
| // be on the main thread and likely block? | |
| ExpensiveOperationPerformer.doExpensiveLoopAndPrint() | |
| } |