shakemno

/// Withable is a simple protocol to make constructing
/// and modifying objects with multiple properties
/// more pleasant (functional, chainable, point-free)
public protocol Withable {
  init()
}

public extension Withable {
  /// Construct a new instance, setting an arbitrary subset of properties
  init(with config: (inout Self) -> Void) {

shakemno

#!/usr/bin/env bash

set -Eeuo pipefail
trap cleanup SIGINT SIGTERM ERR EXIT

script_dir=$(cd "$(dirname "${BASH_SOURCE[0]}")" &>/dev/null && pwd -P)

usage() {
  cat <<EOF
Usage: $(basename "${BASH_SOURCE[0]}") [-h] [-v] [-f] -p param_value arg1 [arg2...]

shakemno

protocol State {}

struct Transition<From: State, To: State> {
    let transition: () -> To
}

struct Machine<CurrentState: State> {
    
    var state: CurrentState
    

shakemno

import Combine
import Foundation

func loadNewsTitles() -> AnyPublisher<[String], Never> {
    ["title1", "title2"]
        .publisher
        .delay(for: .microseconds(500), scheduler: DispatchQueue.main)
        .collect()
        .eraseToAnyPublisher()
}

shakemno

import Foundation
import XCPlayground

/*:
 # Reflux
 */
//: Interfaces
protocol State {
    init()
    var userState: UserState {get}

shakemno

ExportOptions.plist - Options in a better order

Xcodebuild manfile says the following

> **Distributing Archives**
>     The   -exportArchive   option  specifies  that  xcodebuild  should  distribute  the  archive  specified  by  -archivePath  using  the  options  specified  by
>     -exportOptionsPlist.  xcodebuild -help can print the full set of available inputs to -exportOptionsPlist.  The product can either be  uploaded  to  Apple  or
>     exported locally. The exported product will be placed at the path specified by -exportPath.

The following is the list of settings (as of Xcode 10.1) output by `xcodebuild --help` but in a more logical order.

shakemno

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,

shakemno

#!/bin/bash
#
# Self-contained command line processing in bash that supports the
# minimal, lowest common denominator compatibility of flag parsing.

# -u: undefined variables is an error
# -e: exit shell on error
set -eu

function usage() {

shakemno

#!/bin/zsh

cd "$(dirname "$0")/.."

if [[ -n "$CI" ]] || [[ $1 == "--fail-on-errors" ]] ; then
  FAIL_ON_ERRORS=true
  echo "Running in --fail-on-errors mode"
  ERROR_START=""
  COLOR_END=""
  INFO_START=""

shakemno

#!/usr/bin/env bash
set -euo pipefail

function convert_file {
  local xccovarchive_file="$1"
  local file_name="$2"
  local xccov_options="$3"
  echo "  <file path=\"$file_name\">"
  xcrun xccov view $xccov_options --file "$file_name" "$xccovarchive_file" | \
    sed -n '