DEV Community: Simran Preet Singh

SwiftUI Fix: Cannot Convert Binding to Binding in TextField

Simran Preet Singh — Fri, 30 May 2025 15:14:42 +0000

While working with TextField in SwiftUI, you might come across the following error:

Cannot convert value of type 'Binding' to expected argument type 'Binding'

This is a common issue when you're trying to bind a TextField to an optional String?, like in this example:

TextField("Address 2", text: $viewModel.business.address2)

Here, address2 is most likely declared as an optional string (String?), but TextField expects a non-optional Binding. Let’s walk through why this error happens and how to fix it.

Why This Happens

SwiftUI's TextField requires a binding to a concrete String, because it needs to show and update text consistently. Optional values introduce uncertainty: should the field show nil, an empty string, or something else?

That’s why you see this error — SwiftUI doesn’t know what to do with a Binding.

Solution 1: Manual Binding with Default Value

You can manually create a Binding from a Binding using Swift’s computed bindings:

TextField("Address 2", text: Binding(
    get: { viewModel.business.address2 ?? "" },
    set: { viewModel.business.address2 = $0 }
))

What This Does:

get: Returns the optional value if it exists, or an empty string if it's nil.

set: Updates the original optional with the new value from the text field.

This safely bridges the gap between the optional address2 and what TextField expects.

🧼 Bonus: Make It Reusable with an Extension

If you find yourself writing this conversion often, you can add a helpful extension:

extension Binding where Value == String? {
    func orEmpty() -> Binding<String> {
        Binding<String>(
            get: { self.wrappedValue ?? "" },
            set: { self.wrappedValue = $0 }
        )
    }
}

Now you can write:

TextField("Address 2", text: $viewModel.business.address2.orEmpty())

Core Data Part 2 Components of Core Data - NSPersistentContainer

Simran Preet Singh — Mon, 08 Apr 2024 00:58:28 +0000

Introduction

In the first article we learnt about data model and created our xcdatamodeld file which holds all our Core Data models in it. In this article we will explore what is NSPersistentContainer and what role does it play in the Core Data stack.

NSPersistentContainer

NSPersistentContainer is the class that is responsible for actually persisting and reading the data from the permanent data store. This class creates the data store which may be SQLite, some flat file system or whatever it can. But we use this class to help us save the data and retrieve it from the data store.

So we will use NSPersistentContainer to load create the database and make sure everything work with data models we have created. We will create a new class AppPersistenceContainer

import Foundation

class AppPersistentContainer {

}

Create the object of NSPersistentContainer and initialize it in init of the class


import Foundation
import CoreData

class AppPersistenceContainer {

  // Step - 1: Create the object
  private var persistenceContainer: NSPersistentContainer

  init() {
    // Step - 2: Initialize the object
    persistenceContainer = NSPersistentContainer(name: "CoreDataExampleModel")
  }
}

If you look carefully in Step - 2 we are using the exact name of the xcdatamodeld file in the initializer. Make sure it matches your xcdatamodeld file name without the extension.

Not lets initialize the AppPersistenceContainer class in CoreDataExampleApp.swift file.

import SwiftUI

@main
struct CoreDataExampleApp: App {

  // Add this line.
  private var appPersistentContainer = AppPersistenceContainer()

  var body: some Scene {
    WindowGroup {
      ContentView()
    }
  }
}

Now if everything is correct your app should build and run fine. You won't see anything much on the screen as we have not created on data and done anything to show data on the view. But the logs should not show any error.

But if you have named the data model incorrectly in NSPersistentContainer(name: String) then you will see the following error in the logs. App won't crash or anything but things won't work as expected if try to load or save any data.

There is one more step we can do to make 100% sure that the persistent store has been loaded or if there is error we can handle it gracefully. Now after we have initialized NSPersistentContainer in the init of AppPersistenceContainer add this line of code.

persistenceContainer.loadPersistentStores { description, error in
    if let error {
        print("❌ ERROR: Failed to load persistent store with error: \(error.localizedDescription)")
        return
    }
}

Your whole AppPersistentContainer.swift class should look something like this:

import Foundation
import CoreData

class AppPersistenceContainer {

  private var persistenceContainer: NSPersistentContainer

  init() {
    persistenceContainer = NSPersistentContainer(name: "CoreDataExampleMode")

    persistenceContainer.loadPersistentStores { description, error in
      if let error {
        print("❌ ERROR: Failed to load persistent store with error: \(error.localizedDescription)")
        return
      }
    }
  }
}

