1596977100

# Loss Functions for Image-Super-Resolution (SISR)

In SISR, Autoencoder and U-Net are heavily used; however, they are well-known for difficulties in training to convergence. The choice of loss function plays an important role in guiding models to optimum. Today, I introduce 2 loss functions for Single-Image-Super-Resolution.

Zhengyang Lu and Ying Chen published a U-Net model with innovative loss functions for Single-Image-Super-Resolution. Their work introduces 2 loss functions: Mean-Squared-Error (MSE) for pixel-wise comparison and Mean-Gradient-Error (MGrE) for edge-wise comparison. In this article, I will walk you through and provide code snipsets for MSE and MGrE.

## Mean Squared Error (MSE)

MSE is a traditional loss function used in many Machine Learning algorithms (remember Linear Regression, your very first ML algorithm). Still, let’s me explain it again.

Let’s have 2 images (Y and Y^) of the same size (m, n, 3) that each pixel value ranges from 0 to 255. The pixel value represent the pixel color. Then MSE is computed as following:

Picture 1: Mean Squared Error

that _i and j _denotes the pixel location in the image based on x-y coordinates. The MSE formula is to compute the sum of the squared differences of pixel-wis ecolor values divided by m and n. In other words, the MSE formula is to compare pixel-color differences of 2 images. However, this function may not capture differences in edges of objects in 2 images that Lu and Chen proposed Mean Gradient Error to solve the issue.

The code snipset for MSE is not provided because MSE can be easily found in most packages.

#machine-learning #super-resolution #image-processing #artificial-intelligence #loss #function

1653123600

## EasyMDE - Markdown Editor

This repository is a fork of SimpleMDE, made by Sparksuite. Go to the dedicated section for more information.

A drop-in JavaScript text area replacement for writing beautiful and understandable Markdown. EasyMDE allows users who may be less experienced with Markdown to use familiar toolbar buttons and shortcuts.

In addition, the syntax is rendered while editing to clearly show the expected result. Headings are larger, emphasized words are italicized, links are underlined, etc.

EasyMDE also features both built-in auto saving and spell checking. The editor is entirely customizable, from theming to toolbar buttons and javascript hooks.

Try the demo

## Install EasyMDE

Via npm:

``````npm install easymde
``````

Via the UNPKG CDN:

``````<link rel="stylesheet" href="https://unpkg.com/easymde/dist/easymde.min.css">
<script src="https://unpkg.com/easymde/dist/easymde.min.js"></script>
``````

Or jsDelivr:

``````<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/easymde/dist/easymde.min.css">
<script src="https://cdn.jsdelivr.net/npm/easymde/dist/easymde.min.js"></script>
``````

## How to use

After installing and/or importing the module, you can load EasyMDE onto the first `textarea` element on the web page:

``````<textarea></textarea>
<script>
const easyMDE = new EasyMDE();
</script>
``````

Alternatively you can select a specific `textarea`, via JavaScript:

``````<textarea id="my-text-area"></textarea>
<script>
const easyMDE = new EasyMDE({element: document.getElementById('my-text-area')});
</script>
``````

### Editor functions

Use `easyMDE.value()` to get the content of the editor:

``````<script>
easyMDE.value();
</script>
``````

Use `easyMDE.value(val)` to set the content of the editor:

``````<script>
easyMDE.value('New input for **EasyMDE**');
</script>
``````

## Configuration

### Options list

• autoDownloadFontAwesome: If set to `true`, force downloads Font Awesome (used for icons). If set to `false`, prevents downloading. Defaults to `undefined`, which will intelligently check whether Font Awesome has already been included, then download accordingly.
• autofocus: If set to `true`, focuses the editor automatically. Defaults to `false`.
• autosave: Saves the text that's being written and will load it back in the future. It will forget the text when the form it's contained in is submitted.
• enabled: If set to `true`, saves the text automatically. Defaults to `false`.
• delay: Delay between saves, in milliseconds. Defaults to `10000` (10 seconds).
• submit_delay: Delay before assuming that submit of the form failed and saving the text, in milliseconds. Defaults to `autosave.delay` or `10000` (10 seconds).
• uniqueId: You must set a unique string identifier so that EasyMDE can autosave. Something that separates this from other instances of EasyMDE elsewhere on your website.
• timeFormat: Set DateTimeFormat. More information see DateTimeFormat instances. Default `locale: en-US, format: hour:minute`.
• text: Set text for autosave.
• autoRefresh: Useful, when initializing the editor in a hidden DOM node. If set to `{ delay: 300 }`, it will check every 300 ms if the editor is visible and if positive, call CodeMirror's `refresh()`.
• blockStyles: Customize how certain buttons that style blocks of text behave.
• bold: Can be set to `**` or `__`. Defaults to `**`.
• code: Can be set to ````` or `~~~`. Defaults to `````.
• italic: Can be set to `*` or `_`. Defaults to `*`.
• unorderedListStyle: can be `*`, `-` or `+`. Defaults to `*`.
• scrollbarStyle: Chooses a scrollbar implementation. The default is "native", showing native scrollbars. The core library also provides the "null" style, which completely hides the scrollbars. Addons can implement additional scrollbar models.
• element: The DOM element for the `textarea` element to use. Defaults to the first `textarea` element on the page.
• forceSync: If set to `true`, force text changes made in EasyMDE to be immediately stored in original text area. Defaults to `false`.
• hideIcons: An array of icon names to hide. Can be used to hide specific icons shown by default without completely customizing the toolbar.
• indentWithTabs: If set to `false`, indent using spaces instead of tabs. Defaults to `true`.
• initialValue: If set, will customize the initial value of the editor.
• previewImagesInEditor: - EasyMDE will show preview of images, `false` by default, preview for images will appear only for images on separate lines.
• imagesPreviewHandler: - A custom function for handling the preview of images. Takes the parsed string between the parantheses of the image markdown `![]( )` as argument and returns a string that serves as the `src` attribute of the `<img>` tag in the preview. Enables dynamic previewing of images in the frontend without having to upload them to a server, allows copy-pasting of images to the editor with preview.
• insertTexts: Customize how certain buttons that insert text behave. Takes an array with two elements. The first element will be the text inserted before the cursor or highlight, and the second element will be inserted after. For example, this is the default link value: `["[", "](http://)"]`.
• horizontalRule
• image
• table
• lineNumbers: If set to `true`, enables line numbers in the editor.
• lineWrapping: If set to `false`, disable line wrapping. Defaults to `true`.
• minHeight: Sets the minimum height for the composition area, before it starts auto-growing. Should be a string containing a valid CSS value like `"500px"`. Defaults to `"300px"`.
• maxHeight: Sets fixed height for the composition area. `minHeight` option will be ignored. Should be a string containing a valid CSS value like `"500px"`. Defaults to `undefined`.
• onToggleFullScreen: A function that gets called when the editor's full screen mode is toggled. The function will be passed a boolean as parameter, `true` when the editor is currently going into full screen mode, or `false`.
• parsingConfig: Adjust settings for parsing the Markdown during editing (not previewing).
• allowAtxHeaderWithoutSpace: If set to `true`, will render headers without a space after the `#`. Defaults to `false`.
• strikethrough: If set to `false`, will not process GFM strikethrough syntax. Defaults to `true`.
• underscoresBreakWords: If set to `true`, let underscores be a delimiter for separating words. Defaults to `false`.
• overlayMode: Pass a custom codemirror overlay mode to parse and style the Markdown during editing.
• mode: A codemirror mode object.
• combine: If set to `false`, will replace CSS classes returned by the default Markdown mode. Otherwise the classes returned by the custom mode will be combined with the classes returned by the default mode. Defaults to `true`.
• placeholder: If set, displays a custom placeholder message.
• previewClass: A string or array of strings that will be applied to the preview screen when activated. Defaults to `"editor-preview"`.
• previewRender: Custom function for parsing the plaintext Markdown and returning HTML. Used when user previews.
• promptURLs: If set to `true`, a JS alert window appears asking for the link or image URL. Defaults to `false`.
• promptTexts: Customize the text used to prompt for URLs.
• image: The text to use when prompting for an image's URL. Defaults to `URL of the image:`.
• link: The text to use when prompting for a link's URL. Defaults to `URL for the link:`.
• uploadImage: If set to `true`, enables the image upload functionality, which can be triggered by drag and drop, copy-paste and through the browse-file window (opened when the user click on the upload-image icon). Defaults to `false`.
• imageMaxSize: Maximum image size in bytes, checked before upload (note: never trust client, always check the image size at server-side). Defaults to `1024 * 1024 * 2` (2 MB).
• imageAccept: A comma-separated list of mime-types used to check image type before upload (note: never trust client, always check file types at server-side). Defaults to `image/png, image/jpeg`.
• imageUploadFunction: A custom function for handling the image upload. Using this function will render the options `imageMaxSize`, `imageAccept`, `imageUploadEndpoint` and `imageCSRFToken` ineffective.
• The function gets a file and `onSuccess` and `onError` callback functions as parameters. `onSuccess(imageUrl: string)` and `onError(errorMessage: string)`
• imageUploadEndpoint: The endpoint where the images data will be sent, via an asynchronous POST request. The server is supposed to save this image, and return a JSON response.
• if the request was successfully processed (HTTP 200 OK): `{"data": {"filePath": "<filePath>"}}` where filePath is the path of the image (absolute if `imagePathAbsolute` is set to true, relative if otherwise);
• otherwise: `{"error": "<errorCode>"}`, where errorCode can be `noFileGiven` (HTTP 400 Bad Request), `typeNotAllowed` (HTTP 415 Unsupported Media Type), `fileTooLarge` (HTTP 413 Payload Too Large) or `importError` (see errorMessages below). If errorCode is not one of the errorMessages, it is alerted unchanged to the user. This allows for server-side error messages. No default value.
• imagePathAbsolute: If set to `true`, will treat `imageUrl` from `imageUploadFunction` and filePath returned from `imageUploadEndpoint` as an absolute rather than relative path, i.e. not prepend `window.location.origin` to it.
• imageCSRFToken: CSRF token to include with AJAX call to upload image. For various instances like Django, Spring and Laravel.
• imageCSRFName: CSRF token filed name to include with AJAX call to upload image, applied when `imageCSRFToken` has value, defaults to `csrfmiddlewaretoken`.
• imageCSRFHeader: If set to `true`, passing CSRF token via header. Defaults to `false`, which pass CSRF through request body.
• imageTexts: Texts displayed to the user (mainly on the status bar) for the import image feature, where `#image_name#`, `#image_size#` and `#image_max_size#` will replaced by their respective values, that can be used for customization or internationalization:
• sbInit: Status message displayed initially if `uploadImage` is set to `true`. Defaults to `Attach files by drag and dropping or pasting from clipboard.`.
• sbOnDragEnter: Status message displayed when the user drags a file to the text area. Defaults to `Drop image to upload it.`.
• sbOnDrop: Status message displayed when the user drops a file in the text area. Defaults to `Uploading images #images_names#`.
• sbProgress: Status message displayed to show uploading progress. Defaults to `Uploading #file_name#: #progress#%`.
• sbOnUploaded: Status message displayed when the image has been uploaded. Defaults to `Uploaded #image_name#`.
• sizeUnits: A comma-separated list of units used to display messages with human-readable file sizes. Defaults to `B, KB, MB` (example: `218 KB`). You can use `B,KB,MB` instead if you prefer without whitespaces (`218KB`).
• errorMessages: Errors displayed to the user, using the `errorCallback` option, where `#image_name#`, `#image_size#` and `#image_max_size#` will replaced by their respective values, that can be used for customization or internationalization:
• noFileGiven: The server did not receive any file from the user. Defaults to `You must select a file.`.
• typeNotAllowed: The user send a file type which doesn't match the `imageAccept` list, or the server returned this error code. Defaults to `This image type is not allowed.`.
• fileTooLarge: The size of the image being imported is bigger than the `imageMaxSize`, or if the server returned this error code. Defaults to `Image #image_name# is too big (#image_size#).\nMaximum file size is #image_max_size#.`.
• importError: An unexpected error occurred when uploading the image. Defaults to `Something went wrong when uploading the image #image_name#.`.
• errorCallback: A callback function used to define how to display an error message. Defaults to `(errorMessage) => alert(errorMessage)`.
• renderingConfig: Adjust settings for parsing the Markdown during previewing (not editing).
• codeSyntaxHighlighting: If set to `true`, will highlight using highlight.js. Defaults to `false`. To use this feature you must include highlight.js on your page or pass in using the `hljs` option. For example, include the script and the CSS files like:
`<script src="https://cdn.jsdelivr.net/highlight.js/latest/highlight.min.js"></script>`
`<link rel="stylesheet" href="https://cdn.jsdelivr.net/highlight.js/latest/styles/github.min.css">`
• hljs: An injectible instance of highlight.js. If you don't want to rely on the global namespace (`window.hljs`), you can provide an instance here. Defaults to `undefined`.
• markedOptions: Set the internal Markdown renderer's options. Other `renderingConfig` options will take precedence.
• singleLineBreaks: If set to `false`, disable parsing GitHub Flavored Markdown (GFM) single line breaks. Defaults to `true`.
• sanitizerFunction: Custom function for sanitizing the HTML output of Markdown renderer.
• shortcuts: Keyboard shortcuts associated with this instance. Defaults to the array of shortcuts.
• showIcons: An array of icon names to show. Can be used to show specific icons hidden by default without completely customizing the toolbar.
• spellChecker: If set to `false`, disable the spell checker. Defaults to `true`. Optionally pass a CodeMirrorSpellChecker-compliant function.
• inputStyle: `textarea` or `contenteditable`. Defaults to `textarea` for desktop and `contenteditable` for mobile. `contenteditable` option is necessary to enable nativeSpellcheck.
• nativeSpellcheck: If set to `false`, disable native spell checker. Defaults to `true`.
• sideBySideFullscreen: If set to `false`, allows side-by-side editing without going into fullscreen. Defaults to `true`.
• status: If set to `false`, hide the status bar. Defaults to the array of built-in status bar items.
• Optionally, you can set an array of status bar items to include, and in what order. You can even define your own custom status bar items.
• styleSelectedText: If set to `false`, remove the `CodeMirror-selectedtext` class from selected lines. Defaults to `true`.
• syncSideBySidePreviewScroll: If set to `false`, disable syncing scroll in side by side mode. Defaults to `true`.
• tabSize: If set, customize the tab size. Defaults to `2`.
• theme: Override the theme. Defaults to `easymde`.
• toolbar: If set to `false`, hide the toolbar. Defaults to the array of icons.
• toolbarTips: If set to `false`, disable toolbar button tips. Defaults to `true`.
• direction: `rtl` or `ltr`. Changes text direction to support right-to-left languages. Defaults to `ltr`.

### Options example

Most options demonstrate the non-default behavior:

``````const editor = new EasyMDE({
autofocus: true,
autosave: {
enabled: true,
uniqueId: "MyUniqueID",
delay: 1000,
submit_delay: 5000,
timeFormat: {
locale: 'en-US',
format: {
year: 'numeric',
month: 'long',
day: '2-digit',
hour: '2-digit',
minute: '2-digit',
},
},
text: "Autosaved: "
},
blockStyles: {
bold: "__",
italic: "_",
},
unorderedListStyle: "-",
element: document.getElementById("MyID"),
forceSync: true,
indentWithTabs: false,
initialValue: "Hello world!",
insertTexts: {
horizontalRule: ["", "\n\n-----\n\n"],
image: ["![](http://", ")"],
table: ["", "\n\n| Column 1 | Column 2 | Column 3 |\n| -------- | -------- | -------- |\n| Text     | Text      | Text     |\n\n"],
},
lineWrapping: false,
minHeight: "500px",
parsingConfig: {
strikethrough: false,
underscoresBreakWords: true,
},
placeholder: "Type here...",

previewClass: "my-custom-styling",
previewClass: ["my-custom-styling", "more-custom-styling"],

previewRender: (plainText) => customMarkdownParser(plainText), // Returns HTML from a custom parser
previewRender: (plainText, preview) => { // Async method
setTimeout(() => {
preview.innerHTML = customMarkdownParser(plainText);
}, 250);

},
promptURLs: true,
promptTexts: {
image: "Custom prompt for URL:",
},
renderingConfig: {
singleLineBreaks: false,
codeSyntaxHighlighting: true,
sanitizerFunction: (renderedHTML) => {
// Using DOMPurify and only allowing <b> tags
return DOMPurify.sanitize(renderedHTML, {ALLOWED_TAGS: ['b']})
},
},
shortcuts: {
drawTable: "Cmd-Alt-T"
},
showIcons: ["code", "table"],
spellChecker: false,
status: false,
status: ["autosave", "lines", "words", "cursor"], // Optional usage
status: ["autosave", "lines", "words", "cursor", {
className: "keystrokes",
defaultValue: (el) => {
el.setAttribute('data-keystrokes', 0);
},
onUpdate: (el) => {
const keystrokes = Number(el.getAttribute('data-keystrokes')) + 1;
el.innerHTML = `\${keystrokes} Keystrokes`;
el.setAttribute('data-keystrokes', keystrokes);
},
}], // Another optional usage, with a custom status bar item that counts keystrokes
styleSelectedText: false,
sideBySideFullscreen: false,
syncSideBySidePreviewScroll: false,
tabSize: 4,
toolbar: false,
toolbarTips: false,
});
``````

### Toolbar icons

Below are the built-in toolbar icons (only some of which are enabled by default), which can be reorganized however you like. "Name" is the name of the icon, referenced in the JavaScript. "Action" is either a function or a URL to open. "Class" is the class given to the icon. "Tooltip" is the small tooltip that appears via the `title=""` attribute. Note that shortcut hints are added automatically and reflect the specified action if it has a key bind assigned to it (i.e. with the value of `action` set to `bold` and that of `tooltip` set to `Bold`, the final text the user will see would be "Bold (Ctrl-B)").

Additionally, you can add a separator between any icons by adding `"|"` to the toolbar array.

### Toolbar customization

Customize the toolbar using the `toolbar` option.

Only the order of existing buttons:

``````const easyMDE = new EasyMDE({
toolbar: ["bold", "italic", "heading", "|", "quote"]
});
``````

``````const easyMDE = new EasyMDE({
toolbar: [
{
name: "bold",
action: EasyMDE.toggleBold,
className: "fa fa-bold",
title: "Bold",
},
"italics", // shortcut to pre-made button
{
name: "custom",
action: (editor) => {
},
className: "fa fa-star",
title: "Custom Button",
attributes: { // for custom attributes
id: "custom-id",
"data-value": "custom value" // HTML5 data-* attributes need to be enclosed in quotation marks ("") because of the dash (-) in its name.
}
},
"|" // Separator
// [, ...]
]
});
``````

Put some buttons on dropdown menu

``````const easyMDE = new EasyMDE({
toolbar: [{
},
"|",
{
name: "others",
className: "fa fa-blind",
title: "others buttons",
children: [
{
name: "image",
action: EasyMDE.drawImage,
className: "fa fa-picture-o",
title: "Image",
},
{
name: "quote",
action: EasyMDE.toggleBlockquote,
className: "fa fa-percent",
title: "Quote",
},
{
}
]
},
// [, ...]
]
});
``````

### Keyboard shortcuts

EasyMDE comes with an array of predefined keyboard shortcuts, but they can be altered with a configuration option. The list of default ones is as follows:

Here is how you can change a few, while leaving others untouched:

``````const editor = new EasyMDE({
shortcuts: {
"toggleOrderedList": "Ctrl-Alt-K", // alter the shortcut for toggleOrderedList
"toggleCodeBlock": null, // unbind Ctrl-Alt-C
"drawTable": "Cmd-Alt-T", // bind Cmd-Alt-T to drawTable action, which doesn't come with a default shortcut
}
});
``````

Shortcuts are automatically converted between platforms. If you define a shortcut as "Cmd-B", on PC that shortcut will be changed to "Ctrl-B". Conversely, a shortcut defined as "Ctrl-B" will become "Cmd-B" for Mac users.

