diff --git a/CHANGES.rst b/CHANGES.rst
index 83f77c2a..0c4c7ac4 100644
--- a/CHANGES.rst
+++ b/CHANGES.rst
@@ -1,5 +1,16 @@
 .. currentmodule:: wtforms
 
+Version 3.3.0b3
+---------------
+
+Unreleased
+
+- Add :func:`fields.enum_choices`, :func:`fields.enum_coerce` and
+  :func:`~wtforms.datalist.enum_datalist` for Enum-backed choices,
+  replacing ``SelectChoice.from_enum`` and friends. :issue:`922`
+- An Enum ``coerce`` is no longer wrapped, and options default to
+  ``member.value``. :issue:`922`
+
 Version 3.3.0b2
 ---------------
 
diff --git a/docs/fields.rst b/docs/fields.rst
index 355bc753..8657144a 100644
--- a/docs/fields.rst
+++ b/docs/fields.rst
@@ -337,9 +337,7 @@ Choice Fields
     option cannot be applied to your problem you may wish to skip choice
     validation (see below).
 
-    **Select fields with ``<optgroup>``**::
-
-        Use :class:`SelectChoice` to assign an option to an ``<optgroup>``.
+    **Select fields with optgroup**::
 
         class PastebinEntry(Form):
             language = SelectField('Programming Language', choices=[
@@ -349,6 +347,8 @@ Choice Fields
                 SelectChoice('text', 'Plain Text'),
             ])
 
+    Use :class:`SelectChoice` to assign an option to an ``<optgroup>``.
+
     **Select fields with dynamic choice values**::
 
         def available_groups():
@@ -400,28 +400,44 @@ Choice Fields
     **Select fields backed by an Enum**::
 
         from enum import Enum
+        from wtforms.fields import enum_choices, enum_coerce
 
         class Color(Enum):
-            RED = 1
-            GREEN = 2
-            BLUE = 3
+            RED = "red"
+            GREEN = "green"
+            BLUE = "blue"
 
         class PaintForm(Form):
-            color = SelectField(choices=SelectChoice.from_enum(Color), coerce=Color)
+            color = SelectField(
+                choices=enum_choices(Color),
+                coerce=enum_coerce(Color),
+            )
+
+    :func:`~wtforms.fields.enum_choices` builds the option list from
+    the Enum members; by default the HTML ``value`` of each option is the
+    member's ``value`` (``"red"``, ``"green"``, ...).
+    :func:`~wtforms.fields.enum_coerce` returns the matching ``coerce``
+    callable that resolves the submitted string back into a member, so
+    ``form.color.data`` is a ``Color`` member after submit. Pre-selecting
+    works the usual way, with an Enum member: ``PaintForm(color=Color.RED)``.
 
-    :meth:`SelectChoice.from_enum` builds the option list from the Enum items;
-    the HTML ``value`` of each option is the item's ``name``. Passing the
-    Enum class itself as ``coerce`` installs the matching coercion, so
-    ``form.color.data`` is a ``Color`` item after submit. Pre-selecting
-    works the usual way, with an Enum item: ``PaintForm(color=Color.RED)``.
+    Use ``by="name"`` on **both** helpers when the Enum value is not a good
+    transport identifier — non-unique, non-serialisable, or when you simply
+    want ``member.name`` on the wire::
+
+        class PaintForm(Form):
+            color = SelectField(
+                choices=enum_choices(Color, by="name"),
+                coerce=enum_coerce(Color, by="name"),
+            )
 
-    By default the option label is ``str(item)`` if the Enum defines its
+    By default the option label is ``str(member)`` if the Enum defines its
     own ``__str__`` (also the case for :class:`enum.StrEnum`), otherwise
-    ``item.name``. To customise, pass a ``label`` callable taking an Enum
-    item and returning the label string::
+    ``member.name``. To customise, pass a ``label`` callable taking an Enum
+    member and returning the label string::
 
-        SelectChoice.from_enum(Color, label=lambda item: item.name.title())
-        # → [SelectChoice('RED', 'Red'), SelectChoice('GREEN', 'Green'), SelectChoice('BLUE', 'Blue')]
+        enum_choices(Color, label=lambda member: member.name.title())
+        # → [SelectChoice('red', 'Red'), SelectChoice('green', 'Green'), SelectChoice('blue', 'Blue')]
 
     **Skipping choice validation**::
 
@@ -454,6 +470,10 @@ Choice Fields
    which are not in the given choices list will cause validation on the field
    to fail.
 
