Can I bind to Int but edit with TextField

TextField can take a number of native Formatter objects, such as NumberFormatter()

@State private var myInt = 0

...

TextField("", value: self.$myInt, formatter: NumberFormatter())

Any entered values that are deemed invalid by the formatter print as such to the terminal and are ignored.

(I'm new here so if any more experienced people think my answer needs a slight correction please let me know, just trying to help)

strValue is never updated unless when you create a new IntView.

You should not redeclare a IntView in the body, but have it as a property of the ContentView.

Creating this IntView struct seems overkill (but interesting exercise).

That is brilliant, thanks, and scales nicely for various different types.

It does have a slight side-effect thought that I have not been able to get around. I also cannot see that it is possible to get around.

Take the slightly different example below where MyStruct does not contain Ints, but Doubles. When you start off, the text will be "1.2 3.4". As soon as you delete the "4", the text does not change to "1.2 3." as a user would expect, but to "1.2 3.0" because "3." is converted to a valid double.

Any ideas of how to get around it?

struct MyStruct {
  var a: Double
  var b: Double
}

extension MyStruct {
  var strValue: String {
    get {
      return "\(a) \(b)"
    } set {
      let parts = newValue.components(separatedBy: " ")
      guard parts.count == 2, let aValue = Double(parts[0]), let bValue = Double(parts[1]) else {
        // Not valid.
        return
      }
      a = aValue
      b = bValue
    }
  }
}

struct MyStructView: View {
  @Binding var value: MyStruct
  
  var body: some View {
    TextField("", text: $value.strValue)
  }
}

struct ContentView: View {
  @State var myStruct = MyStruct(a: 1.2, b: 3.4)
  
  var body: some View {
    return VStack {
      Text("xValue = \(myStruct.a)")
      Text("yValue = \(myStruct.b)")
      Divider()
      MyStructView(value: $myStruct)
    } .padding()
      .frame(maxWidth: .infinity, maxHeight: .infinity)
  }
}

Take the slightly different example below where MyStruct does not contain Ints, but Doubles. When you start off, the text will be "1.2 3.4". As soon as you delete the "4", the text does not change to "1.2 3." as a user would expect, but to "1.2 3.0" because "3." is converted to a valid double.

That is a common issue when you bind TextField to a numeric type. In my example, if you input "12.001", you'll see "12.1" in the Text.

The best solution for this, I think, is make users not expect such output.

Or else, give up binding to numeric values.

I found a much better solution. Not only does it solve the original problem, but it also solves the problem when editing doubles (see previous comments) and it allows a single value to be edited by multiple TextFields (or sliders, or any other visual element).

The key is in not binding the TextField to a string, but creating a new Binding with a getter and setter. A local private string is used to keep the string being edited by the TextField in synch with the value (or partial value in this case).

The example below shows a struct with two members. A value of this type can be passed to the custom view that is used to edit it. The value is shown at the top of the view (for information only). The view has two TextFields that is used to edit the two members of the value.

This is just a proof of concept and can be improved further by using Formatters. This example also scales nicely in that a custom view can be created to edit a custom type and the complexity can be hidden inside the custom view.

Code Block 
struct MyStruct {
	var a: Int
	var b: Double
}
struct MyStructView: View {
	@Binding var myStruct: MyStruct
	
	@State private var lastValidValue = MyStruct(a: 10, b: 20)
	@State private var isEditingA = false
	@State private var isEditingB = false
	@State private var aStrValue = ""
	@State private var bStrValue = ""
	
	var body: some View {
		
		VStack {
			Text("myStruct.a = \(myStruct.a)	.b = \(myStruct.b)")
			Divider()
			
			HStack {
				Text("a = ")
				TextField("Value a", text: Binding(
				get: {
					if self.isEditingA {
						return self.aStrValue
					} else {
						return "\(self.myStruct.a)"
					}
				}, set: { str in
					self.aStrValue = str
					
					if let tmp = Int(str) {
						self.myStruct.a = tmp
						self.lastValidValue = self.myStruct
					} else {
						self.myStruct.a = self.lastValidValue.a
					}
				}), onEditingChanged: { editing in
					self.isEditingA = editing
				})
			}
			
			HStack {
				Text("b = ")
				TextField("Value b", text: Binding(
					get: {
						if self.isEditingB {
							return self.bStrValue
						} else {
							return "\(self.myStruct.b)"
						}
				}, set: { str in
					self.bStrValue = str
					
					if let tmp = Double(str) {
						self.myStruct.b = tmp
						self.lastValidValue = self.myStruct
					} else {
						self.myStruct.b = self.lastValidValue.b
					}
				}), onEditingChanged: { editing in
					self.isEditingB = editing
				})
			}
		}
		.frame(width: 300, height: 100)
		.padding()
		.onAppear {
			self.lastValidValue = self.myStruct
		}
	}
}
struct ContentView: View {
	@State private var myStruct = MyStruct(a: 1, b: 2.0)
	
	var body: some View {
		MyStructView(myStruct: $myStruct)
	}
}
struct ContentView2_Previews: PreviewProvider {
	static var previews: some View {
		ContentView()
	}
}