Kieran's Components

// 1
protocol MyType { }
// 2
struct Single: MyType {  }
// 3,4
@functionBuilder
struct MyBuilder {
    // 5
    static func buildBlock(_ component: MyType) -> MyType {
            return component
    }
}
//6
struct Example {
    init(@MyBuilder input: () -> MyType) {
        print(input())
    }
}
//7
let test = Example {
    Single()
}

protocol MyType { }
struct Single: MyType {  }
//1
struct Multi: MyType {
    var children: [MyType]
}
@functionBuilder
struct MyBuilder {
    static func buildBlock(_ component: MyType) -> MyType {
            return component
    }
    // 2
    static func buildBlock(_ components: MyType...) -> MyType {
        return Multi(children: components)
    }
}
struct Example {
    init(@MyBuilder input: () -> MyType) {
        print(input())
    }
}
let test = Example {
    // 3
    Single()
    Single()
    Single()
}

// An Example protocol that all of my builder types will inherit from.
// This is helpful for keeping the types consistent.
// Also in examples like the SwiftUI View protocol, the body property is inherited
// by all Views allowing building to occur within the View itself.
protocol MyBuildableType {  }
struct Single: MyBuildableType {  }
struct Multi: MyBuildableType {
    var children: [MyBuildableType]
}
struct Tuple: MyBuildableType {
}
struct Num: MyBuildableType {
    var number: Int
}
// adding the @functionBuilder above tells the system that this struct will
// handle the partial results of the final builder expression
// after implementing the build methods, the @MyBuilder wrapper can
// be used on an escaping expression.
@functionBuilder
struct MyBuilder {
    // Requirements: Only the buildBlock method is required when creating a functionBuilder
    // all the others if not implemented will default to the buildBlock method.

    // The simplest build operation which involves only one partial result
    // Takes in the compent and outputs the component
    static func buildBlock(_ component: MyBuildableType) -> MyBuildableType {
        return component
    }
    // If the partial results contain multiple children this method will
    // make use of the `Multi` type that inherits from the `MyBuildType`
    // I preemptively created the Multi type with its children property to
    // house the multiple components in one spot.
    static func buildBlock(_ children: MyBuildableType...) -> Multi {
        return Multi(children: children)
    }
    // Build optional hands cases where the partial result is an optional value
    // while there are a few ways to handle this circumstance, using the `Multi`
    // with an empty children set is the simplest for our purposes.
    static func buildOptional(_ component: MyBuildableType?) -> MyBuildableType {
        return component ?? Multi(children: [])
    }
    // declared to build combined results for do statement bodys
    static func buildDo(_ children: MyBuildableType...) -> Multi {
        return Multi(children: children)
    }
    // The buildEither methods must be both declared or else the builder will use buildOptional
    // when multiple options are available such as an if or switch statement, these methods
    // handle the partial build of the optional-executed subblocks
    static func buildEither(first: MyBuildableType) -> MyBuildableType {
        return first
    }
    static func buildEither(second: MyBuildableType) -> MyBuildableType {
        return second
    }
    // Here i am using an Int as my expression type but buildExpression can use any type.
    // This allows your syntax to be more flexible and do things like handling numbers and other literals
    // This method can be declared multiple times with different types, giving a lot of variability in the
    // building blocks.
    static func buildExpression(_ expression: Int) -> MyBuildableType {
        return Num(number: expression)
    }
}
// An example of a class which uses a function builder in its initializer
class SomeExample {
    var parameters: MyBuildableType
    init(@MyBuilder builder:  () -> MyBuildableType) {
        self.parameters = builder()
        print(self.parameters)
    }
}

func example() {
    SomeExample {
        Single()
        Single()
    }
}