0Pricing
Swift Academy · Lezione

Scegliere tra some, any e generics

Scelga i generics per il tipaggio statico omogeneo, some P per nascondere un tipo concreto fisso e any P per il polimorfismo eterogeneo.

Scegliere tra some, any e generics è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 3 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 3 lezioni in totale.

Quale scegliere?

Regola pratica:

  • Generics: stesso tipo concreto a ogni chiamata; migliori controlli in fase di compilazione e migliori prestazioni.
  • some P: nasconde il tipo restituito concreto, fisso per funzione.
  • any P: combina tipi conformi diversi, con dispatch dinamico.

Generics: omogenei

I generics sono ideali per dati omogenei e per l'ottimizzazione (dispatch statico, inline).

protocol Shape { func area() -> Double }

struct Circle: Shape { let r: Double; func area() -> Double { .pi * r * r } }
struct Square: Shape { let s: Double; func area() -> Double { s * s } }

// Generic: one concrete Shape type per call site (homogeneous)
func totalAreaGeneric<S: Sequence, T: Shape>(_ xs: S) -> Double where S.Element == T {
    xs.reduce(0) { $0 + $1.area() }
}
print(totalAreaGeneric([Circle(r:1), Circle(r:2)]))  // OK
// totalAreaGeneric([Circle(r:1), Square(s:2)])      // ❌ different types

Opaco: nascosto ma fisso

some P restituisce un tipo fisso ma nascosto. È ideale quando vuole l'incapsulamento senza rinunciare alle prestazioni statiche.

// Opaque factory hides the concrete type while guaranteeing Shape
func unitShape(flag: Bool) -> some Shape {
    // Must return the SAME underlying type on all paths; pick one.
    Circle(r: 1)
}
let s = unitShape(flag: true)
print(String(format: "%.2f", s.area()))  // 3.14

any P: eterogeneo

any P consente di usare tipi misti in una stessa collezione o variabile; i metodi vengono gestiti dinamicamente tramite l'interfaccia del protocollo.

// Existential: store mixed conformers
let mixed: [any Shape] = [Circle(r: 1), Square(s: 2)]
let sum = mixed.reduce(0) { $0 + $1.area() }   // dynamic dispatch
print(String(format: "%.2f", sum))

Confronto delle forme delle API

Scelga l'interfaccia esposta:

  • Generics: chi chiama controlla il tipo concreto.
  • Opaco: lei nasconde il tipo, che rimane fisso per funzione.
  • Esistenziale: i tipi concreti possono variare dinamicamente.
// Three API shapes for the same idea: "make a Shape"

// 1) Generic return — exposes concrete type to caller
func makeGeneric<T: Shape>(_ t: T) -> T { t }

// 2) Opaque return — hides concrete type but fixed
func makeOpaqueCircle() -> some Shape { Circle(r: 1) }

// 3) Existential return — can return any conformer
func makeExistential(_ big: Bool) -> any Shape { big ? Square(s: 3) : Circle(r: 1) }

let g: Circle = makeGeneric(Circle(r: 2))      // caller knows concrete type
let o = makeOpaqueCircle()                      // caller sees only Shape
let e = makeExistential(true)                   // could be Circle or Square at runtime
print(g.area(), o.area(), e.area())

Scheda rapida

Linee guida:

  • Preferisca i generics per prestazioni e tipizzazione forte quando i dati sono omogenei.
  • Usi some P per nascondere i tipi restituiti e mantenere stabili le API.
  • Usi any P per collezioni simili a plugin o contenenti elementi misti.
  • Eviti any P per i protocolli con tipi associati/Self, a meno che non applichi il type erasure.

Verifica della scelta: some/any/generics

Verifica rapida: quale opzione nasconde un tipo restituito concreto e fisso dietro il protocollo P?

Riepilogo

Riepilogo:

  • Generics = omogenei, più veloci, più statici.
  • some P = nasconde il tipo concreto, fisso per funzione.
  • any P = eterogeneo, con dispatch dinamico.

Domande Frequenti

La lezione «Scegliere tra some, any e generics» è gratuita?

Sì — il testo completo di «Scegliere tra some, any e generics» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 3 lezioni in totale.

Cosa imparerò in «Scegliere tra some, any e generics»?

Scelga i generics per il tipaggio statico omogeneo, some P per nascondere un tipo concreto fisso e any P per il polimorfismo eterogeneo. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 3.

Quanto tempo richiede la lezione «Scegliere tra some, any e generics»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. some P (tipi risultato opachi): nascondere i tipi concreti
  2. any P (esistenziale): compromessi e dispatch dinamico
  3. Scegliere tra some, any e generics
← Torna a Swift Academy