Is there an equivalent to the string function String(format: ...) using Swift formatting

Question

I'm starting to like the Swift string formatting since it uses variable names in the string rather than ambiguous formatting tags like "%@"

I want to load a large string from a file that has Swift-style formatting in it (like this)

Now is the time for all good \(who) to come to babble incoherently.

Then I want to feed the contents of that String variable into a statement that lest me replace

\(who)

with the contents of the constant/variable who at runtime.

The code below works with a string constant as the formatting string.

let who = "programmers"
let aString = "Now is the time for all good \(who) to come to babble incoherently."

That code does formatting of a quoted string that appears in-line in my code.

Instead I want something like the code

let formatString = "Now is the time for all good %@ to come to babble incoherently."
aString = String(format: formatString, who)

But where I can pass in a Swift-style format string in a constant/variable I read from a file.

Is that possible? I didn't have any luck searching for it since I wasn't exactly sure what search terms to use.

I can always use C-style string formatting and the String class' initWithFormat method if I have to...

Answer 1

I don't think there's a way to do this. String interpolation is implemented via conforming to the StringInterpolationConvertible protocol, and presumably you're hoping to tap into that in the same way you can tap into the methods required by StringLiteralConvertible, a la:

let someString = toString(42)

// this is the method String implements to conform to StringLiteralConvertible
let anotherString = String(stringLiteral: someString)

// anotherString will be "42"
print(anotherString)

Unfortunately, you can't do quite the same trick with StringInterpolationConvertible. Seeing how the protocol works may help:

struct MyString: Printable {
    let actualString: String
    var description: String { return actualString }
}

extension MyString: StringInterpolationConvertible {
    // first, this will get called for each "segment"
    init<T>(stringInterpolationSegment expr: T) {
        println("Processing segment: " + toString(expr))
        actualString = toString(expr)
    }
    // here is a type-specific override for Int, that coverts
    // small numbers into words:
    init(stringInterpolationSegment expr: Int) {
        if (0..<4).contains(expr) {
            println("Embigening \(expr)")
            let numbers = ["zeo","one","two","three"]
            actualString = numbers[expr]
        }
        else {
            println("Processing segment: " + toString(expr))
            actualString = toString(expr)
        }
    }
    // finally, this gets called with an array of all of the
    // converted segments
    init(stringInterpolation strings: MyString...) {
        // strings will be a bunch of MyString objects
        actualString = "".join(strings.map { $0.actualString })
    }
}

let number = 3
let aString: MyString = "Then shalt thou count to \(number), no more, no less."
println(aString)
// prints "Then shalt thou count to three, no more, no less."

So, while you can call String.init(stringInterpolation:) and String.init(stringInterpolationSegment:) directly yourself if you want (just try String(stringInterpolationSegment: 3.141) and String(stringInterpolation: "blah", "blah")), this doesn't really help you much. What you really need is a facade function that coordinates the calls to them. And unless there's a handy pre-existing function in the standard library that does exactly that which I've missed, I think you're out of luck. I suspect it's built into the compiler.

You could maybe write your own to achieve your goal, but a lot of effort since you'd have to break up the string you want to interpolate manually into bits and handle it yourself, calling the segment init in a loop. Also you'll hit problems with calling the combining function, since you can't splat an array into a variadic function call.