The code that we added just now, whats its doing is that it is loading the Persistent store and if it cannot for some reason, the error will be handled in the loadPersistentStore closure.

In the next article we learn more about NSManagedObjectContext and how it is used to actually save objects of our FolderEntity data model and save it.

Core Data Part 1 Components of Core Data - Data Model

Simran Preet Singh — Mon, 08 Apr 2024 00:56:28 +0000

Introduction

In this series I will go briefly over the 3 main components of the Core Data Stack.

Data Model
NSPersistentContainer
NSManagedObjectContext

First we will just go over what is DataModel and how to use it in our iOS Project with CoreData

Data Model

Defined in the .xcdatamodeld file, this includes all the models that we want to have to store data in Core Data. For example if we want to have a Folders, Notes , Tags models for a notes app, than these will be defined in the .xcdatamodeld file.

.xcdatamodeld just holds the information about how the data will look like. Which means it just holds the classes for those models, the properties in those classes and the relationship between. In holds no actual data to be store. It is simply like a group folder named Models we create in XCode when we want to group our models classes or structs in a single place. But here these models are always classes as they need to be of reference type as other parts that we are gonna discuss later needs to track each reference and any changes done to them.

New iOS Project

To create a data model lets create a new XCode project called CoreDataExample

Make sure the storege is selected as None. We will create everything from scratch so we are not selecting any pre-existing type of storage. As that gives a lot of boilerplate code that can be confusing to many.

Now we get a very empty SwiftUI project that has no way to store data permanently.

Creating `.xcdatamodeld` in our project

First we will create a new folder group in our project named Models. Here we will keep the xcdatamodeld file and all the related files which defines the models for Core Data, their extensions if any and any other helper model files we need in the app.

Now lets create a new file in the Models folders and select Data Model under Core Data section in your file template window.

*** Now be very carefull here. Because the name that we give to this file is very important as we will use it later in the app to define other components of the Core Data stack. So name it in Pascal Case like a class and keep the name a bit simple to remember and find. I am naming it CoreDataExampleModel.xcdatamodeld

Creating our first Model/Entity in `.xcdatamodeld`

Now we have created our .xcdatamodeld file which will store all our data models related to Core Data. We will follow a naming convention here which I personally use. You are free to not follow it and use your naming convention, but then please make sure that you make necessary changes in this series of articles later on. What I do is usually suffix my Core Data models with Entity as it makes it easy to distinguish them from my other models in the project if I needs to create any later on.

So lets create our first model here named FolderEntity. Now open the CoreDataExampleModel.xcdatamodeld file and you will see something like this in your XCode.

Now you need to add an Entity which simply means you are creating a class which will define your data model. You create a new Entity by clicking the following icon in the xcdatamodeld file that you opened.

Now you see an entity as been created with the name Entity.

Just double click on it and rename to something else, in this case we will create an entity named FolderEntity.

Now we would need to add an attribute to this entity which means we are adding a property to our class FolderEntity.
Click on the + icon in the Attributes section.

Now name the attribute to title and select its type(data type) to be String. We will explore other data types as well in upcoming articles but for right now we are keeping it simple here and using String.

Now just make sure your project builds fine. This whole process has create a class named FolderEntity with a property named title underneath the xcdatamodeld which is not directly visible to us. But if you projects builds trust me there is a class named FolderEntity that now exists in your project somewhere hidden from your eyes. We will later also learn to create those classes as Swift files in your project, but not right now.

In the next article we will explore what is NSPersistentContainer and how to create one for our project.

SwiftUI - Open Deeplink url from your terminal

Simran Preet Singh — Thu, 30 Mar 2023 21:02:26 +0000

Original Post

For the longest time when I had to test deeplinks, I would send myself an email with the link and open gmail in the iPhone simulator. But thanks for Stewart Lynch and his Navigation stack video I learnt a way to open deeplink urls from the terminal in my simulator.

xcrun simctl openurl booted <URL Scheme>://PathComponent1/PathComponent2

Your URL Scheme is defined under Targets > Info > URL Types and PathComponent can be anything that we want to read in our app to define where we want to go or what data is being sent from the Deep Link

Removing specific fields from a Mongoose returned object

Simran Preet Singh — Thu, 30 Mar 2023 20:59:42 +0000

Original Post Link...

Very often we have the need to only read certain fields from the database. We might just need username from a collection that has a bunch of other fields related to a User as well or read all the fields except 1 or 2, like we would never want to return password to the client when we are sending the User object even when it is ecrypted. For such scenerios Mongoose gives few different ways to include or exclude fields from the response we read from a MongoDB collection.

