feat(P.object): Make P.object consistent with the object TS type

Author: gvergnaud

README.md

@@ -1485,19 +1485,49 @@ console.log(fn(-3.141592), fn(7)); // logs '✅ ❌'
 
 ## `P.object` predicates
 
-`P.object` has a number of methods to help you match on specific object.
+`P.object` is itself a pattern, but also a module containing predicates related to object types.
 
-### `P.object.empty`
+### `P.object`
 
-`P.object.empty` matches empty object
+`P.object` matches any value assignable to the `object` TypeScript type. This includes all object literals, but also **arrays** and **functions**!
+
+`P.object` does not match primitive types, like strings or numbers.
 
 ```ts
-const fn = (input: string) =>
+import { match, P } from 'ts-pattern';
+
+const fn = (input: unknown) =>
   match(input)
-    .with(P.object.empty(), () => 'Empty!')
-    .otherwise(() => 'Full!');
+    .with(P.object, () => '✅')
+    .otherwise(() => '❌');
+
+console.log(fn({})); // ✅
+console.log(fn({ hello: 'world!' })); // ✅
+console.log(fn([])); // ✅
+console.log(fn(() => {})); // ✅
+
+console.log(fn(1, true, 'hi')); // ❌ ❌ ❌
+```
+
+### `P.object.empty()`
+
+`P.object.empty()` matches the empty object `{}`:
+
+```ts
+import { isMatching, P } from 'ts-pattern';
+
+console.log(isMatching(P.object.empty(), {})); // true
+```
+
+`P.object.empty()` does **not** match empty arrays, 0 values or nullish values:
+
+```ts
+import { isMatching, P } from 'ts-pattern';
 
-console.log(fn({})); // Empty!
+console.log(isMatching(P.object.empty(), [])); // false
+console.log(isMatching(P.object.empty(), 0)); // false
+console.log(isMatching(P.object.empty(), null)); // false
+console.log(isMatching(P.object.empty(), undefined)); // false
 ```
 
 ## Types

src/patterns.ts

@@ -35,6 +35,8 @@ import {
   ArrayChainable,
   Variadic,
   ObjectChainable,
+  ObjectPattern,
+  EmptyObjectPattern,
 } from './types/Pattern';
 
 export type { Pattern, Fn as unstable_Fn };
@@ -156,6 +158,14 @@ function arrayChainable<pattern extends Matcher<any, any, any, any, any>>(
   }) as any;
 }
 
+function objectChainable<pattern extends Matcher<any, any, any, any, any>>(
+  pattern: pattern
+): ObjectChainable<pattern> {
+  return Object.assign(chainable(pattern), {
+    empty: () => emptyObject,
+  }) as any;
+}
+
 /**
  * `P.optional(subpattern)` takes a sub pattern and returns a pattern which matches if the
  * key is undefined or if it is defined and the sub pattern matches its value.
@@ -635,10 +645,15 @@ function isNullish<T>(x: T | null | undefined): x is null | undefined {
   return x === null || x === undefined;
 }
 
-function isObject<T>(x: T | object): x is object {
-  return typeof x === 'object' &&
-  !Array.isArray(x) &&
-  x !== null
+function isObject(x: unknown): x is object {
+  return !!x && (typeof x === 'object' || typeof x === 'function');
+}
+
+function isEmptyObject(x: unknown) {
+  if (!x || typeof x !== 'object') return false;
+  if (Array.isArray(x)) return false;
+  for (const _key in x) return false;
+  return true;
 }
 
 type AnyConstructor = abstract new (...args: any[]) => any;
@@ -1083,6 +1098,28 @@ export const symbol: SymbolPattern = chainable(when(isSymbol));
  */
 export const nullish: NullishPattern = chainable(when(isNullish));
 