+.. autofunction:: wtforms.fields.enum_choices
+
+.. autofunction:: wtforms.fields.enum_coerce
+
 Submit fields
 -------------
 
@@ -580,8 +600,6 @@ Data Lists
 
 .. currentmodule:: wtforms
 
-.. autoclass:: DataListChoice
-
 .. class:: DataList(choices=None, *, render_kw=None, widget=None)
 
     A :mdn-tag:`datalist` of suggestions. Unlike
@@ -658,6 +676,9 @@ Data Lists
     :class:`~wtforms.fields.TextAreaField` is silently ignored by the
     browser.
 
+.. autoclass:: DataListChoice
+
+.. autofunction:: wtforms.datalist.enum_datalist
 
 .. currentmodule:: wtforms.fields
 
diff --git a/src/wtforms/__init__.py b/src/wtforms/__init__.py
index 683f5f43..e25bfdbe 100644
--- a/src/wtforms/__init__.py
+++ b/src/wtforms/__init__.py
@@ -2,6 +2,7 @@
 from wtforms import widgets
 from wtforms.datalist import DataList
 from wtforms.datalist import DataListChoice
+from wtforms.datalist import enum_datalist
 from wtforms.fields.choices import Choice
 from wtforms.fields.choices import RadioField
 from wtforms.fields.choices import SelectChoice
@@ -86,4 +87,5 @@
     "Choice",
     "SelectChoice",
     "DataListChoice",
+    "enum_datalist",
 ]
diff --git a/src/wtforms/datalist.py b/src/wtforms/datalist.py
index d1b41294..e0d34ba5 100644
--- a/src/wtforms/datalist.py
+++ b/src/wtforms/datalist.py
@@ -4,9 +4,10 @@
 
 from wtforms import widgets
 from wtforms._compat import get_signature
+from wtforms.fields.choices import _enum_options
 from wtforms.fields.choices import Choice
 
-__all__ = ("DataList", "DataListChoice")
+__all__ = ("DataList", "DataListChoice", "enum_datalist")
 
 
 @dataclass
@@ -35,16 +36,6 @@ def __post_init__(self):
     def __iter__(self):
         return iter((self.value, self.label, self.render_kw))
 
-    @classmethod
-    def from_enum(cls, enum_cls, *, label=None):
-        """Build a list of choices from an :class:`enum.Enum` class.
-
-        See :meth:`SelectChoice.from_enum` for details.
-        """
-        if label is None:
-            label = str if "__str__" in enum_cls.__dict__ else lambda m: m.name
-        return [cls(value=m.name, label=label(m)) for m in enum_cls]
-
     @classmethod
     def from_input(cls, input):
         """Coerce a value passed by the user into a :class:`DataListChoice`."""
@@ -73,6 +64,20 @@ def from_input(cls, input):
             return cls(*input)
 
 
+def enum_datalist(enum_cls, *, by="value", label=None):
+    """Build a list of :class:`DataListChoice` from an :class:`enum.Enum` class.
+
+    Same semantics as :func:`~wtforms.fields.enum_choices`: ``by`` selects
+    which member attribute becomes the ``<option>`` value (``"value"`` by
+    default, ``"name"`` otherwise) and ``label`` defaults to ``str(member)``
+    when the Enum defines its own ``__str__``, else ``member.name``.
+
+    A ``<datalist>`` only suggests values for a free-text field, so there is
+    no coercion counterpart — the field stores whatever string is submitted.
+    """
+    return _enum_options(enum_cls, by, label, DataListChoice)
+
+
 class DataList:
     """A ``<datalist>`` of suggestions attached to a single field.
 
diff --git a/src/wtforms/fields/__init__.py b/src/wtforms/fields/__init__.py
index 57de3fe5..f8d8d2d1 100644
--- a/src/wtforms/fields/__init__.py
+++ b/src/wtforms/fields/__init__.py
@@ -1,4 +1,6 @@
 from wtforms.fields.choices import Choice
+from wtforms.fields.choices import enum_choices
+from wtforms.fields.choices import enum_coerce
 from wtforms.fields.choices import RadioField
 from wtforms.fields.choices import SelectChoice
 from wtforms.fields.choices import SelectField
@@ -46,6 +48,8 @@
     "SelectMultipleField",
     "SelectFieldBase",
     "RadioField",
+    "enum_choices",
+    "enum_coerce",
     "DateTimeField",
     "DateField",
     "TimeField",
diff --git a/src/wtforms/fields/choices.py b/src/wtforms/fields/choices.py
index e911bab9..e3712973 100644
--- a/src/wtforms/fields/choices.py
+++ b/src/wtforms/fields/choices.py
@@ -2,7 +2,6 @@
 from dataclasses import dataclass
 from dataclasses import field
 from dataclasses import replace
-from enum import Enum
 from itertools import groupby
 from operator import attrgetter
 from typing import NamedTuple
@@ -21,18 +20,6 @@
 )
 
 
-def _enum_coerce(enum_cls):
-    def coerce(v):
-        if isinstance(v, enum_cls):
-            return v
-        try:
-            return enum_cls[v]
-        except KeyError as e:
-            raise ValueError(str(e)) from e
-
-    return coerce
-
-
 class Choice(NamedTuple):
     """
     A rendered option yielded by
