1

Hey there,

I just triggered a compiler error (I think): "INTERNAL ERROR: feautre not implemented: reabstraction of pack values". Here's my minimal example to reproduce this:

func dropFirstArg<First, each Others>(_ closure: @escaping ((repeat each Others)) async throws -> Void) -> ((First, repeat each Others)) async throws -> Void {
    fatalError() // trying to implement this gives more unintelligible errors 
}

Is there any workaround to accomplish what I'm trying to do? In my concrete case, all I want is to drop the initial Substring output of a Regex<(Substring, repeat each ActualArgsThatICareAbout)> such that this compiles:

public struct Match<Args> {
    
    public let regex : Regex<Args>
    public let onRecognize : (Args) async throws -> Void
    
    public init<each Arg>(_ regex: Regex<(Substring, repeat each Arg)>,
                          onRecognize: @escaping ((repeat each Arg)) async throws -> Void) where Args == (Substring, repeat each Arg) {
        self.regex = regex
        self.onRecognize = dropFirstArg(onRecognize)
    }
    
}

Other approaches I considered: putting a regex and onRecognize requirement directly into a protocol so I can actually make onRecognize a func rather than a closure; problem with that approach is that associatedtypes can't be variadic generic, so I'd be stuck with a tuple which don't look quite so nice in funcs.

1 Like
2

Update: I think the second part of the code is actually significant in producing the mentioned error. When I removed the constructor of Match, everything was fine, so dropFirstArg itself is not the issue... maybe I can get this to work still??

3

I'm basically doing it manually again - the very thing that we were supposed to avoid with the shiny new variadic generics :frowning: There's apparently still a lot left to be desired

public protocol Matcher {
    var regexText : String {get}
    func match(_ arg: String) throws -> Any?
    func invoke(with arg: Any) async throws
}

public extension Cucumber {
    
    static func match(_ regex: Regex<Substring>, onRecognize: @escaping () async throws -> Void) -> some Matcher {
        Match0(regex: regex, onRecognize: onRecognize)
    }
    
    static func match<Arg0>(_ regex: Regex<(Substring, Arg0)>, onRecognize: @escaping (Arg0) async throws -> Void) -> some Matcher {
        Match1(regex: regex, onRecognize: onRecognize)
    }
    
    static func match<Arg0, Arg1>(_ regex: Regex<(Substring, Arg0, Arg1)>, onRecognize: @escaping (Arg0, Arg1) async throws -> Void) -> some Matcher {
        Match2(regex: regex, onRecognize: onRecognize)
    }
    
    static func match<Arg0, Arg1, Arg2>(_ regex: Regex<(Substring, Arg0, Arg1, Arg2)>, onRecognize: @escaping (Arg0, Arg1, Arg2) async throws -> Void) -> some Matcher {
        Match3(regex: regex, onRecognize: onRecognize)
    }
    
}

struct Match0 : Matcher {
    
    var regexText: String {
        "\(regex)"
    }
    
    let regex : Regex<Substring>
    let onRecognize : () async throws -> Void
    
    func match(_ arg: String) throws -> Any? {
        try regex.wholeMatch(in: arg)?.output
    }
    
    func invoke(with arg: Any) async throws {
        try await onRecognize()
    }
    
}

struct Match1<Arg0> : Matcher {
    
    var regexText: String {
        "\(regex)"
    }
    
    let regex : Regex<(Substring, Arg0)>
    let onRecognize : (Arg0) async throws -> Void
    
    func match(_ arg: String) throws -> Any? {
        try regex.wholeMatch(in: arg)?.output
    }
    
    func invoke(with arg: Any) async throws {
        let (_, arg0) = arg as! (Substring, Arg0)
        try await onRecognize(arg0)
    }
    
}

struct Match2<Arg0, Arg1> : Matcher {
    
    var regexText: String {
        "\(regex)"
    }
    
    let regex : Regex<(Substring, Arg0, Arg1)>
    let onRecognize : (Arg0, Arg1) async throws -> Void
    
    func match(_ arg: String) throws -> Any? {
        try regex.wholeMatch(in: arg)?.output
    }
    
    func invoke(with arg: Any) async throws {
        let (_, arg0, arg1) = arg as! (Substring, Arg0, Arg1)
        try await onRecognize(arg0, arg1)
    }
    
}

struct Match3<Arg0, Arg1, Arg2> : Matcher {
    
    var regexText: String {
        "\(regex)"
    }
    
    let regex : Regex<(Substring, Arg0, Arg1, Arg2)>
    let onRecognize : (Arg0, Arg1, Arg2) async throws -> Void
    
    func match(_ arg: String) throws -> Any? {
        try regex.wholeMatch(in: arg)?.output
    }
    
    func invoke(with arg: Any) async throws {
        let (_, arg0, arg1, arg2) = arg as! (Substring, Arg0, Arg1, Arg2)
        try await onRecognize(arg0, arg1, arg2)
    }
    
}
4

I ran into a similar issue with the following code:

protocol Runner<Input, Output> {
    associatedtype Input
    associatedtype Output

    func run(on input: Input) -> Output
}

struct Run: Runner {
    func run(on input: (Int, Int)) -> String {
        "\(input.0), \(input.1)"
    }
}

struct AppendOutput<each InputElement, Base: Runner>: Runner where Base.Input == (repeat each InputElement) {
    let base: Base
    func run(on input: (repeat each InputElement)) -> (repeat each InputElement, Base.Output) { // INTERNAL ERROR: feature not implemented: reabstraction of pack values
        (repeat each input, base.run(on: input))
    }
}

Removing the Runner conformance gets rid of the error but that kind of defeats the goal I was trying to achieve with this.

5

This bug appears to be fixed on nightly. The following inhabits the signature you've provided:

func dropFirstArg<First, each Others>(_ closure: @escaping (repeat each Others) async throws -> Void) -> (First, repeat each Others) async throws -> Void {
    return { (_: First, pack: repeat each Others) -> Void in
        try await closure(repeat each pack)
    }
}
1 Like
6 
func droppingFirst<First, each Others>(
    _ closure: @escaping (repeat each Others) async throws -> Void
) -> (First, repeat each Others) async throws -> Void {
    { (_: First, pack: repeat each Others) -> Void in
        try await closure(repeat each pack)
    }
}

public struct Match<each Arg> {
    public let regex: Regex<(Substring, repeat each Arg)>
    public let onRecognize: (Substring, repeat each Arg) async throws -> Void
    
    public init(
        _ regex: Regex<(Substring, repeat each Arg)>,
        onRecognize: @escaping (repeat each Arg) async throws -> Void
    ) {
        self.regex = regex
        self.onRecognize = droppingFirst(onRecognize)
    }
}

Not sure if it will work as expected, but at least it compiles :smiley: