neilpa

Keybase proof

I hereby claim:

• I am neilpa on github.
• I am neilpa (https://keybase.io/neilpa) on keybase.
• I have a public key whose fingerprint is 206A 9788 172B A7F0 C5DD 0930 5BDE 41AD 8199 B734

To claim this, I am signing this object:

neilpa

// Usage

let argv = CStringArray(["ls", "/"])
posix_spawnp(nil, argv.pointers[0], nil, nil, argv.pointers, nil)

// Is this really the best way to extend the lifetime of C-style strings? The lifetime
// of those passed to the String.withCString closure are only guaranteed valid during
// that call. Tried cheating this by returning the same C string from the closure but it
// gets dealloc'd almost immediately after the closure returns. This isn't terrible when
// dealing with a small number of constant C strings since you can nest closures. But

neilpa

# Assuming the raw byte[] buffer from onPreviewFrame was written at $1
INPUT=$1

# Need preview size since we dumped to a raw file w/out header info
SIZE=1280x960

# Converting to JPEG
ffmpeg -f image2 -vcodec rawvideo -s $SIZE -pix_fmt nv21 -i $INPUT out.jpeg

# Converting to PNG

neilpa

#!/usr/bin/env swift

//
// Naive wrapper around CFStringTransform that attempts to transliterate
// Unicode strings to lower-case ASCII
//
// http://nshipster.com/cfstringtransform/
//

import Foundation

neilpa

private enum Either<T, U> {
	case Left(Box<T>)
	case Right(Box<U>)
}

public func zipWith<T, U, E>(otherSignal: Signal<U, E>)(signal: Signal<T, E>) -> Signal<(T, U), E> {
	return Signal { observer in
		var lock = NSRecursiveLock()
		lock.name = "org.reactivecocoa.ReactiveCocoa.zipWith"

neilpa

protocol Randomizable {
    static func random() -> Self
}

protocol IntervalRandomizable: Randomizable, Comparable {
    static func random(interval: HalfOpenInterval<Self>) -> Self
    static func random(interval: ClosedInterval<Self>) -> Self
}

extension CGFloat: Randomizable {

neilpa

// Similar to `enumerate` but provides the collection's index type
// rather than an Int for the position
public func iterate<C: CollectionType>(collection: C) -> SequenceOf<(C.Index, C.Generator.Element)> {
    var index = collection.startIndex

    // type-inference doesn't want to work without this
    return SequenceOf { _ -> GeneratorOf<(C.Index, C.Generator.Element)> in
        return GeneratorOf {
            if index == collection.endIndex {
                return nil

neilpa

//
// A half-baked approach (not thread-safe, poor disposable management) for creating
// aggregate collections from multiple signals of collection mutations. In this
// case we are concating multiple mutation streams into a single container. So for
// each inner signal we need to offset subsequent splices by the count of preceding
// items (which can be recovered by scanning previous splices).
//
// Example:
//
//   let (first, sink1) = SignalProducer<Splice<Int>, NoError>.buffer()

neilpa

//
//  CollectionViewDataSource.swift
//  Khan Academy
//
//  Created by Andy Matuschak on 10/14/14.
//  Copyright (c) 2014 Khan Academy. All rights reserved.
//

import UIKit

neilpa

- (RACSignal*) continueInBackground
{
    return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
        UIApplication* app = UIApplication.sharedApplication;

        __block UIBackgroundTaskIdentifier taskID;
        RACCompoundDisposable* compoundDisposable = [RACCompoundDisposable compoundDisposable];
        RACDisposable* backgroundTaskDisposable = [RACDisposable disposableWithBlock:^{
            [app endBackgroundTask:taskID];
        }];