diff --git a/.changeset/lovely-monkeys-compete.md b/.changeset/lovely-monkeys-compete.md
new file mode 100644
index 0000000000..f2863fed18
--- /dev/null
+++ b/.changeset/lovely-monkeys-compete.md
@@ -0,0 +1,17 @@
+---
+"effect": patch
+---
+
+Support for the tacit usage of external handlers for `Match.tag` and `Match.tagStartsWith` functions
+
+```ts
+type Value = { _tag: "A"; a: string } | { _tag: "B"; b: number }
+const handlerA = (_: { _tag: "A"; a: number }) => _.a
+
+// $ExpectType string | number
+pipe(
+  M.type<Value>(),
+  M.tag("A", handlerA), // <-- no type issue
+  M.orElse((_) => _.b)
+)(value)
+```
diff --git a/packages/effect/dtslint/Match.ts b/packages/effect/dtslint/Match.ts
index 22da26d860..81eff5a038 100644
--- a/packages/effect/dtslint/Match.ts
+++ b/packages/effect/dtslint/Match.ts
@@ -3,6 +3,7 @@ import * as M from "effect/Match"
 
 type Value = { _tag: "A"; a: number } | { _tag: "B"; b: number }
 const value = { _tag: "A", a: 123 } as Value
+const handlerA = (_: { _tag: "A"; a: number }) => _.a.toString()
 
 // -------------------------------------------------------------------------------------
 // valueTags
@@ -139,3 +140,27 @@ pipe(
     C: () => false
   })
 )(value)
+
+// -------------------------------------------------------------------------------------
+// tag
+// -------------------------------------------------------------------------------------
+
+// tacit usage of external handler
+// $ExpectType string | number
+pipe(
+  M.type<Value>(),
+  M.tag("A", handlerA),
+  M.orElse((_) => _.b)
+)(value)
+
+// -------------------------------------------------------------------------------------
+// tagStartsWith
+// -------------------------------------------------------------------------------------
+
+// tacit usage of external handler
+// $ExpectType string | number
+pipe(
+  M.type<Value>(),
+  M.tagStartsWith("A", handlerA),
+  M.orElse((_) => _.b)
+)(value)
diff --git a/packages/effect/src/Match.ts b/packages/effect/src/Match.ts
index 28c7f94f7f..c402bcef36 100644
--- a/packages/effect/src/Match.ts
+++ b/packages/effect/src/Match.ts
@@ -6,7 +6,7 @@ import * as internal from "./internal/matcher.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import * as Predicate from "./Predicate.js"
-import type { Contravariant, Covariant, UnionToIntersection } from "./Types.js"
+import type * as T from "./Types.js"
 import type { Unify } from "./Unify.js"
 
 /**
@@ -36,11 +36,11 @@ export type Matcher<Input, Filters, RemainingApplied, Result, Provided, Return =
 export interface TypeMatcher<in Input, out Filters, out Remaining, out Result, out Return = any> extends Pipeable {
   readonly _tag: "TypeMatcher"
   readonly [MatcherTypeId]: {
-    readonly _input: Contravariant<Input>
-    readonly _filters: Covariant<Filters>
-    readonly _remaining: Covariant<Remaining>
-    readonly _result: Covariant<Result>
-    readonly _return: Covariant<Return>
+    readonly _input: T.Contravariant<Input>
+    readonly _filters: T.Covariant<Filters>
+    readonly _remaining: T.Covariant<Remaining>
+    readonly _result: T.Covariant<Result>
+    readonly _return: T.Covariant<Return>
   }
   readonly cases: ReadonlyArray<Case>
   add<I, R, RA, A>(_case: Case): TypeMatcher<I, R, RA, A>
@@ -55,10 +55,10 @@ export interface ValueMatcher<in Input, Filters, out Remaining, out Result, Prov
 {
   readonly _tag: "ValueMatcher"
   readonly [MatcherTypeId]: {
-    readonly _input: Contravariant<Input>
-    readonly _filters: Covariant<Filters>
-    readonly _result: Covariant<Result>
-    readonly _return: Covariant<Return>
+    readonly _input: T.Contravariant<Input>
+    readonly _filters: T.Covariant<Filters>
+    readonly _result: T.Covariant<Result>
+    readonly _return: T.Covariant<Return>
   }
   readonly provided: Provided
   readonly value: Either.Either<Provided, Remaining>
@@ -196,15 +196,15 @@ export const whenAnd: <
   R,
   const P extends ReadonlyArray<Types.PatternPrimitive<R> | Types.PatternBase<R>>,
   Ret,
-  Fn extends (_: Types.WhenMatch<R, UnionToIntersection<P[number]>>) => Ret
+  Fn extends (_: Types.WhenMatch<R, T.UnionToIntersection<P[number]>>) => Ret
 >(
   ...args: [...patterns: P, f: Fn]
 ) => <I, F, A, Pr>(
   self: Matcher<I, F, R, A, Pr, Ret>
 ) => Matcher<
   I,
-  Types.AddWithout<F, Types.PForExclude<UnionToIntersection<P[number]>>>,
-  Types.ApplyFilters<I, Types.AddWithout<F, Types.PForExclude<UnionToIntersection<P[number]>>>>,
+  Types.AddWithout<F, Types.PForExclude<T.UnionToIntersection<P[number]>>>,
+  Types.ApplyFilters<I, Types.AddWithout<F, Types.PForExclude<T.UnionToIntersection<P[number]>>>>,
   A | ReturnType<Fn>,
   Pr
 > = internal.whenAnd
@@ -297,7 +297,7 @@ export const discriminatorsExhaustive: <D extends string>(
  * @since 1.0.0
  */
 export const tag: <R, P extends Types.Tags<"_tag", R> & string, Ret, B extends Ret>(
-  ...pattern: [first: P, ...values: Array<P>, f: (_: Extract<R, Record<"_tag", P>>) => B]
+  ...pattern: [first: P, ...values: Array<P>, f: (_: Extract<T.NoInfer<R>, Record<"_tag", P>>) => B]
 ) => <I, F, A, Pr>(
   self: Matcher<I, F, R, A, Pr, Ret>
 ) => Matcher<
@@ -315,7 +315,7 @@ export const tag: <R, P extends Types.Tags<"_tag", R> & string, Ret, B extends R
  */
 export const tagStartsWith: <R, P extends string, Ret, B extends Ret>(
   pattern: P,
-  f: (_: Extract<R, Record<"_tag", `${P}${string}`>>) => B
+  f: (_: Extract<T.NoInfer<R>, Record<"_tag", `${P}${string}`>>) => B
 ) => <I, F, A, Pr>(
   self: Matcher<I, F, R, A, Pr, Ret>
 ) => Matcher<
@@ -692,7 +692,7 @@ export declare namespace Types {
   /**
    * @since 1.0.0
    */
-  export type ArrayToIntersection<A extends ReadonlyArray<any>> = UnionToIntersection<
+  export type ArrayToIntersection<A extends ReadonlyArray<any>> = T.UnionToIntersection<
     A[number]
   >