The list of actions that can be bound is the same as the list of built-in actions available for toolbar buttons.

### Event handling

You can catch the following list of events: https://codemirror.net/doc/manual.html#events

``````const easyMDE = new EasyMDE();
easyMDE.codemirror.on("change", () => {
console.log(easyMDE.value());
});
``````

### Removing EasyMDE from text area

You can revert to the initial text area by calling the `toTextArea` method. Note that this clears up the autosave (if enabled) associated with it. The text area will retain any text from the destroyed EasyMDE instance.

``````const easyMDE = new EasyMDE();
// ...
easyMDE.toTextArea();
easyMDE = null;
``````

If you need to remove registered event listeners (when the editor is not needed anymore), call `easyMDE.cleanup()`.

### Useful methods

The following self-explanatory methods may be of use while developing with EasyMDE.

``````const easyMDE = new EasyMDE();
easyMDE.isPreviewActive(); // returns boolean
easyMDE.isSideBySideActive(); // returns boolean
easyMDE.isFullscreenActive(); // returns boolean
easyMDE.clearAutosavedValue(); // no returned value
``````

## How it works

EasyMDE is a continuation of SimpleMDE.

SimpleMDE began as an improvement of lepture's Editor project, but has now taken on an identity of its own. It is bundled with CodeMirror and depends on Font Awesome.

CodeMirror is the backbone of the project and parses much of the Markdown syntax as it's being written. This allows us to add styles to the Markdown that's being written. Additionally, a toolbar and status bar have been added to the top and bottom, respectively. Previews are rendered by Marked using GitHub Flavored Markdown (GFM).

## SimpleMDE fork

I originally made this fork to implement FontAwesome 5 compatibility into SimpleMDE. When that was done I submitted a pull request, which has not been accepted yet. This, and the project being inactive since May 2017, triggered me to make more changes and try to put new life into the project.

Changes include:

• FontAwesome 5 compatibility
• Guide button works when editor is in preview mode
• Links are now `https://` by default
• Small styling changes
• Support for Node 8 and beyond
• Lots of refactored code
• Links in preview will open in a new tab by default
• TypeScript support

My intention is to continue development on this project, improving it and keeping it alive.

## Hacking EasyMDE

You may want to edit this library to adapt its behavior to your needs. This can be done in some quick steps:

1. Follow the prerequisites and installation instructions in the contribution guide;
3. Run `gulp` command, which will generate files: `dist/easymde.min.css` and `dist/easymde.min.js`;
4. Copy-paste those files to your code base, and you are done.

## Contributing

Want to contribute to EasyMDE? Thank you! We have a contribution guide just for you!

Author: Ionaru
Source Code: https://github.com/Ionaru/easy-markdown-editor

1679035563

## How to Add Splash Screen in Android and iOS with Flutter

When your app is opened, there is a brief time while the native app loads Flutter. By default, during this time, the native app displays a white splash screen. This package automatically generates iOS, Android, and Web-native code for customizing this native splash screen background color and splash image. Supports dark mode, full screen, and platform-specific options.

## What's New

[BETA] Support for flavors is in beta. Currently only Android and iOS are supported. See instructions below.

You can now keep the splash screen up while your app initializes! No need for a secondary splash screen anymore. Just use the `preserve` and `remove` methods together to remove the splash screen after your initialization is complete. See details below.

## Usage

Would you prefer a video tutorial instead? Check out Johannes Milke's tutorial.

First, add `flutter_native_splash` as a dependency in your pubspec.yaml file.

``````dependencies:
flutter_native_splash: ^2.2.19
``````

Don't forget to `flutter pub get`.

### 1. Setting the splash screen

Customize the following settings and add to your project's `pubspec.yaml` file or place in a new file in your root project folder named `flutter_native_splash.yaml`.

``````flutter_native_splash:
# This package generates native code to customize Flutter's default white native splash screen
# with background color and splash image.
# Customize the parameters below, and run the following command in the terminal:
# flutter pub run flutter_native_splash:create
# To restore Flutter's default white splash screen, run the following command in the terminal:
# flutter pub run flutter_native_splash:remove

# color or background_image is the only required parameter.  Use color to set the background
# of your splash screen to a solid color.  Use background_image to set the background of your
# splash screen to a png image.  This is useful for gradients. The image will be stretch to the
# size of the app. Only one parameter can be used, color and background_image cannot both be set.
color: "#42a5f5"
#background_image: "assets/background.png"

# Optional parameters are listed below.  To enable a parameter, uncomment the line by removing

# The image parameter allows you to specify an image used in the splash screen.  It must be a
# png file and should be sized for 4x pixel density.
#image: assets/splash.png

# The branding property allows you to specify an image used as branding in the splash screen.
# It must be a png file. It is supported for Android, iOS and the Web.  For Android 12,
# see the Android 12 section below.
#branding: assets/dart.png

# To position the branding image at the bottom of the screen you can use bottom, bottomRight,
# and bottomLeft. The default values is bottom if not specified or specified something else.
#branding_mode: bottom

# The color_dark, background_image_dark, image_dark, branding_dark are parameters that set the background
# and image when the device is in dark mode. If they are not specified, the app will use the
# parameters from above. If the image_dark parameter is specified, color_dark or
# background_image_dark must be specified.  color_dark and background_image_dark cannot both be
# set.
#color_dark: "#042a49"
#background_image_dark: "assets/dark-background.png"
#image_dark: assets/splash-invert.png
#branding_dark: assets/dart_dark.png

# Android 12 handles the splash screen differently than previous versions.  Please visit
# https://developer.android.com/guide/topics/ui/splash-screen
# Following are Android 12 specific parameter.
android_12:
# The image parameter sets the splash screen icon image.  If this parameter is not specified,
# the app's launcher icon will be used instead.
# Please note that the splash screen will be clipped to a circle on the center of the screen.
# App icon with an icon background: This should be 960×960 pixels, and fit within a circle
# 640 pixels in diameter.
# App icon without an icon background: This should be 1152×1152 pixels, and fit within a circle
# 768 pixels in diameter.
#image: assets/android12splash.png

# Splash screen background color.
#color: "#42a5f5"

# App icon background color.
#icon_background_color: "#111111"

# The branding property allows you to specify an image used as branding in the splash screen.
#branding: assets/dart.png

# The image_dark, color_dark, icon_background_color_dark, and branding_dark set values that
# apply when the device is in dark mode. If they are not specified, the app will use the
# parameters from above.
#image_dark: assets/android12splash-invert.png
#color_dark: "#042a49"
#icon_background_color_dark: "#eeeeee"

# The android, ios and web parameters can be used to disable generating a splash screen on a given
# platform.
#android: false
#ios: false
#web: false

# Platform specific images can be specified with the following parameters, which will override
# the respective parameter.  You may specify all, selected, or none of these parameters:
#color_android: "#42a5f5"
#color_dark_android: "#042a49"
#color_ios: "#42a5f5"
#color_dark_ios: "#042a49"
#color_web: "#42a5f5"
#color_dark_web: "#042a49"
#image_android: assets/splash-android.png
#image_dark_android: assets/splash-invert-android.png
#image_ios: assets/splash-ios.png
#image_dark_ios: assets/splash-invert-ios.png
#image_web: assets/splash-web.png
#image_dark_web: assets/splash-invert-web.png
#background_image_android: "assets/background-android.png"
#background_image_dark_android: "assets/dark-background-android.png"
#background_image_ios: "assets/background-ios.png"
#background_image_dark_ios: "assets/dark-background-ios.png"
#background_image_web: "assets/background-web.png"
#background_image_dark_web: "assets/dark-background-web.png"
#branding_android: assets/brand-android.png
#branding_dark_android: assets/dart_dark-android.png
#branding_ios: assets/brand-ios.png
#branding_dark_ios: assets/dart_dark-ios.png

# The position of the splash image can be set with android_gravity, ios_content_mode, and
# web_image_mode parameters.  All default to center.
#
# android_gravity can be one of the following Android Gravity (see
# https://developer.android.com/reference/android/view/Gravity): bottom, center,
# center_horizontal, center_vertical, clip_horizontal, clip_vertical, end, fill, fill_horizontal,
# fill_vertical, left, right, start, or top.
#android_gravity: center
#
# ios_content_mode can be one of the following iOS UIView.ContentMode (see
# https://developer.apple.com/documentation/uikit/uiview/contentmode): scaleToFill,
# scaleAspectFit, scaleAspectFill, center, top, bottom, left, right, topLeft, topRight,
# bottomLeft, or bottomRight.
#ios_content_mode: center
#
# web_image_mode can be one of the following modes: center, contain, stretch, and cover.
#web_image_mode: center

# The screen orientation can be set in Android with the android_screen_orientation parameter.
# Valid parameters can be found here:
# https://developer.android.com/guide/topics/manifest/activity-element#screen
#android_screen_orientation: sensorLandscape

# To hide the notification bar, use the fullscreen parameter.  Has no effect in web since web
# has no notification bar.  Defaults to false.
# NOTE: Unlike Android, iOS will not automatically show the notification bar when the app loads.
#       WidgetsFlutterBinding.ensureInitialized();
#       SystemChrome.setEnabledSystemUIOverlays([SystemUiOverlay.bottom, SystemUiOverlay.top]);
#fullscreen: true

# If you have changed the name(s) of your info.plist file(s), you can specify the filename(s)
# with the info_plist_files parameter.  Remove only the # characters in the three lines below,
# do not remove any spaces:
#info_plist_files:
#  - 'ios/Runner/Info-Debug.plist'
#  - 'ios/Runner/Info-Release.plist'
``````

### 2. Run the package

``````flutter pub run flutter_native_splash:create
``````

To specify the YAML file location just add --path with the command in the terminal:

``````flutter pub run flutter_native_splash:create --path=path/to/my/file.yaml
``````

### 3. Set up app initialization (optional)

By default, the splash screen will be removed when Flutter has drawn the first frame. If you would like the splash screen to remain while your app initializes, you can use the `preserve()` and `remove()` methods together. Pass the `preserve()` method the value returned from `WidgetsFlutterBinding.ensureInitialized()` to keep the splash on screen. Later, when your app has initialized, make a call to `remove()` to remove the splash screen.

``````import 'package:flutter_native_splash/flutter_native_splash.dart';

void main() {
WidgetsBinding widgetsBinding = WidgetsFlutterBinding.ensureInitialized();
FlutterNativeSplash.preserve(widgetsBinding: widgetsBinding);
runApp(const MyApp());
}

// whenever your initialization is completed, remove the splash screen:
FlutterNativeSplash.remove();
``````

NOTE: If you do not need to use the `preserve()` and `remove()` methods, you can place the `flutter_native_splash` dependency in the `dev_dependencies` section of `pubspec.yaml`.

### 4. Support the package (optional)

If you find this package useful, you can support it for free by giving it a thumbs up at the top of this page. Here's another option to support the package:

## Android 12+ Support

Android 12 has a new method of adding splash screens, which consists of a window background, icon, and the icon background. Note that a background image is not supported.

Be aware of the following considerations regarding these elements:

1: `image` parameter. By default, the launcher icon is used:

• App icon without an icon background, as shown on the left: This should be 1152×1152 pixels, and fit within a circle 768 pixels in diameter.
• App icon with an icon background, as shown on the right: This should be 960×960 pixels, and fit within a circle 640 pixels in diameter.

2: `icon_background_color` is optional, and is useful if you need more contrast between the icon and the window background.

3: One-third of the foreground is masked.

4: `color` the window background consists of a single opaque color.

PLEASE NOTE: The splash screen may not appear when you launch the app from Android Studio on API 31. However, it should appear when you launch by clicking on the launch icon in Android. This seems to be resolved in API 32+.

PLEASE NOTE: There are a number of reports that non-Google launchers do not display the launch image correctly. If the launch image does not display correctly, please try the Google launcher to confirm that this package is working.

PLEASE NOTE: The splash screen does not appear when you launch the app from a notification. Apparently this is the intended behavior on Android 12: core-splashscreen Icon not shown when cold launched from notification.

## Flavor Support

If you have a project setup that contains multiple flavors or environments, and you created more than one flavor this would be a feature for you.

Instead of maintaining multiple files and copy/pasting images, you can now, using this tool, create different splash screens for different environments.

### Pre-requirements

In order to use the new feature, and generate the desired splash images for you app, a couple of changes are required.

If you want to generate just one flavor and one file you would use either options as described in Step 1. But in order to setup the flavors, you will then be required to move all your setup values to the `flutter_native_splash.yaml` file, but with a prefix.

Let's assume for the rest of the setup that you have 3 different flavors, `Production`, `Acceptance`, `Development`.

First this you will need to do is to create a different setup file for all 3 flavors with a suffix like so:

``````flutter_native_splash-production.yaml
flutter_native_splash-acceptance.yaml
flutter_native_splash-development.yaml
``````

You would setup those 3 files the same way as you would the one, but with different assets depending on which environment you would be generating. For example (Note: these are just examples, you can use whatever setup you need for your project that is already supported by the package):

``````# flutter_native_splash-development.yaml
flutter_native_splash:
color: "#ffffff"
image: assets/logo-development.png
branding: assets/branding-development.png
color_dark: "#121212"
image_dark: assets/logo-development.png
branding_dark: assets/branding-development.png

android_12:
image: assets/logo-development.png
icon_background_color: "#ffffff"
image_dark: assets/logo-development.png
icon_background_color_dark: "#121212"

web: false

# flutter_native_splash-acceptance.yaml
flutter_native_splash:
color: "#ffffff"
image: assets/logo-acceptance.png
branding: assets/branding-acceptance.png
color_dark: "#121212"
image_dark: assets/logo-acceptance.png
branding_dark: assets/branding-acceptance.png

android_12:
image: assets/logo-acceptance.png
icon_background_color: "#ffffff"
image_dark: assets/logo-acceptance.png
icon_background_color_dark: "#121212"

web: false

# flutter_native_splash-production.yaml
flutter_native_splash:
color: "#ffffff"
image: assets/logo-production.png
branding: assets/branding-production.png
color_dark: "#121212"
image_dark: assets/logo-production.png
branding_dark: assets/branding-production.png

android_12:
image: assets/logo-production.png
icon_background_color: "#ffffff"
image_dark: assets/logo-production.png
icon_background_color_dark: "#121212"

web: false
``````

Great, now comes the fun part running the new command!

The new command is:

``````# If you have a flavor called production you would do this:
flutter pub run flutter_native_splash:create --flavor production

# For a flavor with a name staging you would provide it's name like so:
flutter pub run flutter_native_splash:create --flavor staging

# And if you have a local version for devs you could do that:
flutter pub run flutter_native_splash:create --flavor development
``````

### Android setup

You're done! No, really, Android doesn't need any additional setup.

Note: If it didn't work, please make sure that your flavors are named the same as your config files, otherwise the setup will not work.

### iOS setup

iOS is a bit tricky, so hang tight, it might look scary but most of the steps are just a single click, explained as much as possible to lower the possibility of mistakes.

When you run the new command, you will need to open xCode and follow the steps bellow:

Assumption

• In order for this setup to work, you would already have 3 different `schemes` setup; production, acceptance and development.

Preparation

• Open the iOS Flutter project in Xcode (open the Runner.xcworkspace)
• Find the newly created Storyboard files at the same location where the original is `{project root}/ios/Runner/Base.lproj`
• Select all of them and drag and drop into Xcode, directly to the left hand side where the current LaunchScreen.storyboard is located already
• After you drop your files there Xcode will ask you to link them, make sure you select 'Copy if needed'
• This part is done, you have linked the newly created storyboards in your project.

xCode

Xcode still doesn't know how to use them, so we need to specify for all the current flavors (schemes) which file to use and to use that value inside the Info.plist file.

• Open the iOS Flutter project in Xcode (open the Runner.xcworkspace)
• Click the Runner project in the top left corner (usually the first item in the list)
• In the middle part of the screen, on the left side, select the Runner target
• On the top part of the screen select Build Settings
• Make sure that 'All' and 'Combined' are selected
• Next to 'Combine' you have a '+' button, press it and select 'Add User-Defined Setting'
• Once you do that Xcode will create a new variable for you to name. Suggestion is to name it `LAUNCH_SCREEN_STORYBOARD`
• Once you do that, you will have the option to define a specific name for each flavor (scheme) that you have defined in the project. Make sure that you input the exact name of the LaunchScreen.storyboard that was created by this tool
• Example: If you have a flavor Development, there is a Storyboard created name LaunchScreenDevelopment.storyboard, please add that name (without the storyboard part) to the variable value next to the flavor value
• After you finish with that, you need to update Info.plist file to link the newly created variable so that it's used correctly
• Open the Info.plist file
• Find the entry called 'Launch screen interface file base name'
• The default value is 'LaunchScreen', change that to the variable name that you create previously. If you follow these steps exactly, it would be LAUNCH_SCREEN_STORYBOARD, so input this `\$(LAUNCH_SCREEN_STORYBOARD)`

Congrats you finished your setup for multiple flavors,

## FAQs

### I got the error "A splash screen was provided to Flutter, but this is deprecated."

This message is not related to this package but is related to a change in how Flutter handles splash screens in Flutter 2.5. It is caused by having the following code in your `android/app/src/main/AndroidManifest.xml`, which was included by default in previous versions of Flutter:

``````<meta-data
android:name="io.flutter.embedding.android.SplashScreenDrawable"
android:resource="@drawable/launch_background"
/>
``````

The solution is to remove the above code. Note that this will also remove the fade effect between the native splash screen and your app.

### Are animations/lottie/GIF images supported?

Not at this time. PRs are always welcome!

### I got the error AAPT: error: style attribute 'android:attr/windowSplashScreenBackground' not found

This attribute is only found in Android 12, so if you are getting this error, it means your project is not fully set up for Android 12. Did you update your app's build configuration?

## I see a flash of the wrong splash screen on iOS

This is caused by an iOS splash caching bug, which can be solved by uninstalling your app, powering off your device, power back on, and then try reinstalling.

## I see a white screen between splash screen and app

1. It may be caused by an iOS splash caching bug, which can be solved by uninstalling your app, powering off your device, power back on, and then try reinstalling.
2. It may be caused by the delay due to initialization in your app. To solve this, put any initialization code in the `removeAfter` method.

### Can I base light/dark mode on app settings?

No. This package creates a splash screen that is displayed before Flutter is loaded. Because of this, when the splash screen loads, internal app settings are not available to the splash screen. Unfortunately, this means that it is impossible to control light/dark settings of the splash from app settings.

Notes

If the splash screen was not updated correctly on iOS or if you experience a white screen before the splash screen, run `flutter clean` and recompile your app. If that does not solve the problem, delete your app, power down the device, power up the device, install and launch the app as per this StackOverflow thread.

This package modifies `launch_background.xml` and `styles.xml` files on Android, `LaunchScreen.storyboard` and `Info.plist` on iOS, and `index.html` on Web. If you have modified these files manually, this plugin may not work properly. Please open an issue if you find any bugs.

## How it works

### Android

• Your splash image will be resized to `mdpi`, `hdpi`, `xhdpi`, `xxhdpi` and `xxxhdpi` drawables.
• An `<item>` tag containing a `<bitmap>` for your splash image drawable will be added in `launch_background.xml`
• Background color will be added in `colors.xml` and referenced in `launch_background.xml`.
• Code for full screen mode toggle will be added in `styles.xml`.
• Dark mode variants are placed in `drawable-night`, `values-night`, etc. resource folders.

### iOS

• Your splash image will be resized to `@3x` and `@2x` images.
• Color and image properties will be inserted in `LaunchScreen.storyboard`.
• The background color is implemented by using a single-pixel png file and stretching it to fit the screen.
• Code for hidden status bar toggle will be added in `Info.plist`.

### Web

• A `web/splash` folder will be created for splash screen images and CSS files.
• Your splash image will be resized to `1x`, `2x`, `3x`, and `4x` sizes and placed in `web/splash/img`.
• The splash style sheet will be added to the app's `web/index.html`, as well as the HTML for the splash pictures.

