Compiler error because of recursive function calling in SwiftUI - swift

Question

I am trying to build a simple design system for my pet project to share between android and iOS apps.
The definitions of widgets are in the common Kotlin module.
I am trying to write swift UI functions to build actual views:
#ViewBuilder
func widget(widget: MyWidget) -> some View {
switch widget {
case let box1 as MyBox:
box(box: box1)
default:
fatalError("Unsupported widget: \(widget)")
}
}
#ViewBuilder
func box(box: MyBox) -> some View {
ZStack {
ForEach(box.children) { child in
widget(widget: child)
}
}
}
When compiling the project, I get the following error:
Command CompileSwift failed with a nonzero exit code
Removing the recursion (like replacing widget call with a Text) resolves the compilation problem.
Note that these functions are not called anywhere else.
XCode version 14.1
Removing recursive call fixes compiler error

Answer 1

Structs in Swift must have a size that is knowable at compilation. In other words, a struct cannot contain a variably-sized object. A struct can contain an array or string or other variably-sized object by using a constant-sized reference to said object (a pointer, essentially). You can't do this:
struct A {
var b: B
}
struct B {
var a: A
}
But you can do this, because both _a and _b are actually just pointers to arrays (i.e, constant size regardless of size of the array or the objects in the array), and A.b and B.a are computed properties that are not actually stored.
struct A {
var _b: [B]
var b: B {
get {
return _b[0]
}
set(new) {
_b[0] = new
}
}
}
struct B {
var _a: [A]
var a: A? {
get {
return _a[0]
}
set(new) {
_a[0] = new
}
}
}
And you can also do this, because storing a Box<T> value only stores a pointer to a Box<T> object, so the size of the reference does not depend on the size of the referenced value.
class Box<T> {
var value: T
init(value: T) {
self.value = value
}
}
struct A {
var b: Box<B>
}
struct B {
var a: Box<A>
}
Since SwiftUI views are structs, they cannot be recursive. There are multiple ways of creating recursive data structures in Swift, and I don't know enough about SwiftUI to say what approach is appropriate in your use case. You can box stuff in via a wrapper class or wrapping in an array, or you can create a recursive Enum box object via the indirect keyword:
enum Maybe<T> {
case None
indirect case Some(_ value: T)
}
struct A {
var b: Maybe<B>
}
struct B {
var a: Maybe<A>
}
let foo = A(b: .None)
let bar = B(a: .Some(A(b: .None)))