Swift: tipo de valor recursivo

¿Tengo una estructura en la que quiero tener una variable global de tipo Struct ?. Este ejemplo es esencialmente una versión más breve de la estructura que realmente estoy creando.

struct SplitString { //splits a string into parts before and after the first "/" var preSlash: String = String() var postSlash: SplitString? = nil init(_ str: String) { var arr = Array(str) var x = 0 for ; x < arr.count && arr[x] != "/"; x++ { preSlash.append(arr[x]) } if x + 1 < arr.count { //if there is a slash var postSlashStr = String() for x++; x < arr.count; x++ { postSlashStr.append(arr[x]) } postSlash = SplitString(postSlashStr) } } } 

Sin embargo, arroja el error:

 Recursive value type 'SplitString' is not allowed 

¿Hay alguna forma de evitar esto? Cualquier ayuda sería genial. Gracias 🙂

Editar: en caso de que sea relevante, estoy progtwigndo en iOS, no en OSX.

Editar: si tengo:

 var split = SplitString("first/second/third") 

Espero que split sea:

 {preSlash = "first", postSlash = {preSlash = "second", postSlash = {preSlash = "third", postSlash = nil}}} 

    TL; DR:

    Lo que está tratando de lograr se logra fácilmente usando split:

     for s in split("first/second/third", { c in c == "/" } ) { println("\(s)") } 

    Discusión:

    Parece que está intentando escribir una list enlazada de types de valor. El problema es que Swift asocia los conceptos de semántica de copy con valor / acceso de reference. (a diferencia de decir C ++, que te permite crear el mismo object en la stack o el montón). La solución parece estar envolviéndola en un contenedor de reference, también conocido como class.

     class SplitString { //splits a string into parts before and after the first "/" var preSlash: String = String() var postSlash: Wrapped? = nil init(_ str: String) { var arr = Array(str) var x = 0 for ; x < arr.count && arr[x] != "/"; x++ { preSlash.append(arr[x]) } if x + 1 < arr.count { //if there is a slash var postSlashStr = String() for x++; x < arr.count; x++ { postSlashStr.append(arr[x]) } postSlash = Wrapped(postSlashStr) } } } class Wrapped { var split:SplitString init(var _ str:String) { split = SplitString(str) } } 

    Tenga en count que este código comstack como testing de concepto, pero no he profundizado en su algorithm ni lo ha probado.

    Editar:

    En respuesta a sus ediciones anteriores, este código ejercerá su código anterior y producirá las divisiones que desee:

     for (var s:SplitString? = split; s != nil; s = s?.postSlash?.split) { println("\(s!.preSlash)") } 

    Obviamente tener tortugas completamente no tiene sentido, según la discusión anterior, por lo que debe romper el ciclo, como fue el caso de la class que contiene su estructura.

    Tenga en count que he estado tratando de responder a la pregunta que publicó, no al problema que tiene. La solución al problema que tiene es usar SequenceOf y GeneratorOf para crear un generador de secuencia envuelta que se repite entre las barras y devuelve las subcadenas entre ellas. De hecho, esto se hace por ti a través de la function dividida:

     for s in split("first/second/third", { c in c == "/" } ) { println("\(s)") } 

    Me imagino que esto se debe a que un Opcional se comporta como un tipo de valor. Entonces, lo que tienes es un tipo de valor de un tipo de valor. Un tipo de valor

    Para hacer un layout para un tipo de valor, debe conocer el tamaño de las cosas involucradas.

    Entonces tienes (simplificado):

     sizeof(SplitString) = sizeof(String) + sizeof(SplitString?) 

    con

     sizeof(SplitString?) > sizeof(SplitString) 

    ya que necesita almacenar el hecho de que el valor está o no presente (y, no, un patrón de tamaño de (SplitString) ceros no es una representación válida para eso como lo sería para un tipo de class – ¿por qué? imagine Int? = 0)

    Entonces, ahora tienes

     sizeof(SplitString?) > sizeof(String) + sizeof(SplitString?) 

    pero todas las cantidades involucradas son definitivamente> 0. Más bien el absurdo, ¿verdad?