struct ContentView: View {
    var body: some View {
        Text("hello world")
    }
}

public protocol View {
    /// The type of view representing the body of this view.
    associatedtype Body : View

    /// The content and behavior of the view.
    @ViewBuilder var body: Self.Body { get }
}

struct ContentView: View {
    var body: some View {
        VStack {
            Button("print my type") {
                print(type(of: self.body))
                // VStack<Button<Text>>
            }
        }
    }
}

struct ContentView: View {
    var body: VStack<Button<Text>> {
        VStack {
            Button("print my type") {
                print(type(of: self.body))
            }
        }
    }
}

// Compile Error: Type 'ContentView' does not conform to protocol 'View'
// Cannot infer 'Body' = 'View' because 'View' as a type cannot conform to protocols;
// did you mean to use an opaque result type?
struct ContentView: View {
    var body: View {
        // Compile Error: 
        // Protocol 'View' can only be used as a generic constraint 
        // because it has Self or associated type requirements
        Text("hello")
    }
}

public protocol View {
    /// The type of view representing the body of this view.
    associatedtype Body : View

    /// The content and behavior of the view.
    @ViewBuilder var body: Self.Body { get }
}

func max<T>(_ x: T, _ y: T) -> T where T: Comparable { ... }

// usage example
// max(Int(1), Int(2))
// max(Float(1), Float(2))

struct ContentView: View {
    var body: some View {
        VStack {
            Button("print my type") {
                print(type(of: self.body))
                // VStack<Button<Text>>
            }
        }
    }
}

protocol Shape {}
struct Triangle: Shape {}
struct Rectangle: Shape {}

enum ShapeEnum {
    case triangle
    case rectangle
}

// Compile Success: Could return any type confirms to protocol
func createProtocolType(shapeEnum: ShapeEnum) -> Shape {
    switch shapeEnum {
    case .triangle: return Triangle()
    case .rectangle: return Rectangle()
    }
}

// Compile Success: All path return the same type
func createOpaqueType(shapeEnum: ShapeEnum) -> some Shape {
    switch shapeEnum {
    case .triangle: return Triangle()
    default: return Triangle()
    }
}

// Compile Error: Function declares an opaque return type, 
// but the return statements in its body do not have matching underlying types
func createOpaqueTypeCompileError(shapeEnum: ShapeEnum) -> some Shape {
    switch shapeEnum {
    case .triangle: return Triangle()
    case .rectangle: return Rectangle()
    }
}

struct LazyView<Content: View>: View {
    let build: () -> Content
    init(_ build: @autoclosure @escaping () -> Content) {
        self.build = build
    }
    var body: Content {
        build()
    }
}

struct ContentView: View {
    @State var isLoggedIn = false

    @ViewBuilder
    func createView() -> some View {
        if isLoggedIn {
            Text("Logged In")
        }
        else {
            Button("Click to Login") {
                isLoggedIn.toggle()
            }
        }
    }

    var body: some View {
        let view = createView()

        // print _ConditionalContent<Text, Button<Text>>
        print(type(of: view))

        return view
    }
}

public protocol View {
    /// The type of view representing the body of this view.
    associatedtype Body : View

    /// The content and behavior of the view.
    @ViewBuilder var body: Self.Body { get }
}

/// You typically use ``ViewBuilder`` as a parameter attribute for child
/// view-producing closure parameters, allowing those closures to provide
/// multiple child views. For example, the following `contextMenu` function
/// accepts a closure that produces one or more views via the view builder.
///
///     func contextMenu<MenuItems: View>(
///         @ViewBuilder menuItems: () -> MenuItems
///     ) -> some View
///
/// Clients of this function can use multiple-statement closures to provide
/// several child views, as shown in the following example:
///
///     myView.contextMenu {
///         Text("Cut")
///         Text("Copy")
///         Text("Paste")
///         if isSymbol {
///             Text("Jump to Definition")
///         }
///     }
///
@resultBuilder public struct ViewBuilder {

    /// Builds an empty view from a block containing no statements.
    public static func buildBlock() -> EmptyView

    /// Passes a single view written as a child view through unmodified.
    ///
    /// An example of a single view written as a child view is
    /// `{ Text("Hello") }`.
    public static func buildBlock<Content>(_ content: Content) -> Content where Content : View
}

extension ViewBuilder {

    /// Provides support for “if” statements in multi-statement closures,
    /// producing an optional view that is visible only when the condition
    /// evaluates to `true`.
    public static func buildIf<Content>(_ content: Content?) -> Content? where Content : View

    /// Provides support for "if" statements in multi-statement closures,
    /// producing conditional content for the "then" branch.
    public static func buildEither<TrueContent, FalseContent>(first: TrueContent) -> _ConditionalContent<TrueContent, FalseContent> where TrueContent : View, FalseContent : View

    /// Provides support for "if-else" statements in multi-statement closures,
    /// producing conditional content for the "else" branch.
    public static func buildEither<TrueContent, FalseContent>(second: FalseContent) -> _ConditionalContent<TrueContent, FalseContent> where TrueContent : View, FalseContent : View
}