## Acknowledgments

This package was originally created by Henrique Arthur and it is currently maintained by Jon Hanson.

## Bugs or Requests

If you encounter any problems feel free to open an issue. If you feel the library is missing a feature, please raise a ticket. Pull request are also welcome.

## Use this package as a library

### Depend on it

Run this command:

With Flutter:

`` \$ flutter pub add flutter_native_splash``

This will add a line like this to your package's pubspec.yaml (and run an implicit `flutter pub get`):

``````dependencies:
flutter_native_splash: ^2.2.19``````

Alternatively, your editor might support `flutter pub get`. Check the docs for your editor to learn more.

### Import it

Now in your Dart code, you can use:

``import 'package:flutter_native_splash/flutter_native_splash.dart';``

## example/lib/main.dart

``````import 'package:flutter/material.dart';
import 'package:flutter_native_splash/flutter_native_splash.dart';

void main() {
WidgetsBinding widgetsBinding = WidgetsFlutterBinding.ensureInitialized();
FlutterNativeSplash.preserve(widgetsBinding: widgetsBinding);
runApp(const MyApp());
}

class MyApp extends StatelessWidget {
const MyApp({super.key});

// This widget is the root of your application.
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Flutter Demo',
theme: ThemeData(
// This is the theme of your application.
//
// Try running your application with "flutter run". You'll see the
// application has a blue toolbar. Then, without quitting the app, try
// changing the primarySwatch below to Colors.green and then invoke
// "hot reload" (press "r" in the console where you ran "flutter run",
// or simply save your changes to "hot reload" in a Flutter IDE).
// Notice that the counter didn't reset back to zero; the application
// is not restarted.
primarySwatch: Colors.blue,
),
);
}
}

class MyHomePage extends StatefulWidget {
const MyHomePage({super.key, required this.title});

// that it has a State object (defined below) that contains fields that affect
// how it looks.

// This class is the configuration for the state. It holds the values (in this
// case the title) provided by the parent (in this case the App widget) and
// used by the build method of the State. Fields in a Widget subclass are
// always marked "final".

final String title;

@override
State<MyHomePage> createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
int _counter = 0;

void _incrementCounter() {
setState(() {
// This call to setState tells the Flutter framework that something has
// changed in this State, which causes it to rerun the build method below
// so that the display can reflect the updated values. If we changed
// _counter without calling setState(), then the build method would not be
// called again, and so nothing would appear to happen.
_counter++;
});
}

@override
void initState() {
super.initState();
initialization();
}

void initialization() async {
// This is where you can initialize the resources needed by your app while
// the splash screen is displayed.  Remove the following example because
// delaying the user experience is a bad design practice!
// ignore_for_file: avoid_print
await Future.delayed(const Duration(seconds: 1));
await Future.delayed(const Duration(seconds: 1));
await Future.delayed(const Duration(seconds: 1));
print('go!');
FlutterNativeSplash.remove();
}

@override
Widget build(BuildContext context) {
// This method is rerun every time setState is called, for instance as done
// by the _incrementCounter method above.
//
// The Flutter framework has been optimized to make rerunning build methods
// fast, so that you can just rebuild anything that needs updating rather
// than having to individually change instances of widgets.
return Scaffold(
appBar: AppBar(
// Here we take the value from the MyHomePage object that was created by
// the App.build method, and use it to set our appbar title.
title: Text(widget.title),
),
body: Center(
// Center is a layout widget. It takes a single child and positions it
// in the middle of the parent.
child: Column(
// Column is also a layout widget. It takes a list of children and
// arranges them vertically. By default, it sizes itself to fit its
// children horizontally, and tries to be as tall as its parent.
//
// Invoke "debug painting" (press "p" in the console, choose the
// "Toggle Debug Paint" action from the Flutter Inspector in Android
// Studio, or the "Toggle Debug Paint" command in Visual Studio Code)
// to see the wireframe for each widget.
//
// Column has various properties to control how it sizes itself and
// how it positions its children. Here we use mainAxisAlignment to
// center the children vertically; the main axis here is the vertical
// axis because Columns are vertical (the cross axis would be
// horizontal).
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
const Text(
'You have pushed the button this many times:',
),
Text(
'\$_counter',
),
],
),
),
floatingActionButton: FloatingActionButton(
onPressed: _incrementCounter,
tooltip: 'Increment',
), // This trailing comma makes auto-formatting nicer for build methods.
);
}
}
``````

Author: jonbhanson
Official Website: https://github.com/jonbhanson/flutter_native_splash

1596977100

## Loss Functions for Image-Super-Resolution (SISR)

In SISR, Autoencoder and U-Net are heavily used; however, they are well-known for difficulties in training to convergence. The choice of loss function plays an important role in guiding models to optimum. Today, I introduce 2 loss functions for Single-Image-Super-Resolution.

Zhengyang Lu and Ying Chen published a U-Net model with innovative loss functions for Single-Image-Super-Resolution. Their work introduces 2 loss functions: Mean-Squared-Error (MSE) for pixel-wise comparison and Mean-Gradient-Error (MGrE) for edge-wise comparison. In this article, I will walk you through and provide code snipsets for MSE and MGrE.

## Mean Squared Error (MSE)

MSE is a traditional loss function used in many Machine Learning algorithms (remember Linear Regression, your very first ML algorithm). Still, let’s me explain it again.

Let’s have 2 images (Y and Y^) of the same size (m, n, 3) that each pixel value ranges from 0 to 255. The pixel value represent the pixel color. Then MSE is computed as following:

Picture 1: Mean Squared Error

that _i and j _denotes the pixel location in the image based on x-y coordinates. The MSE formula is to compute the sum of the squared differences of pixel-wis ecolor values divided by m and n. In other words, the MSE formula is to compare pixel-color differences of 2 images. However, this function may not capture differences in edges of objects in 2 images that Lu and Chen proposed Mean Gradient Error to solve the issue.

The code snipset for MSE is not provided because MSE can be easily found in most packages.

#machine-learning #super-resolution #image-processing #artificial-intelligence #loss #function

1666245660

## Swift tips & tricks ⚡️

One of the things I really love about Swift is how I keep finding interesting ways to use it in various situations, and when I do - I usually share them on Twitter. Here's a collection of all the tips & tricks that I've shared so far. Each entry has a link to the original tweet, if you want to respond with some feedback or question, which is always super welcome! 🚀

⚠️ This list is no longer being updated. For my latest Swift tips, checkout the "Tips" section on Swift by Sundell.

Also make sure to check out all of my other Swift content:

## 102 Making async tests faster and more stable

🚀 Here are some quick tips to make async tests faster & more stable:

• 😴 Avoid sleep() - use expectations instead
• ⏱ Use generous timeouts to avoid flakiness on CI
• 🧐 Put all assertions at the end of each test, not inside closures
``````// BEFORE:

class MentionDetectorTests: XCTestCase {
func testDetectingMention() {
let detector = MentionDetector()
let string = "This test was written by @johnsundell."

detector.detectMentions(in: string) { mentions in
XCTAssertEqual(mentions, ["johnsundell"])
}

sleep(2)
}
}

// AFTER:

class MentionDetectorTests: XCTestCase {
func testDetectingMention() {
let detector = MentionDetector()
let string = "This test was written by @johnsundell."

var mentions: [String]?
let expectation = self.expectation(description: #function)

detector.detectMentions(in: string) {
mentions = \$0
expectation.fulfill()
}

waitForExpectations(timeout: 10)
XCTAssertEqual(mentions, ["johnsundell"])
}
}
``````

For more on async testing, check out "Unit testing asynchronous Swift code".

## 101 Adding support for Apple Pencil double-taps

✍️ Adding support for the new Apple Pencil double-tap feature is super easy! All you have to do is to create a `UIPencilInteraction`, add it to a view, and implement one delegate method. Hopefully all pencil-compatible apps will soon adopt this.

``````let interaction = UIPencilInteraction()
interaction.delegate = self

extension ViewController: UIPencilInteractionDelegate {
func pencilInteractionDidTap(_ interaction: UIPencilInteraction) {
// Handle pencil double-tap
}
}
``````

For more on using this and other iPad Pro features, check out "Building iPad Pro features in Swift".

## 100 Combining values with functions

😎 Here's a cool function that combines a value with a function to return a closure that captures that value, so that it can be called without any arguments. Super useful when working with closure-based APIs and we want to use some of our properties without having to capture `self`.

``````func combine<A, B>(_ value: A, with closure: @escaping (A) -> B) -> () -> B {
return { closure(value) }
}

// BEFORE:

class ProductViewController: UIViewController {

buyButton.handler = { [weak self] in
guard let self = self else {
return
}

self.productManager.startCheckout(for: self.product)
}
}
}

// AFTER:

class ProductViewController: UIViewController {

}
}
``````

## 99 Dependency injection using functions

💉 When I'm only using a single function from a dependency, I love to inject that function as a closure, instead of having to create a protocol and inject the whole object. Makes dependency injection & testing super simple.

``````final class ArticleLoader {
typealias Networking = (Endpoint) -> Future<Data>

private let networking: Networking

init(networking: @escaping Networking = URLSession.shared.load) {
self.networking = networking
}

return networking(.latestArticles).decode()
}
}
``````

For more on this technique, check out "Simple Swift dependency injection with functions".

## 98 Using a custom exception handler

💥 It's cool that you can easily assign a closure as a custom `NSException` handler. This is super useful when building things in Playgrounds - since you can't use breakpoints - so instead of just `signal SIGABRT`, you'll get the full exception description if something goes wrong.

``````NSSetUncaughtExceptionHandler { exception in
print(exception)
}
``````

## 97 Using type aliases to give semantic meaning to primitives

❤️ I love that in Swift, we can use the type system to make our code so much more self-documenting - one way of doing so is to use type aliases to give the primitive types that we use a more semantic meaning.

``````extension List.Item {
// Using type aliases, we can give semantic meaning to the
// primitive types that we use, without having to introduce
// wrapper types.
typealias Index = Int
}

extension List {
enum Mutation {
// Our enum cases now become a lot more self-documenting,
// explain them.
case update(Item, Item.Index)
case remove(Item.Index)
}
}
``````

For more on self-documenting code, check out "Writing self-documenting Swift code".

## 96 Specializing protocols using constraints

🤯 A little late night prototyping session reveals that protocol constraints can not only be applied to extensions - they can also be added to protocol definitions!

This is awesome, since it lets us easily define specialized protocols based on more generic ones.

``````protocol Component {
associatedtype Container
}

// Protocols that inherit from other protocols can include
// constraints to further specialize them.
protocol ViewComponent: Component where Container == UIView {
associatedtype View: UIView
var view: View { get }
}

extension ViewComponent {
}
}
``````

For more on specializing protocols, check out "Specializing protocols in Swift".

## 95 Unwrapping an optional or throwing an error

📦 Here's a super handy extension on Swift's `Optional` type, which gives us a really nice API for easily unwrapping an optional, or throwing an error in case the value turned out to be `nil`:

``````extension Optional {
func orThrow(_ errorExpression: @autoclosure () -> Error) throws -> Wrapped {
switch self {
case .some(let value):
return value
case .none:
throw errorExpression()
}
}
}

let file = try loadFile(at: path).orThrow(MissingFileError())
``````

For more ways that optionals can be extended, check out "Extending optionals in Swift".

## 94 Testing code that uses static APIs

👩‍🔬 Testing code that uses static APIs can be really tricky, but there's a way that it can often be done - using Swift's first class function capabilities!

Instead of accessing that static API directly, we can inject the function we want to use, which enables us to mock it!

``````// BEFORE

func loadFriends(then handler: @escaping (Result<[Friend]>) -> Void) {
...
}
}
}

// AFTER

typealias Handler<T> = (Result<T>) -> Void

then handler: @escaping Handler<[Friend]>) {
...
}
}
}

// MOCKING IN TESTS

handler(.success(mockData))
}

...
}
``````

## 93 Matching multiple enum cases with associated values

🐾 Swift's pattern matching capabilities are so powerful! Two enum cases with associated values can even be matched and handled by the same switch case - which is super useful when handling state changes with similar data.

``````enum DownloadState {
case inProgress(progress: Double)
case paused(progress: Double)
case cancelled
case finished(Data)
}

switch state {
case .inProgress(let progress), .paused(let progress):
updateProgressView(with: progress)
case .cancelled:
showCancelledMessage()
case .finished(let data):
process(data)
}
}
``````

## 92 Multiline string literals

🅰 One really nice benefit of Swift multiline string literals - even for single lines of text - is that they don't require quotes to be escaped. Perfect when working with things like HTML, or creating a custom description for an object.

``````let html = highlighter.highlight("Array<String>")

XCTAssertEqual(html, """
<span class="type">Array</span>&lt;<span class="type">String</span>&gt;
""")
``````

## 91 Reducing sequences

💎 While it's very common in functional programming, the `reduce` function might be a bit of a hidden gem in Swift. It provides a super useful way to transform a sequence into a single value.

``````extension Sequence where Element: Equatable {
func numberOfOccurrences(of target: Element) -> Int {
return reduce(0) { result, element in
guard element == target else {
return result
}

return result + 1
}
}
}
``````

You can read more about transforming collections in "Transforming collections in Swift".

## 90 Avoiding manual Codable implementations

📦 When I use Codable in Swift, I want to avoid manual implementations as much as possible, even when there's a mismatch between my code structure and the JSON I'm decoding.

One way that can often be achieved is to use private data containers combined with computed properties.

``````struct User: Codable {
let name: String
let age: Int

var homeTown: String { return originPlace.name }

private let originPlace: Place
}

private extension User {
struct Place: Codable {
let name: String
}
}

extension User {
struct Container: Codable {
let user: User
}
}
``````

## 89 Using feature flags instead of feature branches

🚢 Instead of using feature branches, I merge almost all of my code directly into master - and then I use feature flags to conditionally enable features when they're ready. That way I can avoid merge conflicts and keep shipping!

``````extension ListViewController {
// Rather than having to keep maintaining a separate
// feature branch for a new feature, we can use a flag
// to conditionally turn it on.
guard FeatureFlags.searchEnabled else {
return
}

let resultsVC = SearchResultsViewController()
let searchVC = UISearchController(
searchResultsController: resultsVC
)

searchVC.searchResultsUpdater = resultsVC
}
}
``````

You can read more about feature flags in "Feature flags in Swift".

## 88 Lightweight data hierarchies using tuples

💾 Here I'm using tuples to create a lightweight hierarchy for my data, giving me a nice structure without having to introduce any additional types.

``````struct CodeSegment {
var tokens: (
previous: String?,
current: String
)

var delimiters: (
previous: Character?
next: Character?
)
}

handle(segment.tokens.current)
``````

You can read more about tuples in "Using tuples as lightweight types in Swift"

## 87 The rule of threes

3️⃣ Whenever I have 3 properties or local variables that share the same prefix, I usually try to extract them into their own method or type. That way I can avoid massive types & methods, and also increase readability, without falling into a "premature optimization" trap.

Before

``````public func generate() throws {
let contentFolder = try folder.subfolder(named: "content")

let articleFolder = try contentFolder.subfolder(named: "posts")
let articleProcessor = ContentProcessor(folder: articleFolder)
let articles = try articleProcessor.process()

...
}
``````

After

``````public func generate() throws {
let contentFolder = try folder.subfolder(named: "content")
let articles = try processArticles(in: contentFolder)
...
}

private func processArticles(in folder: Folder) throws -> [ContentItem] {
let folder = try folder.subfolder(named: "posts")
let processor = ContentProcessor(folder: folder)
return try processor.process()
}
``````

## 86 Useful Codable extensions

👨‍🔧 Here's two extensions that I always add to the `Encodable` & `Decodable` protocols, which for me really make the Codable API nicer to use. By using type inference for decoding, a lot of boilerplate can be removed when the compiler is already able to infer the resulting type.

``````extension Encodable {
func encoded() throws -> Data {
return try JSONEncoder().encode(self)
}
}

extension Data {
func decoded<T: Decodable>() throws -> T {
return try JSONDecoder().decode(T.self, from: self)
}
}

let data = try user.encoded()

// By using a generic type in the decoded() method, the
// compiler can often infer the type we want to decode
// from the current context.

// And if not, we can always supply the type, still making
// the call site read very nicely.
let otherUser = try data.decoded() as User
``````

## 85 Using shared UserDefaults suites

📦 `UserDefaults` is a lot more powerful than what it first might seem like. Not only can it store more complex values (like dates & dictionaries) and parse command line arguments - it also enables easy sharing of settings & lightweight data between apps in the same App Group.

``````let sharedDefaults = UserDefaults(suiteName: "my-app-group")!
let useDarkMode = sharedDefaults.bool(forKey: "dark-mode")

// This value is put into the shared suite.
sharedDefaults.set(true, forKey: "dark-mode")

// If you want to treat the shared settings as read-only (and add
// local overrides on top of them), you can simply add the shared
// suite to the standard UserDefaults.
let combinedDefaults = UserDefaults.standard

// This value is a local override, not added to the shared suite.
combinedDefaults.set(true, forKey: "app-specific-override")
``````

## 84 Custom UIView backing layers

🎨 By overriding `layerClass` you can tell UIKit what `CALayer` class to use for a `UIView`'s backing layer. That way you can reduce the amount of layers, and don't have to do any manual layout.

``````final class GradientView: UIView {
override class var layerClass: AnyClass { return CAGradientLayer.self }

var colors: (start: UIColor, end: UIColor)? {
didSet { updateLayer() }
}

private func updateLayer() {
let layer = self.layer as! CAGradientLayer
layer.colors = colors.map { [\$0.start.cgColor, \$0.end.cgColor] }
}
}
``````

## 83 Auto-Equatable enums with associated values

✅ That the compiler now automatically synthesizes Equatable conformances is such a huge upgrade for Swift! And the cool thing is that it works for all kinds of types - even for enums with associated values! Especially useful when using enums for verification in unit tests.

``````struct Article: Equatable {
let title: String
let text: String
}

struct User: Equatable {
let name: String
let age: Int
}

extension Navigator {
enum Destination: Equatable {
case profile(User)
case article(Article)
}
}

func testNavigatingToArticle() {
let article = Article(title: "Title", text: "Text")
controller.select(article)
XCTAssertEqual(navigator.destinations, [.article(article)])
}
``````

## 82 Defaults for associated types

🤝 Associated types can have defaults in Swift - which is super useful for types that are not easily inferred (for example when they're not used for a specific instance method or property).

``````protocol Identifiable {
associatedtype RawIdentifier: Codable = String

var id: Identifier<Self> { get }
}

struct User: Identifiable {
let id: Identifier<User>
let name: String
}

struct Group: Identifiable {
typealias RawIdentifier = Int

let id: Identifier<Group>
let name: String
}
``````

## 81 Creating a dedicated identifier type

🆔 If you want to avoid using plain strings as identifiers (which can increase both type safety & readability), it's really easy to create a custom Identifier type that feels just like a native Swift type, thanks to protocols!

More on this topic in "Type-safe identifiers in Swift".

``````struct Identifier: Hashable {
let string: String
}

extension Identifier: ExpressibleByStringLiteral {
init(stringLiteral value: String) {
string = value
}
}

extension Identifier: CustomStringConvertible {
var description: String {
return string
}
}

extension Identifier: Codable {
init(from decoder: Decoder) throws {
let container = try decoder.singleValueContainer()
string = try container.decode(String.self)
}

func encode(to encoder: Encoder) throws {
var container = encoder.singleValueContainer()
try container.encode(string)
}
}

struct Article: Codable {
let id: Identifier
let title: String
}

let article = Article(id: "my-article", title: "Hello world!")
``````

## 80 Assigning optional tuple members to variables

🙌 A really cool thing about using tuples to model the internal state of a Swift type, is that you can unwrap an optional tuple's members directly into local variables.

Very useful in order to group multiple optional values together for easy unwrapping & handling.

``````class ImageTransformer {
private var queue = [(image: UIImage, transform: Transform)]()

private func processNext() {
// When unwrapping an optional tuple, you can assign the members
// directly to local variables.
guard let (image, transform) = queue.first else {
return
}

let context = Context()
context.draw(image)
context.apply(transform)
...
}
}
``````

## 79 Struct convenience initializers

❤️ I love to structure my code using extensions in Swift. One big benefit of doing so when it comes to struct initializers, is that defining a convenience initializer doesn't remove the default one the compiler generates - best of both worlds!

``````struct Article {
let date: Date
var title: String
var text: String
}

extension Article {
init(title: String, text: String) {
self.init(date: Date(), title: title, text: text, comments: [])
}
}

let articleA = Article(title: "Best Cupcake Recipe", text: "...")

let articleB = Article(
date: Date(),
title: "Best Cupcake Recipe",
text: "...",
Comment(user: currentUser, text: "Yep, can confirm!")
]
)
``````

