Daniel Asher DanielAsher

[F#] Implementing Coroutines (async/await) using continuations

Coroutines or async/await is not a new concept as it was named in 1958 by Melvin Conway. Coroutines had support in languages such as Simula(1962), Smalltalk(1972) and Modula-2(1978) but I think one can argue that coroutines came into mainstream with C# 5(2012) when Microsoft added async/await to C#.

The problem with subroutines

A thread can only execute a single subroutine at a time as a subroutine starts and then runs to completion. In a server environment subroutines can be problematic as in order to service connections concurrently we would usually would start a thread per connection, this was the idiom a few years ago. A thread depending on the operating system and settings needs about 1 MiB of user stack space meaning 1,024 threads needs 1 GiB of for just user stack space. In addition there's the cost of kernel stack space, book-keeping and scheduling of threads. This drives cost of VM/hardwa

Compile Time Constant Expressions for Swift

Proposal: SE-NNNN
Authors: Marc Rasi, Chris Lattner
Review Manager: TBD
Status: Awaiting implementation

Swift-evolution thread: https://forums.swift.org/t/pitch-compile-time-constant-expressions-for-swift/12879

Introduction

Async/Await for Swift

Proposal: SE-XXXX
Authors: Chris Lattner, Joe Groff

Introduction

Modern Cocoa development involves a lot of asynchronous programming using closures and completion handlers, but these APIs are hard to use. This gets particularly problematic when many asynchronous operations are used, error handling is required, or control flow between asynchronous calls gets complicated. This proposal describes a language extension to make this a lot more natural and less error prone.

This paper introduces a first class Coroutine model to Swift. Functions can opt into to being async, allowing the programmer to compose complex logic involving asynchronous operations, leaving the compiler in charge of producing the necessary closures and state machines to implement that logic.

	//: Playground - for Noa 💝
	// http://adventofcode.com/2017/day/1
	// author: Daniel Asher

	func string2Array(number: String) -> [Int] {
	var result: [Int] = []
	for numeral in number {
	result.append(Int(String(numeral))!)
	}
	return result

	//
	// UIAlertController+Rx.swift
	//

	import Foundation
	import RxSwift

	protocol RxAlertActionType {
	associatedtype Result

	import UIKit
	import PlaygroundSupport
	// https://gist.github.com/erica/6f13f3043a330359c035e7660f3fe7f5
	// Original Video: https://www.youtube.com/watch?v=TTmWUSgNOHk
	// Video: https://www.youtube.com/watch?v=hmAB3WJOQTU
	// Video: https://www.youtube.com/watch?v=DWtavuvmKdw (with zoom and fade)

	// String to animate and its attributes
	var string = "Hello, playground"
	let attributes: [String: Any] = [

	func deepDescription(any: Any) -> String {
	guard let any = deepUnwrap(any) else {
	return "nil"
	}

	if any is Void {
	return "Void"
	}

	if let int = any as? Int {

	import Foundation

	// Why bytesView rather than just extending NSData directly?
	// Because this way we can keep our extension internal and not conflict
	// with someone who imports us and has also extended NSData.
	// If you're top-level code, you can just hoist everyting up to NSData directly.
	internal extension NSData {
	var bytesView: BytesView { return BytesView(self) }
	}

	/*
	* This is an example provided by Facebook are for non-commercial testing and
	* evaluation purposes only.
	*
	* Facebook reserves all rights not expressly granted.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NON INFRINGEMENT. IN NO EVENT SHALL
	* FACEBOOK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

	public static class CombGuid
	{
	public static readonly Guid Empty = Guid.Parse("00000000-0000-0000-0000-000000000000");

	private static readonly Func<Guid> GeneratorCore = () =>
	{
	var destinationArray = Guid.NewGuid().ToByteArray();
	var time = new DateTime(1900, 1, 1);
	var now = DateTime.UtcNow;
	var span = new TimeSpan(now.Ticks - time.Ticks);