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

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

protocol P {
   associatedtype A
   associatedtype B
 }

 protocol Q: P {}

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

pofat

enum Either<A, B> {
    case left(A)
    case right(B)
}

extension Either: Decodable where A: Decodable, B: Decodable {
    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        if let a = try? container.decode(A.self) {
            self = .left(a)

pofat

// Using UInt8 as Byte
typealias Byte = UInt8
enum Bit: Int {
    case zero, one
}

extension Data {
    var bytes: [Byte] {
        var byteArray = [UInt8](repeating: 0, count: self.count)
        self.copyBytes(to: &byteArray, count: self.count)

pofat

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

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]]