Substrings
Prefix && Suffix (Thank primo)
let str = "Hello! World"
str.prefix(6) // "Hello!"
str.suffix(5) // "World"
Splitting
The split function can take a closure that tells it what characters to split on. Split on spaces using
i.split{$0==" "}
Typecasting
String
String(i)
can be
"\(i)"
Array
Array(i)
can be
[]+i
Looping
for i in 0...100{print(i)}
(0...100).map{print($0)}
Depending on how many times you use the loop variable, it might be shorter to use for-in instead of map in certain cases. Try them both!
Conditional printing
Usually the same length, but depending on specific situation one can be shorter than the other
if a>0{print(a)}
a>0 ?print(a):()
Argument labels
By wrapping a function or initializer reference in an immediately-executed closure, you can call it without argument labels:
String(repeating:"h",count:3)
{String.init}()("h",3)
["a","b","c"].joined(separator:" ")
{["a","b","c"].joined}()(" ")
This trick works for most functions/initializers with lengthy argument labels, as long as the labels aren't necessary for the compiler to resolve overloads.
Key paths
"hello".map{$0.asciiValue!}
"hello".map(\.asciiValue!)
Type inference
Type placeholders
In cases where the compiler can't infer the full type, it can often infer part of the type:
let f={($0 as[String]).map{$0+"hello"}}
let g={$0.map{$0+"hello"}} // error: cannot infer type of closure parameter '$0' without a type annotation
let h={($0 as[_]).map{$0+"hello"}}
This syntax works for generic parameters; Array, Dictionary, and Optional sugar ([_], [_:_], _?); tuple types; and function types.
Inference via literals
let f={($0,$1,$2)as(Int,String,Double)}
let g={($0+0,$1+"",$2+0.0)}
(If you do this too much, you can very easily time-out the type checker -- sprinkling some explicit type annotations here and there can help.)