khanlou

extension Sequence {
    func eachPair() -> Zip2Sequence<Self, DropFirstSequence<Self>> {
        return zip(self, self.dropFirst())
    }
}

extension Collection {

    func indexed() -> [(index: Index, element: Element)] {
        return zip(indices, self).map({ (index: $0, element: $1) })

anandabits

// This example shows how higher-kinded types can be emulated in Swift today.
// It acheives correct typing at the cost of some boilerplate, manual lifting and an existential representation.
// The technique below was directly inspired by the paper Lightweight Higher-Kinded Polymorphism
// by Jeremy Yallop and Leo White found at http://ocamllabs.io/higher/lightweight-higher-kinded-polymorphism.pdf

/// `ConstructorTag` represents a type constructor.
/// `Argument` represents an argument to the type constructor.
struct Apply<ConstructorTag, Argument> {
    /// An existential containing a value of `Constructor<Argument>`
    /// Where `Constructor` is the type constructor represented by `ConstructorTag`

kastiglione

void addMainThreadCheck(Class cls, SEL selector) {
#if DEBUG
    void *symbol = dlsym(RTLD_DEFAULT, "__main_thread_add_check_for_selector");
    if (!symbol) {
        return;
    }
    void (*addCheck)(Class, SEL) = (__typeof__(addCheck))symbol;
    addCheck(cls, selector);
#endif
}

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 {}

chriseidhof

import Foundation

protocol Channel: IteratorProtocol {
    func send(_ value: Element?)
}

/// A blocking channel for sending values.
///
/// `send` and `receive` must run in separate separate execution contexts, otherwise you get a deadlock.
final class BlockingChannel<A>: Channel {

shaps80

//
//  AppDelegate.swift
//  Scheduling
//
//  Created by Shaps Benkau on 19/02/2018.
//  Copyright © 2018 152percent Ltd. All rights reserved.
//

import UIKit

raulraja

import arrow.Kind
import arrow.core.Option
import arrow.core.Try
import arrow.core.functor
import arrow.effects.IO
import arrow.effects.fix
import arrow.effects.functor
import arrow.typeclasses.Functor

/* algebras */

chriseidhof

//
//  main.swift
//  RoutingApproaches
//
//  Created by Chris Eidhof on 01.08.18.
//  Copyright © 2018 objc.io. All rights reserved.
//

import Foundation

shaps80

import Foundation
import os.log

public protocol StateMachineDelegate: class {

    associatedtype StateType: Hashable

    /// Invoked before a transition is about to occur, allowing you to reject even a valid transition. Defaults to true
    ///
    /// - Parameters:

TheiOSDude

xcrun simctl uninstall booted com.theiosdude.bundleid