Using a parser in a failable initializer

[adauguet]

I would like to use a parser to validate input and instantiate a type.

Since the input may be invalid and the parser fail, this would be a failable initializer. But then, only nil can be returned, so I need an additional private init.

Can I write this simpler?

struct RegistrationNumber {
    let harbor: Harbor
    let number: String
    
    init?(raw: String) {
        let harbor = Prefix<Substring>(2)
            .map(String.init)
            .compactMap(Harbor.init)
        let number = Prefix<Substring>(6)
            .map(String.init)
        let parser = harbor
            .take(number)
            .skip(End())
            .map { RegistrationNumber(harbor: $0, number: $1) }
        if let registrationNumber = parser.parse(raw) {
            self = registrationNumber
        } else {
            return nil
        }
    }
    
    private init(harbor: Harbor, number: String) {
        self.harbor = harbor
        self.number = number
    }
}

[mbrandonw]

In Swift, if you implement an init directly in a struct you lose the automatically (internal) synthesized initializer. So, if you just move your .init?(raw:) to an extension you can get rid of the private init:

struct RegistrationNumber {
    let harbor: Harbor
    let number: String
}
 
extension RegistrationNumber {   
    init?(raw: String) {
        let harbor = Prefix<Substring>(2)
            .map(String.init)
            .compactMap(Harbor.init)
        let number = Prefix<Substring>(6)
            .map(String.init)
        let parser = harbor
            .take(number)
            .skip(End())
            .map { RegistrationNumber(harbor: $0, number: $1) } // ⬅️ Uses the synthesized initializer
        if let registrationNumber = parser.parse(raw) {
            self = registrationNumber
        } else {
            return nil
        }
    }
}

[adauguet]

Yes but that would allow the user to bypass the parser by using the synthesized initializer. Instead I would like to force using this the failable initializer.

[adauguet]

Not sure there is a better solution then. I am just not found of the following part:

if let registrationNumber = parser.parse(raw) {
    self = registrationNumber
} else {
    return nil
}

[mbrandonw]

Ah, if you want to force using the failable initializer then you either need implement the private init, or do something like this:

        let parser = harbor
            .take(number)
            .skip(End())
        if case let .some((harbor, number)) = parser.parse(raw) {
            self.harbor = harbor
            self.number = number
        } else {
            return nil
        }

[adauguet]

That might be a bit better indeed. Thank you!

[mbrandonw]

Also, if you are interested, you can make this .map a bit more succinct:

.map(RegistrationNumber.init(harbor:number:))

[adauguet]

Oh you are right!