Reducing boilerplate in initializers?

I have a protocol with quite a few properties, and my conforming types have duplicated code in init, to set those properties. It seems there is no way to factor this out into a helper function, since you have to set the properties in the body of the initializer. Is that correct? And if so, are there any proposals for letting the compiler see into helper functions, so it could allow this?

I know I can work around this by using a base class, or mutable optionals, but that seems ugly.

protocol P {
    var a: Int { get }
    var b: String { get }
    …
}

// It’s guaranteed to set a,b
func commonInit(a: inout Int, b: inout String) {
    a = …
    b = …
}

struct S: P {
    var a: Int
    var b: String
    init() {
        // duplicated boilerplate
        a = …
        b = …
        // A way to do this?
        commonInit(a: &a, b: &b)
        // or
        commonInit(self)
    }
}

You can define a new value type to encapsulate 'a' and 'b' into a single value, and initialize this value from each one of your duplicated initializers.

You can call class methods or free functions from your init methods. You can also return a tuple that has the values that you want to initialize.

init() {
  (a, b) = S.commonSetup(...)
}

class func commonSetup(...) -> (Int, String) {
  return (5, "hello world")
}

I've used this more for a lot of setup code that I wanted to not have in the init method mainly for readability reasons.