Dave Abrahams dabrahams

## NoRecursiveConstraint.swift
// Everything but the slicing-related requirements of Collection
protocol CollectionCore {

  associatedtype Element
  associatedtype Index

  func startIndex() -> Index
  func endIndex() -> Index
  func index(after i: Index) -> Index

## Memo.swift
// This file demonstrates how memoization might work in the transformation of a `ScopedProgram` into
// a `TypedProgram`, which additionally represents type information.

public struct TypedProgram {
  /// The prior representation of the program, without analysis of types.
  public let base: ScopedProgram

  /// A type.
  public struct Type_: Hashable {
    let id: Int

## ValueMemoize.swift
// Just to give a sense of reality.
struct AST {}

/// The wrapper over a dictionary that maps keys onto non-optional
/// values, expecting them to have already been computed.
struct ImmutablePropertyMap<Key: Hashable, Value> {
  let storage: Dictionary<Key, Value>
  subscript(k: Key) -> Value { storage[k]! }
}

## repl.txt
➜  val git:(interpreter) ✗ swift repl
Welcome to Apple Swift version 5.7.2 (swiftlang-5.7.2.135.5 clang-1400.0.29.51).
Type :help for assistance.

  1> let x = [[1], [2, 3]]
x: [[Int]] = 2 values {
  [0] = 1 value {
    [0] = 1
  }
  [1] = 2 values {

## CrossProduct.swift
struct CrossProduct2<Base0: Collection, Base1: Collection>: Collection {
  public private(set) var base0: Base0
  public private(set) var base1: Base1

  init(_ base0: Base0, _ base1: Base1) {
    self.base0 = base0
    self.base1 = base1
  }

  struct Index: Comparable {

## Grammar+nullSymbolSets.swift
extension Grammar {
  /// Returns the set of nullable symbols (which sometimes derive 𝝐) and the subset of nulling
  /// symbols (which always derive 𝝐) in a grammar that is not yet in nihilist normal form.
  func nullSymbolSets(rulesByRHS: MultiMap<Symbol, Rule>)
    -> (nullable: Set<Symbol>, nulling: Set<Symbol>)
  {
    // - Common setup.

    // Mapping from symbol to the set of ruleIDs having that symbol as a LHS.
    let rulesByLHS = MultiMap(grouping: ruleIDs, by: lhs)

## BitSet.swift
private typealias Word = UInt
/*
/// Returns the offset at which the `i`th bit can be found in an array of
/// `Word`s.
private func wordOffset(ofBit i: Int) -> Int {
  precondition(i >= 0)
  return i / Word.bitWidth
}

/// Returns a mask that isolates the `i`th bit within its `Word` in an array of

## ChartParser.swift
/// A simple bottom-up chart parser.
///
/// - The chart is a lookup table of sets of partial parses (a.k.a. dotted
///   rules), indexed by (predicted-symbol, source-location) pairs.
///
/// - A partial parse is a triple (B, R, N) where:
///   - B is the position in the token stream where the partially-parsed input begins.
///   - R is the partially-recognized BNF rule.
///   - N is the number of RHS symbols of R that have been recognized.
///

## KeynoteTextNotes.md

      
              1 file
            
          
              0 forks
            
          
              0 comments
            
          
              0 stars
            
          
                dabrahams
                / KeynoteTextNotes.md
            
            
              Created
              December 13, 2021 02:09
            
              
                Notes on how Keynote lays out text boxes, and translating that into CSS
              
          
    Line spacing

In keynote, line spacing is specified per-paragraph.  Paragraphs are
line-wrapped into physical lines.
For now, we're only interested in text boxes where spacing is specified in
“lines.”
For a physical line β and a character γ:

  
## CoW.swift
/// Example of a recursive sum type representing a tree.
///
/// The compiler uses copy-on-write under the covers to give instances value
/// semantics.
indirect enum Tree<Body> {
  case o(_ body: Body, _ left: Tree?, _ right: Tree?)
}

extension Tree : Equatable where Body: Equatable {}
	// Everything but the slicing-related requirements of Collection
	protocol CollectionCore {

	associatedtype Element
	associatedtype Index

	func startIndex() -> Index
	func endIndex() -> Index
	func index(after i: Index) -> Index
	// This file demonstrates how memoization might work in the transformation of a `ScopedProgram` into
	// a `TypedProgram`, which additionally represents type information.

	public struct TypedProgram {
	/// The prior representation of the program, without analysis of types.
	public let base: ScopedProgram

	/// A type.
	public struct Type_: Hashable {
	let id: Int
	// Just to give a sense of reality.
	struct AST {}

	/// The wrapper over a dictionary that maps keys onto non-optional
	/// values, expecting them to have already been computed.
	struct ImmutablePropertyMap<Key: Hashable, Value> {
	let storage: Dictionary<Key, Value>
	subscript(k: Key) -> Value { storage[k]! }
	}
	➜ val git:(interpreter) ✗ swift repl
	Welcome to Apple Swift version 5.7.2 (swiftlang-5.7.2.135.5 clang-1400.0.29.51).
	Type :help for assistance.

	1> let x = [[1], [2, 3]]
	x: [[Int]] = 2 values {
	[0] = 1 value {
	[0] = 1
	}
	[1] = 2 values {
	struct CrossProduct2<Base0: Collection, Base1: Collection>: Collection {
	public private(set) var base0: Base0
	public private(set) var base1: Base1

	init(_ base0: Base0, _ base1: Base1) {
	self.base0 = base0
	self.base1 = base1
	}

	struct Index: Comparable {
	extension Grammar {
	/// Returns the set of nullable symbols (which sometimes derive 𝝐) and the subset of nulling
	/// symbols (which always derive 𝝐) in a grammar that is not yet in nihilist normal form.
	func nullSymbolSets(rulesByRHS: MultiMap<Symbol, Rule>)
	-> (nullable: Set<Symbol>, nulling: Set<Symbol>)
	{
	// - Common setup.

	// Mapping from symbol to the set of ruleIDs having that symbol as a LHS.
	let rulesByLHS = MultiMap(grouping: ruleIDs, by: lhs)
	private typealias Word = UInt
	/*
	/// Returns the offset at which the `i`th bit can be found in an array of
	/// `Word`s.
	private func wordOffset(ofBit i: Int) -> Int {
	precondition(i >= 0)
	return i / Word.bitWidth
	}

	/// Returns a mask that isolates the `i`th bit within its `Word` in an array of
	/// A simple bottom-up chart parser.
	///
	/// - The chart is a lookup table of sets of partial parses (a.k.a. dotted
	/// rules), indexed by (predicted-symbol, source-location) pairs.
	///
	/// - A partial parse is a triple (B, R, N) where:
	/// - B is the position in the token stream where the partially-parsed input begins.
	/// - R is the partially-recognized BNF rule.
	/// - N is the number of RHS symbols of R that have been recognized.
	///
	/// Example of a recursive sum type representing a tree.
	///
	/// The compiler uses copy-on-write under the covers to give instances value
	/// semantics.
	indirect enum Tree<Body> {
	case o(_ body: Body, _ left: Tree?, _ right: Tree?)
	}

	extension Tree : Equatable where Body: Equatable {}