Swift Academy · Lesson

Projected Values with $binding

Exposing a projectedValue to provide additional functionality via $prefix.

Projected Values with $binding is a free Swift Academy lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Swift Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Welcome

Projected values (accessed via `$`) give property wrappers a secondary interface — used by SwiftUI's `@State` and `@Published` to expose `Binding` and `Publisher`.

Adding projectedValue

```swift @propertyWrapper struct Toggle { var wrappedValue: Bool = false var projectedValue: String { wrappedValue ? "ON" : "OFF" } } struct Model { @Toggle var active } var m = Model() print(m.$active) // "OFF" — projected value accessed with $ ```

Type of projectedValue

The projected value can be any type — a `Binding`, a `Publisher`, a `String`, or a custom type. SwiftUI's `@State` projects a `Binding` that allows two-way data flow.

Binding Projection Example

```swift // @State projects Binding: @State var isOn = false Toggle(isOn: $isOn) // $isOn is Binding ```

Custom Binding Projection

```swift @propertyWrapper struct Validated { var wrappedValue: String var projectedValue: Bool { !wrappedValue.isEmpty } } struct Form { @Validated var email = "" } var f = Form() f.email = "hi@example.com" print(f.$email) // true — projected Bool ```

@Published Projection

```swift class VM: ObservableObject { @Published var score = 0 } let vm = VM() let cancellable = vm.$score // Publisher .sink { print("Score: \($0)") } vm.score = 10 // "Score: 10" ```

Accessing projectedValue Inside Wrapper

```swift @propertyWrapper struct History { private var current: T private(set) var projectedValue: [T] = [] var wrappedValue: T { get { current } set { projectedValue.append(current); current = newValue } } init(wrappedValue: T) { current = wrappedValue } } ```

Using the History Wrapper

```swift struct Counter { @History var count = 0 } var c = Counter() c.count = 1; c.count = 5; c.count = 3 print(c.$count) // [0,1,5] — history of old values ```

$ Syntax Disambiguation

```swift struct Form { @State var text = "" var body: some View { TextField("Enter", text: $text) // $text is Binding } } // text → String (wrappedValue) // $text → Binding (projectedValue) ```

Design Considerations

• `projectedValue` is optional — add only when a secondary interface is needed • The type can differ completely from `wrappedValue` • Use `$` at call site to access projected value • Projected values are great for Combine publishers and SwiftUI bindings

Quick Check

How do you access a property wrapper's `projectedValue`?

Recap

Key takeaways: • `projectedValue` gives wrappers a secondary API via `$` • Can be any type — Binding, Publisher, Bool, Array • `@State` projects `Binding`; `@Published` projects `Publisher` • Access with `$propertyName` in both body and call site • Only add when a second interface adds real value Next: @Published and Combine.

Frequently asked questions

Is the “Projected Values with $binding” lesson free?

Yes — the full text of “Projected Values with $binding” is free to read here on the web, and the Swift Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Swift Academy course, upgrade to CoddyKit PRO.

What will I learn in “Projected Values with $binding”?

Exposing a projectedValue to provide additional functionality via $prefix. You practise Swift Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Swift Academy?

No prior experience is required. Swift Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Projected Values with $binding” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Swift Academy lesson?

Yes. Every Swift Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Swift Academy