0001    public enum Result
Parser.swift:24
func parseDoc (tokens: [TokenMatch]) -> Result<Yaml> {
Parser.swift:35
func parseDocs (tokens: [TokenMatch]) -> Result<[Yaml]> {
Parser.swift:39
func parseDocs (acc: [Yaml]) -> Context -> Result<[Yaml]> {
Parser.swift:85
func expect (type: TokenType, message: String) -> Context -> Result<Context> {
Parser.swift:93
func expectVersion (context: Context) -> Result<Context> {
Parser.swift:114
func parseHeader (context: Context) -> Result<Context> {
Parser.swift:118
func parseHeader (yamlAllowed: Bool) -> Context -> Result<Context> {
Parser.swift:146
func parse (context: Context) -> Result<ContextValue> {
Parser.swift:284
    -> Result<ContextValue> {
Parser.swift:292
func parseFlowSeq (context: Context) -> Result<ContextValue> {
Parser.swift:298
func parseFlowSeq (acc: [Yaml]) -> Context -> Result<ContextValue> {
Parser.swift:317
func parseFlowMap (context: Context) -> Result<ContextValue> {
Parser.swift:323
func parseFlowMap (acc: [Yaml: Yaml]) -> Context -> Result<ContextValue> {
Parser.swift:348
func parseBlockSeq (context: Context) -> Result<ContextValue> {
Parser.swift:352
func parseBlockSeq (acc: [Yaml]) -> Context -> Result<ContextValue> {
Parser.swift:373
func parseBlockMap (context: Context) -> Result<ContextValue> {
Parser.swift:377
func parseBlockMap (acc: [Yaml: Yaml]) -> Context -> Result<ContextValue> {
Parser.swift:393
func parseQuestionMarkKeyValue (acc: [Yaml: Yaml]) -> Context -> Result<ContextValue> {
Parser.swift:413
func parseColonValueOrNil (context: Context) -> Result<ContextValue> {
Parser.swift:420
func parseColonValue (context: Context) -> Result<ContextValue> {
Parser.swift:427
func parseStringKeyValue (acc: [Yaml: Yaml]) -> Context -> Result<ContextValue> {
Parser.swift:446
func parseString (context: Context) -> Result<ContextValue> {
Parser.swift:467
func parseBlockMapOrString (context: Context) -> Result<ContextValue> {
Parser.swift:494
func parseLiteral (context: Context) -> Result<ContextValue> {
Result.swift:19
  public func map <U> (f: T -> U) -> Result<U> {
Result.swift:26
  public func flatMap <U> (f: T -> Result<U>) -> Result<U> {
Result.swift:26
  public func flatMap <U> (f: T -> Result<U>) -> Result<U> {
Result.swift:35
func <*> <T, U> (f: Result<T -> U>, x: Result<T>) -> Result<U> {
Result.swift:35
func <*> <T, U> (f: Result<T -> U>, x: Result<T>) -> Result<U> {
Result.swift:35
func <*> <T, U> (f: Result<T -> U>, x: Result<T>) -> Result<U> {
Result.swift:44
func <^> <T, U> (f: T -> U, x: Result<T>) -> Result<U> {
Result.swift:44
func <^> <T, U> (f: T -> U, x: Result<T>) -> Result<U> {
Result.swift:49
func >>- <T, U> (x: Result<T>, f: T -> U) -> Result<U> {
Result.swift:49
func >>- <T, U> (x: Result<T>, f: T -> U) -> Result<U> {
Result.swift:54
func >>=- <T, U> (x: Result<T>, f: T -> Result<U>) -> Result<U> {
Result.swift:54
func >>=- <T, U> (x: Result<T>, f: T -> Result<U>) -> Result<U> {
Result.swift:54
func >>=- <T, U> (x: Result<T>, f: T -> Result<U>) -> Result<U> {
Result.swift:59
func >>| <T, U> (x: Result<T>, y: Result<U>) -> Result<U> {
Result.swift:59
func >>| <T, U> (x: Result<T>, y: Result<U>) -> Result<U> {
Result.swift:59
func >>| <T, U> (x: Result<T>, y: Result<U>) -> Result<U> {
Result.swift:63
func lift <V> (v: V) -> Result<V> {
Result.swift:67
func fail <T> (e: String) -> Result<T> {
Result.swift:71
func join <T> (x: Result<Result<T>>) -> Result<T> {
Result.swift:71
func join <T> (x: Result<Result<T>>) -> Result<T> {
Result.swift:71
func join <T> (x: Result<Result<T>>) -> Result<T> {
Result.swift:75
func `guard` (@autoclosure error: () -> String, check: Bool) -> Result<()> {
Tokenizer.swift:118
func tokenize (text: String) -> Result<[TokenMatch]> {
Yaml.swift:98
  public static func load (text: Swift.String) -> Result<Yaml> {
Yaml.swift:102
  public static func loadMultiple (text: Swift.String) -> Result<[Yaml]> {
Yaml.swift:106
  public static func debug (text: Swift.String) -> Result<Yaml> {
Yaml.swift:117
  public static func debugMultiple (text: Swift.String) -> Result<[Yaml]> {
<T
Result.swift:3
  case Value(Box<T>)
Result.swift:12
  public var value: T? {
Result.swift:19
  public func map <U> (f: T -> U) -> Result<U> {
Result.swift:26
  public func flatMap <U> (f: T -> Result<U>) -> Result<U> {
> {
0002      case Error
Result.swift:7
    case .Error(let e): return e
Result.swift:14
    case .Error: return nil
Result.swift:21
    case .Error(let e): return .Error(e)
Result.swift:21
    case .Error(let e): return .Error(e)
Result.swift:28
    case .Error(let e): return .Error(e)
Result.swift:28
    case .Error(let e): return .Error(e)
Result.swift:37
  case (.Error(let e), _): return .Error(e)
Result.swift:37
  case (.Error(let e), _): return .Error(e)
Result.swift:38
  case (.Value, .Error(let e)): return .Error(e)
Result.swift:38
  case (.Value, .Error(let e)): return .Error(e)
Result.swift:68
  return .Error(e)
Result.swift:76
  return check ? lift(()) : .Error(error())
(String)
0003      case Value
Result.swift:8
    case .Value: return nil
Result.swift:15
    case .Value(let v): return v.value
Result.swift:22
    case .Value(let v): return .Value(Box(f(v.value)))
Result.swift:22
    case .Value(let v): return .Value(Box(f(v.value)))
Result.swift:29
    case .Value(let v): return f(v.value)
Result.swift:38
  case (.Value, .Error(let e)): return .Error(e)
Result.swift:39
  case (.Value(let x), .Value(let f)): return .Value(Box(f.value(x.value)))
Result.swift:39
  case (.Value(let x), .Value(let f)): return .Value(Box(f.value(x.value)))
Result.swift:39
  case (.Value(let x), .Value(let f)): return .Value(Box(f.value(x.value)))
Result.swift:64
  return .Value(Box(v))
(Box<T>)
0004    
0005      public var error
Yaml.swift:111
    if let error = result.error {
Yaml.swift:124
    if let error = result.error {
: String? {
0006        switch self {
0007        case .Error(let e): return e
0008        case .Value: return nil
0009        }
0010      }
0011    
0012      public var value: T? {
0013        switch self {
0014        case .Error: return nil
0015        case .Value(let v): return v.value
0016        }
0017      }
0018    
0019      public func map
Result.swift:45
  return x.map(f)
Result.swift:50
  return x.map(f)
 <U> (f: T -> U) -> Result<U> {
0020        switch self {
0021        case .Error(let e): return .Error(e)
0022        case .Value(let v): return .Value(Box(f(v.value)))
0023        }
0024      }
0025    
0026      public func flatMap
Result.swift:55
  return x.flatMap(f)
Result.swift:60
  return x.flatMap { _ in y }
 <U> (f: T -> Result<U>) -> Result<U> {
0027        switch self {
0028        case .Error(let e): return .Error(e)
0029        case .Value(let v): return f(v.value)
0030        }
0031      }
0032    }
0033    
0034    infix operator <*> { associativity left }
0035    func <*> <T, U> (f: Result<T -> U>, x: Result<T>) -> Result<U> {
0036      switch (x, f) {
0037      case (.Error(let e), _): return .Error(e)
0038      case (.Value, .Error(let e)): return .Error(e)
0039      case (.Value(let x), .Value(let f)): return .Value(Box(f.value(x.value)))
0040      }
0041    }
0042    
0043    infix operator <^> { associativity left }
0044    func <^> <T, U> (f: T -> U, x: Result<T>) -> Result<U> {
0045      return x.map(f)
0046    }
0047    
0048    infix operator >>- { associativity left }
0049    func >>- <T, U> (x: Result<T>, f: T -> U) -> Result<U> {
0050      return x.map(f)
0051    }
0052    
0053    infix operator >>=- { associativity left }
0054    func >>=- <T, U> (x: Result<T>, f: T -> Result<U>) -> Result<U> {
0055      return x.flatMap(f)
0056    }
0057    
0058    infix operator >>| { associativity left }
0059    func >>| <T, U> (x: Result<T>, y: Result<U>) -> Result<U> {
0060      return x.flatMap { _ in y }
0061    }
0062    
0063    func lift
Parser.swift:25
  let c = lift(Context(tokens))
Parser.swift:42
      return lift(acc)
Parser.swift:44
    let cv = lift(context)
Parser.swift:89
        >>| lift(advance(context))
Parser.swift:97
      >>| lift(advance(context))
Parser.swift:123
      return lift(context)
Parser.swift:130
          >>| lift(context)
Parser.swift:137
      return lift(advance(context))
Parser.swift:141
          >>| lift(context)
Parser.swift:153
    return lift((advance(context), nil))
Parser.swift:156
    return lift((advance(context), true))
Parser.swift:159
    return lift((advance(context), false))
Parser.swift:165
    return lift((advance(context), v))
Parser.swift:171
    return lift((advance(context), v))
Parser.swift:177
    return lift((advance(context), v))
Parser.swift:182
    return lift((advance(context), v))
Parser.swift:185
    return lift((advance(context), .Double(Double.infinity)))
Parser.swift:188
    return lift((advance(context), .Double(-Double.infinity)))
Parser.swift:191
    return lift((advance(context), .Double(Double.NaN)))
Parser.swift:195
    return lift((advance(context), .Double(m.doubleValue)))
Parser.swift:246
        >>| lift((advance(context), value ?? nil))
Parser.swift:249
    return lift((context, nil))
Parser.swift:288
            >>| lift((context, key))
Parser.swift:293
  return lift(context)
Parser.swift:301
      return lift((advance(context), .Array(acc)))
Parser.swift:303
    let cv = lift(context)
Parser.swift:305
        >>=- (acc.count == 0 ? lift : expect(TokenType.Comma, message: "expected comma"))
Parser.swift:318
  return lift(context)
Parser.swift:326
      return lift((advance(context), .Dictionary(acc)))
Parser.swift:328
    let ck = lift(context)
Parser.swift:330
        >>=- (acc.count == 0 ? lift : expect(TokenType.Comma, message: "expected comma"))
Parser.swift:355
      return lift((context, .Array(acc)))
Parser.swift:357
    let cv = lift(context)
Parser.swift:388
      return lift((context, .Dictionary(acc)))
Parser.swift:395
    let ck = lift(context)
Parser.swift:415
    return lift((context, nil))
Parser.swift:421
  return lift(context)
Parser.swift:429
    let ck = lift(context)
Parser.swift:452
    return lift((advance(context), .String(folded)))
Parser.swift:456
    return lift((advance(context), .String(unescapeDoubleQuotes(foldFlow(m)))))
Parser.swift:460
    return lift((advance(context), .String(unescapeSingleQuotes(foldFlow(m)))))
Parser.swift:504
      >>| lift(blockContext)
Result.swift:76
  return check ? lift(()) : .Error(error())
Tokenizer.swift:258
  return lift(matchList)
 <V> (v: V) -> Result<V> {
0064      return .Value(Box(v))
0065    }
0066    
0067    func fail
Parser.swift:252
    return fail(error("unexpected type \(peekType(context))")(context))
Parser.swift:463
    return fail(error("expected string")(context))
Tokenizer.swift:242
          return fail(escapeErrorContext(text))
Tokenizer.swift:251
    return fail(escapeErrorContext(text))
 <T> (e: String) -> Result<T> {
0068      return .Error(e)
0069    }
0070    
0071    func join
Parser.swift:53
    return parseDocs <^> a <*> c |> join
Parser.swift:313
    return parseFlowSeq <^> a <*> c |> join
Parser.swift:344
    return parseFlowMap <^> a <*> c |> join
Parser.swift:369
    return parseBlockSeq <^> a <*> c |> join
Parser.swift:409
    return parseBlockMap <^> a <*> c |> join
Parser.swift:442
    return parseBlockMap <^> a <*> c |> join
 <T> (x: Result<Result<T>>) -> Result<T> {
0072      return x >>=- { i in i }
0073    }
0074    
0075    func `guard`
Parser.swift:88
    return `guard`(error(message)(context), check: check)
Parser.swift:96
  return `guard`(error("invalid yaml version")(context), check: check)
Parser.swift:129
      return `guard`(error(err)(context), check: yamlAllowed)
Parser.swift:140
      return `guard`(error("expected ---")(context), check: yamlAllowed)
Parser.swift:245
    return `guard`(error(err)(context), check: value != nil)
Parser.swift:287
        return `guard`(error(err)(context), check: !acc.keys.contains(key))
Parser.swift:502
  let c = `guard`(error(error0)(context),
Parser.swift:530
      >>| `guard`(error(error1)(blockContext), check: !check1)
Parser.swift:531
      >>| `guard`(error(error2)(blockContext), check: !check2)
 (@autoclosure error: () -> String, check: Bool) -> Result<()> {
0076      return check ? lift(()) : .Error(error())
0077    }
0078    
0079    // Required for boxing for now.
0080    public class Box
Result.swift:3
  case Value(Box<T>)
Result.swift:22
    case .Value(let v): return .Value(Box(f(v.value)))
Result.swift:39
  case (.Value(let x), .Value(let f)): return .Value(Box(f.value(x.value)))
Result.swift:64
  return .Value(Box(v))
<T
Result.swift:81
  let _value: () -> T
Result.swift:83
  init(_ value: T) {
Result.swift:87
  var value: T {
> {
0081      let _value
Result.swift:84
    _value = { value }
Result.swift:88
    return _value()
: () -> T
0082    
0083      init
Result.swift:22
    case .Value(let v): return .Value(Box(f(v.value)))
Result.swift:39
  case (.Value(let x), .Value(let f)): return .Value(Box(f.value(x.value)))
Result.swift:64
  return .Value(Box(v))
(_ value: T) {
0084        _value = { value }
0085      }
0086    
0087      var value
Result.swift:15
    case .Value(let v): return v.value
Result.swift:22
    case .Value(let v): return .Value(Box(f(v.value)))
Result.swift:29
    case .Value(let v): return f(v.value)
Result.swift:39
  case (.Value(let x), .Value(let f)): return .Value(Box(f.value(x.value)))
Result.swift:39
  case (.Value(let x), .Value(let f)): return .Value(Box(f.value(x.value)))
: T {
0088        return _value()
0089      }
0090    }
0091