danhalliday

import SwiftUI
import Dependencies
import AsyncExtensions

public struct Setting<Value:Sendable>: Sendable {
    let id: String
    let name: String
    let fallback: Value

    let load: @Sendable (String) -> Value?

aheze

struct OverflowLayout: Layout {
    var spacing = CGFloat(10)
    
    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
        let containerWidth = proposal.replacingUnspecifiedDimensions().width
        let sizes = subviews.map { $0.sizeThatFits(.unspecified) }
        return layout(sizes: sizes, containerWidth: containerWidth).size
    }
    
    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {

KazaiMazai

import SwiftUI

extension CollectionView {
    typealias UIKitCollectionView = CollectionViewWithDataSource<SectionIdentifierType, ItemIdentifierType>
    typealias DataSource =  UICollectionViewDiffableDataSource<SectionIdentifierType, ItemIdentifierType>
    typealias Snapshot = NSDiffableDataSourceSnapshot<SectionIdentifierType, ItemIdentifierType>
    typealias UpdateCompletion = () -> Void
}

struct CollectionView<SectionIdentifierType, ItemIdentifierType> 

IanKeen

// MARK: - TCAView
public protocol TCAView: View where Body == WithViewStore<ScopedState, ScopedAction, Content> {
    associatedtype ViewState
    associatedtype ViewAction

    associatedtype ScopedState
    associatedtype ScopedAction

    associatedtype Content

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 Foundation
import AVKit

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

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