Grouping TableColumns with a binding to array won't compile, only staying under 10 columns successfully compiles

Using Swift
1

I have a rather info dense SwiftUI Table that has > 10 columns. If all the columns are simple Text() views, I can group them to get past the constructor constraint of 10 items only.

But if I have one column is a TextField (thus with a binding) it compiles/works great up to 10 columns. When I try to Group {} less than 10 columns or add more than 10 columns with a subset in Group {}, I get Generic parameter 'R' could not be inferred

Here is some minimal viable code that reproduces the issue. If I uncomment out the Group { I get a compile error:

struct ContentView: View {

  @State var selection = Set<TestStruct.ID>()
  @StateObject var viewModel = ViewModel()

  var body: some View {
    VStack {
      Table($viewModel.data, selection: $selection) {
//        Group {
            TableColumn("Col") { $item in
              TextField("Placeholder", text: $item.text)
            }
            TableColumn("Data") { $item in
              Text("\(item.data)")
            }
            TableColumn("D3") { $item in
              Text("\(item.d3)")
            }
            TableColumn("D4") { $item in
              Text("\(item.d4)")
             }
             TableColumn("D5") { $item in
               Text("\(item.d5)")
             }
            TableColumn("D6") { $item in
              Text("\(item.d6)")
            }
           TableColumn("D7") { $item in
             Text("\(item.d7)")
            }
            TableColumn("D8") { $item in
              Text("\(item.d8)")
             }
            TableColumn("D9") { $item in
              Text("\(item.d9)")
             }
             TableColumn("D10") { $item in
               Text("\(item.d10)")
             }
 //           TableColumn("D11") { $item in
 //             Text("\(item.d11)")
 //           }
 //         }
      }
    }
  }

  class ViewModel : ObservableObject {
    struct ContainedTestStruct: Identifiable {
      var id = UUID()
      var text: String
      var data: Double
      var d3: String
      var d4: String
      var d5: String
      var d6: String
      var d7: String
      var d8: String
      var d9: String
      var d10: String
      var d11: String
    }

    @Published var data =
    [ContainedTestStruct(text: "Test", data: 3.141, d3: "d3", d4: "d4", d5: "d5", d6: "d6", d7: "d7", d8: "d8", d9: "d9", d10: "d10", d11: "d11"),
       ContainedTestStruct(text: "editable", data: 2.71828183, d3: "d3", d4: "d4", d5: "d5", d6: "d6", d7: "d7", d8: "d8", d9: "d9", d10: "d10", d11: "d11"),
       ContainedTestStruct(text: "FooBar", data: 42.0, d3: "d3", d4: "d4", d5: "d5", d6: "d6", d7: "d7", d8: "d8", d9: "d9", d10: "d10", d11: "d11")]
  }

Is there a way to have both >10 columns and have some of them be editable?

2

SwiftUI container closures are usually limited to 10 generic parameters, which means 10 views (no variadic generics there yet). You’ll need to group them in some way once you hit the limit.

3

In this instance, that's a TableColumnBuilder and you can see all of its builder blocks at:

4

Am aware of the 10 parameter limit in the constructors, but the usual work around for that is the Group {} approach. But that approach specifically does not compile when within the group are TableColumns with one being a TextField, but groups with Text views are fine.

5

FWIW, I found this to compile:

      Table($viewModel.data, selection: $selection) {

            TableColumn("Col") { $item in
              TextField("Placeholder", text: $item.text)
            }
            TableColumn("Data") { $item in
              Text("\(item.data)")
            }
            TableColumn("D3") { $item in
              Text("\(item.d3)")
            }
            TableColumn("D4") { $item in
              Text("\(item.d4)")
             }
             TableColumn("D5") { $item in
               Text("\(item.d5)")
             }
            TableColumn("D6") { $item in
              Text("\(item.d6)")
            }
           TableColumn("D7") { $item in
             Text("\(item.d7)")
            }
            TableColumn("D8") { $item in
              Text("\(item.d8)")
             }
            TableColumn("D9") { $item in
              Text("\(item.d9)")
             }
             if true {
               TableColumn("D10") { $item in
                 Text("\(item.d10)")
               }
              TableColumn("D11") { $item in
                Text("\(item.d11)")
              }
            }
      }
6

That's probably because the TableColumnBuilder has an implementation for Text and not TextField, but I haven't used Table extensively and that is a SwiftUI framework implementation.

Yes, that's because you have 9 TableColumns which will first be called through the result builder's buildExpression function to build 9 partial values, and the conditional statement will expand using the buildEither implementations which will merged into a single variable.

So, the transformed code will mostly look something like the following, using the 10-parameter buildBlock:

let c1 = buildExpression(TableColumn("C1") { ... })
// ... c2 through c8
let c9 = buildExpression(TableColumn("C9") { ... })

let vMerged: PartialResult

if true {
    vMerged = buildEither(first: ...)
} else {
    vMerged = buildEither(second: ...)
}

// this has 10 parameters
return buildBlock(c1, ..., c9, vMerged)
7

Is there a radar or somesuch that I should create?

I find it surprising that I'm the first person in the world to use Table -> Group -> TableColumn -> TextField and encounter this.