【Swift】ジェネリクスの意味と使い方！Comparableプロトコルとは？

func judgeType<T> (one: T, two: T) -> T? {
    print("oneのデータ型は\(type(of: one))")
    print("twoのデータ型は\(type(of: two))")
    return nil
}

judgeType(one: 6, two: 4000)
// oneのデータ型はInt
// twoのデータ型はInt

judgeType(one: 0.7, two: 4000)
// oneのデータ型はDouble
// twoのデータ型はDouble

judgeType(one: "Swift", two:"UI")
// oneのデータ型はString
// twoのデータ型はString

judgeType(one: "Swift", two: 4000) // パースエラー
expression failed to parse:
error: conflicting arguments to generic parameter 'T' ('Int' vs. 'String')
judgeType(one: "Swift", two:5)

func equalType<T> (one: T, two: T) -> Bool {
    if one == two {
        return true
    }else{
        return false
    }
}

expression failed to parse:
error: binary operator '==' cannot be applied to two 'T' operands
// エラー：二項演算子'=='は2つの'T'オペランドに適用できません

func equalType<T: Comparable> (one: T, two: T) -> Bool {
    if one == two {
        return true
    }else{
        return false
    }
}

equalType(one: 6, two: 6) // true
equalType(one: "SWIFT", two: "swift") // false

public protocol Comparable : Equatable {
    static func < (lhs: Self, rhs: Self) -> Bool
    static func <= (lhs: Self, rhs: Self) -> Bool
    static func >= (lhs: Self, rhs: Self) -> Bool
    static func > (lhs: Self, rhs: Self) -> Bool
}

func test<T>() -> T {
    if T.self == Int.self {
        return 10 as! T
    } else if T.self == String.self {
        return "Hello" as! T
    } else {
        fatalError("Unsupported type")
    }
}

let test2:Int = test() // test2はInt型
print(test2) // 10
let test3:String = test() // test3はString型
print(test3) // Hello

struct Box<T>{
    var area1 : T
    var area2 : T
    var key : String
    
}

public protocol View {
    associatedtype Body : View
    @ViewBuilder  var body: Self.Body { get }
}