Over a million developers have joined DZone.
{{announcement.body}}
{{announcement.title}}

Swiftly Improving

DZone's Guide to

Swiftly Improving

· Java Zone
Free Resource

Learn how to troubleshoot and diagnose some of the most common performance issues in Java today. Brought to you in partnership with AppDynamics.

So you catch the new Swift 1.2 seed yet? If not, looks like we could call this the Daft Punk release:

  • Harder — “compiler crashes have been fixed”, “fewer SourceKit warnings” …
  • Better — “Source files that haven’t changed will no longer be re-compiled by default…”
  • Faster — “Debug builds produce binaries that run considerably faster, and new optimizations…”
  • Stronger — “the language has been further refined to ensure safe, predictable behavior. We also continue to improve the interaction between Swift and Objective-C…”

Time to get on the latest rewrite round! Here’s a selection of good discussions of those “has been further refined” details:

NSHipster’s Swift 1.2

RayWenderlich.com’s What’s New in Swift 1.2

SwiftDoc.org’s Major content update for Swift 1.2

Let’s Talk About Sets, Baby!

Changes to the Swift Standard Library in 1.2 beta 1

Swift 1.2 Performance: Pretty Much Fine

Performance Case Study on Swift 1.1, Swift 1.2, and Objective-C

Also, we’d like to draw your attention to a couple so far generally overlooked points that have shown up on boards and mailing lists. First off, the souped up if let

The “if let” construct has been expanded to allow testing multiple optionals and guarding conditions in a single if (or while) statement using syntax similar to generic constraints:

if let a = foo(), b = bar() where a < b, let c = baz() {}

This allows you to test multiple optionals and include intervening boolean conditions, without introducing undesirable nesting (i.e., to avoid the “pyramid of doom”). (19382942)

is actually more souped up than those notes make fully clear:

  • can be an arbitrary number of let + where clauses in a single statement
  • can also be used with ‘if var’ should you wish to mutate values in the conditions
  • can also use a full multiple clause statement in a while loop!

That should be quite enough conditional flow expressivity to quiet all the grumbling on that front.

Next, if you’re chomping at the bit to add the new return value contract annotations to your legacy Objective-C headers, “nullability” is the so far undocumented clang feature for that, so here is a currently-submittable way to add that to production code, from Jens Alfke on the Xcode list:

So the magic invocation I’m putting in my header files (after the #includes) is:

#if __has_feature(nullability) // Xcode 6.3+
#pragma clang assume_nonnull begin
#else
#define nullable
#define __nullable
#endif

… interface declarations go here…

#if __has_feature(nullability)
#pragma clang assume_nonnull end
#endif

In property declarations you’ll need to make “nullable” the last meta-attribute, otherwise you’ll get syntax errors in earlier versions of Xcode; so for example “(readonly, nonatomic, nullable)” works but “(readonly, nullable, nonatomic)” is a syntax error because in Xcode 6.1 the parser will see two adjacent commas.

[This is working well, but in converting my interfaces I found a nasty compiler bug that I’m about to submit to Apple — if you declare multiple properties on a single line, adding the (nullable) attribute will cause the parser to lock up in an infinite loop:
@property (readonly, nullable) id a, b, c; // don’t do this!
I spent an hour or so with my MBP’s fan running full speed before figuring out which exact line triggered this.]

Lastly, one of the more subtle consequences of Swift 1.2 no-op cleanup is that you can no longer cleanly use ? as a postfix on an optional optional, as for instance when using map on an optional dictionary lookup:

let x:Int? = dict.map { $0["a"] }?

The Chris Lattner approved way to rewrite this pattern for 1.2 is

let x:Int? = dict.map { $0["a"] } ?? nil

to make it more clear to the reader exactly what the intention is here.

So we’re pretty chuffed with how this Swift thing is coming along; pretty much every undue pain point seems addressed to wide satisfaction around teh intertubes — so if you’ve been holding off on jumping in, NOW might be a very good time to get on that!

Understand the needs and benefits around implementing the right monitoring solution for a growing containerized market. Brought to you in partnership with AppDynamics.

Topics:

Published at DZone with permission of Alex Curylo, DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.

THE DZONE NEWSLETTER

Dev Resources & Solutions Straight to Your Inbox

Thanks for subscribing!

Awesome! Check your inbox to verify your email so you can start receiving the latest in tech news and resources.

X

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}