## 78 Usages of throwing functions

🏈 A big benefit of using throwing functions for synchronous Swift APIs is that the caller can decide whether they want to treat the return value as optional (`try?`) or required (`try`).

``````func loadFile(named name: String) throws -> File {
guard let url = urlForFile(named: name) else {
throw File.Error.missing
}

do {
let data = try Data(contentsOf: url)
return File(url: url, data: data)
} catch {
throw File.Error.invalidData(error)
}
}

let requiredFile = try loadFile(named: "AppConfig.json")

let optionalFile = try? loadFile(named: "UserSettings.json")
``````

## 77 Nested generic types

🐝 Types that are nested in generics automatically inherit their parent's generic types - which is super useful when defining accessory types (for things like states or outcomes).

``````struct Task<Input, Output> {
typealias Closure = (Input) throws -> Output

let closure: Closure
}

enum Result {
case success(Output)
case failure(Error)
}
}
``````

## 76 Equatable & Hashable structures

🤖 Now that the Swift compiler automatically synthesizes Equatable & Hashable conformances for value types, it's easier than ever to setup model structures with nested types that are all `Equatable`/`Hashable`!

``````typealias Value = Hashable & Codable

struct User: Value {
var name: String
var age: Int
var settings: Settings
}

extension User {
struct Settings: Value {
var itemsPerPage: Int
var theme: Theme
}
}

extension User.Settings {
enum Theme: String, Value {
case light
case dark
}
}
``````

## 75 Conditional conformances

🎉 Swift 4.1 is here! One of the key features it brings is conditional conformances, which lets you have a type only conform to a protocol under certain constraints.

``````protocol UnboxTransformable {
associatedtype RawValue

static func transform(_ value: RawValue) throws -> Self?
}

extension Array: UnboxTransformable where Element: UnboxTransformable {
typealias RawValue = [Element.RawValue]

static func transform(_ value: RawValue) throws -> [Element]? {
return try value.compactMap(Element.transform)
}
}
``````

I also have an article with lots of more info on conditional conformances here. Paul Hudson also has a great overview of all Swift 4.1 features here.

## 74 Generic type aliases

🕵️‍♀️ A cool thing about Swift type aliases is that they can be generic! Combine that with tuples and you can easily define simple generic types.

``````typealias Pair<T> = (T, T)

extension Game {
func calculateScore(for players: Pair<Player>) -> Int {
...
}
}
``````

## 73 Parsing command line arguments using UserDefaults

☑️ A really cool "hidden" feature of UserDefaults is that it contains any arguments that were passed to the app at launch!

Super useful both in Swift command line tools & scripts, but also to temporarily override a value when debugging iOS apps.

``````let defaults = UserDefaults.standard
let query = defaults.string(forKey: "query")
let resultCount = defaults.integer(forKey: "results")
``````

## 72 Using the & operator

👏 Swift's `&` operator is awesome! Not only can you use it to compose protocols, you can compose other types too! Very useful if you want to hide concrete types & implementation details.

``````protocol LoadableFromURL {
}

...
}
}

class ViewControllerFactory {
func makeContentViewController() -> UIViewController & LoadableFromURL {
return ContentViewController()
}
}
``````

## 71 Capturing multiple values in mocks

🤗 When capturing values in mocks, using an array (instead of just a single value) makes it easy to verify that only a certain number of values were passed.

Perfect for protecting against "over-calling" something.

``````class UserManagerTests: XCTestCase {
func testObserversCalledWhenUserFirstLogsIn() {
let manager = UserManager()

let observer = ObserverMock()

// First login, observers should be notified
let user = User(id: 123, name: "John")
XCTAssertEqual(observer.users, [user])

// If the same user logs in again, observers shouldn't be notified
XCTAssertEqual(observer.users, [user])
}
}

private extension UserManagerTests {
class ObserverMock: UserManagerObserver {
private(set) var users = [User]()

func userDidChange(to user: User) {
users.append(user)
}
}
}
``````

## 70 Reducing the need for mocks

👋 When writing tests, you don't always need to create mocks - you can create stubs using real instances of things like errors, URLs & UserDefaults.

Here's how to do that for some common tasks/object types in Swift:

``````// Create errors using NSError (#function can be used to reference the name of the test)
let error = NSError(domain: #function, code: 1, userInfo: nil)

// Create non-optional URLs using file paths
let url = URL(fileURLWithPath: "Some/URL")

// Reference the test bundle using Bundle(for:)
let bundle = Bundle(for: type(of: self))

// Create an explicit UserDefaults object (instead of having to use a mock)
let userDefaults = UserDefaults(suiteName: #function)

// Create queues to control/await concurrent operations
let queue = DispatchQueue(label: #function)
``````

For when you actually do need mocking, check out "Mocking in Swift".

## 69 Using "then" as an external parameter label for closures

⏱ I've started using "then" as an external parameter label for completion handlers. Makes the call site read really nicely (Because I do ❤️ conversational API design) regardless of whether trailing closure syntax is used or not.

``````protocol DataLoader {
// Adding type aliases to protocols can be a great way to
// reduce verbosity for parameter types.
typealias Handler = (Result<Data>) -> Void
associatedtype Endpoint

func loadData(from endpoint: Endpoint, then handler: @escaping Handler)
}

...
}

...
})
``````

## 68 Combining lazily evaluated sequences with the builder pattern

😴 Combining lazily evaluated sequences with builder pattern-like properties can lead to some pretty sweet APIs for configurable sequences in Swift.

Also useful for queries & other things you "build up" and then execute.

``````// Extension adding builder pattern-like properties that return
// a new sequence value with the given configuration applied
extension FileSequence {
var recursive: FileSequence {
var sequence = self
sequence.isRecursive = true
return sequence
}

var includingHidden: FileSequence {
var sequence = self
sequence.includeHidden = true
return sequence
}
}

// BEFORE

let files = folder.makeFileSequence(recursive: true, includeHidden: true)

// AFTER

let files = folder.files.recursive.includingHidden
``````

Want an intro to lazy sequences? Check out "Swift sequences: The art of being lazy".

## 67 Faster & more stable UI tests

My top 3 tips for faster & more stable UI tests:

📱 Reset the app's state at the beginning of every test.

🆔 Use accessibility identifiers instead of UI strings.

⏱ Use expectations instead of waiting time.

``````func testOpeningArticle() {
// Launch the app with an argument that tells it to reset its state
let app = XCUIApplication()
app.launchArguments.append("--uitesting")
app.launch()

// Check that the app is displaying an activity indicator
let activityIndicator = app.activityIndicator.element
XCTAssertTrue(activityIndicator.exists)

expectation(for: NSPredicate(format: "exists == 0"),
evaluatedWith: activityIndicator)

// Use a generous timeout in case the network is slow
waitForExpectations(timeout: 10)

// Tap the cell for the first article
app.tables.cells["Article.0"].tap()

// Assert that a label with the accessibility identifier "Article.Title" exists
let label = app.staticTexts["Article.Title"]
XCTAssertTrue(label.exists)
}
``````

## 66 Accessing the clipboard from a Swift script

📋 It's super easy to access the contents of the clipboard from a Swift script. A big benefit of Swift scripting is being able to use Cocoa's powerful APIs for Mac apps.

``````import Cocoa

let clipboard = NSPasteboard.general.string(forType: .string)
``````

## 65 Using tuples for view state

🎯 Using Swift tuples for view state can be a super nice way to group multiple properties together and render them reactively using the layout system.

By using a tuple we don't have to either introduce a new type or make our view model-aware.

``````class TextView: UIView {
var state: (title: String?, text: String?) {
// By telling UIKit that our view needs layout and binding our
// state in layoutSubviews, we can react to state changes without
// doing unnecessary layout work.
didSet { setNeedsLayout() }
}

private let titleLabel = UILabel()
private let textLabel = UILabel()

override func layoutSubviews() {
super.layoutSubviews()

titleLabel.text = state.title
textLabel.text = state.text

...
}
}
``````

## 64 Throwing tests and LocalizedError

⚾️ Swift tests can throw, which is super useful in order to avoid complicated logic or force unwrapping. By making errors conform to `LocalizedError`, you can also get a nice error message in Xcode if there's a failure.

``````class ImageCacheTests: XCTestCase {
let bundle = Bundle(for: type(of: self))
let cache = ImageCache(bundle: bundle)

// bundle using this UIImage initializer
let image = try require(UIImage(named: "sample", in: bundle, compatibleWith: nil))
try cache.cache(image, forKey: "key")

let cachedImage = try cache.image(forKey: "key")
XCTAssertEqual(image, cachedImage)
}
}

enum ImageCacheError {
case emptyKey
case dataConversionFailed
}

// When using throwing tests, making your errors conform to
// LocalizedError will render a much nicer error message in
// Xcode (per default only the error code is shown).
extension ImageCacheError: LocalizedError {
var errorDescription: String? {
switch self {
case .emptyKey:
return "An empty key was given"
case .dataConversionFailed:
return "Failed to convert the given image to Data"
}
}
}
``````

For more information, and the implementation of the `require` method used above, check out "Avoiding force unwrapping in Swift unit tests".

## 63 The difference between static and class properties

✍️ Unlike `static` properties, `class` properties can be overridden by subclasses (however, they can't be stored, only computed).

``````class TableViewCell: UITableViewCell {
class var preferredHeight: CGFloat { return 60 }
}

class TallTableViewCell: TableViewCell {
override class var preferredHeight: CGFloat { return 100 }
}
``````

## 62 Creating extensions with static factory methods

👨‍🎨 Creating extensions with static factory methods can be a great alternative to subclassing in Swift, especially for things like setting up UIViews, CALayers or other kinds of styling.

It also lets you remove a lot of styling & setup from your view controllers.

``````extension UILabel {
static func makeForTitle() -> UILabel {
let label = UILabel()
label.font = .boldSystemFont(ofSize: 24)
label.textColor = .darkGray
label.minimumScaleFactor = 0.75
return label
}

static func makeForText() -> UILabel {
let label = UILabel()
label.font = .systemFont(ofSize: 16)
label.textColor = .black
label.numberOfLines = 0
return label
}
}

class ArticleViewController: UIViewController {
lazy var titleLabel = UILabel.makeForTitle()
lazy var textLabel = UILabel.makeForText()
}
``````

## 61 Child view controller auto-resizing

🧒 An awesome thing about child view controllers is that they're automatically resized to match their parent, making them a super nice solution for things like loading & error views.

``````class ListViewController: UIViewController {

self?.handle(result)
}
}
}
``````

For more about child view controller (including the `add` and `remove` methods used above), check out "Using child view controllers as plugins in Swift".

## 60 Using zip

🤐 Using the zip function in Swift you can easily combine two sequences. Super useful when using two sequences to do some work, since zip takes care of all the bounds-checking.

``````func render(titles: [String]) {
for (label, text) in zip(titleLabels, titles) {
print(text)
label.text = text
}
}
``````

## 59 Defining custom option sets

🎛 The awesome thing about option sets in Swift is that they can automatically either be passed as a single member or as a set. Even cooler is that you can easily define your own option sets as well, perfect for options and other non-exclusive values.

``````// Option sets are awesome, because you can easily pass them
// both using dot syntax and array literal syntax, like when
// using the UIView animation API:
UIView.animate(withDuration: 0.3,
delay: 0,
options: .allowUserInteraction,
animations: animations)

UIView.animate(withDuration: 0.3,
delay: 0,
options: [.allowUserInteraction, .layoutSubviews],
animations: animations)

// The cool thing is that you can easily define your own option
// sets as well, by defining a struct that has an Int rawValue,
// that will be used as a bit mask.
extension Cache {
struct Options: OptionSet {
static let saveToDisk = Options(rawValue: 1)
static let clearOnMemoryWarning = Options(rawValue: 1 << 1)
static let clearDaily = Options(rawValue: 1 << 2)

let rawValue: Int
}
}

// We can now use Cache.Options just like UIViewAnimationOptions:
Cache(options: .saveToDisk)
Cache(options: [.saveToDisk, .clearDaily])
``````

## 58 Using the where clause with associated types

🙌 Using the `where` clause when designing protocol-oriented APIs in Swift can let your implementations (or others' if it's open source) have a lot more freedom, especially when it comes to collections.

``````public protocol PathFinderMap {
associatedtype Node
// Using the 'where' clause for associated types, we can
// ensure that a type meets certain requirements (in this
// case that it's a sequence with Node elements).
associatedtype NodeSequence: Sequence where NodeSequence.Element == Node

// Instead of using a concrete type (like [Node]) here, we
// give implementors of this protocol more freedom while
// still meeting our requirements. For example, one
// implementation might use Set<Node>.
func neighbors(of node: Node) -> NodeSequence
}
``````

## 57 Using first class functions when iterating over a dictionary

👨‍🍳 Combine first class functions in Swift with the fact that Dictionary elements are (Key, Value) tuples and you can build yourself some pretty awesome functional chains when iterating over a Dictionary.

``````func makeActor(at coordinate: Coordinate, for building: Building) -> Actor {
let actor = Actor()
actor.position = coordinate.point
actor.animation = building.animation
return actor
}

func render(_ buildings: [Coordinate : Building]) {
}
``````

## 56 Calling instance methods as static functions

😎 In Swift, you can call any instance method as a static function and it will return a closure representing that method. This is how running tests using SPM on Linux works.

``````// This produces a '() -> Void' closure which is a reference to the
// given view's 'removeFromSuperview' method.
let closure = UIView.removeFromSuperview(view)

// We can now call it just like we would any other closure, and it
// will run 'view.removeFromSuperview()'
closure()

// This is how running tests using the Swift Package Manager on Linux
// works, you return your test functions as closures:
extension UserManagerTests {
static var allTests = [
("testLoggingIn", testLoggingIn),
("testLoggingOut", testLoggingOut),
("testUserPermissions", testUserPermissions)
]
}
``````

## 55 Dropping suffixes from method names to support multiple arguments

👏 One really nice benefit of dropping suffixes from method names (and just using verbs, when possible) is that it becomes super easy to support both single and multiple arguments, and it works really well semantically.

``````extension UIView {
}
}

// By dropping the "Subview" suffix from the method name, both
// single and multiple arguments work really well semantically.
``````

## 54 Constraining protocols to classes to ensure mutability

👽 Using the `AnyObject` (or `class`) constraint on protocols is not only useful when defining delegates (or other weak references), but also when you always want instances to be mutable without copying.

``````// By constraining a protocol with 'AnyObject' it can only be adopted
// by classes, which means all instances will always be mutable, and
// that it's the original instance (not a copy) that will be mutated.
protocol DataContainer: AnyObject {
var data: Data? { get set }
}

class UserSettingsManager {
private var settings: Settings
private let dataContainer: DataContainer

// Since DataContainer is a protocol, we an easily mock it in
// tests if we use dependency injection
init(settings: Settings, dataContainer: DataContainer) {
self.settings = settings
self.dataContainer = dataContainer
}

func saveSettings() throws {
let data = try settings.serialize()

// We can now assign properties on an instance of our protocol
// because the compiler knows it's always going to be a class
dataContainer.data = data
}
}
``````

## 53 String-based enums in string interpolation

🍣 Even if you define a custom raw value for a string-based enum in Swift, the full case name will be used in string interpolation.

Super useful when using separate raw values for JSON, while still wanting to use the full case name in other contexts.

``````extension Building {
// This enum has custom raw values that are used when decoding
// a value, for example from JSON.
enum Kind: String {
case castle = "C"
case town = "T"
case barracks = "B"
case goldMine = "G"
case camp = "CA"
case blacksmith = "BL"
}

var animation: Animation {
return Animation(
// When used in string interpolation, the full case name is still used.
// For 'castle' this will be 'buildings/castle'.
name: "buildings/\(kind)",
frameCount: frameCount,
frameDuration: frameDuration
)
}
}
``````

## 52 Expressively comparing a value with a list of candidates

👨‍🔬 Continuing to experiment with expressive ways of comparing a value with a list of candidates in Swift. Adding an extension on Equatable is probably my favorite approach so far.

``````extension Equatable {
func isAny(of candidates: Self...) -> Bool {
return candidates.contains(self)
}
}

let isHorizontal = direction.isAny(of: .left, .right)
``````

See tip 35 for my previous experiment.

## 51 UIView bounds and transforms

📐 A really interesting side-effect of a `UIView`'s `bounds` being its rect within its own coordinate system is that transforms don't affect it at all. That's why it's usually a better fit than `frame` when doing layout calculations of subviews.

``````let view = UIView()
view.frame.size = CGSize(width: 100, height: 100)
view.transform = CGAffineTransform(scaleX: 2, y: 2)

print(view.frame) // (-50.0, -50.0, 200.0, 200.0)
print(view.bounds) // (0.0, 0.0, 100.0, 100.0)
``````

## 50 UIKit default arguments

👏 It's awesome that many UIKit APIs with completion handlers and other optional parameters import into Swift with default arguments (even though they are written in Objective-C). Getting rid of all those nil arguments is so nice!

``````// BEFORE: All parameters are specified, just like in Objective-C

viewController.present(modalViewController, animated: true, completion: nil)

modalViewController.dismiss(animated: true, completion: nil)

to: contentViewController,
duration: 0.3,
options: [],
animations: animations,
completion: nil)

// AFTER: Since many UIKit APIs with completion handlers and other
// optional parameters import into Swift with default arguments,
// we can make our calls shorter

viewController.present(modalViewController, animated: true)

modalViewController.dismiss(animated: true)

to: contentViewController,
duration: 0.3,
animations: animations)
``````

## 49 Avoiding Massive View Controllers

✂️ Avoiding Massive View Controllers is all about finding the right levels of abstraction and splitting things up.

My personal rule of thumb is that as soon as I have 3 methods or properties that have the same prefix, I break them out into their own type.

``````// BEFORE

private lazy var signUpLabel = UILabel()
private lazy var signUpImageView = UIImageView()
private lazy var signUpButton = UIButton()
}

// AFTER

private lazy var signUpView = SignUpView()
}

class SignUpView: UIView {
private lazy var label = UILabel()
private lazy var imageView = UIImageView()
private lazy var button = UIButton()
}
``````

## 48 Extending optionals

❤️ I love the fact that optionals are enums in Swift - it makes it so easy to extend them with convenience APIs for certain types. Especially useful when doing things like data validation on optional values.

``````func validateTextFields() -> Bool {
return false
}

...

return true
}

// Since all optionals are actual enum values in Swift, we can easily
// extend them for certain types, to add our own convenience APIs

extension Optional where Wrapped == String {
var isNilOrEmpty: Bool {
switch self {
case let string?:
return string.isEmpty
case nil:
return true
}
}
}

// Since strings are now Collections in Swift 4, you can even
// add this property to all optional collections:

extension Optional where Wrapped: Collection {
var isNilOrEmpty: Bool {
switch self {
case let collection?:
return collection.isEmpty
case nil:
return true
}
}
}
``````

## 47 Using where with for-loops

