An example formatter design.

Formatter.swift

protocol Formatter {
  associatedtype Input
  associatedtype Output
  
  func format(_ input: Input) -> Output
}

protocol CombiningFormatter: Formatter where
    InnerFormatter.Output == CombinedFormatter.Input
{
  associatedtype InnerFormatter: Formatter
  associatedtype CombinedFormatter: Formatter
  
  func combined(with inner: InnerFormatter) -> CombinedFormatter
}

struct Formatted<FormatterType: Formatter> {
  var input: FormatterType.Input
  var formatter: FormatterType
}

func %% <FormatterType: CombiningFormatter>(lhs: FormatterType.InnerFormatter, rhs: FormatterType) -> FormatterType.CombinedFormatter {
  return rhs.combined(with: lhs)
}
func %% <FormatterType: Formatter>(lhs: FormatterType.Input, rhs: FormatterType) -> Formatted<FormatterType.Input> {
  return Formatted<FormatterType>(input: lhs, formatter: rhs)
}

intFormatter.swift

struct int<Integer: BinaryInteger>: Formatter {
  enum Sign { case always, never, auto }
  var sign: Sign
  var thousandsSeparator: Bool
  var radix: Int
  
  init(sign: Sign = .auto, thousands: Bool = true, radix: Int = 10) {...}
  
  func format(_ input: Integer) -> String { ... }
}

PassthroughFormatter.swift

struct PassthroughFormatter<Input>: Formatter {
  func format(_ input: Input) -> Input {
  	return input
  }
}
extension CombiningFormatter where Self: Formatter, InnerFormatter == PassthroughFormatter<Input> {
  func format(_ input: Input) -> Output {
  	return combined(with: PassthroughFormatter()).format(input)
  }
}

StringFormatted.swift

// Here's the part this proposal touches on. This initializer would be 
// used when interpolating a `Formatted` value.
extension String {
  init<FormatterType: Formatter>(_ formatted: Formatted<FormatterType>)
      where FormatterType.Output == String
  {
  	self = formatted.formatter.format(formatted.input)
  }
}

widthFormatter.swift

struct width<InnerFormatter: Formatter>: CombiningFormatter, Formatter
    where InnerFormatter.Output == String {
  enum Side { case leading, trailing }
  
  var countRange: Range<Int>
  var padOn: Side?
  var padWith: Character
  var truncateOn: Side?
  
  init(padding: Side, with: Character = " ", orTruncating: Side, to: Range<Int>) {...}
  init(padding: Side, with: Character = " ", to: Int) {...}
  init(truncating: Side, to: Int) {...}
  
  func combined(with inner: InnerFormatter) {
    return CombinedFormatter(inner: inner, combining: self)
  }
  
  struct CombinedFormatter: Formatter {
    let inner: InnerFormatter
    let combining: width
    	
    func format(_ input: String) -> String {...}
  }
}