dabrahams

// Copyright 2020 Penguin Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,

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`

lattner

Swift Concurrency Manifesto

Author: Chris Lattner

Chinese Translation by Jason Yu

Contents

• Introduction
• Overall Vision

CodaFi

//: Playground - noun: a place where people can play
//: http://webyrd.net/scheme-2013/papers/HemannMuKanren2013.pdf

typealias Var = Int
typealias Subst = [(Var, Term)]
typealias State = (Subst, Int)
typealias Goal = State -> Stream

indirect enum Stream {
	case Nil, Cons(State, Stream), Lazy(() -> Stream)

erica

//
//  main.swift
//  pggrep - updated 12/4/15
//  Created by Erica Sadun on 6/17/15.
//  Copyright © 2015 Erica Sadun. All rights reserved.
//

import Foundation

extension String {

chriseidhof

import Foundation

// Executes an array of blocks in parallel, but only returns after they're all done.

func parallel(blocks: [() -> ()]) {
    let group = dispatch_group_create()
    let queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
    for block in blocks {
        dispatch_group_async(group, queue, block)
    }

rnapier

// Creating a generic recursive data structure with autoclosure. (READ ALL NOTES; THIS MAY NOT DO WHAT YOU WANT.)
// Closures are reference types, so the size is known (? I think ?)
// Note that this is just because of unimplemented features in the compiler in Beta5
// There's no reason to think this is a long-term requirement.

// IMPORTANT: the closure will run every time you access this value, so if that has
// side effects, this won't work. It's only possible on pure value types.

// But the fact that this works as expected is actually kind of incredible.
// Think about what is required for it to work out the type for NestedList.Elem("first").

CodaFi

// Playground - noun: a place where people can play
// I wouldn't want a pair of birds that were... too demonstrative.


func idiot<A>(a : A) -> A {
	return a
}

func kestrel<A, B>(a : A) -> B -> A {
	return { _ in a }

chriseidhof

// This code accompanies a blog post: http://chris.eidhof.nl/posts/json-parsing-in-swift.html
//
// As of Beta5, the >>= operator is already defined, so I changed it to >>>=    


import Foundation

let parsedJSON : [String:AnyObject] = [
    "stat": "ok",
    "blogs": [

turowicz

Moved to repository: https://github.com/Mailcloud/swift-serializer