smileyborg

// UICollectionView Objective-C example

- (void)viewWillAppear:(BOOL)animated {
    [super viewWillAppear:animated];
        
    NSIndexPath *selectedIndexPath = [[self.collectionView indexPathsForSelectedItems] firstObject];
    if (selectedIndexPath != nil) {
        id<UIViewControllerTransitionCoordinator> coordinator = self.transitionCoordinator;
        if (coordinator != nil) {
            [coordinator animateAlongsideTransition:^(id<UIViewControllerTransitionCoordinatorContext> context) {

0xced

{
  "People" : [
    "😀",
    "😃",
    "😄",
    "😁",
    "😆",
    "😅",
    "😂",
    "🤣",

andymatuschak

A composable pattern for pure state machines with effects

State machines are everywhere in interactive systems, but they're rarely defined clearly and explicitly. Given some big blob of code including implicit state machines, which transitions are possible and under what conditions? What effects take place on what transitions?

There are existing design patterns for state machines, but all the patterns I've seen complect side effects with the structure of the state machine itself. Instances of these patterns are difficult to test without mocking, and they end up with more dependencies. Worse, the classic patterns compose poorly: hierarchical state machines are typically not straightforward extensions. The functional programming world has solutions, but they don't transpose neatly enough to be broadly usable in mainstream languages.

Here I present a composable pattern for pure state machiness with effects,

bparadie

declare module "react-native" {

  import * as React from 'react';
  import {ComponentClass, ReactType, ReactNode, ReactElement} from 'react';
  
  export * from 'react';
  
  /**
   * Represents the completion of an asynchronous operation
   * @see lib.es6.d.ts

rnapier

// Just showing how to hide the underlying functions if you wanted to.
// Also makes some pieces a little less noisy
public struct DigestFunctions<Context> {
    private var digester: (UnsafePointer<Void>, CC_LONG, UnsafeMutablePointer<UInt8>) -> UnsafeMutablePointer<UInt8>
    private var updater: (UnsafeMutablePointer<Context>, UnsafePointer<Void>, CC_LONG) -> Int32
    private var finalizer: (UnsafeMutablePointer<UInt8>, UnsafeMutablePointer<Context>) -> Int32
}

// Digests are reference types because they are stateful. Copying them may lead to confusing results.
public protocol Digest: class {

steipete

static NSData *PSPDFCalculateSHA256FromFileURL(NSURL *fileURL, CC_LONG dataLength, NSError **error) {
    NSCParameterAssert(fileURL);

    NSData *shaData;

    int fd = open(fileURL.path.UTF8String, O_RDONLY);
    if (fd < 0) {
        if (error) *error = [NSError pspdf_errorWithCode:PSPDFErrorCodeUnableToOpenPDF description:@"Failed to open file for calculating SHA256."];
        return nil;
    }

drewcrawford

This, is actually the wrong conclusion. The entire purpose of the “inner class” is to provide value semantics while maintaining effeciency of implementation.

Is that an opinion? Or was there a meeting when the "entire purpose" of inner classes was established and I wasn't invited? Sure, they can be used for efficiency, but they can also be used for other purposes, including inner mutation.

Just for starters, Mike Ash seems to have uncovered that inner classes are used inside the standard library to provide destructors:

Destruction can be solved by using a class, which provides deinit. The pointer can be destroyed there. class doesn't have value semantics, but we can solve this by using class for the implementation of the struct, and exposing the struct as the external interface to the array.

So to say that the "entire purpose" of inner classes is efficiency is I think plainly false; they are used for many reasons. E

blockerList.json

[
    {
        "action": {
            "type": "block"
        },
        "trigger": {
            "url-filter": ".*",
            "resource-type": ["script"],
            "load-type": ["third-party"],
            "if-domain": ["imore.com"]

rbobbins

Wil Turner, Brook Callhan: Speakers

##3 Main components/concepts that enable UI Testing:##

• UITesting
  • Find and interact w/ UI elements
  • Validate UI properties and state
• UIrecording
  • Updated test reports to include UI testing data
  • UI testing is enabled by XCTest and UI Accesibility

ohanhi

Learning FP the hard way: Experiences on the Elm language

by Ossi Hanhinen, @ohanhi

with the support of Futurice 💚.

Licensed under CC BY 4.0.

Editorial note