tarunon

struct User<T> { ... } // ←こういうものをConformしたい

extension Array where User<T> { ... } // ←これはまだできない

// ここからWorkaround

protocol UserProtocol { associatedtype T } // ←まずこれを作って

extension User: UserProtocol {} // Conformして

tarunon

public struct _ModelX<_ModelN: Codable>: Codable {
    public var model0: _ModelN
    public var model1: Bool?
    public var model2: Bool?
    public var model3: Bool?
    public var model4: Bool?
    public var model5: Bool?
    public var model6: Bool?
    public var model7: Bool?
    public var model8: Bool?

tarunon

indexPath

• Aの下にB、というような相対的な配置ではなく絶対座標による指定。ViewOnlyでレイアウトを組むことができず、indexPathを設定するためのロジックが必須になる
• ↑データ群からindexPathを一意に変換する(場合によっては双方向も)必要があり、ここがFatになりやすい
• StaticTableViewは避けれるが、IBがFatになりやすい。Storyboardのみ。

Cellへのアクセス

• 安全なアクセスは生成時に限定されている、ReuseもあるのでデータをCellで保持することが出来ない。もっともMVVMだとVMにデータを保持するので元からそういう作りであれば問題にはならないか。ただしFatVMになりやすいと感じている。
• CellのイベントハンドラをVCに作るときにindexPathを取り出して…など結構煩雑になりがち。
• tableViewCellForIndexPathがFatになりやすい。
• StaticTableViewは避けれるが

tarunon

class Animal: AnimalConvertible {
    func bark() -> String { fatalError() }
    func asAnimal() -> Animal {
        return self
    }
}

protocol AnimalConvertible {
    func bark() -> String
    func asAnimal() -> Animal

tarunon

/// とりあえず各ケースのOptional変換を作っておく。ここはPrivateでも良い。
extension Enum2Convertible {
    func ifCase0() -> Case1? {
        switch self.asEnum() {
        case .case0(let x): return x
        default: return nil
        }
    }

    func ifCase1() -> Case1? {

tarunon

class Animal {}
class Cat: Animal {}

// Rule A
// Cat is subtype of Animal
do {
    let cat: Cat = Cat()
    let animal: Animal = cat
}

tarunon

import Foundation

// Make 5 pattern base types

class A {}
protocol B {}
protocol C: class {}
@objc protocol D {}
protocol E: NSObjectProtocol {}

tarunon

// 多変数の型パラ持ちのprotocolでtype-erasureを書く時に、共変性をサポートしたいが
// 素直なtype-erasureでは引数にバラバラにpropertyを渡すことでしか共変な型消しをinitできなかった。

class Animal {}
class Cat: Animal {}

protocol A {
    associatedtype X

    var x: X { get }

tarunon

protocol Injectable {
    associatedtype Dependency = Void
    
    func inject(_ dependency: Dependency)
}

extension Injectable where Dependency == Void {
    func inject(_ depenency: Dependency) {
        
    }

tarunon

func undefined<T>(_ funcName: String=#function) -> T {
    fatalError("\(funcName) is undefined.")
}

class A {
    lazy var parameter: Int = undefined()
}

let a = A()
a.parameter = 100