airspeedswift

/// Conform references types for use in the COW wrapper to this protocol
protocol Cowable: class {
  /// Make a new unique instance of `copied`
  static func makeUnique(_ copied: Self) -> Self
}

/// A wrapper that turns a Cowable reference type into a value-semantic
/// type with access to all of its properties
@dynamicMemberLookup

anandabits

// This example shows how closed protocols can be emulated in Swift today.
// The technique leverages Swift's support for public (but not open) classes.

// First, it's worth observing that there is an almost trivial technique that can be used when
// it is possible to specify a (possibly abstract) superclass for all conforiming types.
// Simply declare a public (not open) base class and a protocol with a Self inheritance constraint.
// Swift does not support open subclasses of a public superclass so no classes outside the module
// will be able to meet the self inheritance constraint.
public class FooBase {}
public protocol Foo where Self: FooBase {}

anandabits

func testIsBidirectional() {
    func assert<C: Collection>(_ collection: C, isBidirectional: Bool) {
        XCTAssertEqual(collection.isBidirectional, isBidirectional)
    }

    assert([1, 2, 3], isBidirectional: true)
    assert(Set([1, 2, 3]), isBidirectional: false)
}

extension Collection {

dabrahams

extension ObjectIdentifier {
  /// Returns true if the object identified by `self` is uniquely referenced.
  ///
  /// - Requires: the object identified by `self` exists.
  /// - Note: will only work when called from a mutating method
  internal func _liveObjectIsUniquelyReferenced() -> Bool {
    var me = self
    return withUnsafeMutablePointer(to: &me) {
      $0.withMemoryRebound(to: AnyObject.self, capacity: 1) {
        _isUnique(&$0.pointee)

skymobilebuilds

#!/bin/bash -e

echo "🤡 Applying carthage 12 and 13 workaround 🤡"

xcconfig=$(mktemp /tmp/static.xcconfig.XXXXXX)
# For Xcode 12 make sure EXCLUDED_ARCHS is set to arm architectures otherwise
# the build will fail on lipo due to duplicate architectures.
CURRENT_XCODE_VERSION=$(xcodebuild -version | grep "Build version" | cut -d' ' -f3)
echo 'EXCLUDED_ARCHS__EFFECTIVE_PLATFORM_SUFFIX_simulator__NATIVE_ARCH_64_BIT_x86_64__XCODE_1200 = arm64 arm64e armv7 armv7s armv6 armv8' > $xcconfig
echo "EXCLUDED_ARCHS__EFFECTIVE_PLATFORM_SUFFIX_simulator__NATIVE_ARCH_64_BIT_x86_64__XCODE_1200__BUILD_$CURRENT_XCODE_VERSION = arm64 arm64e armv7 armv7s armv6 armv8" >> $xcconfig

magnuskahr

import SwiftUI

struct EnumPicker<T: Hashable & CaseIterable, V: View>: View {
    
    @Binding var selected: T
    var title: String? = nil
    
    let mapping: (T) -> V
    
    var body: some View {

anandabits

/// - returns: `true` when dynamic type is `Equatable` and `==` returns `true`, otherwise `false`.
func areEquatablyEqual(_ lhs: Any, _ rhs: Any) -> Bool {
    func receiveLHS<LHS>(_ typedLHS: LHS) -> Bool {
        guard
            let rhsAsLHS = rhs as? LHS
            else { return false }
        return areEquatablyEqual(typedLHS, rhsAsLHS)
    }
    return _openExistential(lhs, do: receiveLHS)
}

dabrahams

protocol True {}
struct IsBidirectional<C> {}
extension IsBidirectional: True where C : BidirectionalCollection {  }
extension Collection {
  var isBidirectional: Bool {
    return IsBidirectional<Self>() is True
  }
}

func testIsBidirectional() {

DougGregor

pdarragh

Approachable PL Papers for Undergrads

On September 28, 2021, I asked on Twitter:

PL Twitter:

you get to recommend one published PL paper for an undergrad to read with oversight by someone experienced. the paper should be interesting, approachable, and (mostly) self-contained.

what paper do you recommend?