Revolucent

import ComposableArchitecture
import SwiftUI

enum ValidationKey<Model>: Hashable {
  case model
  case key(PartialKeyPath<Model>)
}

@ObservableState
struct ValidationResult: Equatable {

Revolucent

{-# LANGUAGE FlexibleContexts, FlexibleInstances, FunctionalDependencies #-}

module Parsy where

import Control.Monad.Error.Class
import Data.List (foldr1, singleton, (!!))
import GHC.Base (empty)
import RIO hiding (optional)
import RIO.Char

Revolucent

SSH in a Dockerfile

Prerequisites

• You must have BuildKit enabled in Docker.
• You must have ~/.ssh/config set up with a proper alias for the server you want to access via SSH.
• When referencing external resources via SSH, always use a proper domain name, never an SSH alias. In other words, use something like git@github.com:foo/bar.
• Use the latest Dockerfile syntax using # syntax=docker/dockerfile:1.x at the top.

Revolucent

typealias Deserializer<I, O> = (I) -> O?
typealias JsonDeserializer<I, O> = (Json) -> Deserializer<I, O>
typealias JsonElementDeserializer = JsonDeserializer<JsonElement, JsonElement>

private fun <I, O> const(deserializer: Deserializer<I, O>): JsonDeserializer<I, O> = {
    deserializer
}

infix fun <A, B, C> JsonDeserializer<A, B>.j(
    next: JsonDeserializer<B, C>

Revolucent

import UIKit

open class KeyboardAvoidingViewController: UIViewController {

  private var observers: [NSObjectProtocol] = []

  open override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)

    let nc = NotificationCenter.default

Revolucent

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TupleSections #-}

Revolucent

import parse from 'obj-parse'

/*
In its simplest usage, mapStateToProps('foo', 'bar')
maps the state keys 'foo' and 'bar' to keys of the same
name in the props.

To alias, use an object literal: mapStateToProps('foo', {baz: 'bar.buzz'}).
In this case, we're mapping state that's more deeply nested to the 'baz' prop.
The parse method of obj-parse takes care of this for us.

Revolucent

public func descendants<Descendant>(of parent: Descendant, in attribute: KeyPath<Descendant, [Descendant]>, where: (Descendant) throws -> Bool) rethrows -> [Descendant] {
    var descendants: [Descendant] = []
    for child in parent[keyPath: attribute] {
        if try `where`(child) {
            descendants.append(child)
        }
        try descendants.append(contentsOf: MASCore.descendants(of: child, in: attribute, where: `where`))
    }
    return descendants
}

Revolucent

import RxCocoa
import RxSwift
import UIKit

extension Reactive where Base: UIView {
    var isFirstResponder: Observable<Bool> {
        return Observable
            .merge(
                methodInvoked(#selector(UIView.becomeFirstResponder)),
                methodInvoked(#selector(UIView.resignFirstResponder))

Revolucent

import Foundation
import ReSwift
import RxSwift

private class StoreObserver<SelectedState>: StoreSubscriber {
    private let onNext: (SelectedState) -> Void
    init(onNext: @escaping (SelectedState) -> Void) {
        self.onNext = onNext
    }
    func newState(state: SelectedState) {