elfenlaid

// This gist demonstrates how you can implement versioning for a Codable struct to support loading
// old serialized data after changing the structure. Notable features of this solution:
//
// * No need to make new properties optional, or to perform post-processing on the struct after
//   loading in ordeer to populate missing values
// * No need to change the call site - from the outside this struct behaves just the same
//   as if we had implemented codable directly in the normal way.
// * Versioning can be applied individually to parents or leaves in a larger tree of
//   structs without affecting the other elements
// * This approach will work even if the original struct was not designed with versioning in mind

elfenlaid

/*
 * This is an example provided by Facebook are for non-commercial testing and
 * evaluation purposes only.
 *
 * Facebook reserves all rights not expressly granted.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NON INFRINGEMENT. IN NO EVENT SHALL
 * FACEBOOK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

elfenlaid

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,

elfenlaid

// A heterogeneous dictionary with strong types in Swift, https://oleb.net/2022/heterogeneous-dictionary/
// Ole Begemann, April 2022

/// A key in a `HeterogeneousDictionary`.
public protocol HeterogeneousDictionaryKey {
  /// The "namespace" the key belongs to. Every `HeterogeneousDictionary` has its associated domain,
  /// and only keys belonging to that domain can be stored in the dictionary.
  associatedtype Domain
  /// The type of the values that can be stored under this key in the dictionary.
  associatedtype Value

elfenlaid

[
  "easy-first-issue",
  "starter-task",
  "difficulty: easy",
  "difficulty: moderate",
  "difficulty: medium",
  "difficulty: just a custom template away! easiest way to contribute!",
  "difficulty: beginner",
  "difficulty: intermediate",
  "easy contribution",

elfenlaid

struct Message {
    enum Privacy {
        case `public`
        case `private`
    }

    var value: String
}

extension Message: CustomStringConvertible {

elfenlaid

{
  "owner": "SwiftPackageIndex",
  "name": "SwiftPackageIndex-Server"
}

elfenlaid

According to tailwindlabs/tailwindcss-typography#69 (comment)

elfenlaid

Source Here’s my favorite weird trick to debug CSS - General - The freeCodeCamp Forum

elfenlaid

Fish $PATH environment variable manager

Install

Store file at ~/.config/fish/functions/path.fish path

Usage

$ path --help