Hooman Mehr hooman

Swift Concurrency Manifesto

	// 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,

	// 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`

	//: 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)

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

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

	// 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").

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

	// 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": [