🗺 Using the `where` keyword can be a super nice way to quickly apply a filter in a `for`-loop in Swift. You can of course use `map`, `filter` and `forEach`, or `guard`, but for simple loops I think this is very expressive and nice.

``````func archiveMarkedPosts() {
for post in posts where post.isMarked {
archive(post)
}
}

func healAllies() {
for player in players where player.isAllied(to: currentPlayer) {
player.heal()
}
}
``````

👻 Variable shadowing can be super useful in Swift, especially when you want to create a local copy of a parameter value in order to use it as state within a closure.

``````init(repeatMode: RepeatMode, closure: @escaping () -> UpdateOutcome) {
// Shadow the argument with a local, mutable copy
var repeatMode = repeatMode

self.closure = {
// With shadowing, there's no risk of accidentially
// referring to the immutable version
switch repeatMode {
case .forever:
break
case .times(let count):
guard count > 0 else {
return .finished
}

// We can now capture the mutable version and use
// it for state in a closure
repeatMode = .times(count - 1)
}

return closure()
}
}
``````

## 45 Using dot syntax for static properties and initializers

✒️ Dot syntax is one of my favorite features of Swift. What's really cool is that it's not only for enums, any static method or property can be used with dot syntax - even initializers! Perfect for convenience APIs and default parameters.

``````public enum RepeatMode {
case times(Int)
case forever
}

public extension RepeatMode {
static var never: RepeatMode {
return .times(0)
}

static var once: RepeatMode {
return .times(1)
}
}

view.perform(animation, repeated: .once)

// To make default parameters more compact, you can even use init with dot syntax

init(cache: Cache = .init(), decoder: ImageDecoder = .init()) {
...
}
}
``````

## 44 Calling functions as closures with a tuple as parameters

🚀 One really cool aspect of Swift having first class functions is that you can pass any function (or even initializer) as a closure, and even call it with a tuple containing its parameters!

``````// This function lets us treat any "normal" function or method as
// a closure and run it with a tuple that contains its parameters
func call<Input, Output>(_ function: (Input) -> Output, with input: Input) -> Output {
return function(input)
}

class ViewFactory {
// We can now pass an initializer as a closure, and a tuple
// containing its parameters
}

private func loadTextStyles() -> (font: UIFont, color: UIColor) {
return (theme.font, theme.textColor)
}
}

init(font: UIFont, textColor: UIColor) {
...
}
}
``````

## 43 Enabling static dependency injection

💉 If you've been struggling to test code that uses static APIs, here's a technique you can use to enable static dependency injection without having to modify any call sites:

``````// Before: Almost impossible to test due to the use of singletons

class Analytics {
static func log(_ event: Event) {
Database.shared.save(event)

let dictionary = event.serialize()
NetworkManager.shared.post(dictionary, to: eventURL)
}
}

// After: Much easier to test, since we can inject mocks as arguments

class Analytics {
static func log(_ event: Event,
database: Database = .shared,
networkManager: NetworkManager = .shared) {
database.save(event)

let dictionary = event.serialize()
networkManager.post(dictionary, to: eventURL)
}
}
``````

## 42 Type inference for lazy properties in Swift 4

🎉 In Swift 4, type inference works for lazy properties and you don't need to explicitly refer to `self`!

``````// Swift 3

class PurchaseView: UIView {

private func makeBuyButton() -> UIButton {
let button = UIButton()
button.setTitleColor(.blue, for: .normal)
return button
}
}

// Swift 4

class PurchaseView: UIView {

private func makeBuyButton() -> UIButton {
let button = UIButton()
button.setTitleColor(.blue, for: .normal)
return button
}
}
``````

## 41 Converting Swift errors to NSError

😎 You can turn any Swift `Error` into an `NSError`, which is super useful when pattern matching with a code 👍. Also, switching on optionals is pretty cool!

``````let task = urlSession.dataTask(with: url) { data, _, error in
switch error {
case .some(let error as NSError) where error.code == NSURLErrorNotConnectedToInternet:
presenter.showOfflineView()
case .some(let error):
presenter.showGenericErrorView()
case .none:
presenter.renderContent(from: data)
}
}

``````

Also make sure to check out Kostas Kremizas' tip about how you can pattern match directly against a member of `URLError`.

## 40 Making UIImage macOS compatible

🖥 Here's an easy way to make iOS model code that uses `UIImage` macOS compatible - like me and Gui Rambo discussed on the Swift by Sundell Podcast.

``````// Either put this in a separate file that you only include in your macOS target or wrap the code in #if os(macOS) / #endif

import Cocoa

// Step 1: Typealias UIImage to NSImage
typealias UIImage = NSImage

// Step 2: You might want to add these APIs that UIImage has but NSImage doesn't.
extension NSImage {
var cgImage: CGImage? {
var proposedRect = CGRect(origin: .zero, size: size)

return cgImage(forProposedRect: &proposedRect,
context: nil,
hints: nil)
}

convenience init?(named name: String) {
self.init(named: Name(name))
}
}

// Step 3: Profit - you can now make your model code that uses UIImage cross-platform!
struct User {
let name: String
let profileImage: UIImage
}
``````

## 39 Internally mutable protocol-oriented APIs

🤖 You can easily define a protocol-oriented API that can only be mutated internally, by using an internal protocol that extends a public one.

``````// Declare a public protocol that acts as your immutable API
public protocol ModelHolder {
associatedtype Model
var model: Model { get }
}

// Declare an extended, internal protocol that provides a mutable API
internal protocol MutableModelHolder: ModelHolder {
var model: Model { get set }
}

// You can now implement the requirements using 'public internal(set)'
public class UserHolder: MutableModelHolder {
public internal(set) var model: User

internal init(model: User) {
self.model = model
}
}
``````

## 38 Switching on a set

🎛 You can switch on a set using array literals as cases in Swift! Can be really useful to avoid many `if`/`else if` statements.

``````class RoadTile: Tile {
var connectedDirections = Set<Direction>()

func render() {
switch connectedDirections {
case [.up, .down]:
case [.left, .right]:
default:
}
}
}
``````

## 37 Adding the current locale to cache keys

🌍 When caching localized content in an app, it's a good idea to add the current locale to all keys, to prevent bugs when switching languages.

``````func cache(_ content: Content, forKey key: String) throws {
let data = try wrap(content) as Data
let key = localize(key: key)
try storage.store(data, forKey: key)
}

func loadCachedContent(forKey key: String) -> Content? {
let key = localize(key: key)
return data.flatMap { try? unbox(data: \$0) }
}

private func localize(key: String) -> String {
return key + "-" + Bundle.main.preferredLocalizations[0]
}
``````

## 36 Setting up tests to avoid retain cycles with weak references

🚳 Here's an easy way to setup a test to avoid accidental retain cycles with object relationships (like weak delegates & observers) in Swift:

``````func testDelegateNotRetained() {
// Assign the delegate (weak) and also retain it using a local var
var delegate: Delegate? = DelegateMock()
controller.delegate = delegate
XCTAssertNotNil(controller.delegate)

// Release the local var, which should also release the weak reference
delegate = nil
XCTAssertNil(controller.delegate)
}
``````

## 35 Expressively matching a value against a list of candidates

👨‍🔬 Playing around with an expressive way to check if a value matches any of a list of candidates in Swift:

``````// Instead of multiple conditions like this:

if string == "One" || string == "Two" || string == "Three" {

}

// You can now do:

if string == any(of: "One", "Two", "Three") {

}
``````

You can find a gist with the implementation here.

## 34 Organizing code using extensions

👪 APIs in a Swift extension automatically inherit its access control level, making it a neat way to organize public, internal & private APIs.

``````public extension Animation {
init(textureNamed textureName: String) {
frames = [Texture(name: textureName)]
}

init(texturesNamed textureNames: [String], frameDuration: TimeInterval = 1) {
frames = textureNames.map(Texture.init)
self.frameDuration = frameDuration
}

init(image: Image) {
frames = [Texture(image: image)]
}
}

internal extension Animation {
}
}
``````

## 33 Using map to transform an optional into a Result type

🗺 Using `map` you can transform an optional value into an optional `Result` type by simply passing in the enum case.

``````enum Result<Value> {
case value(Value)
case error(Error)
}

class Promise<Value> {
private var result: Result<Value>?

init(value: Value? = nil) {
result = value.map(Result.value)
}
}
``````

## 32 Assigning to self in struct initializers

👌 It's so nice that you can assign directly to `self` in `struct` initializers in Swift. Very useful when adding conformance to protocols.

``````extension Bool: AnswerConvertible {
public init(input: String) throws {
switch input.lowercased() {
case "y", "yes", "👍":
self = true
default:
self = false
}
}
}
``````

## 31 Recursively calling closures as inline functions

☎️ Defining Swift closures as inline functions enables you to recursively call them, which is super useful in things like custom sequences.

``````class Database {
func records(matching query: Query) -> AnySequence<Record> {

func iterate() -> Record? {
guard let nextRecord = recordIterator.next() else {
return nil
}

guard nextRecord.matches(query) else {
// Since the closure is an inline function, it can be recursively called,
// in this case in order to advance to the next item.
return iterate()
}

return nextRecord
}

// AnySequence/AnyIterator are part of the standard library and provide an easy way
// to define custom sequences using closures.
return AnySequence { AnyIterator(iterate) }
}
}
``````

Rob Napier points out that using the above might cause crashes if used on a large databaset, since Swift has no guaranteed Tail Call Optimization (TCO).

Slava Pestov also points out that another benefit of inline functions vs closures is that they can have their own generic parameter list.

## 30 Passing self to required Objective-C dependencies

🏖 Using lazy properties in Swift, you can pass `self` to required Objective-C dependencies without having to use force-unwrapped optionals.

``````class DataLoader: NSObject {
lazy var urlSession: URLSession = self.makeURLSession()

private func makeURLSession() -> URLSession {
return URLSession(configuration: .default, delegate: self, delegateQueue: .main)
}
}

class Renderer {

}
}
``````

## 29 Making weak or lazy properties readonly

👓 If you have a property in Swift that needs to be `weak` or `lazy`, you can still make it readonly by using `private(set)`.

``````class Node {
private(set) weak var parent: Node?
private(set) lazy var children = [Node]()

children.append(child)
child.parent = self
}
}
``````

## 28 Defining static URLs using string literals

🌏 Tired of using `URL(string: "url")!` for static URLs? Make `URL` conform to `ExpressibleByStringLiteral` and you can now simply use `"url"` instead.

``````extension URL: ExpressibleByStringLiteral {
// By using 'StaticString' we disable string interpolation, for safety
public init(stringLiteral value: StaticString) {
self = URL(string: "\(value)").require(hint: "Invalid URL string literal: \(value)")
}
}

// We can now define URLs using static string literals 🎉
let url: URL = "https://www.swiftbysundell.com"

// In Swift 3 or earlier, you also have to implement 2 additional initializers
extension URL {
public init(extendedGraphemeClusterLiteral value: StaticString) {
self.init(stringLiteral: value)
}

public init(unicodeScalarLiteral value: StaticString) {
self.init(stringLiteral: value)
}
}
``````

To find the extension that adds the `require()` method on `Optional` that I use above, check out Require.

## 27 Manipulating points, sizes and frames using math operators

✚ I'm always careful with operator overloading, but for manipulating things like sizes, points & frames I find them super useful.

``````extension CGSize {
static func *(lhs: CGSize, rhs: CGFloat) -> CGSize {
return CGSize(width: lhs.width * rhs, height: lhs.height * rhs)
}
}

button.frame.size = image.size * 2
``````

If you like the above idea, check out CGOperators, which contains math operator overloads for all Core Graphics' vector types.

## 26 Using closure types in generic constraints

🔗 You can use closure types in generic constraints in Swift. Enables nice APIs for handling sequences of closures.

``````extension Sequence where Element == () -> Void {
func callAll() {
forEach { \$0() }
}
}

extension Sequence where Element == () -> String {
func joinedResults(separator: String) -> String {
return map { \$0() }.joined(separator: separator)
}
}

callbacks.callAll()
let names = nameProviders.joinedResults(separator: ", ")
``````

(If you're using Swift 3, you have to change `Element` to `Iterator.Element`)

## 25 Using associated enum values to avoid state-specific optionals

🎉 Using associated enum values is a super nice way to encapsulate mutually exclusive state info (and avoiding state-specific optionals).

``````// BEFORE: Lots of state-specific, optional properties

class Player {
var isWaitingForMatchMaking: Bool
var invitingUser: User?
var numberOfLives: Int
var playerDefeatedBy: Player?
var roundDefeatedIn: Int?
}

// AFTER: All state-specific information is encapsulated in enum cases

class Player {
enum State {
case waitingForMatchMaking
case waitingForInviteResponse(from: User)
case active(numberOfLives: Int)
case defeated(by: Player, roundNumber: Int)
}

var state: State
}
``````

## 24 Using enums for async result types

👍 I really like using enums for all async result types, even boolean ones. Self-documenting, and makes the call site a lot nicer to read too!

``````protocol PushNotificationService {
// Before
func enablePushNotifications(completionHandler: @escaping (Bool) -> Void)

// After
}

case enabled
case disabled
}

if status == .enabled {
}
}
``````

## 23 Working on async code in a playground

🏃 Want to work on your async code in a Swift Playground? Just set `needsIndefiniteExecution` to true to keep it running:

``````import PlaygroundSupport

PlaygroundPage.current.needsIndefiniteExecution = true

let greeting = "Hello after 3 seconds"
print(greeting)
}
``````

To stop the playground from executing, simply call `PlaygroundPage.current.finishExecution()`.

## 22 Overriding self with a weak reference

💦 Avoid memory leaks when accidentially refering to `self` in closures by overriding it locally with a weak reference:

Swift >= 4.2

