Does SwiftUI's ForEach cache @State variables of child views beyond their existence?

So here is a little piece of code that sums up a problem I cannot figure out atm. In the code below I add and remove entries to a dictionary keyed by an Enum.

What I would expect is that every time I add an item a new random number is being generated in the Element view and displayed.

What happens is that for every same Ident the same random number shows up - event though the ForEach loop has had a state where that Ident key was not in the dictionary any more.

It appears as if ForEach does not purge the @State vars of the Element views that are not present any more, but reuses them when a new entry to the dictionary is added with the same Ident.

Is this expected behavior? What am I doing wrong? Here is the code:

import Foundation
import SwiftUI


enum Ident:Int, Comparable, CaseIterable {
    case one=1, two, three, four
    
    static func < (lhs: Ident, rhs: Ident) -> Bool {
        lhs.rawValue < rhs.rawValue
    }
    
}

extension Dictionary where Key == Ident,Value== String {
    
    var asSortedArray:Array<(Ident,Value)> {
        Array(self).sorted(by: { $0.key < $1.key })
    }
    
    var nextKey:Ident? {
        if self.isEmpty {
            return .one
        }
        else {
            return Array(Set(Ident.allCases).subtracting(Set(self.keys))).sorted().first
        }
    }
}


struct ContentView: View {
    @State var dictionary:[Ident:String] = [:]
    
    var body: some View {
        Form {
            Section {
                ForEach(dictionary.asSortedArray, id: \.0) { (ident, text) in
                    Element(dictionary: $dictionary, ident: ident, text: text)
                }
            }
            Section {
                Button(action: {
                    if let nextIdent = dictionary.nextKey {
                        dictionary[nextIdent] = "Something"
                    }
                }, label: {
                    Text("Add one")
                })
            }
        }
    }
}

struct Element:View {
    @Binding var dictionary:[Ident:String]
    var ident:Ident
    var text:String
    @State var random:Int = Int.random(in: 0...1000)
    
    var body: some View {
        HStack {
            Text(String(ident.rawValue))
            Text(String(random))
            Button(action: {
                dictionary.removeValue(forKey: ident)
            }, label: {
                Text("Delete me.")
            })
            Spacer()
        }
    }
}