Since I started programming in Swift, I moved to the “Ash Rule” of left-hugging colons in all uses except ternary, up to and including dictionary references,  protocols, etc. Here’s what that looks like in use:

let x: [String: String] = ["key": "value"]
let y = foo(param1: value1, param2: value2)
func bar<T: Hashable>(a: T) -> Void {}

It felt weird for a while but I’ve now grown used to it. This approach is consistent, prioritizes the role of the left item, and is (in my opinion) quite readable. Compare and contrast with my prior style, which I call the “Full Space Monty” approach:

let x : [String : String] = ["key" : "value"]
let y = foo(param1 : value1, param2 : value2)
func bar<T : Hashable>(a : T) -> Void {}

The Ash Rule puts me in step with about half of Apple source code and out of step with the rest. Colon magnetism tends to vary by both group and individual producer. I mention this because Dave Abrahams clarified StdLib style on the Swift Evolution list today:

• Full monty spaces for declarations and extensions
• Left magnetism for providing values

Here’s an example I grabbed from Evolution that showcases some fascinating code styling choices. Focusing only on colons however, here’s what there is:

public func contains(value: Bound) -> Bool 
public var description: String 

protocol _ClosedRange : _RangeProtocol {}
public struct ClosedRangeIndex<
  Bound : Comparable where Bound : _Strideable
> : Comparable {

I’m going to assume the bolded use in the following snippet is an oversight:

extension _ClosedRange {
 @inline(__always)
 public init<
   Other: _ClosedRange where Other.Bound == Bound
 >(_ other: Other) {
     self.init(
     _uncheckedBounds: (lower: other.lowerBound, upper: other.upperBound)
     )
   }
...
}

While this next one is intentional since the ClosedRangeIndex is typing the lhs and rhs arguments:

public func == <B>(lhs: ClosedRangeIndex<B>, rhs: ClosedRangeIndex<B>) -> Bool {

This style isn’t universal. Apple Developer Publications uses Mike Ash colons.

When it comes to colon style, I don’t think there are right or wrong answers but I do think that whatever style you do choose naturally breaks down into the following categories:

• label declarations func f(x: T)
• collection lookups [key: value] (Empty case is universally [:] not [: ].)
• cases case A, B:
• inheritance class x: Y
• conformance <T: A>, <T: protocol<A, B>> {}
• attribute  @attribute(key: value), e.g. @available(*, unavailable, renamed: “MyRenamed”)
• ternary A ? B : C

I think there’s a general unity of opinion when it comes to case and ternary. No space for cases; always spaces for ternary. There’s little controversy or variation as far as I can tell.

The newly attribute style is up for grabs but I think it will follow label declarations in using left-magnetic colons.

The Swift Programming Language uses left-magnetic colons for dictionaries:

although the grammar does not: (Jordan Rose: ” Not sure I’d count the grammar as any particular evidence. Traditionally, grammars put spaces around everything.”)

Its property, constant, and variable declarations are pretty much uniformly left-magnetic:

I didn’t find any inheritance that wasn’t left-magnetic:

So what’s your house style and how did you come to it?