``````dataLoader.loadData(from: url) { [weak self] result in
guard let self = self else {
return
}

self.cache(result)

...
``````

Swift < 4.2

``````dataLoader.loadData(from: url) { [weak self] result in
guard let `self` = self else {
return
}

self.cache(result)

...
``````

Note that the reason the above currently works is because of a compiler bug (which I hope gets turned into a properly supported feature soon).

## 21 Using DispatchWorkItem

🕓 Using dispatch work items you can easily cancel a delayed asynchronous GCD task if you no longer need it:

``````let workItem = DispatchWorkItem {
// Your async code goes in here
}

// Execute the work item after 1 second
DispatchQueue.main.asyncAfter(deadline: .now() + 1, execute: workItem)

// You can cancel the work item if you no longer need it
workItem.cancel()
``````

## 20 Combining a sequence of functions

➕ While working on a new Swift developer tool (to be open sourced soon 😉), I came up with a pretty neat way of organizing its sequence of operations, by combining their functions into a closure:

``````internal func +<A, B, C>(lhs: @escaping (A) throws -> B,
rhs: @escaping (B) throws -> C) -> (A) throws -> C {
return { try rhs(lhs(\$0)) }
}

public func run() throws {
try (determineTarget + build + analyze + output)()
}
``````

If you're familiar with the functional programming world, you might know the above technique as the pipe operator (thanks to Alexey Demedreckiy for pointing this out!)

## 19 Chaining optionals with map() and flatMap()

🗺 Using `map()` and `flatMap()` on optionals you can chain multiple operations without having to use lengthy `if lets` or `guards`:

``````// BEFORE

guard let string = argument(at: 1) else {
return
}

guard let url = URL(string: string) else {
return
}

handle(url)

// AFTER

argument(at: 1).flatMap(URL.init).map(handle)
``````

## 18 Using self-executing closures for lazy properties

🚀 Using self-executing closures is a great way to encapsulate lazy property initialization:

``````class StoreViewController: UIViewController {
private lazy var collectionView: UICollectionView = {
let layout = UICollectionViewFlowLayout()
let view = UICollectionView(frame: self.view.bounds, collectionViewLayout: layout)
view.delegate = self
view.dataSource = self
return view
}()

}
}
``````

## 17 Speeding up Swift package tests

⚡️ You can speed up your Swift package tests using the `--parallel` flag. For Marathon, the tests execute 3 times faster that way!

``````swift test --parallel
``````

## 16 Avoiding mocking UserDefaults

🛠 Struggling with mocking `UserDefaults` in a test? The good news is: you don't need mocking - just create a real instance:

``````class LoginTests: XCTestCase {
private var userDefaults: UserDefaults!

override func setUp() {
super.setup()

userDefaults = UserDefaults(suiteName: #file)
userDefaults.removePersistentDomain(forName: #file)

}
}
``````

👍 Using variadic parameters in Swift, you can create some really nice APIs that take a list of objects without having to use an array:

``````extension Canvas {
}
}

let circle = Circle(center: CGPoint(x: 5, y: 5), radius: 5)
let lineA = Line(start: .zero, end: CGPoint(x: 10, y: 10))
let lineB = Line(start: CGPoint(x: 0, y: 10), end: CGPoint(x: 10, y: 0))

let canvas = Canvas()
canvas.render()
``````

## 14 Referring to enum cases with associated values as closures

😮 Just like you can refer to a Swift function as a closure, you can do the same thing with enum cases with associated values:

``````enum UnboxPath {
case key(String)
case keyPath(String)
}

struct UserSchema {
static let name = key("name")
static let age = key("age")
static let posts = key("posts")

private static let key = UnboxPath.key
}
``````

## 13 Using the === operator to compare objects by instance

📈 The `===` operator lets you check if two objects are the same instance. Very useful when verifying that an array contains an instance in a test:

``````protocol InstanceEquatable: class, Equatable {}

extension InstanceEquatable {
static func ==(lhs: Self, rhs: Self) -> Bool {
return lhs === rhs
}
}

extension Enemy: InstanceEquatable {}

func testDestroyingEnemy() {
player.attack(enemy)
XCTAssertTrue(player.destroyedEnemies.contains(enemy))
}
``````

## 12 Calling initializers with dot syntax and passing them as closures

😎 Cool thing about Swift initializers: you can call them using dot syntax and pass them as closures! Perfect for mocking dates in tests.

``````class Logger {
private let storage: LogStorage
private let dateProvider: () -> Date

init(storage: LogStorage = .init(), dateProvider: @escaping () -> Date = Date.init) {
self.storage = storage
self.dateProvider = dateProvider
}

func log(event: Event) {
storage.store(event: event, date: dateProvider())
}
}
``````

## 11 Structuring UI tests as extensions on XCUIApplication

📱 Most of my UI testing logic is now categories on `XCUIApplication`. Makes the test cases really easy to read:

``````func testLoggingInAndOut() {
XCTAssertFalse(app.userIsLoggedIn)

app.launch()
XCTAssertTrue(app.userIsLoggedIn)

app.logout()
XCTAssertFalse(app.userIsLoggedIn)
}

func testDisplayingCategories() {
XCTAssertFalse(app.isDisplayingCategories)

app.launch()
app.goToCategories()
XCTAssertTrue(app.isDisplayingCategories)
}
``````

## 10 Avoiding default cases in switch statements

🙂 It’s a good idea to avoid “default” cases when switching on Swift enums - it’ll “force you” to update your logic when a new case is added:

``````enum State {
case loggedIn
case loggedOut
case onboarding
}

func handle(_ state: State) {
switch state {
case .loggedIn:
showMainUI()
case .loggedOut:
// Compiler error: Switch must be exhaustive
}
}
``````

## 9 Using the guard statement in many different scopes

💂 It's really cool that you can use Swift's 'guard' statement to exit out of pretty much any scope, not only return from functions:

``````// You can use the 'guard' statement to...

for string in strings {
// ...continue an iteration
guard shouldProcess(string) else {
continue
}

// ...or break it
guard !shouldBreak(for: string) else {
break
}

// ...or return
guard !shouldReturn(for: string) else {
return
}

// ..or throw an error
guard string.isValid else {
throw StringError.invalid(string)
}

// ...or exit the program
guard !shouldExit(for: string) else {
exit(1)
}
}
``````

## 8 Passing functions & operators as closures

❤️ Love how you can pass functions & operators as closures in Swift. For example, it makes the syntax for sorting arrays really nice!

``````let array = [3, 9, 1, 4, 6, 2]
let sorted = array.sorted(by: <)
``````

## 7 Using #function for UserDefaults key consistency

🗝 Here's a neat little trick I use to get UserDefault key consistency in Swift (#function expands to the property name in getters/setters). Just remember to write a good suite of tests that'll guard you against bugs when changing property names.

``````extension UserDefaults {
var onboardingCompleted: Bool {
get { return bool(forKey: #function) }
set { set(newValue, forKey: #function) }
}
}
``````

## 6 Using a name already taken by the standard library

📛 Want to use a name already taken by the standard library for a nested type? No problem - just use `Swift.` to disambiguate:

``````extension Command {
enum Error: Swift.Error {
case missing
case invalid(String)
}
}
``````

## 5 Using Wrap to implement Equatable

📦 Playing around with using Wrap to implement `Equatable` for any type, primarily for testing:

``````protocol AutoEquatable: Equatable {}

extension AutoEquatable {
static func ==(lhs: Self, rhs: Self) -> Bool {
let lhsData = try! wrap(lhs) as Data
let rhsData = try! wrap(rhs) as Data
return lhsData == rhsData
}
}
``````

## 4 Using typealiases to reduce the length of method signatures

📏 One thing that I find really useful in Swift is to use typealiases to reduce the length of method signatures in generic types:

``````public class PathFinder<Object: PathFinderObject> {
public typealias Map = Object.Map
public typealias Node = Map.Node
public typealias Path = PathFinderPath<Object>

public static func possiblePaths(for object: Object, at rootNode: Node, on map: Map) -> Path.Sequence {
return .init(object: object, rootNode: rootNode, map: map)
}
}
``````

## 3 Referencing either external or internal parameter name when writing docs

📖 You can reference either the external or internal parameter label when writing Swift docs - and they get parsed the same:

``````// EITHER:

class Foo {
/**
*   - parameter string: A string
*/
func bar(with string: String) {}
}

// OR:

class Foo {
/**
*   - parameter with: A string
*/
func bar(with string: String) {}
}
``````

## 2 Using auto closures

👍 Finding more and more uses for auto closures in Swift. Can enable some pretty nice APIs:

``````extension Dictionary {
mutating func value(for key: Key, orAdd valueClosure: @autoclosure () -> Value) -> Value {
if let value = self[key] {
return value
}

let value = valueClosure()
self[key] = value
return value
}
}
``````

## 1 Namespacing with nested types

🚀 I’ve started to become a really big fan of nested types in Swift. Love the additional namespacing it gives you!

``````public struct Map {
public struct Model {
public let size: Size
public let theme: Theme
public var terrain: [Position : Terrain.Model]
public var units: [Position : Unit.Model]
public var buildings: [Position : Building.Model]
}

public enum Direction {
case up
case right
case down
case left
}

public struct Position {
public var x: Int
public var y: Int
}

public enum Size: String {
case small = "S"
case medium = "M"
case large = "L"
case extraLarge = "XL"
}
}``````

Author: JohnSundell
Source Code: https://github.com/JohnSundell/SwiftTips

1661592007

## A Collection Of Swift Tips & Tricks That I've Shared on Twitter

⚠️ This list is no longer being updated. For my latest Swift tips, checkout the "Tips" section on Swift by Sundell.

## Swift tips & tricks ⚡️

One of the things I really love about Swift is how I keep finding interesting ways to use it in various situations, and when I do - I usually share them on Twitter. Here's a collection of all the tips & tricks that I've shared so far. Each entry has a link to the original tweet, if you want to respond with some feedback or question, which is always super welcome! 🚀

Also make sure to check out all of my other Swift content:

## #102 Making async tests faster and more stable

🚀 Here are some quick tips to make async tests faster & more stable:

• 😴 Avoid sleep() - use expectations instead
• ⏱ Use generous timeouts to avoid flakiness on CI
• 🧐 Put all assertions at the end of each test, not inside closures
``````// BEFORE:

class MentionDetectorTests: XCTestCase {
func testDetectingMention() {
let detector = MentionDetector()
let string = "This test was written by @johnsundell."

detector.detectMentions(in: string) { mentions in
XCTAssertEqual(mentions, ["johnsundell"])
}

sleep(2)
}
}

// AFTER:

class MentionDetectorTests: XCTestCase {
func testDetectingMention() {
let detector = MentionDetector()
let string = "This test was written by @johnsundell."

var mentions: [String]?
let expectation = self.expectation(description: #function)

detector.detectMentions(in: string) {
mentions = \$0
expectation.fulfill()
}

waitForExpectations(timeout: 10)
XCTAssertEqual(mentions, ["johnsundell"])
}
}
``````

For more on async testing, check out "Unit testing asynchronous Swift code".

## #101 Adding support for Apple Pencil double-taps

✍️ Adding support for the new Apple Pencil double-tap feature is super easy! All you have to do is to create a `UIPencilInteraction`, add it to a view, and implement one delegate method. Hopefully all pencil-compatible apps will soon adopt this.

``````let interaction = UIPencilInteraction()
interaction.delegate = self

extension ViewController: UIPencilInteractionDelegate {
func pencilInteractionDidTap(_ interaction: UIPencilInteraction) {
// Handle pencil double-tap
}
}
``````

For more on using this and other iPad Pro features, check out "Building iPad Pro features in Swift".

## #100 Combining values with functions

😎 Here's a cool function that combines a value with a function to return a closure that captures that value, so that it can be called without any arguments. Super useful when working with closure-based APIs and we want to use some of our properties without having to capture `self`.

``````func combine<A, B>(_ value: A, with closure: @escaping (A) -> B) -> () -> B {
return { closure(value) }
}

// BEFORE:

class ProductViewController: UIViewController {

buyButton.handler = { [weak self] in
guard let self = self else {
return
}

self.productManager.startCheckout(for: self.product)
}
}
}

// AFTER:

class ProductViewController: UIViewController {

}
}
``````

## #99 Dependency injection using functions

💉 When I'm only using a single function from a dependency, I love to inject that function as a closure, instead of having to create a protocol and inject the whole object. Makes dependency injection & testing super simple.

``````final class ArticleLoader {
typealias Networking = (Endpoint) -> Future<Data>

private let networking: Networking

init(networking: @escaping Networking = URLSession.shared.load) {
self.networking = networking
}

return networking(.latestArticles).decode()
}
}
``````

For more on this technique, check out "Simple Swift dependency injection with functions".

## #98 Using a custom exception handler

💥 It's cool that you can easily assign a closure as a custom `NSException` handler. This is super useful when building things in Playgrounds - since you can't use breakpoints - so instead of just `signal SIGABRT`, you'll get the full exception description if something goes wrong.

``````NSSetUncaughtExceptionHandler { exception in
print(exception)
}
``````

## #97 Using type aliases to give semantic meaning to primitives

❤️ I love that in Swift, we can use the type system to make our code so much more self-documenting - one way of doing so is to use type aliases to give the primitive types that we use a more semantic meaning.

``````extension List.Item {
// Using type aliases, we can give semantic meaning to the
// primitive types that we use, without having to introduce
// wrapper types.
typealias Index = Int
}

extension List {
enum Mutation {
// Our enum cases now become a lot more self-documenting,
// explain them.
case update(Item, Item.Index)
case remove(Item.Index)
}
}
``````

For more on self-documenting code, check out "Writing self-documenting Swift code".

## #96 Specializing protocols using constraints

🤯 A little late night prototyping session reveals that protocol constraints can not only be applied to extensions - they can also be added to protocol definitions!

This is awesome, since it lets us easily define specialized protocols based on more generic ones.

``````protocol Component {
associatedtype Container
}

// Protocols that inherit from other protocols can include
// constraints to further specialize them.
protocol ViewComponent: Component where Container == UIView {
associatedtype View: UIView
var view: View { get }
}

extension ViewComponent {
}
}
``````

For more on specializing protocols, check out "Specializing protocols in Swift".

## #95 Unwrapping an optional or throwing an error

📦 Here's a super handy extension on Swift's `Optional` type, which gives us a really nice API for easily unwrapping an optional, or throwing an error in case the value turned out to be `nil`:

``````extension Optional {
func orThrow(_ errorExpression: @autoclosure () -> Error) throws -> Wrapped {
switch self {
case .some(let value):
return value
case .none:
throw errorExpression()
}
}
}

let file = try loadFile(at: path).orThrow(MissingFileError())
``````

For more ways that optionals can be extended, check out "Extending optionals in Swift".

## #94 Testing code that uses static APIs

👩‍🔬 Testing code that uses static APIs can be really tricky, but there's a way that it can often be done - using Swift's first class function capabilities!

Instead of accessing that static API directly, we can inject the function we want to use, which enables us to mock it!

``````// BEFORE

func loadFriends(then handler: @escaping (Result<[Friend]>) -> Void) {
...
}
}
}

// AFTER

typealias Handler<T> = (Result<T>) -> Void

then handler: @escaping Handler<[Friend]>) {
...
}
}
}

// MOCKING IN TESTS

handler(.success(mockData))
}

...
}
``````

## #93 Matching multiple enum cases with associated values

🐾 Swift's pattern matching capabilities are so powerful! Two enum cases with associated values can even be matched and handled by the same switch case - which is super useful when handling state changes with similar data.

``````enum DownloadState {
case inProgress(progress: Double)
case paused(progress: Double)
case cancelled
case finished(Data)
}

switch state {
case .inProgress(let progress), .paused(let progress):
updateProgressView(with: progress)
case .cancelled:
showCancelledMessage()
case .finished(let data):
process(data)
}
}
``````

## #92 Multiline string literals

🅰 One really nice benefit of Swift multiline string literals - even for single lines of text - is that they don't require quotes to be escaped. Perfect when working with things like HTML, or creating a custom description for an object.

``````let html = highlighter.highlight("Array<String>")

XCTAssertEqual(html, """
<span class="type">Array</span>&lt;<span class="type">String</span>&gt;
""")
``````

## #91 Reducing sequences

💎 While it's very common in functional programming, the `reduce` function might be a bit of a hidden gem in Swift. It provides a super useful way to transform a sequence into a single value.

``````extension Sequence where Element: Equatable {
func numberOfOccurrences(of target: Element) -> Int {
return reduce(0) { result, element in
guard element == target else {
return result
}

return result + 1
}
}
}
``````

You can read more about transforming collections in "Transforming collections in Swift".

## #90 Avoiding manual Codable implementations

📦 When I use Codable in Swift, I want to avoid manual implementations as much as possible, even when there's a mismatch between my code structure and the JSON I'm decoding.

One way that can often be achieved is to use private data containers combined with computed properties.

``````struct User: Codable {
let name: String
let age: Int

var homeTown: String { return originPlace.name }

private let originPlace: Place
}

private extension User {
struct Place: Codable {
let name: String
}
}

extension User {
struct Container: Codable {
let user: User
}
}
``````

## #89 Using feature flags instead of feature branches

🚢 Instead of using feature branches, I merge almost all of my code directly into master - and then I use feature flags to conditionally enable features when they're ready. That way I can avoid merge conflicts and keep shipping!

``````extension ListViewController {
// Rather than having to keep maintaining a separate
// feature branch for a new feature, we can use a flag
// to conditionally turn it on.
guard FeatureFlags.searchEnabled else {
return
}

let resultsVC = SearchResultsViewController()
let searchVC = UISearchController(
searchResultsController: resultsVC
)

searchVC.searchResultsUpdater = resultsVC
}
}
``````

You can read more about feature flags in "Feature flags in Swift".

## #88 Lightweight data hierarchies using tuples

💾 Here I'm using tuples to create a lightweight hierarchy for my data, giving me a nice structure without having to introduce any additional types.

``````struct CodeSegment {
var tokens: (
previous: String?,
current: String
)

var delimiters: (
previous: Character?
next: Character?
)
}

handle(segment.tokens.current)
``````

You can read more about tuples in "Using tuples as lightweight types in Swift"

## #87 The rule of threes

3️⃣ Whenever I have 3 properties or local variables that share the same prefix, I usually try to extract them into their own method or type. That way I can avoid massive types & methods, and also increase readability, without falling into a "premature optimization" trap.

Before

``````public func generate() throws {
let contentFolder = try folder.subfolder(named: "content")

let articleFolder = try contentFolder.subfolder(named: "posts")
let articleProcessor = ContentProcessor(folder: articleFolder)
let articles = try articleProcessor.process()

...
}
``````

After

``````public func generate() throws {
let contentFolder = try folder.subfolder(named: "content")
let articles = try processArticles(in: contentFolder)
...
}

private func processArticles(in folder: Folder) throws -> [ContentItem] {
let folder = try folder.subfolder(named: "posts")
let processor = ContentProcessor(folder: folder)
return try processor.process()
}
``````

## #86 Useful Codable extensions

👨‍🔧 Here's two extensions that I always add to the `Encodable` & `Decodable` protocols, which for me really make the Codable API nicer to use. By using type inference for decoding, a lot of boilerplate can be removed when the compiler is already able to infer the resulting type.

``````extension Encodable {
func encoded() throws -> Data {
return try JSONEncoder().encode(self)
}
}

extension Data {
func decoded<T: Decodable>() throws -> T {
return try JSONDecoder().decode(T.self, from: self)
}
}

let data = try user.encoded()

// By using a generic type in the decoded() method, the
// compiler can often infer the type we want to decode
// from the current context.

// And if not, we can always supply the type, still making
// the call site read very nicely.
let otherUser = try data.decoded() as User
``````

## #85 Using shared UserDefaults suites

📦 `UserDefaults` is a lot more powerful than what it first might seem like. Not only can it store more complex values (like dates & dictionaries) and parse command line arguments - it also enables easy sharing of settings & lightweight data between apps in the same App Group.

``````let sharedDefaults = UserDefaults(suiteName: "my-app-group")!
let useDarkMode = sharedDefaults.bool(forKey: "dark-mode")

// This value is put into the shared suite.
sharedDefaults.set(true, forKey: "dark-mode")

// If you want to treat the shared settings as read-only (and add
// local overrides on top of them), you can simply add the shared
// suite to the standard UserDefaults.
let combinedDefaults = UserDefaults.standard

// This value is a local override, not added to the shared suite.
combinedDefaults.set(true, forKey: "app-specific-override")
``````

## #84 Custom UIView backing layers

🎨 By overriding `layerClass` you can tell UIKit what `CALayer` class to use for a `UIView`'s backing layer. That way you can reduce the amount of layers, and don't have to do any manual layout.

``````final class GradientView: UIView {
override class var layerClass: AnyClass { return CAGradientLayer.self }

var colors: (start: UIColor, end: UIColor)? {
didSet { updateLayer() }
}

private func updateLayer() {
let layer = self.layer as! CAGradientLayer
layer.colors = colors.map { [\$0.start.cgColor, \$0.end.cgColor] }
}
}
``````

## #83 Auto-Equatable enums with associated values

✅ That the compiler now automatically synthesizes Equatable conformances is such a huge upgrade for Swift! And the cool thing is that it works for all kinds of types - even for enums with associated values! Especially useful when using enums for verification in unit tests.

``````struct Article: Equatable {
let title: String
let text: String
}

struct User: Equatable {
let name: String
let age: Int
}

extension Navigator {
enum Destination: Equatable {
case profile(User)
case article(Article)
}
}

func testNavigatingToArticle() {
let article = Article(title: "Title", text: "Text")
controller.select(article)
XCTAssertEqual(navigator.destinations, [.article(article)])
}
``````

## #82 Defaults for associated types

🤝 Associated types can have defaults in Swift - which is super useful for types that are not easily inferred (for example when they're not used for a specific instance method or property).

``````protocol Identifiable {
associatedtype RawIdentifier: Codable = String

var id: Identifier<Self> { get }
}

struct User: Identifiable {
let id: Identifier<User>
let name: String
}

struct Group: Identifiable {
typealias RawIdentifier = Int

let id: Identifier<Group>
let name: String
}
``````

## #81 Creating a dedicated identifier type

🆔 If you want to avoid using plain strings as identifiers (which can increase both type safety & readability), it's really easy to create a custom Identifier type that feels just like a native Swift type, thanks to protocols!

More on this topic in "Type-safe identifiers in Swift".

``````struct Identifier: Hashable {
let string: String
}

extension Identifier: ExpressibleByStringLiteral {
init(stringLiteral value: String) {
string = value
}
}

extension Identifier: CustomStringConvertible {
var description: String {
return string
}
}

extension Identifier: Codable {
init(from decoder: Decoder) throws {
let container = try decoder.singleValueContainer()
string = try container.decode(String.self)
}

func encode(to encoder: Encoder) throws {
var container = encoder.singleValueContainer()
try container.encode(string)
}
}

struct Article: Codable {
let id: Identifier
let title: String
}

let article = Article(id: "my-article", title: "Hello world!")
``````

## #80 Assigning optional tuple members to variables

🙌 A really cool thing about using tuples to model the internal state of a Swift type, is that you can unwrap an optional tuple's members directly into local variables.

Very useful in order to group multiple optional values together for easy unwrapping & handling.

``````class ImageTransformer {
private var queue = [(image: UIImage, transform: Transform)]()

private func processNext() {
// When unwrapping an optional tuple, you can assign the members
// directly to local variables.
guard let (image, transform) = queue.first else {
return
}

let context = Context()
context.draw(image)
context.apply(transform)
...
}
}
``````

## #79 Struct convenience initializers

❤️ I love to structure my code using extensions in Swift. One big benefit of doing so when it comes to struct initializers, is that defining a convenience initializer doesn't remove the default one the compiler generates - best of both worlds!

``````struct Article {
let date: Date
var title: String
var text: String
}

extension Article {
init(title: String, text: String) {
self.init(date: Date(), title: title, text: text, comments: [])
}
}

let articleA = Article(title: "Best Cupcake Recipe", text: "...")

let articleB = Article(
date: Date(),
title: "Best Cupcake Recipe",
text: "...",
Comment(user: currentUser, text: "Yep, can confirm!")
]
)
``````

## #78 Usages of throwing functions

🏈 A big benefit of using throwing functions for synchronous Swift APIs is that the caller can decide whether they want to treat the return value as optional (`try?`) or required (`try`).

``````func loadFile(named name: String) throws -> File {
guard let url = urlForFile(named: name) else {
throw File.Error.missing
}

do {
let data = try Data(contentsOf: url)
return File(url: url, data: data)
} catch {
throw File.Error.invalidData(error)
}
}

let requiredFile = try loadFile(named: "AppConfig.json")

let optionalFile = try? loadFile(named: "UserSettings.json")
``````

## #77 Nested generic types

🐝 Types that are nested in generics automatically inherit their parent's generic types - which is super useful when defining accessory types (for things like states or outcomes).

``````struct Task<Input, Output> {
typealias Closure = (Input) throws -> Output

let closure: Closure
}

enum Result {
case success(Output)
case failure(Error)
}
}
``````

## #76 Equatable & Hashable structures

🤖 Now that the Swift compiler automatically synthesizes Equatable & Hashable conformances for value types, it's easier than ever to setup model structures with nested types that are all `Equatable`/`Hashable`!

``````typealias Value = Hashable & Codable

struct User: Value {
var name: String
var age: Int
var settings: Settings
}

extension User {
struct Settings: Value {
var itemsPerPage: Int
var theme: Theme
}
}

extension User.Settings {
enum Theme: String, Value {
case light
case dark
}
}
``````

## #75 Conditional conformances

🎉 Swift 4.1 is here! One of the key features it brings is conditional conformances, which lets you have a type only conform to a protocol under certain constraints.

``````protocol UnboxTransformable {
associatedtype RawValue

static func transform(_ value: RawValue) throws -> Self?
}

extension Array: UnboxTransformable where Element: UnboxTransformable {
typealias RawValue = [Element.RawValue]

static func transform(_ value: RawValue) throws -> [Element]? {
return try value.compactMap(Element.transform)
}
}
``````

