mattt

func zalgo(_ string: String, intensity: Int = 5) -> String {
    let combiningDiacriticMarks = 0x0300...0x036f
    let latinAlphabetUppercase = 0x0041...0x005a
    let latinAlphabetLowercase = 0x0061...0x007a
    
    var output: [UnicodeScalar] = []
    for scalar in string.unicodeScalars {
        output.append(scalar)
        guard (latinAlphabetUppercase).contains(numericCast(scalar.value)) ||
              (latinAlphabetLowercase).contains(numericCast(scalar.value))

mattt

// Calculate prime numbers in a given range
// using Sieve of Eratosthenes

import Accelerate

var primes: [Int] = []

let range = 0...999
var numbers = range.map(Float.init)

mattt

0  swift                    0x00000001109fac5a PrintStackTraceSignalHandler(void*) + 42
1  swift                    0x00000001109fa066 SignalHandler(int) + 966
2  libsystem_platform.dylib 0x00007fff65e29d9a _sigtramp + 26
3  libsystem_malloc.dylib   0x00007fff65e09ed4 tiny_malloc_should_clear + 289
4  CoreNLP                  0x00007fff4d7948eb invocation function for block in CoreNLP::NLModelTrainer::readSample(__CFString const*, std::__1::vector<CFRange, std::__1::allocator<CFRange> > const&, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&, CoreNLP::NLTrainerDataType) + 1010
5  CoreNLP                  0x00007fff4d751fd7 CoreNLP::CompositeTagger::enumerateTokens(NLTokenizerUnit, CFRange, unsigned long, void (NLToken, bool*) block_pointer) + 567
6  CoreNLP                  0x00007fff4d7944c0 CoreNLP::NLModelTrainer::readSample(__CFString 

mattt

This document was originally posted on 8/1/2013.

Rocket is a technique for building real-time functionality on top of REST web services that leverages web standards like [Server-Sent Events][SSE] and [JSON Patch][RFC6902]. Most importantly, it fits comfortably with how you're already building applications.

A Tale of Two Paradigms

Just as light can act as both a particle and a wave, so information can be thought as both a document and a stream.

Each approach has its particular strengths and weaknesses:

mattt

struct Regex {
    let pattern: String
    let options: NSRegularExpressionOptions!

    private var matcher: NSRegularExpression {
        return NSRegularExpression(pattern: self.pattern, options: self.options, error: nil)
    }

    init(pattern: String, options: NSRegularExpressionOptions = nil) {
        self.pattern = pattern

mattt

import CoreGraphics

infix operator |> { precedence 50 associativity left }

// MARK: CGPoint

func +(lhs: CGPoint, rhs: CGPoint) -> CGPoint {
    return CGPoint(x: lhs.x + rhs.x, y: lhs.y + rhs.y)
}

mattt

protocol Calendar {
    typealias Unit: BidirectionalIndexType

    typealias Era: Unit
    typealias Year: Unit
    typealias Month: Unit
    typealias Week: Unit
    typealias Day: Unit
    typealias Weekday: Unit
    typealias Hour: Unit

mattt

struct URL {
    var scheme: String?
    var user: String?
    var password: String?
    var host: String?
    var port: Int?
    var path: String?
    var query: String?
    var fragment: String?

mattt

struct Complex<T: FloatLiteralConvertible> {
    var real: T
    var imaginary: T
}

func +(lhs: Complex<Double>, rhs: Complex<Double>) -> Complex<Double> {
    return Complex<Double>(real: lhs.real + rhs.real, imaginary: lhs.imaginary + rhs.imaginary)
}

mattt

import Darwin

extension Int {
    static func random() -> Int {
        return Int(arc4random())
    }

    static func random(range: Range<Int>) -> Int {
        return Int(arc4random_uniform(UInt32(range.endIndex - range.startIndex))) + range.startIndex
    }