Полиморфизм с унаследованными генериками вызывает плохой доступ в Swift
У меня есть два класса, которые наследуются от общего класса.
class Parser<I: CollectionType, T> {
func parse(ts: I) -> [(T, I)] { return [] }
func parse_all(ts: I) -> [(T, I)] {
return parse(ts).filter { isEmpty($0.1) }
}
}
class CharParser<I: CollectionType, T> : Parser<[Character], Character> {
let c: Character
init(c: Character) { self.c = c }
override func parse(ts: [Character]) -> [(Character, [Character])] {
println(ts)
return ts[0] == c ? [(ts[0], Array(ts[1..<ts.count]))] : []
}
}
class AltParser<I: CollectionType, T> : Parser<I, T> {
let p: Parser<I, T>
let q: Parser<I, T>
init(p: Parser<I, T>, q: Parser<I,T>) {
self.p = p
self.q = q
}
override func parse(ts: I) -> [(T, I)] {
println(ts)
return p.parse(ts) + q.parse(ts)
}
}
class SeqParser<I: CollectionType, T, S>: Parser<I, (T, S)> {
let p: Parser<I, T>, q: Parser<I,S>
init(p: Parser<I, T>, q: Parser<I,S>) { self.p = p; self.q = q }
override func parse(ts: I) -> [((T, S), I)] {
var acc = [((T, S), I)]()
for (head1, tail1) in p.parse(ts) {
for (head2, tail2) in q.parse(tail1) {
acc += [((head1, head2), tail2)]
}
}
return acc
}
}
призвание
let x = CharParser<[Character], Character>(c: "a")
x.parse(Array("a"))
работает нормально, однако попытка вызвать его через AltParser вызывает EXC_BAD_ACCESS
let x2 = CharParser<[Character], Character>(c: "b")
let y = AltParser(p: x, q: x2)
let z = y.parse(Array("a"))
Это ошибка компилятора или я неправильно понимаю дженерики?
1 ответ
Хорошо, я не смог доказать, что ты не можешь этого сделать, теперь я попытаюсь показать, что ты можешь это сделать. Вот сильно упрощенная версия вашего кода, которая, я считаю, работает (по крайней мере, она компилируется и не дает сбоя):
class Parser<T> {
func parse(ts:[T]) -> [(T, [T])] { println ("super"); return []}
}
class StringParser<T> : Parser<String> {
let c : String
init(c: String) { self.c=c }
override func parse(ts:[String]) -> [(String, [String])] {
println ("sub")
return ts[0] == c ? [(ts[0], Array(ts[1..<ts.count]))] : []
}
}
class AltParser<T> : Parser<T> {
let p : Parser<T>
init(p:Parser<T>) {
self.p = p
}
override func parse(ts:[T]) -> [(T, [T])] {
return p.parse(ts)
}
}
func test() {
let x = StringParser<Character>(c:"a")
x.parse(["a"])
let z = AltParser(p:x)
println(z.parse(["a"]))
}
Я исключил все, что показалось лишним в примере. Я превратил Персонажа в Строку, потому что я нахожу персонажа запутанным Я удалил parse_all
и второе свойство q
потому что ты не использовал их ни для чего. Самое важное, что я удалил весь тип CollectionType из универсального и везде заменил его явным массивом; это было потому, что CollectionType доставлял мне проблемы при компиляции. В частности, я был разочарован, когда у меня все еще был CollectionType в универсальном, из-за невозможности найти способ указать, что это коллекция T; мне казалось каким-то решающим, что это должно быть ясно. Это одна из причин, почему я удалил его и заменил его явным массивом T. Но, возможно, я наткнулся на что-то полезное, потому что код, кажется, теперь работает.
Иди и выбери это на части...!