@@ -90,19 +77,6 @@ def __post_init__(self):
     def __iter__(self):
         return iter((self.value, self.label, self.render_kw, self.optgroup))
 
-    @classmethod
-    def from_enum(cls, enum_cls, *, label=None):
-        """Build a list of choices from an :class:`enum.Enum` class.
-
-        The HTML value of each option is the item ``name``. The label
-        defaults to ``str(item)`` when the Enum defines its own
-        ``__str__``, otherwise to ``item.name``. Pass ``label=`` (a
-        callable taking an item) to override.
-        """
-        if label is None:
-            label = str if "__str__" in enum_cls.__dict__ else lambda m: m.name
-        return [cls(value=m.name, label=label(m)) for m in enum_cls]
-
     @classmethod
     def from_input(cls, input, optgroup=None):
         """Coerce a value passed by the user via ``choices=...`` into a
@@ -141,6 +115,60 @@ def from_input(cls, input, optgroup=None):
             return cls(*input, optgroup=optgroup)
 
 
+def _enum_options(enum_cls, by, label, factory):
+    if by not in ("value", "name"):
+        raise ValueError(f"by must be 'value' or 'name', got {by!r}")
+    if label is None:
+        label = str if "__str__" in enum_cls.__dict__ else lambda m: m.name
+    return [factory(value=getattr(m, by), label=label(m)) for m in enum_cls]
+
+
+def enum_choices(enum_cls, *, by="value", label=None):
+    """Build a list of :class:`SelectChoice` from an :class:`enum.Enum` class.
+
+    ``by`` selects which member attribute becomes the HTML ``value=``:
+    ``"value"`` (the default) emits ``member.value``, ``"name"`` emits
+    ``member.name``. Use ``"name"`` for enums whose values are not good
+    transport identifiers (non-string, non-unique or non-serialisable).
+
+    The label defaults to ``str(member)`` when the Enum defines its own
+    ``__str__``, otherwise to ``member.name``. Pass ``label=`` (a callable
+    taking a member) to override.
+
+    Pair with :func:`enum_coerce` using the same ``by`` to round-trip the
+    submitted string back into a member.
+    """
+    return _enum_options(enum_cls, by, label, SelectChoice)
+
+
+def enum_coerce(enum_cls, *, by="value"):
+    """Return a ``coerce`` callable mapping a submitted string back to an
+    :class:`enum.Enum` member.
+
+    ``by`` must match the one passed to :func:`enum_choices`: ``"value"``
+    (the default) resolves ``str(member.value)`` — so ``IntEnum`` values
+    round-trip too — and ``"name"`` resolves ``member.name``. Already-coerced
+    members pass through unchanged.
+    """
+    if by not in ("value", "name"):
+        raise ValueError(f"by must be 'value' or 'name', got {by!r}")
+
+    def coerce(v):
+        if isinstance(v, enum_cls):
+            return v
+
+        try:
+            if by == "value":
+                by_value = {str(m.value): m for m in enum_cls}
+                return by_value[str(v)]
+            else:
+                return enum_cls[v]
+        except KeyError as e:
+            raise ValueError(str(e)) from e
+
+    return coerce
+
+
 def _normalize_iter_choice(choice):
     """Coerce a value yielded by :meth:`SelectFieldBase.iter_choices` or
     :meth:`SelectFieldBase.iter_groups` into a :class:`Choice`.
@@ -334,8 +362,6 @@ def __init__(
         **kwargs,
     ):
         super().__init__(label, validators, **kwargs)
