diff --git a/README.md b/README.md
index a8c2ac4..0108405 100644
--- a/README.md
+++ b/README.md
@@ -51,9 +51,9 @@ pipe(
 ## Documentation
 
 Documentation is generated for each github tagged release. The latest
-documentation can be found [here](https://jsr.io/@baetheus/fun). Following is a list
-of the [algebraic data types](https://en.wikipedia.org/wiki/Algebraic_data_type)
-and
+documentation can be found [here](https://jsr.io/@baetheus/fun). Following is a
+list of the
+[algebraic data types](https://en.wikipedia.org/wiki/Algebraic_data_type) and
 [algebraic structures](https://en.wikipedia.org/wiki/Algebraic_structure)/[type classes](https://en.wikipedia.org/wiki/Type_class)
 that are implemented in fun. Note that some of these types are bote data
 structures and more general algebraic structures.
diff --git a/contrib/dux.ts b/contrib/dux.ts
new file mode 100644
index 0000000..14e763a
--- /dev/null
+++ b/contrib/dux.ts
@@ -0,0 +1,284 @@
+import type { DatumEither } from "../datum_either.ts";
+import type { Lens } from "../optic.ts";
+
+import * as D from "../datum.ts";
+import * as DE from "../datum_either.ts";
+import * as O from "../optic.ts";
+
+import { pipe } from "../fn.ts";
+
+// =======
+// Actions
+// ======
+
+/**
+ * The bare minimum interface for actions in the dux system.
+ * If your existing store doesn't have actions with a type parameter
+ * that you can switch on then dux won't work (at least with typescript).
+ *
+ * @since 2.1.0
+ */
+export type ActionType = {
+  readonly type: string;
+};
+
+/**
+ * Interface for FSA Action.
+ *
+ * @since 2.1.0
+ */
+export interface Action<P> extends ActionType {
+  readonly value: P;
+  readonly error: boolean;
+}
+
+/**
+ * Interface for action matcher property
+ *
+ * @since 2.1.0
+ */
+export type ActionMatcher<P> = {
+  readonly match: (action: ActionType) => action is Action<P>;
+};
+
+/**
+ * Interface for action creator function
+ *
+ * @since 2.1.0
+ */
+export type ActionFunction<P> = (payload: P) => Action<P>;
+
+/**
+ * Interface for action creator intersection
+ *
+ * @since 2.1.0
+ */
+export type ActionCreator<P> =
+  & ActionFunction<P>
+  & ActionMatcher<P>
+  & ActionType;
+
+/**
+ * Extract an Action type from an ActionCreator
+ *
+ * @since 8.0.0
+ */
+export type ExtractAction<T> = T extends ActionCreator<infer P>[] ? Action<P>
+  : never;
+
+/**
+ * Interface for "Success" Action payload.
+ *
+ * @since 2.1.0
+ */
+export interface Success<P, R> {
+  readonly params: P;
+  readonly result: R;
+}
+
+/**
+ * Interface for "Failure" Action payload.
+ *
+ * @since 2.1.0
+ */
+export interface Failure<P, E> {
+  readonly params: P;
+  readonly error: E;
+}
+/**
+ * Interface for async action creator
+ *
+ * @since 2.1.0
+ */
+export interface AsyncActionCreators<
+  P,
+  R = unknown,
+  E = unknown,
+> {
+  readonly pending: ActionCreator<P>;
+  readonly success: ActionCreator<Success<P, R>>;
+  readonly failure: ActionCreator<Failure<P, E>>;
+}
+
+/**
+ * Interface for the action creator bundle.
+ *
+ * @since 2.1.0
+ */
+export type ActionCreatorBundle<G extends string> = {
+  simple: <P>(type: string) => ActionCreator<P>;
+  async: <P, R = unknown, E = unknown>(
+    type: string,
+  ) => AsyncActionCreators<P, R, E>;
+  group: G;
+};
+
+/**
+ * @since 2.1.0
+ */
+export function collapseType(...types: string[]): string {
+  return types.length > 0 ? types.join("/") : "UNKNOWN_TYPE";
+}
+
+function matcherFactory<P>(type: string): ActionMatcher<P> {
+  return {
+    match: (action: ActionType): action is Action<P> => action.type === type,
+  };
+}
+
+function tagFactory(...tags: string[]): ActionType {
+  return { type: collapseType(...tags) };
+}
+
+/**
+ * The simplest way to create an action.
+ * Generally, for all but the simplest of applications, using
+ * actionCreatorsFactory is a better move.
+ *
+ * @since 7.0.0
+ */
+export function actionFactory<P>(type: string): ActionFunction<P> {
+  return ((value: P) => ({ type, value })) as ActionFunction<P>;
+}
+
+/**
+ * General action creator factory
+ *
+ * @since 2.1.0
+ */
+function actionCreator<P>(
+  tag: string,
+): ActionCreator<P> {
+  return Object.assign(
+    actionFactory<P>(tag),
+    matcherFactory<P>(tag),
+    tagFactory(tag),
+  );
+}
+
+/**
+ * Async action creator factory
+ *
+ * @since 2.1.0
+ */
+function asyncActionsCreator<P, R, E>(
+  group: string,
+): AsyncActionCreators<P, R, E> {
+  return {
+    pending: actionCreator<P>(collapseType(group, "PENDING")),
+    failure: actionCreator<Failure<P, E>>(collapseType(group, "FAILURE")),
+    success: actionCreator<Success<P, R>>(collapseType(group, "SUCCESS")),
+  };
+}
+
+/**
+ * General action group creator (wraps other action creators into a group)
+ *
+ * @since 2.1.0
+ */
+export function actionCreatorFactory<G extends string>(
+  group: G,
+): ActionCreatorBundle<G> {
+  return {
+    group,
+    simple: <P>(type: string) => actionCreator<P>(collapseType(group, type)),
+    async: <P, R, E>(type: string) =>
+      asyncActionsCreator<P, R, E>(collapseType(group, type)),
+  };
+}
+
+// ========
+// Reducers
+// ========
+
+/**
+ * Reducer Interface
+ *
+ * @since 2.1.0
+ */
+export type Reducer<S, A extends ActionType = ActionType> = (s: S, a: A) => S;
+
+/**
+ * Case function matches ActionCreator to Reducer.
+ *
+ * @since 2.1.0
+ */
+export function caseFn<S, P>(
+  action: ActionCreator<P>,
+  reducer: Reducer<S, Action<P>>,
+): Reducer<S, ActionType> {
+  return (s, a) => (action.match(a) ? reducer(s, a) : s);
+}
+
+/**
+ * Case function matches multiple ActionCreators to a Reducer.
+ *
+ * @since 2.1.0
+ */
+export function casesFn<S, A extends ActionCreator<unknown>[]>(
+  actionCreators: A,
+  reducer: Reducer<S, ExtractAction<A>>,
+): Reducer<S, ActionType> {
+  return (s, a) =>
+    actionCreators.some(({ match }) => match(a))
+      ? reducer(s, <ExtractAction<A>> a)
+      : s;
+}
+
+/**
+ * Compose caseFn and casesFn.
+ *
+ * @since 2.1.0
+ */
+export function reducerFn<S>(
+  ...cases: Array<Reducer<S, ActionType>>
+): Reducer<S, ActionType> {
+  return (state, action) => cases.reduce((s, r) => r(s, action), state);
+}
+
+/**
+ * Compose caseFn and casesFn with initial state.
+ *
+ * @since 2.1.0
+ */
+export function reducerDefaultFn<S>(
+  initialState: S,
+  ...cases: Array<Reducer<S, ActionType>>
+): Reducer<S | undefined, ActionType> {
+  return (state = initialState, action) =>
+    cases.reduce((s, r) => r(s, action), state);
+}
+
+/**
+ * Generate a reducer that wraps a single DatumEither store value
+ *
+ * @since 2.1.0
+ */
+export function asyncReducerFactory<P, R, E, S>(
+  action: AsyncActionCreators<P, R, E>,
+  lens: Lens<S, DatumEither<E, R>>,
+): Reducer<S, ActionType> {
+  return reducerFn(
+    caseFn(action.pending, pipe(lens, O.modify(D.toLoading))),
+    caseFn(
+      action.success,
+      (s, a) => pipe(lens, O.replace(DE.success(a.value.result)))(s),
+    ),
+    caseFn(
+      action.failure,
+      (s, a) => pipe(lens, O.replace(DE.failure(a.value.error)))(s),
+    ),
+  );
+}
+
+/**
+ * Filters actions by first section of action type to bypass sections of the store
+ *
+ * @since 7.1.0
+ */
+export const filterReducer = <S>(
+  match: string,
+  reducer: Reducer<S, ActionType>,
+): Reducer<S, ActionType> =>
+(state, action) =>
+  action.type.startsWith(match) ? reducer(state, action) : state;
diff --git a/datum_either.ts b/datum_either.ts
new file mode 100644
index 0000000..305c89a
--- /dev/null
+++ b/datum_either.ts
@@ -0,0 +1,506 @@
+/**
+ * The DatumEither datastructure represents an asynchronous operation that can
+ * fail. At its heart it is implemented as `() => Promise<Either<B, A>>`. This
+ * thunk makes it a performant but lazy operation at the expense of stack
+ * safety.
+ *
+ * @module DatumEither
+ * @since 2.1.0
+ */
+
+import type { Kind, Out } from "./kind.ts";
+import type { Applicable } from "./applicable.ts";
+import type { Bimappable } from "./bimappable.ts";
+import type { Bind, Flatmappable } from "./flatmappable.ts";
+import type { BindTo, Mappable } from "./mappable.ts";
+import type { Combinable } from "./combinable.ts";
+import type { Comparable } from "./comparable.ts";
+import type { Datum } from "./datum.ts";
+import type { Either } from "./either.ts";
+import type { Failable, Tap } from "./failable.ts";
+import type { Initializable } from "./initializable.ts";
+import type { Option } from "./option.ts";
+import type { Showable } from "./showable.ts";
+import type { Sortable } from "./sortable.ts";
+import type { Wrappable } from "./wrappable.ts";
+
+import * as E from "./either.ts";
+import * as D from "./datum.ts";
+import { none, some } from "./option.ts";
+import { apply as createApply } from "./applicable.ts";
+import { createBind } from "./flatmappable.ts";
+import { createBindTo } from "./mappable.ts";
+import { createTap } from "./failable.ts";
+import { handleThrow, pipe } from "./fn.ts";
+import { isNotNil } from "./nil.ts";
+
+/**
+ * The DatumEither type can best be thought of as an asynchronous function that
+ * returns an `Either`. ie. `async () => Promise<Either<B, A>>`. This
+ * forms the basis of most Promise based asynchronous communication in
+ * TypeScript.
+ *
+ * @since 2.1.0
+ */
+export type DatumEither<L, R> = Datum<Either<L, R>>;
+
+/**
+ * @since 2.0.0
+ */
+export type Success<A> = D.Refresh<E.Right<A>> | D.Replete<E.Right<A>>;
+
+/**
+ * @since 2.0.0
+ */
+export type Failure<B> = D.Refresh<E.Left<B>> | D.Replete<E.Left<B>>;
+
+/**
+ * Specifies DatumEither as a Higher Kinded Type, with covariant
+ * parameter A corresponding to the 0th index of any substitutions and covariant
+ * parameter B corresponding to the 1st index of any substitutions.
+ *
+ * @since 2.1.0
+ */
+export interface KindDatumEither extends Kind {
+  readonly kind: DatumEither<Out<this, 1>, Out<this, 0>>;
+}
+
+/**
+ * Constructs a DatumEither from a value and wraps it in an inner *Left*
+ * traditionally signaling a failure.
+ *
+ * @example
+ * ```ts
+ * import * as DE from "./datum_either.ts";
+ *
+ * const left = DE.left(1);
+ * ```
+ *
+ * @since 2.1.0
+ */
+export function left<B, A = never>(left: B): DatumEither<B, A> {
+  return D.wrap(E.left(left));
+}
+
+/**
+ * Constructs a DatumEither from a value and wraps it in an inner *Right*
+ * traditionally signaling a successful computation.
+ *
+ * @example
+ * ```ts
+ * import * as DE from "./datum_either.ts";
+ *
+ * const right = DE.right(1);
+ * ```
+ *
+ * @since 2.1.0
+ */
+export function right<A = never, B = never>(right: A): DatumEither<B, A> {
+  return D.wrap(E.right(right));
+}
+
+/**
+ * @since 2.1.0
+ */
+export const initial: D.Initial = { tag: "Initial" };
+
+/**
+ * @since 2.1.0
+ */
+export const pending: D.Pending = { tag: "Pending" };
+
+/**
+ * @since 2.1.0
+ */
+export function success<A, B = never>(
+  value: A,
+  refresh: boolean = false,
+): DatumEither<B, A> {
+  return refresh ? D.refresh(E.right(value)) : D.replete(E.right(value));
+}
+
+/**
+ * @since 2.1.0
+ */
+export function failure<B, A = never>(
+  value: B,
+  refresh: boolean = false,
+): DatumEither<B, A> {
+  return refresh ? D.refresh(E.left(value)) : D.replete(E.left(value));
+}
+
+/**
+ * @since 2.1.0
+ */
+export function constInitial<A = never, B = never>(): DatumEither<B, A> {
+  return initial;
+}
+
+/**
+ * @since 2.1.0
+ */
+export function constPending<A = never, B = never>(): DatumEither<B, A> {
+  return pending;
+}
+
+/**
+ * @since 2.1.0
+ */
+export function fromNullable<A>(a: A): DatumEither<never, NonNullable<A>> {
+  return isNotNil(a) ? success(a as NonNullable<A>) : initial;
+}
+/**
+ * @since 2.1.0
+ */
+export function match<A, B, O>(
+  onInitial: () => O,
+  onPending: () => O,
+  onFailure: (b: B, refresh: boolean) => O,
+  onSuccess: (a: A, refresh: boolean) => O,
+): (ua: DatumEither<B, A>) => O {
+  return (ua) => {
+    switch (ua.tag) {
+      case "Initial":
+        return onInitial();
+      case "Pending":
+        return onPending();
+      case "Refresh":
+        return pipe(
+          ua.value,
+          E.match((b) => onFailure(b, true), (a) => onSuccess(a, true)),
+        );
+      case "Replete":
+        return pipe(
+          ua.value,
+          E.match((b) => onFailure(b, false), (a) => onSuccess(a, false)),
+        );
+    }
+  };
+}
+
+/**
+ * Wraps a Datum of A in a try-catch block which upon failure returns B instead.
+ * Upon success returns a *Right<A>* and *Left<B>* for a failure.
+ *
+ * @since 2.1.0
+ */
+export function tryCatch<AS extends unknown[], A, B>(
+  fasr: (...as: AS) => A,
+  onThrow: (e: unknown, as: AS) => B,
+): (...as: AS) => DatumEither<B, A> {
+  return handleThrow(
+    fasr,
+    (a) => right(a),
+    (e: unknown, as) => left(onThrow(e, as)),
+  );
+}
+
+/**
+ * @since 2.0.0
+ */
+export function isSuccess<A, B>(ua: DatumEither<B, A>): ua is Success<A> {
+  return D.isSome(ua) && E.isRight(ua.value);
+}
+
+/**
+ * @since 2.0.0
+ */
+export function isFailure<A, B>(ua: DatumEither<B, A>): ua is Failure<B> {
+  return D.isSome(ua) && E.isLeft(ua.value);
+}
+
+/**
+ * Lift an always succeeding async computation (Datum) into a DatumEither.
+ *
+ * @example
+ * ```ts
+ * import * as DE from "./datum_either.ts";
+ * import * as D from "./datum.ts";
+ *
+ * const value = DE.fromDatum(D.wrap(1));
+ * ```
+ *
+ * @since 2.1.0
+ */
+export function fromDatum<A, B = never>(ta: Datum<A>): DatumEither<B, A> {
+  return pipe(ta, D.map(E.right));
+}
+
+/**
+ * Lifts an Either<B,A> into a DatumEither<B, A>.
+ *
+ * @example
+ * ```ts
+ * import * as DE from "./datum_either.ts";
+ * import * as E from "./either.ts";
+ *
+ * const value1 = DE.fromEither(E.right(1));
+ * const value2 = DE.fromEither(E.left("Error!"));
+ * ```
+ *
+ * @since 2.1.0
+ */
+export function fromEither<A, B>(ta: Either<B, A>): DatumEither<B, A> {
+  return D.wrap(ta);
+}
+
+/**
+ * @since 2.1.0
+ */
+export function getSuccess<A, B>(ua: DatumEither<B, A>): Option<A> {
+  return isSuccess(ua) ? some(ua.value.right) : none;
+}
+
+/**
+ * @since 2.1.0
+ */
+export function getFailure<A, B>(ua: DatumEither<B, A>): Option<B> {
+  return isFailure(ua) ? some(ua.value.left) : none;
+}
+
+/**
+ * Construct an DatumEither<B, A> from a value D.
+ *
+ * @example
+ * ```ts
+ * import * as DE from "./datum_either.ts";
+ *
+ * const value = DE.wrap(1);
+ * ```
+ *
+ * @since 2.1.0
+ */
+export function wrap<A, B = never>(a: A): DatumEither<B, A> {
+  return right(a);
+}
+
+/**
+ * Construct an DatumEither<B, A> from a value B.
+ *
+ * @example
+ * ```ts
+ * import * as DE from "./datum_either.ts";
+ *
+ * const value = DE.fail("Error!");
+ * ```
+ *
+ * @since 2.1.0
+ */
+export function fail<A = never, B = never>(b: B): DatumEither<B, A> {
+  return left(b);
+}
+
+/**
+ * Map a function over the *Right* side of a DatumEither
+ *
+ * @since 2.1.0
+ */
+export function map<A, I>(
+  fai: (a: A) => I,
+): <B>(ta: DatumEither<B, A>) => DatumEither<B, I> {
+  return (ta) => pipe(ta, D.map(E.map(fai)));
+}
+
+/**
+ * Map a function over the *Left* side of a DatumEither
+ *
+ * @since 2.1.0
+ */
+export function mapSecond<B, J>(
+  fbj: (b: B) => J,
+): <A>(ta: DatumEither<B, A>) => DatumEither<J, A> {
+  return (ta) => pipe(ta, D.map(E.mapSecond(fbj)));
+}
+
+/**
+ * TODO: revisit createApply to align types.
+ *
+ * @since 2.1.0
+ */
+const _apply: Applicable<KindDatumEither>["apply"] = createApply(
+  D.ApplicableDatum,
+  E.ApplicableEither,
+) as Applicable<KindDatumEither>["apply"];
+
+/**
+ * Apply an argument to a function under the *Right* side.
+ *
+ * @since 2.1.0
+ */
+export function apply<A, B>(
+  ua: DatumEither<B, A>,
+): <I, J>(ufai: DatumEither<J, (a: A) => I>) => DatumEither<B | J, I> {
+  return _apply(ua);
+}
+
+/**
+ * Chain DatumEither based computations together in a pipeline
+ *
+ * @since 2.1.0
+ */
+export function flatmap<A, I, J>(
+  fati: (a: A) => DatumEither<J, I>,
+): <B>(ua: DatumEither<B, A>) => DatumEither<B | J, I> {
+  return match(
+    // Cast to any as TS does not infer the B in B | J
+    // deno-lint-ignore no-explicit-any
+    constInitial<any, any>,
+    constPending,
+    failure,
+    (a, refresh) => refresh ? D.toLoading(fati(a)) : fati(a),
+  );
+}
+
+/**
+ * Chain DatumEither based failures, *Left* sides, useful for recovering
+ * from error conditions.
+ *
+ * @since 2.1.0
+ */
+export function recover<B, J, I>(
+  fbtj: (b: B) => DatumEither<J, I>,
+): <A>(ta: DatumEither<B, A>) => DatumEither<J, A | I> {
+  return match(
+    // Cast to any as TS does not infer the A in A | I
+    // deno-lint-ignore no-explicit-any
+    constInitial<any, any>,
+    constPending,
+    (b, refresh) => refresh ? D.toLoading(fbtj(b)) : fbtj(b),
+    success,
+  );
+}
+
+/**
+ * Provide an alternative for a failed computation.
+ * Useful for implementing defaults.
+ *
+ * @since 2.1.0
+ */
+export function alt<I, J>(
+  ui: DatumEither<J, I>,
+): <A, B>(ta: DatumEither<B, A>) => DatumEither<B | J, A | I> {
+  return (ua) => isFailure(ua) ? ui : ua;
+}
+
+/**
+ * @since 2.1.0
+ */
+export function getShowableDatumEither<A, B>(
+  CA: Showable<A>,
+  CB: Showable<B>,
+): Showable<DatumEither<B, A>> {
+  return D.getShowableDatum(E.getShowableEither(CB, CA));
+}
+
+/**
+ * @since 2.1.0
+ */
+export function getCombinableDatumEither<A, B>(
+  CA: Combinable<A>,
+  CB: Combinable<B>,
+): Combinable<DatumEither<B, A>> {
+  return D.getCombinableDatum(E.getCombinableEither(CA, CB));
+}
+
+/**
+ * @since 2.1.0
+ */
+export function getInitializableDatumEither<A, B>(
+  CA: Initializable<A>,
+  CB: Initializable<B>,
+): Initializable<DatumEither<B, A>> {
+  return D.getInitializableDatum(E.getInitializableEither(CA, CB));
+}
+
+/**
+ * @since 2.1.0
+ */
+export function getComparableDatumEither<A, B>(
+  CA: Comparable<A>,
+  CB: Comparable<B>,
+): Comparable<DatumEither<B, A>> {
+  return D.getComparableDatum(E.getComparableEither(CB, CA));
+}
+
+/**
+ * @since 2.1.0
+ */
+export function getSortableDatumEither<A, B>(
+  CA: Sortable<A>,
+  CB: Sortable<B>,
+): Sortable<DatumEither<B, A>> {
+  return D.getSortableDatum(E.getSortableEither(CB, CA));
+}
+
+/**
+ * @since 2.1.0
+ */
+export const ApplicableDatumEither: Applicable<KindDatumEither> = {
+  apply,
+  map,
+  wrap,
+};
+
+/**
+ * @since 2.1.0
+ */
+export const BimappableDatumEither: Bimappable<KindDatumEither> = {
+  map,
+  mapSecond,
+};
+
+/**
+ * @since 2.1.0
+ */
+export const FlatmappableDatumEither: Flatmappable<KindDatumEither> = {
+  wrap,
+  apply,
+  map,
+  flatmap,
+};
+
+/**
+ * @since 2.1.0
+ */
+export const FailableDatumEither: Failable<KindDatumEither> = {
+  wrap,
+  apply,
+  map,
+  flatmap,
+  alt,
+  fail,
+  recover,
+};
+
+/**
+ * @since 2.1.0
+ */
+export const MappableDatumEither: Mappable<KindDatumEither> = {
+  map,
+};
+
+/**
+ * @since 2.1.0
+ */
+export const WrappableDatumEither: Wrappable<KindDatumEither> = {
+  wrap,
+};
+
+/**
+ * @since 2.1.0
+ */
+export const tap: Tap<KindDatumEither> = createTap(FailableDatumEither);
+
+/**
+ * @since 2.1.0
+ */
+export const bind: Bind<KindDatumEither> = createBind(
+  FlatmappableDatumEither,
+);
+
+/**
+ * @since 2.1.0
+ */
+export const bindTo: BindTo<KindDatumEither> = createBindTo(
+  FlatmappableDatumEither,
+);
diff --git a/deno.json b/deno.json
index db6dcd4..a38ead1 100644
--- a/deno.json
+++ b/deno.json
@@ -1,6 +1,6 @@
 {
   "name": "@baetheus/fun",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "exports": {
     "./applicable": "./applicable.ts",
     "./array": "./array.ts",
@@ -13,6 +13,7 @@
     "./comparable": "./comparable.ts",
     "./composable": "./composable.ts",
     "./datum": "./datum.ts",
+    "./datum_either": "./datum_either.ts",
     "./decoder": "./decoder.ts",
     "./either": "./either.ts",
     "./failable": "./failable.ts",
@@ -51,6 +52,7 @@
     "./traversable": "./traversable.ts",
     "./tree": "./tree.ts",
     "./wrappable": "./wrappable.ts",
+    "./contrib/dux": "./contrib/dux.ts",
     "./contrib/fast-check": "./contrib/fast-check.ts",
     "./contrib/free": "./contrib/free.ts",
     "./contrib/most": "./contrib/most.ts"
diff --git a/optic.ts b/optic.ts
index 3b54001..8e13646 100644
--- a/optic.ts
+++ b/optic.ts
@@ -30,6 +30,7 @@
 
 import type { $, Kind } from "./kind.ts";
 import type { Comparable } from "./comparable.ts";
+import type { DatumEither } from "./datum_either.ts";
 import type { Initializable } from "./initializable.ts";
 import type { Either } from "./either.ts";
 import type { Flatmappable } from "./flatmappable.ts";
@@ -41,13 +42,14 @@ import type { Refinement } from "./refinement.ts";
 import type { Traversable } from "./traversable.ts";
 import type { Tree } from "./tree.ts";
 
-import * as I from "./identity.ts";
-import * as O from "./option.ts";
 import * as A from "./array.ts";
-import * as R from "./record.ts";
+import * as DE from "./datum_either.ts";
 import * as E from "./either.ts";
+import * as I from "./identity.ts";
 import * as M from "./map.ts";
+import * as O from "./option.ts";
 import * as P from "./pair.ts";
+import * as R from "./record.ts";
 import { TraversableSet } from "./set.ts";
 import { TraversableTree } from "./tree.ts";
 import { isNotNil } from "./nil.ts";
@@ -1520,3 +1522,21 @@ export const first: <U extends Tag, S, B, A>(
 export const second: <U extends Tag, S, B, A>(
   optic: Optic<U, S, Pair<A, B>>,
 ) => Optic<Align<U, LensTag>, S, B> = compose(lens(P.getSecond, P.mapSecond));
+
+/**
+ * @since 2.1.0
+ */
+export const success: <U extends Tag, S, B, A>(
+  optic: Optic<U, S, DatumEither<B, A>>,
+) => Optic<Align<U, AffineTag>, S, A> = compose(
+  prism(DE.getSuccess, DE.success, DE.map),
+);
+
+/**
+ * @since 2.1.0
+ */
+export const failure: <U extends Tag, S, B, A>(
+  optic: Optic<U, S, DatumEither<B, A>>,
+) => Optic<Align<U, AffineTag>, S, B> = compose(
+  prism(DE.getFailure, DE.failure, DE.mapSecond),
+);