Including a certain field

If we want to include only 1 single field from a collection in the response we can use .include("<field-name>") after the mongoose query.

await User.find({}).select("username");

The above example will only return username and _id from the User collection.

Excluding a certain field

If we want to exclude only 1 single field from a collection in the response we can use .include("-<field-name>") after the mongoose query.

await User.find({}).select("-username");

The above example will exclude username from the User collection and return all other fields.

Always remove a certain field when Mongoose Schema returns a response

There are situations when we never want to return a field in the results from the Mongoose query. In such situations Mongoose itself provides us a way to modify its JSON object at the schema level and we can modify it the way we want.

userSchema.methods.toJSON = function () {
    const user = this;
    const userObject = user.toObject();

    delete userObject.password;

    return userObject;
}

Free path to Android development - 0 to PRO

Simran Preet Singh — Wed, 26 Jan 2022 19:09:19 +0000

There are a lot paid courses and bootcamps that teach you Android development
and an endless list youtube tutorials. But no where there is a clear path for
someone completly new to it. In this blog post I am gonna compile all the resources
that I have found over the years and some very recently that I think are great for
anyone. They will be mentioned in the order I think you should follow them, but
feel free to follow them as per your wish if you are already familiar with the
topics covered in previous playlists.

You will make creating almost 10 apps and will teach you all the best and latest
practices that are recommended in Android world by Google and Android developers.

The Kotlin Programming Language Course for Beginners

This playlist is by Donn Felker.
He is one of the greatest Android developers and has worked for so many
great companies and helped them create their initial version of Android app.
This playlist takes you from no Kotlin knowledge to an intermediate Kotlin developer.

Getting Started with Android Development

This is one of the newer Android channels I found and the content on this channel
is just awesome for a beginner. This playlist do not teach anything much about
Android development, but get you setup with your Android development environment.

Android Development: Layout & UI

Another playlist likely will be the next few by The Android Factory
that will teach you the basics Android layout including different layouts and
widgets, ScrollView and RecyclerView.

Android Development: Our first App

In this playlist you will create your first functioning Android app combining
the concepts learnt in the previous playlists + Fragments, SharedPreferences,
Intents and navigation between activities.

Git & GitHub

Nothing about Android here, but an essential skill for any developer is to learn
source code control system. And git being the most popular one, you should just learn it.

For full list of resources visit my blog

Short - Sheets in SwiftUI creates a new Environment

Simran Preet Singh — Wed, 26 Jan 2022 19:05:58 +0000

In SwiftUI we can inject objects at the environment level using .environmentObject() modifier and use them using @EnvironmentObject property wrapper. In a perfect world this environment object is available to all the subviews in that tree with certain exceptions.

One of the exceptions is that when we create a new .sheet() in any of the subviews this environment object will NOT be available for for that sheet view and its children. To use them in the sheet view and its children you would have to inject it again using .environmentObject().

I am learning Ruby on Rails

Simran Preet Singh — Sat, 19 Sep 2020 04:36:44 +0000

I am an iOS developer with experience in C# backend development. I want to create some iOS content on youtube to help people understand more about Networking in iOS apps without Firebase or other similar services. I have played around with ExpressJS in the last couple of years, but the moment I have to write Javascript it gives me a headache with its inconsistencies and bizarre different ways to do the same simple thing and every way has its own gotchas.

So today I decided to learn Ruby and then Ruby on Rails for my future personal projects. I am excited and nervous at the same time.

DEV Community: Simran Preet Singh

SwiftUI Fix: Cannot Convert Binding to Binding in TextField

Why This Happens

Solution 1: Manual Binding with Default Value

What This Does:

🧼 Bonus: Make It Reusable with an Extension

Core Data Part 2 Components of Core Data - NSPersistentContainer

Introduction

NSPersistentContainer

Core Data Part 1 Components of Core Data - Data Model

Introduction

Data Model

New iOS Project

Creating .xcdatamodeld in our project

Creating our first Model/Entity in .xcdatamodeld

SwiftUI - Open Deeplink url from your terminal

Removing specific fields from a Mongoose returned object

Including a certain field

Excluding a certain field

Always remove a certain field when Mongoose Schema returns a response

Free path to Android development - 0 to PRO

The Kotlin Programming Language Course for Beginners

Getting Started with Android Development

Android Development: Layout & UI

Android Development: Our first App

Git & GitHub

Short - Sheets in SwiftUI creates a new Environment

I am learning Ruby on Rails

Creating `.xcdatamodeld` in our project

Creating our first Model/Entity in `.xcdatamodeld`