Make the number Cake reject NaN

README.md

@@ -829,6 +829,13 @@ number.is(5); // true
 number.is("5"); // false
 ```
 
+Although `typeof NaN === "number"`, this Cake does not accept `NaN`:
+
+```ts
+number.is(NaN); // false
+number.as(NaN); // TypeError: Value is NaN.
+```
+
 ---
 
 #### `string`
@@ -2015,7 +2022,8 @@ const c: Class<Date, [number]> = Date;
 
 #### Changed
 
-- Built-in named Cakes (e.g. [number](#number)) now have type `Cake` instead of `TypeGuardCake` ([#60](https://github.com/justinyaodu/caketype/pull/60))
+- [number](#number) no longer accepts `NaN` ([#64](https://github.com/justinyaodu/caketype/pull/64))
+- Built-in named Cakes (e.g. [boolean](#boolean)) now have type `Cake` instead of `TypeGuardCake` ([#60](https://github.com/justinyaodu/caketype/pull/60))
 - Replaced `TypeGuardFailedCakeError` with `WrongTypeCakeError`, which is more general and has a more concise error message ([#60](https://github.com/justinyaodu/caketype/pull/60))
 
 ---

etc/caketype.api.md

@@ -367,7 +367,17 @@ export class NotAnObjectCakeError extends CakeError {
 }
 
 // @public
-export const number: Cake<number>;
+export const number: NumberCake;
+
+// @public
+export class NumberCake extends Cake<number> {
+    // (undocumented)
+    dispatchCheck(value: unknown, context: CakeDispatchCheckContext): CakeError | null;
+    // (undocumented)
+    dispatchStringify(context: CakeDispatchStringifyContext): string;
+    // (undocumented)
+    withName(name: string | null): NumberCake;
+}
 
 // @public
 export type ObjectBakeable = {

src/cake/NumberCake.ts

@@ -0,0 +1,71 @@
+import {
+  Cake,
+  CakeDispatchCheckContext,
+  CakeDispatchStringifyContext,
+  CakeError,
+  CakeErrorDispatchFormatContext,
+  StringTree,
+  WrongTypeCakeError,
+} from "./index-internal";
+
+/**
+ * See {@link number}.
+ *
+ * @public
+ */
+class NumberCake extends Cake<number> {
+  dispatchCheck(
+    value: unknown,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    context: CakeDispatchCheckContext
+  ): CakeError | null {
+    if (typeof value !== "number") {
+      return new WrongTypeCakeError(this, value);
+    }
+    if (Number.isNaN(value)) {
+      return new IsNaNCakeError();
+    }
+    return null;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  dispatchStringify(context: CakeDispatchStringifyContext): string {
+    return "number";
+  }
+
+  withName(name: string | null): NumberCake {
+    return new NumberCake({ ...this, name });
+  }
+}
+
+class IsNaNCakeError extends CakeError {
+  constructor() {
+    super();
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  dispatchFormat(context: CakeErrorDispatchFormatContext): StringTree {
+    return "Value is NaN.";
+  }
+}
+
+/**
+ * A {@link Cake} representing the `number` type.
+ *
+ * @example
+ * ```ts
+ * number.is(5); // true
+ * number.is("5"); // false
+ * ```
+ *
+ * @example Although `typeof NaN === "number"`, this Cake does not accept `NaN`:
+ * ```ts
+ * number.is(NaN); // false
+ * number.as(NaN); // TypeError: Value is NaN.
+ * ```
+ *
+ * @public
+ */
+const number = new NumberCake({});
+
+export { NumberCake, number };

src/cake/TypeGuardCake.ts

@@ -3,7 +3,6 @@ import {
   is_boolean,
   is_bigint,
   is_never,
-  is_number,
   is_string,
   is_symbol,
   is_unknown,
@@ -141,19 +140,6 @@ const bigint: Cake<bigint> = typeGuard("bigint", is_bigint);
  */
 const never: Cake<never> = typeGuard("never", is_never);
 
-/**
- * A {@link Cake} representing the `number` type.
- *
- * @example
- * ```ts
- * number.is(5); // true
- * number.is("5"); // false
- * ```
- *
- * @public
- */
-const number: Cake<number> = typeGuard("number", is_number);
-
 /**
  * A {@link Cake} representing the `string` type.
  *
@@ -206,7 +192,6 @@ export {
   boolean,
   bigint,
   never,
-  number,
   string,
   symbol,
   unknown,

src/cake/index-internal.ts

@@ -9,6 +9,7 @@ export * from "./CakeStringifier";
 export * from "./Checker";
 export * from "./CheckOptions";
 export * from "./LiteralCake";
+export * from "./NumberCake";
 export * from "./ObjectCake";
 export * from "./ReferenceCake";
 export * from "./StringTree";

src/cake/index.ts

@@ -24,6 +24,9 @@ export {
   LiteralCake,
   LiteralCakeArgs,
   LiteralNotEqualCakeError,
+  // NumberCake.ts
+  NumberCake,
+  number,
   // ObjectCake.ts
   ObjectCake,
   ObjectCakeArgs,
@@ -56,7 +59,6 @@ export {
   boolean,
   bigint,
   never,
-  number,
   string,
   symbol,
   unknown,

src/type-guards.ts

@@ -15,10 +15,6 @@ function is_never(value: unknown): value is never {
   return false;
 }
 
-function is_number(value: unknown): value is number {
-  return typeof value === "number";
-}
-
 function is_object(value: unknown): value is object {
   switch (typeof value) {
     case "object":
@@ -47,7 +43,6 @@ export {
   is_bigint,
   is_boolean,
   is_never,
-  is_number,
   is_object,
   is_string,
   is_symbol,

tests/cake/Cake-withName.test.ts

@@ -3,6 +3,7 @@ import {
   bake,
   boolean,
   keysUnsound,
+  number,
   reference,
   TupleCake,
   TypeGuardCake,
@@ -13,6 +14,7 @@ import { is_boolean } from "../../src/type-guards";
 const cakes = {
   array: array({}),
   literal: bake(0),
+  number: number,
   object: bake({}),
   reference: reference<boolean>(() => boolean),
   tuple: new TupleCake({

tests/cake/NumberCake.test.ts

@@ -0,0 +1,14 @@
+import { number } from "../../src";
+import { expectTypeError } from "../test-helpers";
+
+describe("documentation examples", () => {
+  test("number", () => {
+    expect(number.is(5)).toStrictEqual(true);
+    expect(number.is("5")).toStrictEqual(false);
+  });
+
+  test("number NaN", () => {
+    expect(number.is(NaN)).toStrictEqual(false);
+    expectTypeError(() => number.as(NaN), "Value is NaN.");
+  });
+});

tests/cake/TypeGuardCake.test.ts

@@ -33,11 +33,6 @@ describe("documentation examples", () => {
     expect(never.is(undefined)).toStrictEqual(false);
   });
 
-  test("number", () => {
-    expect(number.is(5)).toStrictEqual(true);
-    expect(number.is("5")).toStrictEqual(false);
-  });
-
   test("string", () => {
     expect(string.is("hello")).toStrictEqual(true);
     expect(string.is("")).toStrictEqual(true);