DougGregor

import Darwin

@dynamicMemberLookup
struct Environment {
  subscript(dynamicMember name: String) -> String? {
    get {
      guard let value = getenv(name) else { return nil }

      return String(validatingUTF8: value)
    }

regexident

Generic protocols

One of the most commonly requested features is the ability to parameterize protocols themselves. For example, a protocol that indicates that the Self type can be constructed from some specified type T or converted into T:

// T -> Self:
protocol ConstructibleFrom<T> {
  init(from value: T)
}

Azoy

public protocol RandomSource {
  static var shared: RandomSource { get }
  func next<T : FixedWidthInteger>(_ type: T.Type) -> T
  func nextUniform<T : BinaryFloatingPoint>(_ type: T.Type) -> T
}

// Utilizes /dev/urandom
public class DevRandom: RandomSource {
  public static let shared = DevRandom()
	

lattner

Swift Concurrency Manifesto

Author: Chris Lattner

Chinese Translation by Jason Yu

Contents

• Introduction
• Overall Vision

rxwei

/// Y combinator
func fix<D, R>(
    _ f: @escaping (Rep<(D) -> R>) -> Rep<(D) -> R>) -> Rep<(D) -> R> {
    return lambda { d in f(fix(f))[d] }
}

let fac: Rep<(Int) -> Int> = fix { f in
    lambda { (n: Rep<Int>) in
        .if(n == 0, then: ^1, else: n * f[n - 1])
    }

CTMacUser

Fixed-Size Arrays

• Proposal: SE-NNNN
• Authors: Daryle Walker, Author 2
• Review Manager: TBD
• Status: Awaiting review

During the review process, add the following fields as needed:

• Decision Notes: Rationale, Additional Commentary

bittlingmayer

"""

Takes two files produced by fastText's print-word-vectors or print-sentence-vectors and compares the vectors by similarity.

(See https://github.com/facebookresearch/fastText.)

This can be useful for benchmarking output or even generating benchmark data.

For example:

joshbuchea

Semantic Commit Messages

See how a minor change to your commit message style can make you a better programmer.

Format: <type>(<scope>): <subject>

<scope> is optional

Example

threepointone

I made a little styling lib called glam

(some features are in development)

one

let's start off with the simplest use case. we'll make an 'index.html' page, and assume we've setup our js bundler to output bundle.js

rxwei

/// A type equality guarantee is capable of safely casting one value to a
/// different type. It can only be created when `S` and `T` are statically known
/// to be equal.
struct TypeEqualityGuarantee<S, T> {
  private init() {}

  /// Safely cast a value to the other type.
  func cast(_ value: T) -> S {
    return value as! S
  }