+/**
+ * `P.object.empty()` is a pattern, matching **objects** with no keys.
+ *
+ * [Read the documentation for `P.object.empty()` on GitHub](https://github.com/gvergnaud/ts-pattern#pobjectempty)
+ *
+ * @example
+ *  match(value)
+ *   .with(P.object.empty(), () => 'will match on empty objects')
+ */
+const emptyObject: EmptyObjectPattern = chainable(when(isEmptyObject));
+
+/**
+ * `P.object` is a wildcard pattern, matching any **object**.
+ *
+ * [Read the documentation for `P.object` on GitHub](https://github.com/gvergnaud/ts-pattern#pobject-predicates)
+ *
+ * @example
+ * match(value)
+ *  .with(P.object, () => 'will match on objects')
+ **/
+export const object: ObjectPattern = objectChainable(when(isObject));
+
 /**
  * `P.instanceOf(SomeClass)` is a pattern matching instances of a given class.
  *
@@ -1117,40 +1154,3 @@ export function shape<input, const pattern extends Pattern<input>>(
 export function shape(pattern: UnknownPattern) {
   return chainable(when(isMatching(pattern)));
 }
-
-/**
- * `P.object.empty()` is a pattern, matching **objects** with no keys.
- *
- * [Read the documentation for `P.object.empty` on GitHub](https://github.com/gvergnaud/ts-pattern#pobjectempty)
- *
- * @example
- *  match(value)
- *   .with(P.object.empty(), () => 'will match on empty objects')
- */
-const emptyObject = <input>(): GuardExcludeP<input, object, never> => when(
-    (value) => {
-      if (!isObject(value)) return false;
-
-      for (var prop in value) return false;
-      return true;
-    },
-  );
-
-const objectChainable = <pattern extends Matcher<any, any, any, any, any>>(
-  pattern: pattern
-): ObjectChainable<pattern> => 
-  Object.assign(chainable(pattern), {
-    empty: () => chainable(intersection(pattern, emptyObject())),
-  }) as any;
-
-/**
- * `P.object` is a wildcard pattern, matching any **object**.
- * It lets you call methods like `.empty()`, `.and`, `.or` and `.select()`
- * On structural patterns, like objects and arrays.
- * [Read the documentation for `P.object` on GitHub](https://github.com/gvergnaud/ts-pattern#pobject-predicates)
- * 
- * @example 
- * match(value)
- *  .with(P.object.empty(), () => 'will match on empty objects')
- **/
-export const object: ObjectChainable<GuardP<unknown, object>> = objectChainable(when(isObject));

src/types/Pattern.ts

@@ -164,10 +164,12 @@ type KnownPatternInternal<
 > =
   | primitives
   | PatternMatcher<a>
-  | ([objs] extends [never] ? never : ObjectPattern<Readonly<MergeUnion<objs>>>)
+  | ([objs] extends [never]
+      ? never
+      : ObjectLiteralPattern<Readonly<MergeUnion<objs>>>)
   | ([arrays] extends [never] ? never : ArrayPattern<arrays>);
 
-type ObjectPattern<a> =
+type ObjectLiteralPattern<a> =
   | {
       readonly [k in keyof a]?: Pattern<a[k]>;
     }
@@ -193,6 +195,11 @@ export type NullishPattern = Chainable<
   GuardP<unknown, null | undefined>,
   never
 >;
+export type ObjectPattern = ObjectChainable<GuardP<unknown, object>, never>;
+export type EmptyObjectPattern = Chainable<
+  GuardExcludeP<unknown, object, never>,
+  never
+>;
 
 type MergeGuards<input, guard1, guard2> = [guard1, guard2] extends [
   GuardExcludeP<any, infer narrowed1, infer excluded1>,
@@ -668,18 +675,15 @@ export type ObjectChainable<
   Omit<
     {
       /**
-       * `.empty()` matches an empty object.
+       * `P.object.empty()` is a pattern, matching **objects** with no keys.
        *
-       * [Read the documentation for `P.object.empty` on GitHub](https://github.com/gvergnaud/ts-pattern#pobjectempty)
+       * [Read the documentation for `P.object.empty()` on GitHub](https://github.com/gvergnaud/ts-pattern#pobjectempty)
        *
        * @example
-       * match(value)
-       *  .with(P.object.empty(), () => 'empty object')
+       *  match(value)
+       *   .with(P.object.empty(), () => 'will match on empty objects')
        */
-      empty<input>(): Chainable<
-        GuardExcludeP<input, {}, never>,
-        omitted | 'empty'
-    >;
+      empty: () => EmptyObjectPattern;
     },
     omitted
-  >;
+  >;