public typealias VarName = String

public struct Var: Hashable {
  let name: VarName
}

public enum BoolExpr {
  case literal(Bool)
}

public enum Expr {
  case bool(BoolExpr)
}

public typealias Substitution = (VarName) -> VarName

public func substitute(_ e: BoolExpr, using s: Substitution) -> BoolExpr {
    return e
}

public func substitute(_ c: Expr, using s: Substitution) -> Expr {
    return c
}

class X {
  func apply(_ generic: Expr) {
    var substitution = [Var: Var]()
    var results: [Expr] = []
    switch generic {
    case let .bool(expr):
      results.append(substitute(expr, using: { substitution[$0] }))
    }
  }
}

error.swift:31:33: error: cannot convert value of type 'BoolExpr' to expected argument type 'Expr'
      results.append(substitute(expr, using: { substitution[$0] }))
                                ^~~~

struct DefaultDict<K : Hashable, V> {
  var dict: [K: V] = [:]
  let def: V

  init(_ def: V) { self.def = def }

  subscript(_ key: K) -> V {
    mutating get {
      if dict[key] == nil { dict[key] = def }
      return dict[key]!
    }
  }
}

func error() {
    let x = Var(name: "asdf")
    var lookup = DefaultDict<Var,Var>(x)
    print(lookup[x])
    substitute(BoolExpr.literal(false), using: { lookup[$0] })
}

error2.swift:43:56: error: value of type 'DefaultDict<Var, Var>' has no subscripts
    substitute(BoolExpr.literal(false), using: { lookup[$0] })
                                                 ~~~~~~^~~~