diff --git a/CHANGELOG.md b/CHANGELOG.md
index df10ac8..e8d68cf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 Note: I’m currently working on several breaking changes to tiny-decoders, but I’m trying out releasing them piece by piece. The idea is that you can either upgrade version by version only having to deal with one or a few breaking changes at a time, or wait and do a bunch of them at the same time.
 
+### Version 15.1.0 (unreleased)
+
+This release adds the `Infer` utility type. It’s currently basically just an alias to the TypeScript built-in `ReturnType` utility type, but in a future version of tiny-decoders it’ll need to do a little bit more than just `ReturnType`. If you’d like to reduce the amount of migration work when upgrading to that future version, change all your `ReturnType<typeof myDecoder>` to `Infer<typeof myDecoder>` now!
+
 ### Version 15.0.0 (2023-10-23)
 
 This release changes the options parameter of `fieldsAuto` and `fieldsUnion` from:
diff --git a/README.md b/README.md
index 8d2f650..110b0ea 100644
--- a/README.md
+++ b/README.md
@@ -30,6 +30,7 @@ import {
   DecoderError,
   field,
   fieldsAuto,
+  type Infer,
   number,
   string,
 } from "tiny-decoders";
@@ -76,7 +77,7 @@ Got: "30"
 You can even [infer the type from the decoder](#type-inference) instead of writing it manually!
 
 ```ts
-type User2 = ReturnType<typeof userDecoder2>;
+type User2 = Infer<typeof userDecoder2>;
 ```
 
 `User2` above is equivalent to the `User` type already shown earlier.
@@ -963,7 +964,7 @@ const personDecoder = fieldsAuto({
   age: number,
 });
 
-type Person = ReturnType<typeof personDecoder>;
+type Person = Infer<typeof personDecoder>;
 // equivalent to:
 type Person = {
   name: string;
@@ -971,6 +972,8 @@ type Person = {
 };
 ```
 
+The `Infer` utility type is currently basically just an alias to the TypeScript built-in `ReturnType` utility type, but it’s recommended to use `Infer` because in a future version of tiny-decoders it’ll need to do a little bit more than just `ReturnType` and then you don’t need to migrate.
+
 See the [type inference example](examples/type-inference.test.ts) for more details.
 
 ## Things left out
diff --git a/examples/readme.test.ts b/examples/readme.test.ts
index 73e38af..b722b87 100644
--- a/examples/readme.test.ts
+++ b/examples/readme.test.ts
@@ -8,6 +8,7 @@ import {
   DecoderError,
   field,
   fieldsAuto,
+  Infer,
   number,
   repr,
   ReprOptions,
@@ -143,7 +144,7 @@ test("fieldsAuto", () => {
 
   type Example = { name?: string };
 
-  expectType<TypeEqual<ReturnType<typeof exampleDecoder>, Example>>(true);
+  expectType<TypeEqual<Infer<typeof exampleDecoder>, Example>>(true);
 
   const exampleDecoder2 = fieldsAuto({
     name: field(undefinedOr(string), { optional: true }),
@@ -156,7 +157,7 @@ test("fieldsAuto", () => {
 
   type Example2 = { name?: string | undefined };
 
-  expectType<TypeEqual<ReturnType<typeof exampleDecoder2>, Example2>>(true);
+  expectType<TypeEqual<Infer<typeof exampleDecoder2>, Example2>>(true);
 
   expect(exampleDecoder2({ name: undefined })).toStrictEqual({
     name: undefined,
@@ -185,7 +186,7 @@ test("field", () => {
     d?: string | undefined;
   };
 
-  expectType<TypeEqual<ReturnType<typeof exampleDecoder>, Example>>(true);
+  expectType<TypeEqual<Infer<typeof exampleDecoder>, Example>>(true);
 
   expect(exampleDecoder({ a: "", c: undefined })).toStrictEqual({
     a: "",
diff --git a/examples/renaming-union-field.test.ts b/examples/renaming-union-field.test.ts
index 5d65ac5..7da4ba9 100644
--- a/examples/renaming-union-field.test.ts
+++ b/examples/renaming-union-field.test.ts
@@ -1,7 +1,7 @@
 import { expectType, TypeEqual } from "ts-expect";
 import { expect, test } from "vitest";
 
-import { fieldsUnion, number, tag } from "../";
+import { fieldsUnion, Infer, number, tag } from "../";
 
 test("using different tags in JSON and in TypeScript", () => {
   // Here’s how to use different keys and values in JSON and TypeScript.
@@ -17,7 +17,7 @@ test("using different tags in JSON and in TypeScript", () => {
     },
   ]);
 
-  type InferredType = ReturnType<typeof decoder>;
+  type InferredType = Infer<typeof decoder>;
   type ExpectedType =
     | { tag: "Circle"; radius: number }
     | { tag: "Square"; size: number };
diff --git a/examples/type-inference.test.ts b/examples/type-inference.test.ts
index 169f7d3..cd68cb1 100644
--- a/examples/type-inference.test.ts
+++ b/examples/type-inference.test.ts
@@ -8,6 +8,7 @@ import {
   chain,
   field,
   fieldsAuto,
+  Infer,
   multi,
   number,
   string,
@@ -18,21 +19,21 @@ test("making a type from a decoder", () => {
   // Rather than first typing out a `type` for `Person` and then essentially
   // typing the same thing again in the decoder (especially `fieldsAuto` decoders
   // look almost identical to `type` they decode to!), you can start with the
-  // decoder and extract the type afterwards with TypeScript’s `ReturnType` utility.
+  // decoder and extract the type afterwards with tiny-decoder’s `Infer` utility.
   const personDecoder = fieldsAuto({
     name: string,
     age: number,
   });
 
   // Hover over `Person` to see what it looks like!
-  type Person = ReturnType<typeof personDecoder>;
+  type Person = Infer<typeof personDecoder>;
   expectType<TypeEqual<Person, { name: string; age: number }>>(true);
 
   // If it feels like you are specifying everything twice – once in a `type` or
-  // `interface`, and once in the decoder – you might find this `ReturnType`
-  // technique interesting. But this `ReturnType` approach you don’t have to
+  // `interface`, and once in the decoder – you might find this `Infer`
+  // technique interesting. But this `Infer` approach you don’t have to
   // write what your records look like “twice.” Personally I don’t always mind
-  // the “duplication,” but when you do – try out the `ReturnType` approach!
+  // the “duplication,” but when you do – try out the `Infer` approach!
 
   // Here’s a more complex example for trying out TypeScript’s inference.
   const userDecoder = fieldsAuto({
@@ -45,7 +46,7 @@ test("making a type from a decoder", () => {
   });
 
   // Then, let TypeScript infer the `User` type!
-  type User = ReturnType<typeof userDecoder>;
+  type User = Infer<typeof userDecoder>;
   // Try hovering over `User` in the line above – your editor should reveal the
   // exact shape of the type.
 
@@ -116,7 +117,7 @@ test("making a type from an object and stringUnion", () => {
   expectType<TypeEqual<Severity, "Critical" | "High" | "Low" | "Medium">>(true);
 
   const severityDecoder = stringUnion(SEVERITIES);
-  expectType<TypeEqual<Severity, ReturnType<typeof severityDecoder>>>(true);
+  expectType<TypeEqual<Severity, Infer<typeof severityDecoder>>>(true);
   expect(severityDecoder("High")).toBe("High");
 
   function coloredSeverity(severity: Severity): string {
diff --git a/examples/untagged-union.test.ts b/examples/untagged-union.test.ts
index 7e5a1b8..1a0bd48 100644
--- a/examples/untagged-union.test.ts
+++ b/examples/untagged-union.test.ts
@@ -6,6 +6,7 @@ import {
   chain,
   Decoder,
   fieldsAuto,
+  Infer,
   number,
   string,
   undefinedOr,
@@ -85,9 +86,7 @@ test("tagged union, but using boolean instead of string", () => {
     }),
   );
 
-  type User =
-    | ReturnType<typeof adminDecoder>
-    | ReturnType<typeof notAdminDecoder>;
+  type User = Infer<typeof adminDecoder> | Infer<typeof notAdminDecoder>;
 
   const userDecoder: Decoder<User> = (value) => {
     const { isAdmin } = fieldsAuto({ isAdmin: boolean })(value);
diff --git a/index.ts b/index.ts
index e019be4..efa4385 100644
--- a/index.ts
+++ b/index.ts
@@ -4,6 +4,8 @@
 
 export type Decoder<T, U = unknown> = (value: U) => T;
 
+export type Infer<T extends Decoder<any>> = ReturnType<T>;
+
 // Make VSCode show `{ a: string; b?: number }` instead of `{ a: string } & { b?: number }`.
 // https://stackoverflow.com/a/57683652/2010616
 type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
@@ -109,9 +111,9 @@ type FieldsMapping = Record<string, Decoder<any> | Field<any, FieldMeta>>;
 
 type InferField<T extends Decoder<any> | Field<any, FieldMeta>> =
   T extends Field<any, FieldMeta>
-    ? ReturnType<T["decoder"]>
+    ? Infer<T["decoder"]>
     : T extends Decoder<any>
-    ? ReturnType<T>
+    ? Infer<T>
     : never;
 
 type InferFields<Mapping extends FieldsMapping> = Expand<
diff --git a/tests/decoders.test.ts b/tests/decoders.test.ts
index c64e0bd..0f7c6ff 100644
--- a/tests/decoders.test.ts
+++ b/tests/decoders.test.ts
@@ -91,7 +91,7 @@ test("string", () => {
 
 describe("stringUnion", () => {
   test("basic", () => {
-    type Color = ReturnType<typeof colorDecoder>;
+    type Color = Infer<typeof colorDecoder>;
     const colorDecoder = stringUnion(["red", "green", "blue"]);
 
     expectType<TypeEqual<Color, "blue" | "green" | "red">>(true);
@@ -136,14 +136,14 @@ describe("stringUnion", () => {
     // @ts-expect-error Type 'number' is not assignable to type 'string'.
     stringUnion([1]);
     const goodDecoder = stringUnion(["1"]);
-    expectType<TypeEqual<ReturnType<typeof goodDecoder>, "1">>(true);
+    expectType<TypeEqual<Infer<typeof goodDecoder>, "1">>(true);
     expect(goodDecoder("1")).toBe("1");
   });
 });
 
 describe("array", () => {
   test("basic", () => {
-    type Bits = ReturnType<typeof bitsDecoder>;
+    type Bits = Infer<typeof bitsDecoder>;
     const bitsDecoder = array(stringUnion(["0", "1"]));
 
     expectType<TypeEqual<Bits, Array<"0" | "1">>>(true);
@@ -183,7 +183,7 @@ describe("array", () => {
 
 describe("record", () => {
   test("basic", () => {
-    type Registers = ReturnType<typeof registersDecoder>;
+    type Registers = Infer<typeof registersDecoder>;
     const registersDecoder = record(stringUnion(["0", "1"]));
 
     expectType<TypeEqual<Registers, Record<string, "0" | "1">>>(true);
@@ -223,7 +223,7 @@ describe("record", () => {
     );
 
     expectType<
-      TypeEqual<ReturnType<typeof decoder>, Array<readonly [RegExp, string]>>
+      TypeEqual<Infer<typeof decoder>, Array<readonly [RegExp, string]>>
     >(true);
 
     const good = { "\\d{4}:\\d{2}": "Year/month", ".*": "Rest" };
@@ -267,7 +267,7 @@ describe("fieldsAuto", () => {
   fieldsAuto([string]);
 
   test("basic", () => {
-    type Person = ReturnType<typeof personDecoder>;
+    type Person = Infer<typeof personDecoder>;
     const personDecoder = fieldsAuto({
       id: number,
       firstName: string,
@@ -308,7 +308,7 @@ describe("fieldsAuto", () => {
   });
 
   test("optional and renamed fields", () => {
-    type Person = ReturnType<typeof personDecoder>;
+    type Person = Infer<typeof personDecoder>;
     const personDecoder = fieldsAuto({
       id: number,
       firstName: field(string, { renameFrom: "first_name" }),
@@ -571,7 +571,7 @@ describe("fieldsAuto", () => {
 
 describe("fieldsUnion", () => {
   test("basic", () => {
-    type Shape = ReturnType<typeof shapeDecoder>;
+    type Shape = Infer<typeof shapeDecoder>;
     const shapeDecoder = fieldsUnion("tag", [
       {
         tag: tag("Circle"),
@@ -683,9 +683,9 @@ describe("fieldsUnion", () => {
       { tag: tag("A", { renameFieldFrom: "type" }) },
       { tag: tag("B", { renameFieldFrom: "type" }) },
     ]);
-    expectType<
-      TypeEqual<ReturnType<typeof decoder>, { tag: "A" } | { tag: "B" }>
-    >(true);
+    expectType<TypeEqual<Infer<typeof decoder>, { tag: "A" } | { tag: "B" }>>(
+      true,
+    );
     expect(decoder({ type: "A" })).toStrictEqual({ tag: "A" });
     expect(decoder({ type: "B" })).toStrictEqual({ tag: "B" });
   });
@@ -786,7 +786,7 @@ describe("fieldsUnion", () => {
 describe("tag", () => {
   test("basic", () => {
     const { decoder } = tag("Test");
-    expectType<TypeEqual<ReturnType<typeof decoder>, "Test">>(true);
+    expectType<TypeEqual<Infer<typeof decoder>, "Test">>(true);
     expect(decoder("Test")).toBe("Test");
     expect(run(decoder, "other")).toMatchInlineSnapshot(`
       At root:
@@ -797,7 +797,7 @@ describe("tag", () => {
 
   test("renamed", () => {
     const { decoder } = tag("Test", { renameTagFrom: "test" });
-    expectType<TypeEqual<ReturnType<typeof decoder>, "Test">>(true);
+    expectType<TypeEqual<Infer<typeof decoder>, "Test">>(true);
     expect(decoder("test")).toBe("Test");
     expect(run(decoder, "other")).toMatchInlineSnapshot(`
       At root:
@@ -814,7 +814,7 @@ describe("tuple", () => {
   tuple(number);
 
   test("0 items", () => {
-    type Type = ReturnType<typeof decoder>;
+    type Type = Infer<typeof decoder>;
     const decoder = tuple([]);
 
     expectType<TypeEqual<Type, []>>(true);
@@ -830,7 +830,7 @@ describe("tuple", () => {
   });
 
   test("1 item", () => {
-    type Type = ReturnType<typeof decoder>;
+    type Type = Infer<typeof decoder>;
     const decoder = tuple([number]);
 
     expectType<TypeEqual<Type, [number]>>(true);
@@ -852,7 +852,7 @@ describe("tuple", () => {
   });
 
   test("2 items", () => {
-    type Type = ReturnType<typeof decoder>;
+    type Type = Infer<typeof decoder>;
     const decoder = tuple([number, string]);
 
     expectType<TypeEqual<Type, [number, string]>>(true);
@@ -880,7 +880,7 @@ describe("tuple", () => {
   });
 
   test("3 items", () => {
-    type Type = ReturnType<typeof decoder>;
+    type Type = Infer<typeof decoder>;
     const decoder = tuple([number, string, boolean]);
 
     expectType<TypeEqual<Type, [number, string, boolean]>>(true);
@@ -902,7 +902,7 @@ describe("tuple", () => {
   });
 
   test("4 items", () => {
-    type Type = ReturnType<typeof decoder>;
+    type Type = Infer<typeof decoder>;
     const decoder = tuple([number, string, boolean, number]);
 
     expectType<TypeEqual<Type, [number, string, boolean, number]>>(true);
@@ -944,7 +944,7 @@ describe("tuple", () => {
 
 describe("multi", () => {
   test("basic", () => {
-    type Id = ReturnType<typeof idDecoder>;
+    type Id = Infer<typeof idDecoder>;
     const idDecoder = multi(["string", "number"]);
 
     expectType<
@@ -973,7 +973,7 @@ describe("multi", () => {
   });
 
   test("basic – mapped", () => {
-    type Id = ReturnType<typeof idDecoder>;
+    type Id = Infer<typeof idDecoder>;
     const idDecoder = chain(multi(["string", "number"]), (value) => {
       switch (value.type) {
         case "string":
@@ -1006,7 +1006,7 @@ describe("multi", () => {
   });
 
   test("basic – variation", () => {
-    type Id = ReturnType<typeof idDecoder>;
+    type Id = Infer<typeof idDecoder>;
     const idDecoder = chain(multi(["string", "number"]), (value) => {
       switch (value.type) {
         case "string":
@@ -1135,7 +1135,7 @@ describe("undefinedOr", () => {
   test("undefined or string", () => {
     const decoder = undefinedOr(string);
 
-    expectType<TypeEqual<ReturnType<typeof decoder>, string | undefined>>(true);
+    expectType<TypeEqual<Infer<typeof decoder>, string | undefined>>(true);
 
     expect(decoder(undefined)).toBeUndefined();
     expect(decoder("a")).toBe("a");
@@ -1150,7 +1150,7 @@ describe("undefinedOr", () => {
   test("with default", () => {
     const decoder = undefinedOr(string, "def");
 
-    expectType<TypeEqual<ReturnType<typeof decoder>, string>>(true);
+    expectType<TypeEqual<Infer<typeof decoder>, string>>(true);
 
     expect(decoder(undefined)).toBe("def");
     expect(decoder("a")).toBe("a");
@@ -1159,14 +1159,14 @@ describe("undefinedOr", () => {
   test("with other type default", () => {
     const decoder = undefinedOr(string, 0);
 
-    expectType<TypeEqual<ReturnType<typeof decoder>, number | string>>(true);
+    expectType<TypeEqual<Infer<typeof decoder>, number | string>>(true);
 
     expect(decoder(undefined)).toBe(0);
     expect(decoder("a")).toBe("a");
   });
 
   test("using with fieldsAuto does NOT result in an optional field", () => {
-    type Person = ReturnType<typeof personDecoder>;
+    type Person = Infer<typeof personDecoder>;
     const personDecoder = fieldsAuto({
       name: string,
       age: undefinedOr(number),
@@ -1252,7 +1252,7 @@ describe("nullable", () => {
   test("nullable string", () => {
     const decoder = nullable(string);
 
-    expectType<TypeEqual<ReturnType<typeof decoder>, string | null>>(true);
+    expectType<TypeEqual<Infer<typeof decoder>, string | null>>(true);
 
     expect(decoder(null)).toBeNull();
     expect(decoder("a")).toBe("a");
@@ -1267,7 +1267,7 @@ describe("nullable", () => {
   test("with default", () => {
     const decoder = nullable(string, "def");
 
-    expectType<TypeEqual<ReturnType<typeof decoder>, string>>(true);
+    expectType<TypeEqual<Infer<typeof decoder>, string>>(true);
 
     expect(decoder(null)).toBe("def");
     expect(decoder("a")).toBe("a");
@@ -1276,7 +1276,7 @@ describe("nullable", () => {
   test("with other type default", () => {
     const decoder = nullable(string, 0);
 
-    expectType<TypeEqual<ReturnType<typeof decoder>, number | string>>(true);
+    expectType<TypeEqual<Infer<typeof decoder>, number | string>>(true);
 
     expect(decoder(null)).toBe(0);
     expect(decoder("a")).toBe("a");
@@ -1285,14 +1285,14 @@ describe("nullable", () => {
   test("with undefined instead of null", () => {
     const decoder = nullable(string, undefined);
 
-    expectType<TypeEqual<ReturnType<typeof decoder>, string | undefined>>(true);
+    expectType<TypeEqual<Infer<typeof decoder>, string | undefined>>(true);
 
     expect(decoder(null)).toBeUndefined();
     expect(decoder("a")).toBe("a");
   });
 
   test("nullable field", () => {
-    type Person = ReturnType<typeof personDecoder>;
+    type Person = Infer<typeof personDecoder>;
     const personDecoder = fieldsAuto({
       name: string,
       age: nullable(number),
@@ -1338,7 +1338,7 @@ describe("nullable", () => {
   });
 
   test("nullable autoField", () => {
-    type Person = ReturnType<typeof personDecoder>;
+    type Person = Infer<typeof personDecoder>;
     const personDecoder = fieldsAuto({
       name: string,
       age: nullable(number),