我发现原始代码存在以下问题：
1.表单字段本身永远不会被记住（因此嵌套的状态属性将在每次呈现时被新属性替换）

1. Required类具有引用语义，因此field.validators.contains(Required())永远不会匹配
2. requiredFieldsNotEmpty()的计算依赖于状态（由于声明var text: String by mutableStateOf("")），但没有 Package 在derivedStateOf中
   以下调整：

sealed interface Validator
open class Email(var message: String = EMAIL_MESSAGE): Validator
data class Required(var message: String = REQUIRED_MESSAGE): Validator
open class Regex(var message: String, var regex: String = REGEX_MESSAGE): Validator
open class MinLength(val length: Int, var message: String = MIN_LENGTH_MESSAGE): Validator

@Preview
    @Composable
    fun Screen(){
        val fields = remember {
            listOf(
                Field(name = "username", validators = listOf(Required(), MinLength(length = 3))),
                Field(name = "email", validators = listOf(Required(), Email()))
            )
        }

        val state by remember { mutableStateOf(FormState()) }
        val buttonEnabled by remember { derivedStateOf { state.requiredFieldsNotEmpty() } }

        Column {
            Form(
                state = state,
                fields = fields
            )
            Button(
                enabled = buttonEnabled,
                onClick = { if (state.validate()) toast("Our form works!") }) {
                Text("Submit")
            }
        }
    }

解决了这个问题。

我尝试了提供的代码，我发现从UI中提取状态是最佳实践。
在提供的代码中，FormComposable函数遵循了从UI中提取状态的最佳实践。Form类负责维护表单字段的状态，并处理表单字段的验证。UI是使用JetpackCompose可组合函数组合的，这些函数使用Form类提供的状态。

class FormFieldState(
    val name: String,
    label: String,
    placeHolder: String? = null,
    val keyboardType: KeyboardType = KeyboardType.Text,
    private val validators: List<Validator> = emptyList()
) {
    var text by mutableStateOf("")
        private set
 
    var label by mutableStateOf(label)
        private set

    var supportingText by mutableStateOf("")
        private set

    val placeHolderText by mutableStateOf(placeHolder)
    var isError by mutableStateOf(false)
        private set

    fun onValueChange(value: String) {
        text = value
        isError = false
        supportingText = ""
    }

    @RequiresApi(Build.VERSION_CODES.O)
    fun validate(): Boolean {
        return validators.map {
            val isValid = when (it) {
                is Email -> Patterns.EMAIL_ADDRESS.matcher(text).matches()
                    // Validates if the text matches a valid email address pattern

                is Required -> text.isNotEmpty()
                    // Validates if the text is not empty (i.e., required)

                is NotExpired -> {
                    val month = text.substring(0, 2).trimStart('0').toInt()
                    val year = text.substring(2, 4).trimStart('0').toInt()
                    val now = LocalDate.now()
                    (year < now.year) || (year == now.year && month < now.monthValue)
                }
                    // Validates if the date is not expired by comparing the month and year

                is MinLength -> text.length > it.length
                    // Validates if the text has a minimum length

            }
            if (!isValid) {
                supportingText = it.message
                isError = true
                // If the validation fails, set the supporting text and mark the field as an error
            }
            isValid
            // Returns the result of the validation
        }.all { it }
        // Returns true if all validations pass, false otherwise
    }
}

FormField函数是一个可组合的函数，用于表示用户界面中的表单字段。以FormFieldState类型的formFieldState对象和onValueChange回调函数为参数

@Composable
fun FormField(formFieldState: FormFieldState, onValueChange: (String) -> Unit) {
    OutlinedTextField(
        value = formFieldState.text,
        onValueChange = onValueChange,
        label = { Text(formFieldState.label) },
        supportingText = { Text(formFieldState.supportingText) },
        isError = formFieldState.isError,
        keyboardOptions = KeyboardOptions(keyboardType = formFieldState.keyboardType),
        placeholder = { formFieldState.placeHolderText?.let { Text(it) } }
    )
}

Form类表示表单字段的集合，提供处理和验证表单数据的功能。

class Form(val fields: List<FormFieldState>) {

    // State Indicates whether any form fields are empty
    var hasEmptyFields by mutableStateOf(true)
        private set

    // Handles the value change of a form field
    // Updates the form field's value and checks if any fields are empty
    fun onValueChange(fieldState: FormFieldState, value: String) {
        fieldState.onValueChange(value)
        hasEmptyFields = value.isBlank()
    }

    // Validates all the form fields
    @RequiresApi(Build.VERSION_CODES.O)
    fun validate() = fields.all { it.validate() }

    // Retrieves the form data as a map
    fun formData() = fields.associate { it.name to it.text }
}

Form和FormFieldState的一个示例用法。

@RequiresApi(Build.VERSION_CODES.O)
@Preview
@Composable
fun FormComposable(submitData: (Map<String, String>) -> Unit = {}) {
    val form = remember {
        Form(
            listOf(
                FormFieldState("firstName", "First name", validators = listOf(Required())),
                FormFieldState("lastName", "Last name", validators = listOf(Required())),
                FormFieldState(
                    "panNumber",
                    "Pan number",
                    validators = listOf(MinLength(8), Required()),
                    keyboardType = KeyboardType.Number
                ),
            )
        )
    }

    Column(
        modifier = Modifier
            .fillMaxWidth()
            .padding(16.dp)
    ) {
        form.fields.forEach {
            FormField(it) { value ->
                form.onValueChange(it, value)
            }
        }

        Button(
            modifier = Modifier.align(Alignment.CenterHorizontally),
            enabled = !form.hasEmptyFields,
            onClick = { if (form.validate()) submitData(form.formData()) }
        ) {
            Text(text = "Submit")
        }
    }
}