I also have an article with lots of more info on conditional conformances here. Paul Hudson also has a great overview of all Swift 4.1 features here.

## #74 Generic type aliases

🕵️‍♀️ A cool thing about Swift type aliases is that they can be generic! Combine that with tuples and you can easily define simple generic types.

``````typealias Pair<T> = (T, T)

extension Game {
func calculateScore(for players: Pair<Player>) -> Int {
...
}
}
``````

## #73 Parsing command line arguments using UserDefaults

☑️ A really cool "hidden" feature of UserDefaults is that it contains any arguments that were passed to the app at launch!

Super useful both in Swift command line tools & scripts, but also to temporarily override a value when debugging iOS apps.

``````let defaults = UserDefaults.standard
let query = defaults.string(forKey: "query")
let resultCount = defaults.integer(forKey: "results")
``````

## #72 Using the & operator

👏 Swift's `&` operator is awesome! Not only can you use it to compose protocols, you can compose other types too! Very useful if you want to hide concrete types & implementation details.

``````protocol LoadableFromURL {
}

...
}
}

class ViewControllerFactory {
func makeContentViewController() -> UIViewController & LoadableFromURL {
return ContentViewController()
}
}
``````

## #71 Capturing multiple values in mocks

🤗 When capturing values in mocks, using an array (instead of just a single value) makes it easy to verify that only a certain number of values were passed.

Perfect for protecting against "over-calling" something.

``````class UserManagerTests: XCTestCase {
func testObserversCalledWhenUserFirstLogsIn() {
let manager = UserManager()

let observer = ObserverMock()

// First login, observers should be notified
let user = User(id: 123, name: "John")
XCTAssertEqual(observer.users, [user])

// If the same user logs in again, observers shouldn't be notified
XCTAssertEqual(observer.users, [user])
}
}

private extension UserManagerTests {
class ObserverMock: UserManagerObserver {
private(set) var users = [User]()

func userDidChange(to user: User) {
users.append(user)
}
}
}
``````

## #70 Reducing the need for mocks

👋 When writing tests, you don't always need to create mocks - you can create stubs using real instances of things like errors, URLs & UserDefaults.

Here's how to do that for some common tasks/object types in Swift:

``````// Create errors using NSError (#function can be used to reference the name of the test)
let error = NSError(domain: #function, code: 1, userInfo: nil)

// Create non-optional URLs using file paths
let url = URL(fileURLWithPath: "Some/URL")

// Reference the test bundle using Bundle(for:)
let bundle = Bundle(for: type(of: self))

// Create an explicit UserDefaults object (instead of having to use a mock)
let userDefaults = UserDefaults(suiteName: #function)

// Create queues to control/await concurrent operations
let queue = DispatchQueue(label: #function)
``````

For when you actually do need mocking, check out "Mocking in Swift".

## #69 Using "then" as an external parameter label for closures

⏱ I've started using "then" as an external parameter label for completion handlers. Makes the call site read really nicely (Because I do ❤️ conversational API design) regardless of whether trailing closure syntax is used or not.

``````protocol DataLoader {
// Adding type aliases to protocols can be a great way to
// reduce verbosity for parameter types.
typealias Handler = (Result<Data>) -> Void
associatedtype Endpoint

func loadData(from endpoint: Endpoint, then handler: @escaping Handler)
}

...
}

...
})
``````

## #68 Combining lazily evaluated sequences with the builder pattern

😴 Combining lazily evaluated sequences with builder pattern-like properties can lead to some pretty sweet APIs for configurable sequences in Swift.

Also useful for queries & other things you "build up" and then execute.

``````// Extension adding builder pattern-like properties that return
// a new sequence value with the given configuration applied
extension FileSequence {
var recursive: FileSequence {
var sequence = self
sequence.isRecursive = true
return sequence
}

var includingHidden: FileSequence {
var sequence = self
sequence.includeHidden = true
return sequence
}
}

// BEFORE

let files = folder.makeFileSequence(recursive: true, includeHidden: true)

// AFTER

let files = folder.files.recursive.includingHidden
``````

Want an intro to lazy sequences? Check out "Swift sequences: The art of being lazy".

## #67 Faster & more stable UI tests

My top 3 tips for faster & more stable UI tests:

📱 Reset the app's state at the beginning of every test.

🆔 Use accessibility identifiers instead of UI strings.

⏱ Use expectations instead of waiting time.

``````func testOpeningArticle() {
// Launch the app with an argument that tells it to reset its state
let app = XCUIApplication()
app.launchArguments.append("--uitesting")
app.launch()

// Check that the app is displaying an activity indicator
let activityIndicator = app.activityIndicator.element
XCTAssertTrue(activityIndicator.exists)

expectation(for: NSPredicate(format: "exists == 0"),
evaluatedWith: activityIndicator)

// Use a generous timeout in case the network is slow
waitForExpectations(timeout: 10)

// Tap the cell for the first article
app.tables.cells["Article.0"].tap()

// Assert that a label with the accessibility identifier "Article.Title" exists
let label = app.staticTexts["Article.Title"]
XCTAssertTrue(label.exists)
}
``````

## #66 Accessing the clipboard from a Swift script

📋 It's super easy to access the contents of the clipboard from a Swift script. A big benefit of Swift scripting is being able to use Cocoa's powerful APIs for Mac apps.

``````import Cocoa

let clipboard = NSPasteboard.general.string(forType: .string)
``````

## #65 Using tuples for view state

🎯 Using Swift tuples for view state can be a super nice way to group multiple properties together and render them reactively using the layout system.

By using a tuple we don't have to either introduce a new type or make our view model-aware.

``````class TextView: UIView {
var state: (title: String?, text: String?) {
// By telling UIKit that our view needs layout and binding our
// state in layoutSubviews, we can react to state changes without
// doing unnecessary layout work.
didSet { setNeedsLayout() }
}

private let titleLabel = UILabel()
private let textLabel = UILabel()

override func layoutSubviews() {
super.layoutSubviews()

titleLabel.text = state.title
textLabel.text = state.text

...
}
}
``````

## #64 Throwing tests and LocalizedError

⚾️ Swift tests can throw, which is super useful in order to avoid complicated logic or force unwrapping. By making errors conform to `LocalizedError`, you can also get a nice error message in Xcode if there's a failure.

``````class ImageCacheTests: XCTestCase {
let bundle = Bundle(for: type(of: self))
let cache = ImageCache(bundle: bundle)

// bundle using this UIImage initializer
let image = try require(UIImage(named: "sample", in: bundle, compatibleWith: nil))
try cache.cache(image, forKey: "key")

let cachedImage = try cache.image(forKey: "key")
XCTAssertEqual(image, cachedImage)
}
}

enum ImageCacheError {
case emptyKey
case dataConversionFailed
}

// When using throwing tests, making your errors conform to
// LocalizedError will render a much nicer error message in
// Xcode (per default only the error code is shown).
extension ImageCacheError: LocalizedError {
var errorDescription: String? {
switch self {
case .emptyKey:
return "An empty key was given"
case .dataConversionFailed:
return "Failed to convert the given image to Data"
}
}
}
``````

For more information, and the implementation of the `require` method used above, check out "Avoiding force unwrapping in Swift unit tests".

## #63 The difference between static and class properties

✍️ Unlike `static` properties, `class` properties can be overridden by subclasses (however, they can't be stored, only computed).

``````class TableViewCell: UITableViewCell {
class var preferredHeight: CGFloat { return 60 }
}

class TallTableViewCell: TableViewCell {
override class var preferredHeight: CGFloat { return 100 }
}
``````

## #62 Creating extensions with static factory methods

👨‍🎨 Creating extensions with static factory methods can be a great alternative to subclassing in Swift, especially for things like setting up UIViews, CALayers or other kinds of styling.

It also lets you remove a lot of styling & setup from your view controllers.

``````extension UILabel {
static func makeForTitle() -> UILabel {
let label = UILabel()
label.font = .boldSystemFont(ofSize: 24)
label.textColor = .darkGray
label.minimumScaleFactor = 0.75
return label
}

static func makeForText() -> UILabel {
let label = UILabel()
label.font = .systemFont(ofSize: 16)
label.textColor = .black
label.numberOfLines = 0
return label
}
}

class ArticleViewController: UIViewController {
lazy var titleLabel = UILabel.makeForTitle()
lazy var textLabel = UILabel.makeForText()
}
``````

## #61 Child view controller auto-resizing

🧒 An awesome thing about child view controllers is that they're automatically resized to match their parent, making them a super nice solution for things like loading & error views.

``````class ListViewController: UIViewController {

self?.handle(result)
}
}
}
``````

For more about child view controller (including the `add` and `remove` methods used above), check out "Using child view controllers as plugins in Swift".

## #60 Using zip

🤐 Using the zip function in Swift you can easily combine two sequences. Super useful when using two sequences to do some work, since zip takes care of all the bounds-checking.

``````func render(titles: [String]) {
for (label, text) in zip(titleLabels, titles) {
print(text)
label.text = text
}
}
``````

## #59 Defining custom option sets

🎛 The awesome thing about option sets in Swift is that they can automatically either be passed as a single member or as a set. Even cooler is that you can easily define your own option sets as well, perfect for options and other non-exclusive values.

``````// Option sets are awesome, because you can easily pass them
// both using dot syntax and array literal syntax, like when
// using the UIView animation API:
UIView.animate(withDuration: 0.3,
delay: 0,
options: .allowUserInteraction,
animations: animations)

UIView.animate(withDuration: 0.3,
delay: 0,
options: [.allowUserInteraction, .layoutSubviews],
animations: animations)

// The cool thing is that you can easily define your own option
// sets as well, by defining a struct that has an Int rawValue,
// that will be used as a bit mask.
extension Cache {
struct Options: OptionSet {
static let saveToDisk = Options(rawValue: 1)
static let clearOnMemoryWarning = Options(rawValue: 1 << 1)
static let clearDaily = Options(rawValue: 1 << 2)

let rawValue: Int
}
}

// We can now use Cache.Options just like UIViewAnimationOptions:
Cache(options: .saveToDisk)
Cache(options: [.saveToDisk, .clearDaily])
``````

## #58 Using the where clause with associated types

🙌 Using the `where` clause when designing protocol-oriented APIs in Swift can let your implementations (or others' if it's open source) have a lot more freedom, especially when it comes to collections.

``````public protocol PathFinderMap {
associatedtype Node
// Using the 'where' clause for associated types, we can
// ensure that a type meets certain requirements (in this
// case that it's a sequence with Node elements).
associatedtype NodeSequence: Sequence where NodeSequence.Element == Node

// Instead of using a concrete type (like [Node]) here, we
// give implementors of this protocol more freedom while
// still meeting our requirements. For example, one
// implementation might use Set<Node>.
func neighbors(of node: Node) -> NodeSequence
}
``````

## #57 Using first class functions when iterating over a dictionary

👨‍🍳 Combine first class functions in Swift with the fact that Dictionary elements are (Key, Value) tuples and you can build yourself some pretty awesome functional chains when iterating over a Dictionary.

``````func makeActor(at coordinate: Coordinate, for building: Building) -> Actor {
let actor = Actor()
actor.position = coordinate.point
actor.animation = building.animation
return actor
}

func render(_ buildings: [Coordinate : Building]) {
}
``````

## #56 Calling instance methods as static functions

😎 In Swift, you can call any instance method as a static function and it will return a closure representing that method. This is how running tests using SPM on Linux works.

``````// This produces a '() -> Void' closure which is a reference to the
// given view's 'removeFromSuperview' method.
let closure = UIView.removeFromSuperview(view)

// We can now call it just like we would any other closure, and it
// will run 'view.removeFromSuperview()'
closure()

// This is how running tests using the Swift Package Manager on Linux
// works, you return your test functions as closures:
extension UserManagerTests {
static var allTests = [
("testLoggingIn", testLoggingIn),
("testLoggingOut", testLoggingOut),
("testUserPermissions", testUserPermissions)
]
}
``````

## #55 Dropping suffixes from method names to support multiple arguments

👏 One really nice benefit of dropping suffixes from method names (and just using verbs, when possible) is that it becomes super easy to support both single and multiple arguments, and it works really well semantically.

``````extension UIView {
}
}

// By dropping the "Subview" suffix from the method name, both
// single and multiple arguments work really well semantically.
``````

## #54 Constraining protocols to classes to ensure mutability

👽 Using the `AnyObject` (or `class`) constraint on protocols is not only useful when defining delegates (or other weak references), but also when you always want instances to be mutable without copying.

``````// By constraining a protocol with 'AnyObject' it can only be adopted
// by classes, which means all instances will always be mutable, and
// that it's the original instance (not a copy) that will be mutated.
protocol DataContainer: AnyObject {
var data: Data? { get set }
}

class UserSettingsManager {
private var settings: Settings
private let dataContainer: DataContainer

// Since DataContainer is a protocol, we an easily mock it in
// tests if we use dependency injection
init(settings: Settings, dataContainer: DataContainer) {
self.settings = settings
self.dataContainer = dataContainer
}

func saveSettings() throws {
let data = try settings.serialize()

// We can now assign properties on an instance of our protocol
// because the compiler knows it's always going to be a class
dataContainer.data = data
}
}
``````

## #53 String-based enums in string interpolation

🍣 Even if you define a custom raw value for a string-based enum in Swift, the full case name will be used in string interpolation.

Super useful when using separate raw values for JSON, while still wanting to use the full case name in other contexts.

``````extension Building {
// This enum has custom raw values that are used when decoding
// a value, for example from JSON.
enum Kind: String {
case castle = "C"
case town = "T"
case barracks = "B"
case goldMine = "G"
case camp = "CA"
case blacksmith = "BL"
}

var animation: Animation {
return Animation(
// When used in string interpolation, the full case name is still used.
// For 'castle' this will be 'buildings/castle'.
name: "buildings/\(kind)",
frameCount: frameCount,
frameDuration: frameDuration
)
}
}
``````

## #52 Expressively comparing a value with a list of candidates

👨‍🔬 Continuing to experiment with expressive ways of comparing a value with a list of candidates in Swift. Adding an extension on Equatable is probably my favorite approach so far.

``````extension Equatable {
func isAny(of candidates: Self...) -> Bool {
return candidates.contains(self)
}
}

let isHorizontal = direction.isAny(of: .left, .right)
``````

See tip #35 for my previous experiment.

## #51 UIView bounds and transforms

📐 A really interesting side-effect of a `UIView`'s `bounds` being its rect within its own coordinate system is that transforms don't affect it at all. That's why it's usually a better fit than `frame` when doing layout calculations of subviews.

``````let view = UIView()
view.frame.size = CGSize(width: 100, height: 100)
view.transform = CGAffineTransform(scaleX: 2, y: 2)

print(view.frame) // (-50.0, -50.0, 200.0, 200.0)
print(view.bounds) // (0.0, 0.0, 100.0, 100.0)
``````

## #50 UIKit default arguments

👏 It's awesome that many UIKit APIs with completion handlers and other optional parameters import into Swift with default arguments (even though they are written in Objective-C). Getting rid of all those nil arguments is so nice!

``````// BEFORE: All parameters are specified, just like in Objective-C

viewController.present(modalViewController, animated: true, completion: nil)

modalViewController.dismiss(animated: true, completion: nil)

to: contentViewController,
duration: 0.3,
options: [],
animations: animations,
completion: nil)

// AFTER: Since many UIKit APIs with completion handlers and other
// optional parameters import into Swift with default arguments,
// we can make our calls shorter

viewController.present(modalViewController, animated: true)

modalViewController.dismiss(animated: true)

to: contentViewController,
duration: 0.3,
animations: animations)
``````

## #49 Avoiding Massive View Controllers

✂️ Avoiding Massive View Controllers is all about finding the right levels of abstraction and splitting things up.

My personal rule of thumb is that as soon as I have 3 methods or properties that have the same prefix, I break them out into their own type.

``````// BEFORE

private lazy var signUpLabel = UILabel()
private lazy var signUpImageView = UIImageView()
private lazy var signUpButton = UIButton()
}

// AFTER

private lazy var signUpView = SignUpView()
}

class SignUpView: UIView {
private lazy var label = UILabel()
private lazy var imageView = UIImageView()
private lazy var button = UIButton()
}
``````

## #48 Extending optionals

❤️ I love the fact that optionals are enums in Swift - it makes it so easy to extend them with convenience APIs for certain types. Especially useful when doing things like data validation on optional values.

``````func validateTextFields() -> Bool {
return false
}

...

return true
}

// Since all optionals are actual enum values in Swift, we can easily
// extend them for certain types, to add our own convenience APIs

extension Optional where Wrapped == String {
var isNilOrEmpty: Bool {
switch self {
case let string?:
return string.isEmpty
case nil:
return true
}
}
}

// Since strings are now Collections in Swift 4, you can even
// add this property to all optional collections:

extension Optional where Wrapped: Collection {
var isNilOrEmpty: Bool {
switch self {
case let collection?:
return collection.isEmpty
case nil:
return true
}
}
}
``````

## #47 Using where with for-loops

🗺 Using the `where` keyword can be a super nice way to quickly apply a filter in a `for`-loop in Swift. You can of course use `map`, `filter` and `forEach`, or `guard`, but for simple loops I think this is very expressive and nice.

``````func archiveMarkedPosts() {
for post in posts where post.isMarked {
archive(post)
}
}

func healAllies() {
for player in players where player.isAllied(to: currentPlayer) {
player.heal()
}
}
``````

👻 Variable shadowing can be super useful in Swift, especially when you want to create a local copy of a parameter value in order to use it as state within a closure.

``````init(repeatMode: RepeatMode, closure: @escaping () -> UpdateOutcome) {
// Shadow the argument with a local, mutable copy
var repeatMode = repeatMode

self.closure = {
// With shadowing, there's no risk of accidentially
// referring to the immutable version
switch repeatMode {
case .forever:
break
case .times(let count):
guard count > 0 else {
return .finished
}

// We can now capture the mutable version and use
// it for state in a closure
repeatMode = .times(count - 1)
}

return closure()
}
}
``````

## #45 Using dot syntax for static properties and initializers

✒️ Dot syntax is one of my favorite features of Swift. What's really cool is that it's not only for enums, any static method or property can be used with dot syntax - even initializers! Perfect for convenience APIs and default parameters.

``````public enum RepeatMode {
case times(Int)
case forever
}

public extension RepeatMode {
static var never: RepeatMode {
return .times(0)
}

static var once: RepeatMode {
return .times(1)
}
}

view.perform(animation, repeated: .once)

// To make default parameters more compact, you can even use init with dot syntax

init(cache: Cache = .init(), decoder: ImageDecoder = .init()) {
...
}
}
``````

## #44 Calling functions as closures with a tuple as parameters

🚀 One really cool aspect of Swift having first class functions is that you can pass any function (or even initializer) as a closure, and even call it with a tuple containing its parameters!

``````// This function lets us treat any "normal" function or method as
// a closure and run it with a tuple that contains its parameters
func call<Input, Output>(_ function: (Input) -> Output, with input: Input) -> Output {
return function(input)
}

class ViewFactory {
// We can now pass an initializer as a closure, and a tuple
// containing its parameters
}

private func loadTextStyles() -> (font: UIFont, color: UIColor) {
return (theme.font, theme.textColor)
}
}

init(font: UIFont, textColor: UIColor) {
...
}
}
``````

## #43 Enabling static dependency injection

💉 If you've been struggling to test code that uses static APIs, here's a technique you can use to enable static dependency injection without having to modify any call sites:

``````// Before: Almost impossible to test due to the use of singletons

class Analytics {
static func log(_ event: Event) {
Database.shared.save(event)

let dictionary = event.serialize()
NetworkManager.shared.post(dictionary, to: eventURL)
}
}

// After: Much easier to test, since we can inject mocks as arguments

class Analytics {
static func log(_ event: Event,
database: Database = .shared,
networkManager: NetworkManager = .shared) {
database.save(event)

let dictionary = event.serialize()
networkManager.post(dictionary, to: eventURL)
}
}
``````

