buh

/// The authentication state.
enum AuthenticationState: StateType {
    
    // A list of events.
    enum Event {
        case userSignIn(email: String, password: String)
        case accessTokenReceived(AccessToken)
        case userReceived(User)
        case userSignedOut
    }

m5r

import notifierQueue from "~/queues/notifier.server.ts";

export const loader = async () => {
    await notifierQueue.add("test", { emailAddress: "mokhtar@remixtape.dev" });

    return null;
};

Martini024

import AVKit
import Foundation

class VideoHelper {

    static func getThumbnail(from player: AVPlayer, at time: CMTime, maximumSize: CGSize? = nil) -> CGImage? {
        guard let currentItem = player.currentItem else { return nil }
        return getThumbnail(from: currentItem.asset, at: time, maximumSize: maximumSize)
    }

DougGregor

extension Collection {
  func parallelMap<T>(
    parallelism requestedParallelism: Int? = nil,
    _ transform: @escaping (Element) async throws -> T
  ) async throws -> [T] {
    let defaultParallelism = 2
    let parallelism = requestedParallelism ?? defaultParallelism

    let n = self.count
    if n == 0 {

IanColdwater

Mute these words in your settings here: https://twitter.com/settings/muted_keywords

ActivityTweet
generic_activity_highlights
generic_activity_momentsbreaking
RankedOrganicTweet
suggest_activity
suggest_activity_feed
suggest_activity_highlights
suggest_activity_tweet

stoichammer

Introducing the Transpose Merkle Tree

A Transpose Merkle Tree (TMT) is a data structure wherein interim nodes are transposed such that the walk from the leaf node to the root node essentially contains the Merkle branch(proof). The leaf & root nodes remain in the same position/s as in a standard Merkle tree.

This post includes,

• a highly efficient algorithm to compute the TMT with only O(3 log n) space complexity (primary memory).
• a compact pre-ready data-structure, that can be persisted in a graph database(Neo4j), and can readily serve Merkle branch/paths trivially, traversal (by DB engine) of only O(log n) nodes.

The algorithm needs to store only the node-id, left-child-id, right-child-id for each height of the Merkle tree, hence the 3 log n. And the recursive algorithm shown below simultaneously constructs the intermediate nodes & transposes them appropriately upto the final root node recursively, with this simple structure. The time complexity of TMT construction is comparable to the standar

IanKeen

import XCTest

@_functionBuilder
struct Test<T> {
    var data: T
    var given: given<T>
    var when: when<T>
    var then: then<T>

    func execute() {

mattt

import UIKit

#if canImport(SwiftUI) && DEBUG
import SwiftUI
struct UIViewControllerPreview<ViewController: UIViewController>: UIViewControllerRepresentable {
    let viewController: ViewController

    init(_ builder: @escaping () -> ViewController) {
        viewController = builder()
    }

keith

addmedia
addphoto
addvideo
appinfo
boot
bootstatus
clone
create
darwinup
delete

keybuk

SwiftUI Custom Alignments

Moved to https://netsplit.com/swiftui/alignments/