mayoff

@import Foundation;
@import CoreGraphics;

typedef struct __attribute__((objc_boxable)) CGPoint CGPoint;
typedef struct __attribute__((objc_boxable)) CGSize CGSize;
typedef struct __attribute__((objc_boxable)) CGRect CGRect;
typedef struct __attribute__((objc_boxable)) CGVector CGVector;

int main(int argc, const char * argv[]) {
    @autoreleasepool {

chriseidhof

import UIKit

struct Monoid<A> {
    let zero: A
    let append: (A, A) -> A
}

let additive = Monoid(zero: 0, append: +)
let multiplicative = Monoid(zero: 1, append: *)

CodaFi

Modular Swift

• Proposal: SE-NNNN
• Authors: Robert Widmann, Jaden Geller
• Review Manager: TBD
• Status: Awaiting review

Introduction

avafloww

/*<?php
//*/public class PhpJava { public static void main(String[] args) { System.out.printf("/*%s",
//\u000A\u002F\u002A
class PhpJava {
    static function main() {
        echo(//\u000A\u002A\u002F
        "Hello World!");
}}
//\u000A\u002F\u002A
PhpJava::main();

CodaFi

/// An operator is given by a list of arities, where each element indicates the number of
/// variables bound by the operator at that position and the length of the list determines the
/// number of variables the operator accepts.  The full generalization of arity is called
/// the operator's "valence".
///
/// For example, if I have a little calculator language with let-bindings, its operators
/// would look like this:
///
/// 
///		enum CalcOps : Operator {

airspeedswift

private class MyArrayBuffer<Element>: ManagedBuffer<Int,Element> {
    
    func clone() -> MyArrayBuffer<Element> {
        return self.withUnsafeMutablePointerToElements { elements -> MyArrayBuffer<Element> in
            return MyArrayBuffer<Element>.create(self.allocatedElementCount) { newBuf in
                newBuf.withUnsafeMutablePointerToElements { newElems->Void in
                    newElems.initializeFrom(elements, count: self.value)
                }
                return self.value

brentsimmons

import Cocoa

protocol Thing {
	var x: String {get}
	init(s: String)
}

class Foo: Thing {

	let x: String

ohanhi

Learning FP the hard way: Experiences on the Elm language

by Ossi Hanhinen, @ohanhi

with the support of Futurice 💚.

Licensed under CC BY 4.0.

Editorial note

nathggns

declare function require(module:string):any;
declare var process:any;

var readline = require('readline');
var fs = require('fs');

type brainfuckDone = (char : string) => void;
type brainfuckInput = (done : brainfuckDone) => void;

function brainfuck(tokens : string[], inp : brainfuckInput) {

nathggns

function await(generatorFunction) {
	let gen = generatorFunction();

	/**
	 * @param  {any?}   err    The error to throw in the generator, where yield was last called.
	 * @param  {any?}   result The result to pass to the genarator for the last call to yield
	 */
	function next(err, result) {
		// If the last promise that was yielded was rejected,
		// trigger an error inside the generator where yield was last called