Below is the short answer:

You cannot pass an “uninitialized” enum case (one with associated values not yet provided) to a function in Swift. In Swift an enum case with associated values is actually a function that requires its parameters before it returns a value. There isn’t a built‐in way to “tag” a case without its associated data.

That means if you write this:

SWIFTCopied
enum MyEnum: Codable {
    case case1(data: Data)
    case case2(str: String)
    case case3(url: URL)
}

myFunc(myEnumType: MyEnum.case1)

then the compiler sees MyEnum.case1 as a function of type (Data) -> MyEnum. There is no “uninitialized” version available to pass as a type token. (Even making a generic alias like typealias MyEnumType = (Arg) -> MyEnum won’t guarantee that the passed function is actually one of MyEnum’s cases.)

There are two common workarounds:

---

1. Pass a Marker (Tag) That Indicates the Case

One approach is to introduce a helper enum (or some other marker type) that indicates which case you want. Then inside your function you “fill in” the associated value by your own logic. For example:

SWIFTCopied
enum MyEnum: Codable {
    case case1(data: Data)
    case case2(str: String)
    case case3(url: URL)
}

enum MyEnumCase {
    case case1
    case case2
    case case3
}

func myFunc(for marker: MyEnumCase) -> MyEnum {
    switch marker {
    case .case1:
        // Compute or retrieve a Data value
        let data = Data(/* ... */)
        return .case1(data: data)
    case .case2:
        let str = "example"
        return .case2(str: str)
    case .case3:
        let url = URL(string: "https://example.com")!
        return .case3(url: url)
    }
}

This is what you already mentioned as “very ugly” but it is a clear and type‐safe way to do it.

---

2. Pass a Closure That “Completes” the Case

Another approach is to pass a closure that, given the data you compute, returns the corresponding enum case. For example:

SWIFTCopied
enum MyEnum: Codable {
    case case1(data: Data)
    case case2(str: String)
    case case3(url: URL)
}

// Use a generic function that receives the “constructor”
func myFunc<T>(using constructor: (T) -> MyEnum, input: T) -> MyEnum {
    // Process the input if needed.
    // Then use the closure to construct the enum.
    return constructor(input)
}

// Usage:
let result = myFunc(using: MyEnum.case1, input: Data("Hello".utf8))

In this pattern the enum case (like MyEnum.case1) acts as a closure of type (Data) -> MyEnum. However, note that you must provide the associated data when calling the function. There’s no way around providing some value because Swift requires fully constructing such cases.

If you really want to defer the assembling of the associated value until later, you’d still need to design an API where the information about which case to create is passed as a marker (or use a closure that takes no parameter and returns the correctly constructed enum—but then you are responsible for creating that value outside the function).

---

Conclusion

Swift does not provide a native way to pass an “uninitialized” associated-value enum case such that the function can later decide which associated value to plug in. You must either:

• Pass an additional marker (or enum without associated values) to denote which case to construct, or
• Pass a closure that knows how to construct the enum given the necessary data.

Both approaches have tradeoffs. Using a marker is explicit and lets you inspect which case to produce, while using a closure keeps you closer to the enum’s natural constructor but requires you to supply (or compute) an initial “dummy” value if the signature demands one.

In short, you’ll need to adjust your API design since Swift enums with associated values are not “uninitialized” constructs.