pofat

protocol FooDelegate: AnyObject {
  func didReceive(value: Int)
  func didOpen()
  func didClose()
}

class Foo {
  weak var delegate: FooDelegate?

  func open() {

pofat

import ComposableArchitecture
import SwiftUI

struct <#Name#>State: Equatable {}

enum <#Name#>Action: Equatable {}

struct <#Name#>Environment {}

extension <#Name#>Environment {

pofat

protocol P {
   associatedtype A
   associatedtype B
 }

 protocol Q: P {}

 extension Q where A == Int {
   typealias B = Int
 }

pofat

struct Collapsable<Content: View>: View {
  @State var collapsed: Bool = true
  let content: () -> Content

  init(@ViewBuilder content: @escapin () -> Content) {
    self.content = content
  }

  var body: some View {
    VStack {

pofat

struct Foo {
   var bar: Int
   var overThreshold: Bool {
      bar > 5
   }
}

let fooArray: [Foo] = ...
let filtered = fooArray.filter(\.overThreshold) 

pofat

import Foundation

guard CommandLine.arguments.count > 1 else {
  print("Please specify object file/executable")
  exit(EXIT_FAILURE)
}

var nm = Process()
nm.launchPath = "/usr/bin/nm"
nm.arguments = [CommandLine.arguments[1]]

pofat

extension Effect {
    // Zip with other effects
    func zip<Others: Collection>(with others: Others)
        -> Effect<[Output], Failure>
        where Others.Element == Effect<Output, Failure> {
        let first = map { [$0] }
                .eraseToEffect()

        return others
            .reduce(first) { zipped, next in

pofat

import Combine
import CombineExt // Check this implementation: https://github.com/CombineCommunity/CombineExt/blob/main/Sources/Operators/Create.swift
import CoreBluetooth 

// Client to generate target delegate publisher
// Learned from https://github.com/pointfreeco/composable-core-location/blob/main/Sources/ComposableCoreLocation/Live.swift
struct PeripheralClient {
    enum Action: Equatable {
        case didUptateName

pofat

// Kind of type
public enum Kind {
    case `struct`
    case `enum`
    case optional
    case opaque
    case tuple
    case function
    case existential
    case metatype

pofat

/// Call this at main()
/// return: time in milliseconds
func getPreMainTime() -> Double {
        let currentTimeIntervalInMilliSecond = Date().timeIntervalSince1970 * 1000.0
        var procInfo = kinfo_proc()
        let pid = ProcessInfo.processInfo.processIdentifier
        var cmd: [Int32] = [CTL_KERN, KERN_PROC, KERN_PROC_PID, pid]
        var size = MemoryLayout.stride(ofValue: procInfo)
        // Retrieve information of current process
        if sysctl(&cmd, UInt32(cmd.count), &procInfo, &size, nil, 0) == 0 {