-        if isinstance(coerce, type) and issubclass(coerce, Enum):
-            coerce = _enum_coerce(coerce)
         self.coerce = coerce
         if callable(choices):
             self._choices_callable = choices
diff --git a/tests/fields/test_select.py b/tests/fields/test_select.py
index 7618118c..f55c445a 100644
--- a/tests/fields/test_select.py
+++ b/tests/fields/test_select.py
@@ -8,6 +8,8 @@
 from wtforms import validators
 from wtforms import widgets
 from wtforms.fields import Choice
+from wtforms.fields import enum_choices
+from wtforms.fields import enum_coerce
 from wtforms.fields import Field
 from wtforms.fields import SelectChoice
 from wtforms.fields import SelectField
@@ -630,76 +632,161 @@ class _Level(IntEnum):
     HIGH = 2
 
 
-def test_choice_from_enum_plain():
-    """Plain Enum without ``__str__`` falls back to ``member.name`` for the label."""
-    assert SelectChoice.from_enum(_Plain) == [
+class _Provider(Enum):
+    GITHUB = "github"
+    GITLAB = "gitlab"
+
+
+def test_enum_choices_default_value():
+    """By default the HTML value is ``member.value``."""
+    assert enum_choices(_Provider) == [
+        SelectChoice(value="github", label="GITHUB"),
+        SelectChoice(value="gitlab", label="GITLAB"),
+    ]
+
+
+def test_enum_choices_by_name():
+    """``by="name"`` puts ``member.name`` on the wire."""
+    assert enum_choices(_Plain, by="name") == [
         SelectChoice(value="RED", label="RED"),
         SelectChoice(value="GREEN", label="GREEN"),
     ]
 
 
-def test_choice_from_enum_with_dunder_str():
-    """An Enum that overrides ``__str__`` uses ``str(member)`` as label."""
-    assert SelectChoice.from_enum(_Pretty) == [
-        SelectChoice(value="RED", label="Red"),
-        SelectChoice(value="GREEN", label="Green"),
+def test_enum_choices_dunder_str_label():
+    """An Enum overriding ``__str__`` uses ``str(member)`` as label."""
+    assert enum_choices(_Pretty) == [
+        SelectChoice(value=1, label="Red"),
+        SelectChoice(value=2, label="Green"),
     ]
 
 
 @pytest.mark.skipif(sys.version_info < (3, 11), reason="StrEnum requires 3.11+")
-def test_choice_from_enum_strenum():
-    """StrEnum uses ``str(member)`` (the value) as label."""
+def test_enum_choices_strenum():
+    """StrEnum uses ``str(member)`` (the value) for both value and label."""
 
     class _Status(StrEnum):
         ACTIVE = "active"
         INACTIVE = "inactive"
 
-    assert SelectChoice.from_enum(_Status) == [
-        SelectChoice(value="ACTIVE", label="active"),
-        SelectChoice(value="INACTIVE", label="inactive"),
+    assert enum_choices(_Status) == [
+        SelectChoice(value="active", label="active"),
+        SelectChoice(value="inactive", label="inactive"),
     ]
 
 
-def test_choice_from_enum_intenum():
-    """IntEnum has no ``__str__`` injected; falls back to ``member.name``."""
-    assert SelectChoice.from_enum(_Level) == [
-        SelectChoice(value="LOW", label="LOW"),
-        SelectChoice(value="HIGH", label="HIGH"),
+def test_enum_choices_intenum_label():
+    """IntEnum has no ``__str__`` injected; label falls back to ``member.name``."""
+    assert enum_choices(_Level) == [
+        SelectChoice(value=1, label="LOW"),
+        SelectChoice(value=2, label="HIGH"),
     ]
 
 
-def test_choice_from_enum_custom_label():
+def test_enum_choices_custom_label():
     """A ``label=`` callable overrides the default."""
-    assert SelectChoice.from_enum(_Plain, label=lambda m: m.name.title()) == [
-        SelectChoice(value="RED", label="Red"),
-        SelectChoice(value="GREEN", label="Green"),
+    assert enum_choices(_Provider, label=lambda m: m.name.title()) == [
+        SelectChoice(value="github", label="Github"),
+        SelectChoice(value="gitlab", label="Gitlab"),
     ]
 
 
-def test_select_field_enum_coerce_round_trip():
-    """``coerce=EnumCls`` round-trips form data back to an Enum member."""
-    F = make_form(a=SelectField(choices=SelectChoice.from_enum(_Plain), coerce=_Plain))
+def test_enum_choices_invalid_by():
+    """An unknown ``by`` is rejected."""
+    with pytest.raises(ValueError):
+        enum_choices(_Provider, by="bogus")
+
+
+def test_enum_coerce_value_round_trip():
+    """The default ``enum_coerce`` round-trips ``member.value``."""
+    F = make_form(
+        a=SelectField(
+            choices=enum_choices(_Provider),
+            coerce=enum_coerce(_Provider),
+        )
+    )
+    form = F(DummyPostData(a=["github"]))
+    assert form.a.data is _Provider.GITHUB
+    assert form.validate()
+
+
+def test_enum_coerce_intenum_value_round_trip():
+    """``enum_coerce`` resolves through ``str(value)``, so IntEnum round-trips."""
+    F = make_form(
+        a=SelectField(
+            choices=enum_choices(_Level),
+            coerce=enum_coerce(_Level),
+        )
+    )
+    form = F(DummyPostData(a=["1"]))
+    assert form.a.data is _Level.LOW
+    assert form.validate()
+
+
+def test_enum_coerce_by_name_round_trip():
+    """``by="name"`` round-trips ``member.name``."""
+    F = make_form(
+        a=SelectField(
+            choices=enum_choices(_Plain, by="name"),
+            coerce=enum_coerce(_Plain, by="name"),
+        )
+    )
     form = F(DummyPostData(a=["RED"]))
     assert form.a.data is _Plain.RED
     assert form.validate()
 
 
-def test_select_field_enum_coerce_accepts_member():
-    """``coerce=EnumCls`` accepts an already-coerced member without re-lookup."""
-    F = make_form(a=SelectField(choices=SelectChoice.from_enum(_Plain), coerce=_Plain))
-    form = F(a=_Plain.GREEN)
-    assert form.a.data is _Plain.GREEN
+def test_enum_coerce_accepts_member():
+    """``enum_coerce`` accepts an already-coerced member without re-lookup."""
+    F = make_form(
+        a=SelectField(
+            choices=enum_choices(_Provider),
+            coerce=enum_coerce(_Provider),
+        )
+    )
+    form = F(a=_Provider.GITLAB)
+    assert form.a.data is _Provider.GITLAB
 
 
-def test_select_field_enum_coerce_invalid():
-    """An unknown name fails validation cleanly (KeyError → ValueError)."""
-    F = make_form(a=SelectField(choices=SelectChoice.from_enum(_Plain), coerce=_Plain))
-    form = F(DummyPostData(a=["BAD"]))
+def test_enum_coerce_invalid():
+    """An unknown submitted value fails validation cleanly (KeyError → ValueError)."""
+    F = make_form(
+        a=SelectField(
+            choices=enum_choices(_Provider),
+            coerce=enum_coerce(_Provider),
+        )
+    )
+    form = F(DummyPostData(a=["nope"]))
     assert not form.validate()
     assert form.a.data is None
     assert "Invalid Choice: could not coerce." in form.a.errors
 
 
+def test_enum_coerce_invalid_by():
+    """An unknown ``by`` is rejected."""
+    with pytest.raises(ValueError):
+        enum_coerce(_Provider, by="bogus")
+
+
+def test_select_field_enum_class_as_coerce():
+    """A string-valued Enum works as ``coerce`` directly (standard lookup)."""
+    F = make_form(
+        a=SelectField(
+            choices=enum_choices(_Provider),
+            coerce=_Provider,
+        )
+    )
+    form = F(DummyPostData(a=["github"]))
+    assert form.a.data is _Provider.GITHUB
+    assert form.validate()
+
+
+def test_select_field_coerce_passed_through():
+    """``coerce`` is stored as provided — no implicit wrapping."""
+    F = make_form(a=SelectField(choices=[SelectChoice("x", "X")], coerce=_Plain))
+    assert F().a.coerce is _Plain
+
+
 def test_iter_choices_tuple_unpacking():
     """``iter_choices()`` yields ``Choice`` 4-tuples — unpacking matches the
     3.2 yield shape ``(value, label, selected, render_kw)``."""
@@ -713,6 +800,11 @@ def test_iter_choices_tuple_unpacking():
 
 def test_select_field_enum_renders_selected():
     """Pre-selecting a member highlights the right option."""
-    F = make_form(a=SelectField(choices=SelectChoice.from_enum(_Plain), coerce=_Plain))
-    form = F(a=_Plain.GREEN)
-    assert '<option selected value="GREEN">GREEN</option>' in form.a()
+    F = make_form(
+        a=SelectField(
+            choices=enum_choices(_Provider),
+            coerce=enum_coerce(_Provider),
+        )
+    )
+    form = F(a=_Provider.GITLAB)
+    assert '<option selected value="gitlab">GITLAB</option>' in form.a()
diff --git a/tests/fields/test_selectmultiple.py b/tests/fields/test_selectmultiple.py
index d0557f01..985f364a 100644
--- a/tests/fields/test_selectmultiple.py
+++ b/tests/fields/test_selectmultiple.py
@@ -1,10 +1,13 @@
 from enum import Enum
+from enum import IntEnum
 
 import pytest
 
 from tests.common import DummyPostData
 from wtforms import validators
 from wtforms.fields import Choice
+from wtforms.fields import enum_choices
+from wtforms.fields import enum_coerce
 from wtforms.fields import SelectChoice
 from wtforms.fields import SelectField
 from wtforms.fields import SelectMultipleField
@@ -290,16 +293,50 @@ def test_can_supply_coercable_values_as_options():
 
 
 class _Color(Enum):
-    RED = 1
-    GREEN = 2
-    BLUE = 3
+    RED = "red"
+    GREEN = "green"
+    BLUE = "blue"
 
 
-def test_select_multiple_enum_round_trip():
-    """``coerce=EnumCls`` works for SelectMultipleField too."""
+def test_select_multiple_enum_value_round_trip():
+    """The default value coercion works for SelectMultipleField too."""
     F = make_form(
-        a=SelectMultipleField(choices=SelectChoice.from_enum(_Color), coerce=_Color)
+        a=SelectMultipleField(
+            choices=enum_choices(_Color),
+            coerce=enum_coerce(_Color),
+        )
+    )
+    form = F(DummyPostData(a=["red", "blue"]))
+    assert form.validate()
+    assert form.a.data == [_Color.RED, _Color.BLUE]
+
+
+def test_select_multiple_enum_by_name_round_trip():
+    """``by="name"`` round-trips member names on multi-select."""
+    F = make_form(
+        a=SelectMultipleField(
+            choices=enum_choices(_Color, by="name"),
+            coerce=enum_coerce(_Color, by="name"),
+        )
     )
     form = F(DummyPostData(a=["RED", "BLUE"]))
     assert form.validate()
     assert form.a.data == [_Color.RED, _Color.BLUE]
+
+
+def test_select_multiple_enum_intenum_round_trip():
+    """``enum_coerce`` resolves through ``str(value)``, so IntEnum round-trips."""
+
+    class _Kind(IntEnum):
+        SMALL = 2
+        BIG = 5
+
+    F = make_form(
+        a=SelectMultipleField(
+            choices=enum_choices(_Kind),
+            coerce=enum_coerce(_Kind),
+        )
+    )
+    form = F(DummyPostData(a=["2", "5"]))
+    assert form.validate()
+    assert form.a.data == [_Kind.SMALL, _Kind.BIG]
diff --git a/tests/test_datalist.py b/tests/test_datalist.py
index 9f5beb34..bc381819 100644
--- a/tests/test_datalist.py
+++ b/tests/test_datalist.py
@@ -1,9 +1,12 @@
+from enum import Enum
+
 import pytest
 
 from tests.common import DummyPostData
 from wtforms import DataList
 from wtforms import DataListChoice
 from wtforms import EmailField
+from wtforms import enum_datalist
 from wtforms import FieldList
 from wtforms import Form
 from wtforms import FormField
@@ -337,3 +340,20 @@ def test_default_widget_is_datalist_widget():
     assert isinstance(DataList.widget, DataListWidget)
     dl = DataList(["a"])
     assert isinstance(dl.widget, DataListWidget)
+
+
+def test_enum_datalist():
+    """``enum_datalist`` mirrors ``enum_choices`` for DataListChoice."""
+
+    class Provider(Enum):
+        GITHUB = "github"
+        GITLAB = "gitlab"
+
+    assert enum_datalist(Provider) == [
+        DataListChoice(value="github", label="GITHUB"),
+        DataListChoice(value="gitlab", label="GITLAB"),
+    ]
+    assert enum_datalist(Provider, by="name") == [
+        DataListChoice(value="GITHUB", label="GITHUB"),
+        DataListChoice(value="GITLAB", label="GITLAB"),
+    ]