## #42 Type inference for lazy properties in Swift 4

🎉 In Swift 4, type inference works for lazy properties and you don't need to explicitly refer to `self`!

``````// Swift 3

class PurchaseView: UIView {

private func makeBuyButton() -> UIButton {
let button = UIButton()
button.setTitleColor(.blue, for: .normal)
return button
}
}

// Swift 4

class PurchaseView: UIView {

private func makeBuyButton() -> UIButton {
let button = UIButton()
button.setTitleColor(.blue, for: .normal)
return button
}
}
``````

## #41 Converting Swift errors to NSError

😎 You can turn any Swift `Error` into an `NSError`, which is super useful when pattern matching with a code 👍. Also, switching on optionals is pretty cool!

``````let task = urlSession.dataTask(with: url) { data, _, error in
switch error {
case .some(let error as NSError) where error.code == NSURLErrorNotConnectedToInternet:
presenter.showOfflineView()
case .some(let error):
presenter.showGenericErrorView()
case .none:
presenter.renderContent(from: data)
}
}

``````

Also make sure to check out Kostas Kremizas' tip about how you can pattern match directly against a member of `URLError`.

## #40 Making UIImage macOS compatible

🖥 Here's an easy way to make iOS model code that uses `UIImage` macOS compatible - like me and Gui Rambo discussed on the Swift by Sundell Podcast.

``````// Either put this in a separate file that you only include in your macOS target or wrap the code in #if os(macOS) / #endif

import Cocoa

// Step 1: Typealias UIImage to NSImage
typealias UIImage = NSImage

// Step 2: You might want to add these APIs that UIImage has but NSImage doesn't.
extension NSImage {
var cgImage: CGImage? {
var proposedRect = CGRect(origin: .zero, size: size)

return cgImage(forProposedRect: &proposedRect,
context: nil,
hints: nil)
}

convenience init?(named name: String) {
self.init(named: Name(name))
}
}

// Step 3: Profit - you can now make your model code that uses UIImage cross-platform!
struct User {
let name: String
let profileImage: UIImage
}
``````

## #39 Internally mutable protocol-oriented APIs

🤖 You can easily define a protocol-oriented API that can only be mutated internally, by using an internal protocol that extends a public one.

``````// Declare a public protocol that acts as your immutable API
public protocol ModelHolder {
associatedtype Model
var model: Model { get }
}

// Declare an extended, internal protocol that provides a mutable API
internal protocol MutableModelHolder: ModelHolder {
var model: Model { get set }
}

// You can now implement the requirements using 'public internal(set)'
public class UserHolder: MutableModelHolder {
public internal(set) var model: User

internal init(model: User) {
self.model = model
}
}
``````

## #38 Switching on a set

🎛 You can switch on a set using array literals as cases in Swift! Can be really useful to avoid many `if`/`else if` statements.

``````class RoadTile: Tile {
var connectedDirections = Set<Direction>()

func render() {
switch connectedDirections {
case [.up, .down]:
case [.left, .right]:
default:
}
}
}
``````

## #37 Adding the current locale to cache keys

🌍 When caching localized content in an app, it's a good idea to add the current locale to all keys, to prevent bugs when switching languages.

``````func cache(_ content: Content, forKey key: String) throws {
let data = try wrap(content) as Data
let key = localize(key: key)
try storage.store(data, forKey: key)
}

func loadCachedContent(forKey key: String) -> Content? {
let key = localize(key: key)
return data.flatMap { try? unbox(data: \$0) }
}

private func localize(key: String) -> String {
return key + "-" + Bundle.main.preferredLocalizations[0]
}
``````

## #36 Setting up tests to avoid retain cycles with weak references

🚳 Here's an easy way to setup a test to avoid accidental retain cycles with object relationships (like weak delegates & observers) in Swift:

``````func testDelegateNotRetained() {
// Assign the delegate (weak) and also retain it using a local var
var delegate: Delegate? = DelegateMock()
controller.delegate = delegate
XCTAssertNotNil(controller.delegate)

// Release the local var, which should also release the weak reference
delegate = nil
XCTAssertNil(controller.delegate)
}
``````

## #35 Expressively matching a value against a list of candidates

👨‍🔬 Playing around with an expressive way to check if a value matches any of a list of candidates in Swift:

``````// Instead of multiple conditions like this:

if string == "One" || string == "Two" || string == "Three" {

}

// You can now do:

if string == any(of: "One", "Two", "Three") {

}
``````

You can find a gist with the implementation here.

## #34 Organizing code using extensions

👪 APIs in a Swift extension automatically inherit its access control level, making it a neat way to organize public, internal & private APIs.

``````public extension Animation {
init(textureNamed textureName: String) {
frames = [Texture(name: textureName)]
}

init(texturesNamed textureNames: [String], frameDuration: TimeInterval = 1) {
frames = textureNames.map(Texture.init)
self.frameDuration = frameDuration
}

init(image: Image) {
frames = [Texture(image: image)]
}
}

internal extension Animation {
}
}
``````

## #33 Using map to transform an optional into a Result type

🗺 Using `map` you can transform an optional value into an optional `Result` type by simply passing in the enum case.

``````enum Result<Value> {
case value(Value)
case error(Error)
}

class Promise<Value> {
private var result: Result<Value>?

init(value: Value? = nil) {
result = value.map(Result.value)
}
}
``````

## #32 Assigning to self in struct initializers

👌 It's so nice that you can assign directly to `self` in `struct` initializers in Swift. Very useful when adding conformance to protocols.

``````extension Bool: AnswerConvertible {
public init(input: String) throws {
switch input.lowercased() {
case "y", "yes", "👍":
self = true
default:
self = false
}
}
}
``````

## #31 Recursively calling closures as inline functions

☎️ Defining Swift closures as inline functions enables you to recursively call them, which is super useful in things like custom sequences.

``````class Database {
func records(matching query: Query) -> AnySequence<Record> {

func iterate() -> Record? {
guard let nextRecord = recordIterator.next() else {
return nil
}

guard nextRecord.matches(query) else {
// Since the closure is an inline function, it can be recursively called,
// in this case in order to advance to the next item.
return iterate()
}

return nextRecord
}

// AnySequence/AnyIterator are part of the standard library and provide an easy way
// to define custom sequences using closures.
return AnySequence { AnyIterator(iterate) }
}
}
``````

Rob Napier points out that using the above might cause crashes if used on a large databaset, since Swift has no guaranteed Tail Call Optimization (TCO).

Slava Pestov also points out that another benefit of inline functions vs closures is that they can have their own generic parameter list.

## #30 Passing self to required Objective-C dependencies

🏖 Using lazy properties in Swift, you can pass `self` to required Objective-C dependencies without having to use force-unwrapped optionals.

``````class DataLoader: NSObject {
lazy var urlSession: URLSession = self.makeURLSession()

private func makeURLSession() -> URLSession {
return URLSession(configuration: .default, delegate: self, delegateQueue: .main)
}
}

class Renderer {

}
}
``````

## #29 Making weak or lazy properties readonly

👓 If you have a property in Swift that needs to be `weak` or `lazy`, you can still make it readonly by using `private(set)`.

``````class Node {
private(set) weak var parent: Node?
private(set) lazy var children = [Node]()

children.append(child)
child.parent = self
}
}
``````

## #28 Defining static URLs using string literals

🌏 Tired of using `URL(string: "url")!` for static URLs? Make `URL` conform to `ExpressibleByStringLiteral` and you can now simply use `"url"` instead.

``````extension URL: ExpressibleByStringLiteral {
// By using 'StaticString' we disable string interpolation, for safety
public init(stringLiteral value: StaticString) {
self = URL(string: "\(value)").require(hint: "Invalid URL string literal: \(value)")
}
}

// We can now define URLs using static string literals 🎉
let url: URL = "https://www.swiftbysundell.com"

// In Swift 3 or earlier, you also have to implement 2 additional initializers
extension URL {
public init(extendedGraphemeClusterLiteral value: StaticString) {
self.init(stringLiteral: value)
}

public init(unicodeScalarLiteral value: StaticString) {
self.init(stringLiteral: value)
}
}
``````

To find the extension that adds the `require()` method on `Optional` that I use above, check out Require.

## #27 Manipulating points, sizes and frames using math operators

✚ I'm always careful with operator overloading, but for manipulating things like sizes, points & frames I find them super useful.

``````extension CGSize {
static func *(lhs: CGSize, rhs: CGFloat) -> CGSize {
return CGSize(width: lhs.width * rhs, height: lhs.height * rhs)
}
}

button.frame.size = image.size * 2
``````

If you like the above idea, check out CGOperators, which contains math operator overloads for all Core Graphics' vector types.

## #26 Using closure types in generic constraints

🔗 You can use closure types in generic constraints in Swift. Enables nice APIs for handling sequences of closures.

``````extension Sequence where Element == () -> Void {
func callAll() {
forEach { \$0() }
}
}

extension Sequence where Element == () -> String {
func joinedResults(separator: String) -> String {
return map { \$0() }.joined(separator: separator)
}
}

callbacks.callAll()
let names = nameProviders.joinedResults(separator: ", ")
``````

(If you're using Swift 3, you have to change `Element` to `Iterator.Element`)

## #25 Using associated enum values to avoid state-specific optionals

🎉 Using associated enum values is a super nice way to encapsulate mutually exclusive state info (and avoiding state-specific optionals).

``````// BEFORE: Lots of state-specific, optional properties

class Player {
var isWaitingForMatchMaking: Bool
var invitingUser: User?
var numberOfLives: Int
var playerDefeatedBy: Player?
var roundDefeatedIn: Int?
}

// AFTER: All state-specific information is encapsulated in enum cases

class Player {
enum State {
case waitingForMatchMaking
case waitingForInviteResponse(from: User)
case active(numberOfLives: Int)
case defeated(by: Player, roundNumber: Int)
}

var state: State
}
``````

## #24 Using enums for async result types

👍 I really like using enums for all async result types, even boolean ones. Self-documenting, and makes the call site a lot nicer to read too!

``````protocol PushNotificationService {
// Before
func enablePushNotifications(completionHandler: @escaping (Bool) -> Void)

// After
}

case enabled
case disabled
}

if status == .enabled {
}
}
``````

## #23 Working on async code in a playground

🏃 Want to work on your async code in a Swift Playground? Just set `needsIndefiniteExecution` to true to keep it running:

``````import PlaygroundSupport

PlaygroundPage.current.needsIndefiniteExecution = true

let greeting = "Hello after 3 seconds"
print(greeting)
}
``````

To stop the playground from executing, simply call `PlaygroundPage.current.finishExecution()`.

## #22 Overriding self with a weak reference

💦 Avoid memory leaks when accidentially refering to `self` in closures by overriding it locally with a weak reference:

Swift >= 4.2

``````dataLoader.loadData(from: url) { [weak self] result in
guard let self = self else {
return
}

self.cache(result)

...
``````

Swift < 4.2

``````dataLoader.loadData(from: url) { [weak self] result in
guard let `self` = self else {
return
}

self.cache(result)

...
``````

Note that the reason the above currently works is because of a compiler bug (which I hope gets turned into a properly supported feature soon).

## #21 Using DispatchWorkItem

🕓 Using dispatch work items you can easily cancel a delayed asynchronous GCD task if you no longer need it:

``````let workItem = DispatchWorkItem {
// Your async code goes in here
}

// Execute the work item after 1 second
DispatchQueue.main.asyncAfter(deadline: .now() + 1, execute: workItem)

// You can cancel the work item if you no longer need it
workItem.cancel()
``````

## #20 Combining a sequence of functions

➕ While working on a new Swift developer tool (to be open sourced soon 😉), I came up with a pretty neat way of organizing its sequence of operations, by combining their functions into a closure:

``````internal func +<A, B, C>(lhs: @escaping (A) throws -> B,
rhs: @escaping (B) throws -> C) -> (A) throws -> C {
return { try rhs(lhs(\$0)) }
}

public func run() throws {
try (determineTarget + build + analyze + output)()
}
``````

If you're familiar with the functional programming world, you might know the above technique as the pipe operator (thanks to Alexey Demedreckiy for pointing this out!)

## #19 Chaining optionals with map() and flatMap()

🗺 Using `map()` and `flatMap()` on optionals you can chain multiple operations without having to use lengthy `if lets` or `guards`:

``````// BEFORE

guard let string = argument(at: 1) else {
return
}

guard let url = URL(string: string) else {
return
}

handle(url)

// AFTER

argument(at: 1).flatMap(URL.init).map(handle)
``````

## #18 Using self-executing closures for lazy properties

🚀 Using self-executing closures is a great way to encapsulate lazy property initialization:

``````class StoreViewController: UIViewController {
private lazy var collectionView: UICollectionView = {
let layout = UICollectionViewFlowLayout()
let view = UICollectionView(frame: self.view.bounds, collectionViewLayout: layout)
view.delegate = self
view.dataSource = self
return view
}()

}
}
``````

## #17 Speeding up Swift package tests

⚡️ You can speed up your Swift package tests using the `--parallel` flag. For Marathon, the tests execute 3 times faster that way!

``````swift test --parallel
``````

## #16 Avoiding mocking UserDefaults

🛠 Struggling with mocking `UserDefaults` in a test? The good news is: you don't need mocking - just create a real instance:

``````class LoginTests: XCTestCase {
private var userDefaults: UserDefaults!

override func setUp() {
super.setup()

userDefaults = UserDefaults(suiteName: #file)
userDefaults.removePersistentDomain(forName: #file)

}
}
``````

👍 Using variadic parameters in Swift, you can create some really nice APIs that take a list of objects without having to use an array:

``````extension Canvas {
}
}

let circle = Circle(center: CGPoint(x: 5, y: 5), radius: 5)
let lineA = Line(start: .zero, end: CGPoint(x: 10, y: 10))
let lineB = Line(start: CGPoint(x: 0, y: 10), end: CGPoint(x: 10, y: 0))

let canvas = Canvas()
canvas.render()
``````

## #14 Referring to enum cases with associated values as closures

😮 Just like you can refer to a Swift function as a closure, you can do the same thing with enum cases with associated values:

``````enum UnboxPath {
case key(String)
case keyPath(String)
}

struct UserSchema {
static let name = key("name")
static let age = key("age")
static let posts = key("posts")

private static let key = UnboxPath.key
}
``````

## #13 Using the === operator to compare objects by instance

📈 The `===` operator lets you check if two objects are the same instance. Very useful when verifying that an array contains an instance in a test:

``````protocol InstanceEquatable: class, Equatable {}

extension InstanceEquatable {
static func ==(lhs: Self, rhs: Self) -> Bool {
return lhs === rhs
}
}

extension Enemy: InstanceEquatable {}

func testDestroyingEnemy() {
player.attack(enemy)
XCTAssertTrue(player.destroyedEnemies.contains(enemy))
}
``````

## #12 Calling initializers with dot syntax and passing them as closures

😎 Cool thing about Swift initializers: you can call them using dot syntax and pass them as closures! Perfect for mocking dates in tests.

``````class Logger {
private let storage: LogStorage
private let dateProvider: () -> Date

init(storage: LogStorage = .init(), dateProvider: @escaping () -> Date = Date.init) {
self.storage = storage
self.dateProvider = dateProvider
}

func log(event: Event) {
storage.store(event: event, date: dateProvider())
}
}
``````

## #11 Structuring UI tests as extensions on XCUIApplication

📱 Most of my UI testing logic is now categories on `XCUIApplication`. Makes the test cases really easy to read:

``````func testLoggingInAndOut() {
XCTAssertFalse(app.userIsLoggedIn)

app.launch()
XCTAssertTrue(app.userIsLoggedIn)

app.logout()
XCTAssertFalse(app.userIsLoggedIn)
}

func testDisplayingCategories() {
XCTAssertFalse(app.isDisplayingCategories)

app.launch()
app.goToCategories()
XCTAssertTrue(app.isDisplayingCategories)
}
``````

## #10 Avoiding default cases in switch statements

🙂 It’s a good idea to avoid “default” cases when switching on Swift enums - it’ll “force you” to update your logic when a new case is added:

``````enum State {
case loggedIn
case loggedOut
case onboarding
}

func handle(_ state: State) {
switch state {
case .loggedIn:
showMainUI()
case .loggedOut:
// Compiler error: Switch must be exhaustive
}
}
``````

## #9 Using the guard statement in many different scopes

💂 It's really cool that you can use Swift's 'guard' statement to exit out of pretty much any scope, not only return from functions:

``````// You can use the 'guard' statement to...

for string in strings {
// ...continue an iteration
guard shouldProcess(string) else {
continue
}

// ...or break it
guard !shouldBreak(for: string) else {
break
}

// ...or return
guard !shouldReturn(for: string) else {
return
}

// ..or throw an error
guard string.isValid else {
throw StringError.invalid(string)
}

// ...or exit the program
guard !shouldExit(for: string) else {
exit(1)
}
}
``````

## #8 Passing functions & operators as closures

❤️ Love how you can pass functions & operators as closures in Swift. For example, it makes the syntax for sorting arrays really nice!

``````let array = [3, 9, 1, 4, 6, 2]
let sorted = array.sorted(by: <)
``````

## #7 Using #function for UserDefaults key consistency

🗝 Here's a neat little trick I use to get UserDefault key consistency in Swift (#function expands to the property name in getters/setters). Just remember to write a good suite of tests that'll guard you against bugs when changing property names.

``````extension UserDefaults {
var onboardingCompleted: Bool {
get { return bool(forKey: #function) }
set { set(newValue, forKey: #function) }
}
}
``````

## #6 Using a name already taken by the standard library

📛 Want to use a name already taken by the standard library for a nested type? No problem - just use `Swift.` to disambiguate:

``````extension Command {
enum Error: Swift.Error {
case missing
case invalid(String)
}
}
``````

## #5 Using Wrap to implement Equatable

📦 Playing around with using Wrap to implement `Equatable` for any type, primarily for testing:

``````protocol AutoEquatable: Equatable {}

extension AutoEquatable {
static func ==(lhs: Self, rhs: Self) -> Bool {
let lhsData = try! wrap(lhs) as Data
let rhsData = try! wrap(rhs) as Data
return lhsData == rhsData
}
}
``````

## #4 Using typealiases to reduce the length of method signatures

📏 One thing that I find really useful in Swift is to use typealiases to reduce the length of method signatures in generic types:

``````public class PathFinder<Object: PathFinderObject> {
public typealias Map = Object.Map
public typealias Node = Map.Node
public typealias Path = PathFinderPath<Object>

public static func possiblePaths(for object: Object, at rootNode: Node, on map: Map) -> Path.Sequence {
return .init(object: object, rootNode: rootNode, map: map)
}
}
``````

## #3 Referencing either external or internal parameter name when writing docs

📖 You can reference either the external or internal parameter label when writing Swift docs - and they get parsed the same:

``````// EITHER:

class Foo {
/**
*   - parameter string: A string
*/
func bar(with string: String) {}
}

// OR:

class Foo {
/**
*   - parameter with: A string
*/
func bar(with string: String) {}
}
``````

## #2 Using auto closures

👍 Finding more and more uses for auto closures in Swift. Can enable some pretty nice APIs:

``````extension Dictionary {
mutating func value(for key: Key, orAdd valueClosure: @autoclosure () -> Value) -> Value {
if let value = self[key] {
return value
}

let value = valueClosure()
self[key] = value
return value
}
}
``````

## #1 Namespacing with nested types

🚀 I’ve started to become a really big fan of nested types in Swift. Love the additional namespacing it gives you!

``````public struct Map {
public struct Model {
public let size: Size
public let theme: Theme
public var terrain: [Position : Terrain.Model]
public var units: [Position : Unit.Model]
public var buildings: [Position : Building.Model]
}

public enum Direction {
case up
case right
case down
case left
}

public struct Position {
public var x: Int
public var y: Int
}

public enum Size: String {
case small = "S"
case medium = "M"
case large = "L"
case extraLarge = "XL"
}
}``````