diff --git a/.changeset/swift-melons-reflect.md b/.changeset/swift-melons-reflect.md
new file mode 100644
index 000000000..6c5950291
--- /dev/null
+++ b/.changeset/swift-melons-reflect.md
@@ -0,0 +1,5 @@
+---
+"@fp-ts/core": patch
+---
+
+remove Compactable, Filterable, TraversableFilterable and /data folder
diff --git a/dtslint/ts4.7/SemiProduct.ts b/dtslint/ts4.7/SemiProduct.ts
index 8999c2545..e4024d816 100644
--- a/dtslint/ts4.7/SemiProduct.ts
+++ b/dtslint/ts4.7/SemiProduct.ts
@@ -1,4 +1,4 @@
-import { OptionTypeLambda } from "@fp-ts/core/data/Option"
+import { OptionTypeLambda } from "@fp-ts/core/test/data/Option"
 import * as _ from "@fp-ts/core/typeclass/SemiProduct"
 
 export declare const SemiProduct: _.SemiProduct<OptionTypeLambda>
diff --git a/src/data/Either.ts b/src/data/Either.ts
deleted file mode 100644
index 9fdd1920b..000000000
--- a/src/data/Either.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-/**
- * @since 1.0.0
- */
-import type { TypeLambda } from "@fp-ts/core/HKT"
-
-/**
- * @category models
- * @since 1.0.0
- */
-export interface Left<out E> {
-  readonly _tag: "Left"
-  readonly left: E
-}
-
-/**
- * @category models
- * @since 1.0.0
- */
-export interface Right<out A> {
-  readonly _tag: "Right"
-  readonly right: A
-}
-
-/**
- * @category models
- * @since 1.0.0
- */
-export type Either<E, A> = Left<E> | Right<A>
-
-/**
- * @category type lambdas
- * @since 1.0.0
- */
-export interface EitherTypeLambda extends TypeLambda {
-  readonly type: Either<this["Out1"], this["Target"]>
-}
diff --git a/src/data/Option.ts b/src/data/Option.ts
deleted file mode 100644
index 7fb5f2b6c..000000000
--- a/src/data/Option.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-/**
- * @since 1.0.0
- */
-import type { TypeLambda } from "@fp-ts/core/HKT"
-
-/**
- * @category models
- * @since 1.0.0
- */
-export interface None {
-  readonly _tag: "None"
-}
-
-/**
- * @category models
- * @since 1.0.0
- */
-export interface Some<out A> {
-  readonly _tag: "Some"
-  readonly value: A
-}
-
-/**
- * @category models
- * @since 1.0.0
- */
-export type Option<A> = None | Some<A>
-
-/**
- * @category type lambdas
- * @since 1.0.0
- */
-export interface OptionTypeLambda extends TypeLambda {
-  readonly type: Option<this["Target"]>
-}
diff --git a/src/index.ts b/src/index.ts
index ebfee7123..cd437d1bb 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -17,11 +17,9 @@ import * as applicative from "@fp-ts/core/typeclass/Applicative"
 import * as bicovariant from "@fp-ts/core/typeclass/Bicovariant"
 import * as bounded from "@fp-ts/core/typeclass/Bounded"
 import * as chainable from "@fp-ts/core/typeclass/Chainable"
-import * as compactable from "@fp-ts/core/typeclass/Compactable"
 import * as contravariant from "@fp-ts/core/typeclass/Contravariant"
 import * as coproduct from "@fp-ts/core/typeclass/Coproduct"
 import * as covariant from "@fp-ts/core/typeclass/Covariant"
-import * as filterable from "@fp-ts/core/typeclass/Filterable"
 import * as flatMap from "@fp-ts/core/typeclass/FlatMap"
 import * as foldable from "@fp-ts/core/typeclass/Foldable"
 import * as invariant from "@fp-ts/core/typeclass/Invariant"
@@ -38,14 +36,6 @@ import * as semiCoproduct from "@fp-ts/core/typeclass/SemiCoproduct"
 import * as semigroup from "@fp-ts/core/typeclass/Semigroup"
 import * as semiProduct from "@fp-ts/core/typeclass/SemiProduct"
 import * as traversable from "@fp-ts/core/typeclass/Traversable"
-import * as traversableFilterable from "@fp-ts/core/typeclass/TraversableFilterable"
-
-// -------------------------------------------------------------------------------------
-// data types
-// -------------------------------------------------------------------------------------
-
-import * as either from "@fp-ts/core/data/Either"
-import * as option from "@fp-ts/core/data/Option"
 
 export {
   /**
@@ -73,11 +63,6 @@ export {
    * @since 1.0.0
    */
   chainable,
-  /**
-   * @category typeclass
-   * @since 1.0.0
-   */
-  compactable,
   /**
    * @category typeclass
    * @since 1.0.0
@@ -93,16 +78,6 @@ export {
    * @since 1.0.0
    */
   covariant,
-  /**
-   * @category data types
-   * @since 1.0.0
-   */
-  either,
-  /**
-   * @category typeclass
-   * @since 1.0.0
-   */
-  filterable,
   /**
    * @category typeclass
    * @since 1.0.0
@@ -142,11 +117,6 @@ export {
    * @since 1.0.0
    */
   of,
-  /**
-   * @category data types
-   * @since 1.0.0
-   */
-  option,
   /**
    * @category typeclass
    * @since 1.0.0
@@ -191,10 +161,5 @@ export {
    * @category typeclass
    * @since 1.0.0
    */
-  traversable,
-  /**
-   * @category typeclass
-   * @since 1.0.0
-   */
-  traversableFilterable
+  traversable
 }
diff --git a/src/internal/Either.ts b/src/internal/Either.ts
deleted file mode 100644
index 752a98f44..000000000
--- a/src/internal/Either.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-/**
- * @since 1.0.0
- */
-
-import type { Either, Left, Right } from "@fp-ts/core/data/Either"
-import type { Option } from "@fp-ts/core/data/Option"
-import * as option from "@fp-ts/core/internal/Option"
-
-/**
- * @since 1.0.0
- */
-export const left = <E>(e: E): Either<E, never> => ({ _tag: "Left", left: e })
-
-/**
- * @since 1.0.0
- */
-export const right = <A>(a: A): Either<never, A> => ({ _tag: "Right", right: a })
-
-/**
- * @since 1.0.0
- */
-export const isLeft = <E, A>(self: Either<E, A>): self is Left<E> => self._tag === "Left"
-
-/**
- * @since 1.0.0
- */
-export const isRight = <E, A>(self: Either<E, A>): self is Right<A> => self._tag === "Right"
-
-/**
- * @since 1.0.0
- */
-export const getLeft = <E, A>(
-  self: Either<E, A>
-): Option<E> => (isRight(self) ? option.none : option.some(self.left))
-
-/**
- * @since 1.0.0
- */
-export const getRight = <E, A>(
-  self: Either<E, A>
-): Option<A> => (isLeft(self) ? option.none : option.some(self.right))
diff --git a/src/internal/Function.ts b/src/internal/Function.ts
index f0e49ae96..2b02a2d18 100644
--- a/src/internal/Function.ts
+++ b/src/internal/Function.ts
@@ -1,27 +1,17 @@
-/**
- * @since 1.0.0
- */
+/** @internal */
 
-/**
- * A lazy argument.
- *
- * @since 1.0.0
- */
-export interface LazyArg<A> {
-  (): A
-}
-/**
- * @since 1.0.0
- */
+/** @internal */
 export const identity = <A>(a: A): A => a
 
-/**
- * @since 1.0.0
- */
+/** @internal */
 export function pipe<A>(a: A): A
+/** @internal */
 export function pipe<A, B>(a: A, ab: (a: A) => B): B
+/** @internal */
 export function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C
+/** @internal */
 export function pipe<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D
+/** @internal */
 export function pipe<A, B, C, D, E>(
   a: A,
   ab: (a: A) => B,
@@ -29,6 +19,7 @@ export function pipe<A, B, C, D, E>(
   cd: (c: C) => D,
   de: (d: D) => E
 ): E
+/** @internal */
 export function pipe<A, B, C, D, E, F>(
   a: A,
   ab: (a: A) => B,
@@ -37,6 +28,7 @@ export function pipe<A, B, C, D, E, F>(
   de: (d: D) => E,
   ef: (e: E) => F
 ): F
+/** @internal */
 export function pipe<A, B, C, D, E, F, G>(
   a: A,
   ab: (a: A) => B,
@@ -46,6 +38,7 @@ export function pipe<A, B, C, D, E, F, G>(
   ef: (e: E) => F,
   fg: (f: F) => G
 ): G
+/** @internal */
 export function pipe<A, B, C, D, E, F, G, H>(
   a: A,
   ab: (a: A) => B,
@@ -56,6 +49,7 @@ export function pipe<A, B, C, D, E, F, G, H>(
   fg: (f: F) => G,
   gh: (g: G) => H
 ): H
+/** @internal */
 export function pipe<A, B, C, D, E, F, G, H, I>(
   a: A,
   ab: (a: A) => B,
@@ -67,6 +61,7 @@ export function pipe<A, B, C, D, E, F, G, H, I>(
   gh: (g: G) => H,
   hi: (h: H) => I
 ): I
+/** @internal */
 export function pipe<A, B, C, D, E, F, G, H, I, J>(
   a: A,
   ab: (a: A) => B,
@@ -79,6 +74,7 @@ export function pipe<A, B, C, D, E, F, G, H, I, J>(
   hi: (h: H) => I,
   ij: (i: I) => J
 ): J
+/** @internal */
 export function pipe<A, B, C, D, E, F, G, H, I, J, K>(
   a: A,
   ab: (a: A) => B,
@@ -92,6 +88,7 @@ export function pipe<A, B, C, D, E, F, G, H, I, J, K>(
   ij: (i: I) => J,
   jk: (j: J) => K
 ): K
+/** @internal */
 export function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(
   a: A,
   ab: (a: A) => B,
@@ -106,6 +103,7 @@ export function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(
   jk: (j: J) => K,
   kl: (k: K) => L
 ): L
+/** @internal */
 export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(
   a: A,
   ab: (a: A) => B,
@@ -121,6 +119,7 @@ export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(
   kl: (k: K) => L,
   lm: (l: L) => M
 ): M
+/** @internal */
 export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
   a: A,
   ab: (a: A) => B,
@@ -137,6 +136,7 @@ export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
   lm: (l: L) => M,
   mn: (m: M) => N
 ): N
+/** @internal */
 export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
   a: A,
   ab: (a: A) => B,
@@ -154,7 +154,7 @@ export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
   mn: (m: M) => N,
   no: (n: N) => O
 ): O
-
+/** @internal */
 export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
   a: A,
   ab: (a: A) => B,
@@ -173,7 +173,7 @@ export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
   no: (n: N) => O,
   op: (o: O) => P
 ): P
-
+/** @internal */
 export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
   a: A,
   ab: (a: A) => B,
@@ -193,7 +193,7 @@ export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
   op: (o: O) => P,
   pq: (p: P) => Q
 ): Q
-
+/** @internal */
 export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(
   a: A,
   ab: (a: A) => B,
@@ -214,7 +214,7 @@ export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(
   pq: (p: P) => Q,
   qr: (q: Q) => R
 ): R
-
+/** @internal */
 export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(
   a: A,
   ab: (a: A) => B,
@@ -236,7 +236,7 @@ export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(
   qr: (q: Q) => R,
   rs: (r: R) => S
 ): S
-
+/** @internal */
 export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(
   a: A,
   ab: (a: A) => B,
diff --git a/src/internal/Option.ts b/src/internal/Option.ts
deleted file mode 100644
index e6891324e..000000000
--- a/src/internal/Option.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-/**
- * @since 1.0.0
- */
-import type { None, Option, Some } from "@fp-ts/core/data/Option"
-
-/**
- * @since 1.0.0
- */
-export const none: Option<never> = { _tag: "None" }
-
-/**
- * @since 1.0.0
- */
-export const some = <A>(a: A): Option<A> => ({ _tag: "Some", value: a })
-
-/**
- * @since 1.0.0
- */
-export const isNone = <A>(fa: Option<A>): fa is None => fa._tag === "None"
-
-/**
- * @since 1.0.0
- */
-export const isSome = <A>(fa: Option<A>): fa is Some<A> => fa._tag === "Some"
diff --git a/src/typeclass/Compactable.ts b/src/typeclass/Compactable.ts
deleted file mode 100644
index bcd41ad18..000000000
--- a/src/typeclass/Compactable.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-/**
- * `Compactable` represents data structures which can be _compacted_/_separated_.
- *
- * @since 1.0.0
- */
-import type { Either } from "@fp-ts/core/data/Either"
-import type { Option } from "@fp-ts/core/data/Option"
-import type { Kind, TypeClass, TypeLambda } from "@fp-ts/core/HKT"
-import * as either from "@fp-ts/core/internal/Either"
-import { pipe } from "@fp-ts/core/internal/Function"
-import type { Covariant } from "@fp-ts/core/typeclass/Covariant"
-
-/**
- * @category models
- * @since 1.0.0
- */
-export interface Compactable<F extends TypeLambda> extends TypeClass<F> {
-  readonly compact: <R, O, E, A>(self: Kind<F, R, O, E, Option<A>>) => Kind<F, R, O, E, A>
-}
-
-/**
- * Returns a default `compact` composition.
- *
- * @since 1.0.0
- */
-export const compactComposition = <F extends TypeLambda, G extends TypeLambda>(
-  F: Covariant<F>,
-  G: Compactable<G>
-): (<FR, FO, FE, GR, GO, GE, A>(
-  self: Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, Option<A>>>
-) => Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, A>>) => F.map(G.compact)
-
-/**
- * @since 1.0.0
- */
-export const separate = <F extends TypeLambda>(
-  F: Covariant<F> & Compactable<F>
-) =>
-  <R, O, E, A, B>(
-    self: Kind<F, R, O, E, Either<A, B>>
-  ): readonly [Kind<F, R, O, E, A>, Kind<F, R, O, E, B>] => {
-    return [
-      pipe(self, F.map(either.getLeft), F.compact),
-      pipe(self, F.map(either.getRight), F.compact)
-    ]
-  }
diff --git a/src/typeclass/Filterable.ts b/src/typeclass/Filterable.ts
deleted file mode 100644
index 2f8bc38fe..000000000
--- a/src/typeclass/Filterable.ts
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * `Filterable` represents data structures which can be _partitioned_/_filtered_.
- *
- * @since 1.0.0
- */
-import type { Either } from "@fp-ts/core/data/Either"
-import type { Option } from "@fp-ts/core/data/Option"
-import type { Kind, TypeClass, TypeLambda } from "@fp-ts/core/HKT"
-import * as either from "@fp-ts/core/internal/Either"
-import { pipe } from "@fp-ts/core/internal/Function"
-import * as option from "@fp-ts/core/internal/Option"
-import type { Covariant } from "@fp-ts/core/typeclass/Covariant"
-
-/**
- * @category models
- * @since 1.0.0
- */
-export interface Filterable<F extends TypeLambda> extends TypeClass<F> {
-  readonly filterMap: <A, B>(
-    f: (a: A) => Option<B>
-  ) => <R, O, E>(self: Kind<F, R, O, E, A>) => Kind<F, R, O, E, B>
-}
-
-/**
- * Returns a default `filterMap` composition.
- *
- * @since 1.0.0
- */
-export const filterMapComposition = <F extends TypeLambda, G extends TypeLambda>(
-  F: Covariant<F>,
-  G: Filterable<G>
-) =>
-  <A, B>(
-    f: (a: A) => Option<B>
-  ): <FR, FO, FE, GR, GO, GE>(
-    self: Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, A>>
-  ) => Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, B>> => F.map(G.filterMap(f))
-
-/**
- * @since 1.0.0
- */
-export const filter: <F extends TypeLambda>(
-  F: Filterable<F>
-) => {
-  <C extends A, B extends A, A = C>(refinement: (a: A) => a is B): <R, O, E>(
-    self: Kind<F, R, O, E, C>
-  ) => Kind<F, R, O, E, B>
-  <B extends A, A = B>(
-    predicate: (a: A) => boolean
-  ): <R, O, E>(self: Kind<F, R, O, E, B>) => Kind<F, R, O, E, B>
-} = <F extends TypeLambda>(Filterable: Filterable<F>) =>
-  <B extends A, A = B>(
-    predicate: (a: A) => boolean
-  ): (<R, O, E>(self: Kind<F, R, O, E, B>) => Kind<F, R, O, E, B>) =>
-    Filterable.filterMap(b => (predicate(b) ? option.some(b) : option.none))
-
-/**
- * @since 1.0.0
- */
-export const partitionMap = <F extends TypeLambda>(F: Filterable<F>) =>
-  <A, B, C>(f: (a: A) => Either<B, C>) =>
-    <R, O, E>(
-      self: Kind<F, R, O, E, A>
-    ): readonly [Kind<F, R, O, E, B>, Kind<F, R, O, E, C>] => {
-      return [
-        pipe(self, F.filterMap(a => either.getLeft(f(a)))),
-        pipe(self, F.filterMap(a => either.getRight(f(a))))
-      ]
-    }
-
-/**
- * @since 1.0.0
- */
-export const partition: <F extends TypeLambda>(
-  F: Filterable<F>
-) => {
-  <C extends A, B extends A, A = C>(refinement: (a: A) => a is B): <R, O, E>(
-    self: Kind<F, R, O, E, C>
-  ) => readonly [Kind<F, R, O, E, C>, Kind<F, R, O, E, B>]
-  <B extends A, A = B>(predicate: (a: A) => boolean): <R, O, E>(
-    self: Kind<F, R, O, E, B>
-  ) => readonly [Kind<F, R, O, E, B>, Kind<F, R, O, E, B>]
-} = <F extends TypeLambda>(Filterable: Filterable<F>) =>
-  <B extends A, A = B>(
-    predicate: (a: A) => boolean
-  ): (<R, O, E>(
-    self: Kind<F, R, O, E, B>
-  ) => readonly [Kind<F, R, O, E, B>, Kind<F, R, O, E, B>]) =>
-    partitionMap(Filterable)(b => (predicate(b) ? either.right(b) : either.left(b)))
diff --git a/src/typeclass/SemiCoproduct.ts b/src/typeclass/SemiCoproduct.ts
index c7527426f..d13d6e044 100644
--- a/src/typeclass/SemiCoproduct.ts
+++ b/src/typeclass/SemiCoproduct.ts
@@ -1,10 +1,7 @@
 /**
  * @since 1.0.0
  */
-import type { Either, Left, Right } from "@fp-ts/core/data/Either"
 import type { Kind, TypeLambda } from "@fp-ts/core/HKT"
-import * as either from "@fp-ts/core/internal/Either"
-import { pipe } from "@fp-ts/core/internal/Function"
 import type { Invariant } from "@fp-ts/core/typeclass/Invariant"
 import type { Semigroup } from "@fp-ts/core/typeclass/Semigroup"
 
@@ -34,19 +31,3 @@ export const getSemigroup = <F extends TypeLambda>(F: SemiCoproduct<F>) =>
     combine: F.coproduct,
     combineMany: F.coproductMany
   })
-
-/**
- * @since 1.0.0
- */
-export const coproductEither = <F extends TypeLambda>(F: SemiCoproduct<F>) =>
-  <R2, O2, E2, B>(
-    that: Kind<F, R2, O2, E2, B>
-  ) =>
-    <R1, O1, E1, A>(
-      self: Kind<F, R1, O1, E1, A>
-    ): Kind<F, R1 & R2, O1 | O2, E1 | E2, Either<A, B>> =>
-      pipe(
-        self,
-        F.imap(a => either.left(a) as Left<A>, e => e.left),
-        F.coproduct(pipe(that, F.imap(b => either.right(b) as Right<B>, e => e.right)))
-      )
diff --git a/src/typeclass/SemiProduct.ts b/src/typeclass/SemiProduct.ts
index 112db620a..c8b6958dd 100644
--- a/src/typeclass/SemiProduct.ts
+++ b/src/typeclass/SemiProduct.ts
@@ -100,7 +100,7 @@ export const productMany = <F extends TypeLambda>(
 export const andThenBind = <F extends TypeLambda>(F: SemiProduct<F>) =>
   <N extends string, A extends object, R2, O2, E2, B>(
     name: Exclude<N, keyof A>,
-    fb: Kind<F, R2, O2, E2, B>
+    that: Kind<F, R2, O2, E2, B>
   ) =>
     <R1, O1, E1>(
       self: Kind<F, R1, O1, E1, A>
@@ -113,7 +113,7 @@ export const andThenBind = <F extends TypeLambda>(F: SemiProduct<F>) =>
     > =>
       pipe(
         self,
-        F.product(fb),
+        F.product(that),
         F.imap(
           ([a, b]) => Object.assign({}, a, { [name]: b }) as any,
           ({ [name]: b, ...rest }) => [rest, b] as any
diff --git a/src/typeclass/TraversableFilterable.ts b/src/typeclass/TraversableFilterable.ts
deleted file mode 100644
index a791ec9f4..000000000
--- a/src/typeclass/TraversableFilterable.ts
+++ /dev/null
@@ -1,107 +0,0 @@
-/**
- * `TraversableFilterable` represents data structures which can be _partitioned_ with effects in some `Applicative` functor.
- *
- * @since 1.0.0
- */
-import type { Either } from "@fp-ts/core/data/Either"
-import type { Option } from "@fp-ts/core/data/Option"
-import type { Kind, TypeClass, TypeLambda } from "@fp-ts/core/HKT"
-import * as either from "@fp-ts/core/internal/Either"
-import { pipe } from "@fp-ts/core/internal/Function"
-import * as option from "@fp-ts/core/internal/Option"
-import type { Applicative } from "@fp-ts/core/typeclass/Applicative"
-import * as compactable from "@fp-ts/core/typeclass/Compactable"
-import type { Compactable } from "@fp-ts/core/typeclass/Compactable"
-import type { Covariant } from "@fp-ts/core/typeclass/Covariant"
-import type { Traversable } from "@fp-ts/core/typeclass/Traversable"
-
-/**
- * @category models
- * @since 1.0.0
- */
-export interface TraversableFilterable<T extends TypeLambda> extends TypeClass<T> {
-  readonly traversePartitionMap: <F extends TypeLambda>(
-    F: Applicative<F>
-  ) => <A, R, O, E, B, C>(
-    f: (a: A) => Kind<F, R, O, E, Either<B, C>>
-  ) => <TR, TO, TE>(
-    self: Kind<T, TR, TO, TE, A>
-  ) => Kind<F, R, O, E, readonly [Kind<T, TR, TO, TE, B>, Kind<T, TR, TO, TE, C>]>
-
-  readonly traverseFilterMap: <F extends TypeLambda>(
-    F: Applicative<F>
-  ) => <A, R, O, E, B>(
-    f: (a: A) => Kind<F, R, O, E, Option<B>>
-  ) => <TR, TO, TE>(
-    self: Kind<T, TR, TO, TE, A>
-  ) => Kind<F, R, O, E, Kind<T, TR, TO, TE, B>>
-}
-
-/**
- * Returns a default `traversePartitionMap` implementation.
- *
- * @since 1.0.0
- */
-export const traversePartitionMap = <T extends TypeLambda>(
-  T: Traversable<T> & Covariant<T> & Compactable<T>
-): TraversableFilterable<T>["traversePartitionMap"] =>
-  (F) =>
-    f =>
-      ta =>
-        pipe(
-          ta,
-          T.traverse(F)(f),
-          F.map(compactable.separate(T))
-        )
-
-/**
- * Returns a default `traverseFilterMap` implementation.
- *
- * @since 1.0.0
- */
-export const traverseFilterMap = <T extends TypeLambda>(
-  T: Traversable<T> & Compactable<T>
-): TraversableFilterable<T>["traverseFilterMap"] =>
-  (F) => f => ta => pipe(ta, T.traverse(F)(f), F.map(T.compact))
-
-/**
- * @since 1.0.0
- */
-export const traverseFilter = <T extends TypeLambda>(
-  T: TraversableFilterable<T>
-) =>
-  <F extends TypeLambda>(
-    F: Applicative<F>
-  ): (<B extends A, R, O, E, A = B>(
-    predicate: (a: A) => Kind<F, R, O, E, boolean>
-  ) => <TR, TO, TE>(
-    self: Kind<T, TR, TO, TE, B>
-  ) => Kind<F, R, O, E, Kind<T, TR, TO, TE, B>>) =>
-    (predicate) =>
-      T.traverseFilterMap(F)(b =>
-        pipe(
-          predicate(b),
-          F.map(keep => (keep ? option.some(b) : option.none))
-        )
-      )
-
-/**
- * @since 1.0.0
- */
-export const traversePartition = <T extends TypeLambda>(
-  T: TraversableFilterable<T>
-) =>
-  <F extends TypeLambda>(
-    F: Applicative<F>
-  ): (<B extends A, R, O, E, A = B>(
-    predicate: (a: A) => Kind<F, R, O, E, boolean>
-  ) => <TR, TO, TE>(
-    self: Kind<T, TR, TO, TE, B>
-  ) => Kind<F, R, O, E, readonly [Kind<T, TR, TO, TE, B>, Kind<T, TR, TO, TE, B>]>) =>
-    (predicate) =>
-      T.traversePartitionMap(F)(b =>
-        pipe(
-          predicate(b),
-          F.map((keep) => (keep ? either.right(b) : either.left(b)))
-        )
-      )
diff --git a/test/data/Either.ts b/test/data/Either.ts
new file mode 100644
index 000000000..643702a48
--- /dev/null
+++ b/test/data/Either.ts
@@ -0,0 +1,64 @@
+import type { TypeLambda } from "@fp-ts/core/HKT"
+import * as covariant from "@fp-ts/core/typeclass/Covariant"
+import * as semiCoproduct from "@fp-ts/core/typeclass/SemiCoproduct"
+import type { Semigroup } from "@fp-ts/core/typeclass/Semigroup"
+
+export interface Left<out E> {
+  readonly _tag: "Left"
+  readonly left: E
+}
+
+export interface Right<out A> {
+  readonly _tag: "Right"
+  readonly right: A
+}
+
+export type Either<E, A> = Left<E> | Right<A>
+
+export interface EitherTypeLambda extends TypeLambda {
+  readonly type: Either<this["Out1"], this["Target"]>
+}
+
+export const left = <E>(e: E): Either<E, never> => ({ _tag: "Left", left: e })
+
+export const right = <A>(a: A): Either<never, A> => ({ _tag: "Right", right: a })
+
+/**
+ * @since 1.0.0
+ */
+export const isLeft = <E, A>(self: Either<E, A>): self is Left<E> => self._tag === "Left"
+
+/**
+ * @since 1.0.0
+ */
+export const isRight = <E, A>(self: Either<E, A>): self is Right<A> => self._tag === "Right"
+
+const map = <A, B>(f: (a: A) => B) =>
+  <E>(self: Either<E, A>): Either<E, B> => isRight(self) ? right(f(self.right)) : self
+
+const imap = covariant.imap<EitherTypeLambda>(map)
+
+const coproduct = <E2, B>(
+  that: Either<E2, B>
+) => <E1, A>(self: Either<E1, A>): Either<E2, A | B> => isRight(self) ? self : that
+
+export const SemiCoproduct: semiCoproduct.SemiCoproduct<EitherTypeLambda> = {
+  imap,
+  coproduct,
+  coproductMany: collection =>
+    self => {
+      let out = self
+      if (isRight(out)) {
+        return out
+      }
+      for (out of collection) {
+        if (isRight(out)) {
+          return out
+        }
+      }
+      return out
+    }
+}
+
+export const getSemigroup: <E, A>() => Semigroup<Either<E, A>> = semiCoproduct
+  .getSemigroup(SemiCoproduct)
diff --git a/test/test-data/NonEmptyArray.ts b/test/data/NonEmptyArray.ts
similarity index 100%
rename from test/test-data/NonEmptyArray.ts
rename to test/data/NonEmptyArray.ts
diff --git a/test/test-data/NonEmptyReadonlyArray.ts b/test/data/NonEmptyReadonlyArray.ts
similarity index 100%
rename from test/test-data/NonEmptyReadonlyArray.ts
rename to test/data/NonEmptyReadonlyArray.ts
diff --git a/test/test-data/Option.ts b/test/data/Option.ts
similarity index 63%
rename from test/test-data/Option.ts
rename to test/data/Option.ts
index fa0ce70bb..c3890a22f 100644
--- a/test/test-data/Option.ts
+++ b/test/data/Option.ts
@@ -12,19 +12,13 @@
  *
  * @since 1.0.0
  */
-import type { Either } from "@fp-ts/core/data/Either"
 import type { Kind, TypeLambda } from "@fp-ts/core/HKT"
-import * as either from "@fp-ts/core/internal/Either"
-import type { LazyArg } from "@fp-ts/core/internal/Function"
 import { identity, pipe } from "@fp-ts/core/internal/Function"
-import * as option from "@fp-ts/core/internal/Option"
 import type * as extendable from "@fp-ts/core/test/limbo/Extendable"
 import type * as alternative from "@fp-ts/core/typeclass/Alternative"
 import type * as applicative from "@fp-ts/core/typeclass/Applicative"
 import * as chainable from "@fp-ts/core/typeclass/Chainable"
-import type * as compactable from "@fp-ts/core/typeclass/Compactable"
 import * as covariant from "@fp-ts/core/typeclass/Covariant"
-import * as filterable from "@fp-ts/core/typeclass/Filterable"
 import * as flatMap_ from "@fp-ts/core/typeclass/FlatMap"
 import type * as foldable from "@fp-ts/core/typeclass/Foldable"
 import * as invariant from "@fp-ts/core/typeclass/Invariant"
@@ -40,98 +34,37 @@ import type * as semiCoproduct from "@fp-ts/core/typeclass/SemiCoproduct"
 import type * as semigroup from "@fp-ts/core/typeclass/Semigroup"
 import * as semiProduct from "@fp-ts/core/typeclass/SemiProduct"
 import * as traversable from "@fp-ts/core/typeclass/Traversable"
-import * as traversableFilterable from "@fp-ts/core/typeclass/TraversableFilterable"
 import type * as foldableWithIndex from "../limbo/FoldableWithIndex"
 import * as nonEmptyArray from "./NonEmptyArray"
 import * as nonEmptyReadonlyArray from "./NonEmptyReadonlyArray"
 
-/**
- * @category models
- * @since 1.0.0
- */
+export interface LazyArg<A> {
+  (): A
+}
+
 export interface None {
   readonly _tag: "None"
 }
 
-/**
- * @category models
- * @since 1.0.0
- */
 export interface Some<A> {
   readonly _tag: "Some"
   readonly value: A
 }
 
-/**
- * @category models
- * @since 1.0.0
- */
 export type Option<A> = None | Some<A>
 
-// -------------------------------------------------------------------------------------
-// type lambdas
-// -------------------------------------------------------------------------------------
-
-/**
- * @category type lambdas
- * @since 1.0.0
- */
 export interface OptionTypeLambda extends TypeLambda {
   readonly type: Option<this["Target"]>
 }
 
-// -------------------------------------------------------------------------------------
-// refinements
-// -------------------------------------------------------------------------------------
+export const isNone = <A>(fa: Option<A>): fa is None => fa._tag === "None"
 
-/**
- * Returns `true` if the option is `None`, `false` otherwise.
- *
- * @exampleTodo
- * import { some, none, isNone } from '@fp-ts/data/Option'
- *
- * assert.strictEqual(isNone(some(1)), false)
- * assert.strictEqual(isNone(none), true)
- *
- * @category refinements
- * @since 1.0.0
- */
-export const isNone: (fa: Option<unknown>) => fa is None = option.isNone
+export const isSome = <A>(fa: Option<A>): fa is Some<A> => fa._tag === "Some"
 
-/**
- * Returns `true` if the option is an instance of `Some`, `false` otherwise.
- *
- * @exampleTodo
- * import { some, none, isSome } from '@fp-ts/data/Option'
- *
- * assert.strictEqual(isSome(some(1)), true)
- * assert.strictEqual(isSome(none), false)
- *
- * @category refinements
- * @since 1.0.0
- */
-export const isSome: <A>(fa: Option<A>) => fa is Some<A> = option.isSome
-
-/**
- * `None` doesn't have a constructor, instead you can use it directly as a value. Represents a missing value.
- *
- * @category constructors
- * @since 1.0.0
- */
-export const none: Option<never> = option.none
+export const none: Option<never> = { _tag: "None" }
 
-/**
- * Constructs a `Some`. Represents an optional value that exists.
- *
- * @category constructors
- * @since 1.0.0
- */
-export const some: <A>(a: A) => Option<A> = option.some
+export const some = <A>(a: A): Option<A> => ({ _tag: "Some", value: a })
 
-/**
- * @category conversions
- * @since 1.0.0
- */
 export const fromIterable = <A>(collection: Iterable<A>): Option<A> => {
   for (const a of collection) {
     return some(a)
@@ -139,98 +72,12 @@ export const fromIterable = <A>(collection: Iterable<A>): Option<A> => {
   return none
 }
 
-/**
- * Converts a `Result` to an `Option` discarding the error.
- *
- * @exampleTodo
- * import * as O from '@fp-ts/data/Option'
- * import * as R from '@fp-ts/data/Result'
- *
- * assert.deepStrictEqual(O.fromResult(R.succeed(1)), O.some(1))
- * assert.deepStrictEqual(O.fromResult(R.fail('a')), O.none)
- *
- * @category conversions
- * @since 1.0.0
- */
-export const fromEither: <E, A>(self: Either<E, A>) => Option<A> = either.getRight
-
-/**
- * Takes a (lazy) default value, a function, and an `Option` value, if the `Option` value is `None` the default value is
- * returned, otherwise the function is applied to the value inside the `Some` and the result is returned.
- *
- * @exampleTodo
- * import { some, none, match } from '@fp-ts/data/Option'
- * import { pipe } from '@fp-ts/data/Function'
- *
- * assert.strictEqual(
- *   pipe(
- *     some(1),
- *     match(() => 'a none', a => `a some containing ${a}`)
- *   ),
- *   'a some containing 1'
- * )
- *
- * assert.strictEqual(
- *   pipe(
- *     none,
- *     match(() => 'a none', a => `a some containing ${a}`)
- *   ),
- *   'a none'
- * )
- *
- * @category pattern matching
- * @since 1.0.0
- */
 export const match = <B, A, C = B>(onNone: LazyArg<B>, onSome: (a: A) => C) =>
   (ma: Option<A>): B | C => isNone(ma) ? onNone() : onSome(ma.value)
 
-/**
- * Extracts the value out of the structure, if it exists. Otherwise returns the given default value
- *
- * @exampleTodo
- * import { some, none, getOrElse } from '@fp-ts/data/Option'
- * import { pipe } from '@fp-ts/data/Function'
- *
- * assert.strictEqual(
- *   pipe(
- *     some(1),
- *     getOrElse(0)
- *   ),
- *   1
- * )
- * assert.strictEqual(
- *   pipe(
- *     none,
- *     getOrElse(0)
- *   ),
- *   0
- * )
- *
- * @category error handling
- * @since 1.0.0
- */
 export const getOrElse = <B>(onNone: B) =>
   <A>(ma: Option<A>): A | B => isNone(ma) ? onNone : ma.value
 
-/**
- * Converts an exception into an `Option`. If `f` throws, returns `None`, otherwise returns the output wrapped in a
- * `Some`.
- *
- * @exampleTodo
- * import { none, some, fromThrowable } from '@fp-ts/data/Option'
- *
- * assert.deepStrictEqual(
- *   fromThrowable(() => {
- *     throw new Error()
- *   }),
- *   none
- * )
- * assert.deepStrictEqual(fromThrowable(() => 1), some(1))
- *
- * @category interop
- * @see {@link liftThrowable}
- * @since 1.0.0
- */
 export const fromThrowable = <A>(f: () => A): Option<A> => {
   try {
     return some(f())
@@ -239,41 +86,10 @@ export const fromThrowable = <A>(f: () => A): Option<A> => {
   }
 }
 
-/**
- * Lifts a function that may throw to one returning a `Option`.
- *
- * @category interop
- * @since 1.0.0
- */
 export const liftThrowable = <A extends ReadonlyArray<unknown>, B>(
   f: (...a: A) => B
 ): ((...a: A) => Option<B>) => (...a) => fromThrowable(() => f(...a))
 
-/**
- * Extracts the value out of the structure, if it exists. Otherwise returns `null`.
- *
- * @exampleTodo
- * import { some, none, toNull } from '@fp-ts/data/Option'
- * import { pipe } from '@fp-ts/data/Function'
- *
- * assert.strictEqual(
- *   pipe(
- *     some(1),
- *     toNull
- *   ),
- *   1
- * )
- * assert.strictEqual(
- *   pipe(
- *     none,
- *     toNull
- *   ),
- *   null
- * )
- *
- * @category conversions
- * @since 1.0.0
- */
 export const toNull: <A>(self: Option<A>) => A | null = getOrElse(null)
 
 /**
@@ -472,15 +288,6 @@ export const duplicate: <A>(ma: Option<A>) => Option<Option<A>> = extend(identit
  */
 export const compact: <A>(foa: Option<Option<A>>) => Option<A> = flatten
 
-const defaultSeparated = [none, none] as const
-
-/**
- * @category filtering
- * @since 1.0.0
- */
-export const separate: <A, B>(fe: Option<Either<A, B>>) => readonly [Option<A>, Option<B>] = (ma) =>
-  isNone(ma) ? defaultSeparated : [either.getLeft(ma.value), fromEither(ma.value)]
-
 /**
  * @category filtering
  * @since 1.0.0
@@ -488,14 +295,6 @@ export const separate: <A, B>(fe: Option<Either<A, B>>) => readonly [Option<A>,
 export const filterMap: <A, B>(f: (a: A) => Option<B>) => (fa: Option<A>) => Option<B> = (f) =>
   (fa) => isNone(fa) ? none : f(fa.value)
 
-/**
- * @category filtering
- * @since 1.0.0
- */
-export const partitionMap: <A, B, C>(
-  f: (a: A) => Either<B, C>
-) => (fa: Option<A>) => readonly [Option<B>, Option<C>] = (f) => oa => pipe(oa, map(f), separate)
-
 /**
  * @category traversing
  * @since 1.0.0
@@ -810,44 +609,6 @@ export const Extendable: extendable.Extendable<OptionTypeLambda> = {
   extend
 }
 
-/**
- * @category instances
- * @since 1.0.0
- */
-export const Compactable: compactable.Compactable<OptionTypeLambda> = {
-  compact
-}
-
-/**
- * @category instances
- * @since 1.0.0
- */
-export const Filterable: filterable.Filterable<OptionTypeLambda> = {
-  filterMap
-}
-
-/**
- * @category filtering
- * @since 1.0.0
- */
-export const filter: {
-  <C extends A, B extends A, A = C>(refinement: (a: A) => a is B): (fc: Option<C>) => Option<B>
-  <B extends A, A = B>(predicate: (a: A) => boolean): (fb: Option<B>) => Option<B>
-} = filterable.filter(Filterable)
-
-/**
- * @category filtering
- * @since 1.0.0
- */
-export const partition: {
-  <C extends A, B extends A, A = C>(
-    refinement: (a: A) => a is B
-  ): (fc: Option<C>) => readonly [Option<C>, Option<B>]
-  <B extends A, A = B>(
-    predicate: (a: A) => boolean
-  ): (fb: Option<B>) => readonly [Option<B>, Option<B>]
-} = filterable.partition(Filterable)
-
 /**
  * @category traversing
  * @since 1.0.0
@@ -866,165 +627,9 @@ export const Traversable: traversable.Traversable<OptionTypeLambda> = {
   sequence
 }
 
-/**
- * @category filtering
- * @since 1.0.0
- */
-export const traverseFilterMap: <F extends TypeLambda>(
-  Applicative: applicative.Applicative<F>
-) => <A, R, O, E, B>(
-  f: (a: A) => Kind<F, R, O, E, Option<B>>
-) => (ta: Option<A>) => Kind<F, R, O, E, Option<B>> = traversableFilterable.traverseFilterMap(
-  { ...Traversable, ...Compactable }
-)
-
-/**
- * @category filtering
- * @since 1.0.0
- */
-export const traversePartitionMap: <F extends TypeLambda>(
-  Applicative: applicative.Applicative<F>
-) => <A, R, O, E, B, C>(
-  f: (a: A) => Kind<F, R, O, E, Either<B, C>>
-) => (wa: Option<A>) => Kind<F, R, O, E, readonly [Option<B>, Option<C>]> = traversableFilterable
-  .traversePartitionMap({ ...Traversable, ...Covariant, ...Compactable })
-
-/**
- * @category instances
- * @since 1.0.0
- */
-export const TraversableFilterable: traversableFilterable.TraversableFilterable<
-  OptionTypeLambda
-> = {
-  traverseFilterMap,
-  traversePartitionMap
-}
-
-/**
- * @category filtering
- * @since 1.0.0
- */
-export const traverseFilter: <F extends TypeLambda>(
-  Applicative: applicative.Applicative<F>
-) => <B extends A, R, O, E, A = B>(
-  predicate: (a: A) => Kind<F, R, O, E, boolean>
-) => (self: Option<B>) => Kind<F, R, O, E, Option<B>> = traversableFilterable.traverseFilter(
-  TraversableFilterable
-)
-
-/**
- * @category filtering
- * @since 1.0.0
- */
-export const traversePartition: <F extends TypeLambda>(
-  Applicative: applicative.Applicative<F>
-) => <B extends A, R, O, E, A = B>(
-  predicate: (a: A) => Kind<F, R, O, E, boolean>
-) => (self: Option<B>) => Kind<F, R, O, E, readonly [Option<B>, Option<B>]> = traversableFilterable
-  .traversePartition(TraversableFilterable)
-
-// TODO
-// /**
-//  * Returns a *smart constructor* based on the given predicate.
-//  *
-//  * @exampleTodo
-//  * import * as O from '@fp-ts/data/Option'
-//  *
-//  * const getOption = O.liftPredicate((n: number) => n >= 0)
-//  *
-//  * assert.deepStrictEqual(getOption(-1), O.none)
-//  * assert.deepStrictEqual(getOption(1), O.some(1))
-//  *
-//  * @category lifting
-//  * @since 1.0.0
-//  */
-// export const liftPredicate: {
-//   <C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (c: C) => Option<B>
-//   <B extends A, A = B>(predicate: Predicate<A>): (b: B) => Option<B>
-// } = fromOption_.liftPredicate(FromOption)
-
-// TODO
-// /**
-//  * @category instances
-//  * @since 1.0.0
-//  */
-// export const FromResult: fromResult_.FromResult<OptionTypeLambda> = {
-//   fromResult: fromEither
-// }
-
-// TODO
-// /**
-//  * @category lifting
-//  * @since 1.0.0
-//  */
-// export const liftResult: <A extends ReadonlyArray<unknown>, E, B>(
-//   f: (...a: A) => Result<E, B>
-// ) => (...a: A) => Option<B> = fromResult_.liftResult(FromResult)
-
-// TODO
-// /**
-//  * @category sequencing
-//  * @since 1.0.0
-//  */
-// export const flatMapResult: <A, E, B>(f: (a: A) => Result<E, B>) => (ma: Option<A>) => Option<B> =
-//   fromResult_.flatMapResult(FromResult, FlatMap)
-
-// TODO
-// /**
-//  * Tests whether a value is a member of a `Option`.
-//  *
-//  * @exampleTodo
-//  * import * as O from '@fp-ts/data/Option'
-//  * import * as N from '@fp-ts/data/number'
-//  * import { pipe } from '@fp-ts/data/Function'
-//  *
-//  * assert.strictEqual(pipe(O.some(1), O.elem(N.Eq)(1)), true)
-//  * assert.strictEqual(pipe(O.some(1), O.elem(N.Eq)(2)), false)
-//  * assert.strictEqual(pipe(O.none, O.elem(N.Eq)(1)), false)
-//  *
-//  * @since 1.0.0
-//  */
-// export const elem = <A>(a: A) =>
-//   (ma: Option<A>): boolean => isNone(ma) ? false : equals(ma.value)(a)
-
-/**
- * Returns `true` if the predicate is satisfied by the wrapped value
- *
- * @exampleTodo
- * import { some, none, exists } from '@fp-ts/data/Option'
- * import { pipe } from '@fp-ts/data/Function'
- *
- * assert.strictEqual(
- *   pipe(
- *     some(1),
- *     exists(n => n > 0)
- *   ),
- *   true
- * )
- * assert.strictEqual(
- *   pipe(
- *     some(1),
- *     exists(n => n > 1)
- *   ),
- *   false
- * )
- * assert.strictEqual(
- *   pipe(
- *     none,
- *     exists(n => n > 0)
- *   ),
- *   false
- * )
- *
- * @since 1.0.0
- */
 export const exists = <A>(predicate: (a: A) => boolean) =>
   (ma: Option<A>): boolean => isNone(ma) ? false : predicate(ma.value)
 
-// -------------------------------------------------------------------------------------
-// do notation
-// -------------------------------------------------------------------------------------
-
 /**
  * @category do notation
  * @since 1.0.0
diff --git a/test/test-data/Predicate.ts b/test/data/Predicate.ts
similarity index 100%
rename from test/test-data/Predicate.ts
rename to test/data/Predicate.ts
diff --git a/test/test-data/ReadonlyArray.ts b/test/data/ReadonlyArray.ts
similarity index 78%
rename from test/test-data/ReadonlyArray.ts
rename to test/data/ReadonlyArray.ts
index 9413cb09a..a11bea077 100644
--- a/test/test-data/ReadonlyArray.ts
+++ b/test/data/ReadonlyArray.ts
@@ -1,6 +1,4 @@
-import type { compactable, filterable } from "@fp-ts/core"
-import { semiProduct, traversableFilterable } from "@fp-ts/core"
-import type { Option } from "@fp-ts/core/data/Option"
+import { semiProduct } from "@fp-ts/core"
 import type { Kind, TypeLambda } from "@fp-ts/core/HKT"
 import { identity, pipe } from "@fp-ts/core/internal/Function"
 import type * as applicative from "@fp-ts/core/typeclass/Applicative"
@@ -11,12 +9,12 @@ import type { Order } from "@fp-ts/core/typeclass/Order"
 import type * as semiApplicative from "@fp-ts/core/typeclass/SemiApplicative"
 import type * as traverse_ from "@fp-ts/core/typeclass/Traversable"
 import type * as covariantWithIndex from "../limbo/CovariantWithIndex"
-import * as filterableWithIndex from "../limbo/FilterableWithIndex"
 import * as foldableWithIndex from "../limbo/FoldableWithIndex"
 import type * as traversableWithIndex from "../limbo/TraversableWithIndex"
 import type { NonEmptyReadonlyArray } from "./NonEmptyReadonlyArray"
 import * as nonEmptyReadonlyArray from "./NonEmptyReadonlyArray"
 import * as O from "./Option"
+import type { Option } from "./Option"
 
 export interface ReadonlyArrayTypeLambda extends TypeLambda {
   readonly type: ReadonlyArray<this["Target"]>
@@ -150,51 +148,3 @@ export const filterMapWithIndex = <A, B>(f: (a: A, i: number) => Option<B>) =>
     }
     return out
   }
-
-export const FilterableWithIndex: filterableWithIndex.FilterableWithIndex<
-  ReadonlyArrayTypeLambda,
-  number
-> = {
-  filterMapWithIndex
-}
-
-export const filterMap: <A, B>(
-  f: (a: A) => Option<B>
-) => (fa: ReadonlyArray<A>) => ReadonlyArray<B> = filterableWithIndex.filterMap(FilterableWithIndex)
-
-export const compact: <A>(fa: ReadonlyArray<Option<A>>) => ReadonlyArray<A> =
-  /*#__PURE__*/ filterMap(identity)
-
-export const Compactable: compactable.Compactable<ReadonlyArrayTypeLambda> = {
-  compact
-}
-
-export const Filterable: filterable.Filterable<ReadonlyArrayTypeLambda> = {
-  filterMap
-}
-
-/**
- * @category filtering
- * @since 1.0.0
- */
-export const traverseFilterMap = traversableFilterable.traverseFilterMap(
-  { ...Traversable, ...Compactable }
-)
-
-/**
- * @category filtering
- * @since 1.0.0
- */
-export const traversePartitionMap = traversableFilterable
-  .traversePartitionMap({ ...Traversable, ...Covariant, ...Compactable })
-
-/**
- * @category instances
- * @since 1.0.0
- */
-export const TraversableFilterable: traversableFilterable.TraversableFilterable<
-  ReadonlyArrayTypeLambda
-> = {
-  traverseFilterMap,
-  traversePartitionMap
-}
diff --git a/test/test-data/boolean.ts b/test/data/boolean.ts
similarity index 100%
rename from test/test-data/boolean.ts
rename to test/data/boolean.ts
diff --git a/test/test-data/number.ts b/test/data/number.ts
similarity index 100%
rename from test/test-data/number.ts
rename to test/data/number.ts
diff --git a/test/test-data/string.ts b/test/data/string.ts
similarity index 100%
rename from test/test-data/string.ts
rename to test/data/string.ts
diff --git a/test/internal/Either.ts b/test/internal/Either.ts
deleted file mode 100644
index 2a171f52f..000000000
--- a/test/internal/Either.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import * as _ from "@fp-ts/core/internal/Either"
-import * as U from "../util"
-
-describe("Either", () => {
-  it("isRight", () => {
-    U.deepStrictEqual(_.isRight(_.right(1)), true)
-    U.deepStrictEqual(_.isRight(_.left("e")), false)
-  })
-
-  it("isLeft", () => {
-    U.deepStrictEqual(_.isLeft(_.right(1)), false)
-    U.deepStrictEqual(_.isLeft(_.left("e")), true)
-  })
-})
diff --git a/test/limbo/FilterableWithIndex.ts b/test/limbo/FilterableWithIndex.ts
deleted file mode 100644
index 4a08506ce..000000000
--- a/test/limbo/FilterableWithIndex.ts
+++ /dev/null
@@ -1,104 +0,0 @@
-/**
- * @since 1.0.0
- */
-import type { Either } from "@fp-ts/core/data/Either"
-import type { Option } from "@fp-ts/core/data/Option"
-import type { Kind, TypeClass, TypeLambda } from "@fp-ts/core/HKT"
-import * as either from "@fp-ts/core/internal/Either"
-import { pipe } from "@fp-ts/core/internal/Function"
-import * as option from "@fp-ts/core/internal/Option"
-import type { Covariant } from "@fp-ts/core/typeclass/Covariant"
-import type { Filterable } from "@fp-ts/core/typeclass/Filterable"
-
-/**
- * @category models
- * @since 1.0.0
- */
-export interface FilterableWithIndex<F extends TypeLambda, I> extends TypeClass<F> {
-  readonly filterMapWithIndex: <A, B>(
-    f: (a: A, i: I) => Option<B>
-  ) => <R, O, E>(self: Kind<F, R, O, E, A>) => Kind<F, R, O, E, B>
-}
-
-/**
- * Returns a default `filterMapWithIndex` composition.
- *
- * @since 1.0.0
- */
-export const filterMapWithIndexComposition = <F extends TypeLambda, G extends TypeLambda, I>(
-  F: Covariant<F>,
-  G: FilterableWithIndex<G, I>
-) =>
-  <A, B>(
-    f: (a: A, i: I) => Option<B>
-  ): <FR, FO, FE, GR, GO, GE>(
-    self: Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, A>>
-  ) => Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, B>> => F.map(G.filterMapWithIndex(f))
-
-/**
- * Returns a default `filterMap` implementation.
- *
- * @since 1.0.0
- */
-export const filterMap = <F extends TypeLambda, I>(
-  F: FilterableWithIndex<F, I>
-): Filterable<F>["filterMap"] => (f) => F.filterMapWithIndex(f)
-
-/**
- * @since 1.0.0
- */
-export const filterWithIndex: <F extends TypeLambda, I>(
-  F: FilterableWithIndex<F, I>
-) => {
-  <C extends A, B extends A, A = C>(refinement: (a: A, i: I) => a is B): <R, O, E>(
-    self: Kind<F, R, O, E, C>
-  ) => Kind<F, R, O, E, B>
-  <B extends A, A = B>(
-    predicate: (a: A, i: I) => boolean
-  ): <R, O, E>(self: Kind<F, R, O, E, B>) => Kind<F, R, O, E, B>
-} = <F extends TypeLambda, I>(FilterableWithIndex: FilterableWithIndex<F, I>) =>
-  <B extends A, A = B>(
-    predicate: (a: A, i: I) => boolean
-  ): (<R, O, E>(self: Kind<F, R, O, E, B>) => Kind<F, R, O, E, B>) =>
-    FilterableWithIndex.filterMapWithIndex((
-      b,
-      i
-    ) => (predicate(b, i) ? option.some(b) : option.none))
-
-/**
- * @since 1.0.0
- */
-export const partitionMapWithIndex = <F extends TypeLambda, I>(
-  F: FilterableWithIndex<F, I>
-) =>
-  <A, B, C>(f: (a: A, i: I) => Either<B, C>) =>
-    <R, O, E>(
-      self: Kind<F, R, O, E, A>
-    ): readonly [Kind<F, R, O, E, B>, Kind<F, R, O, E, C>] => {
-      return [
-        pipe(self, F.filterMapWithIndex((a, i) => either.getLeft(f(a, i)))),
-        pipe(self, F.filterMapWithIndex((a, i) => either.getRight(f(a, i))))
-      ]
-    }
-
-/**
- * @since 1.0.0
- */
-export const partitionWithIndex: <F extends TypeLambda, I>(
-  F: FilterableWithIndex<F, I>
-) => {
-  <C extends A, B extends A, A = C>(refinement: (a: A, i: I) => a is B): <R, O, E>(
-    self: Kind<F, R, O, E, C>
-  ) => readonly [Kind<F, R, O, E, C>, Kind<F, R, O, E, B>]
-  <B extends A, A = B>(predicate: (a: A, i: I) => boolean): <R, O, E>(
-    self: Kind<F, R, O, E, B>
-  ) => readonly [Kind<F, R, O, E, B>, Kind<F, R, O, E, B>]
-} = <F extends TypeLambda, I>(FilterableWithIndex: FilterableWithIndex<F, I>) => {
-  const partitionMapWithIndex_ = partitionMapWithIndex(FilterableWithIndex)
-  return <B extends A, A = B>(
-    predicate: (a: A, i: I) => boolean
-  ): (<R, O, E>(
-    self: Kind<F, R, O, E, B>
-  ) => readonly [Kind<F, R, O, E, B>, Kind<F, R, O, E, B>]) =>
-    partitionMapWithIndex_((b, i) => (predicate(b, i) ? either.right(b) : either.left(b)))
-}
diff --git a/test/test-data/Either.ts b/test/test-data/Either.ts
deleted file mode 100644
index 048828d60..000000000
--- a/test/test-data/Either.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import type { Either, EitherTypeLambda } from "@fp-ts/core/data/Either"
-import * as either from "@fp-ts/core/internal/Either"
-import * as covariant from "@fp-ts/core/typeclass/Covariant"
-import * as semiCoproduct from "@fp-ts/core/typeclass/SemiCoproduct"
-import type { Semigroup } from "@fp-ts/core/typeclass/Semigroup"
-
-export const right = either.right
-
-export const left = either.left
-
-const map = <A, B>(f: (a: A) => B) =>
-  <E>(self: Either<E, A>): Either<E, B> => either.isRight(self) ? right(f(self.right)) : self
-
-const imap = covariant.imap<EitherTypeLambda>(map)
-
-const coproduct = <E2, B>(
-  that: Either<E2, B>
-) => <E1, A>(self: Either<E1, A>): Either<E2, A | B> => either.isRight(self) ? self : that
-
-export const SemiCoproduct: semiCoproduct.SemiCoproduct<EitherTypeLambda> = {
-  imap,
-  coproduct,
-  coproductMany: collection =>
-    self => {
-      let out = self
-      if (either.isRight(out)) {
-        return out
-      }
-      for (out of collection) {
-        if (either.isRight(out)) {
-          return out
-        }
-      }
-      return out
-    }
-}
-
-export const getSemigroup: <E, A>() => Semigroup<Either<E, A>> = semiCoproduct
-  .getSemigroup(SemiCoproduct)
diff --git a/test/typeclass/Applicative.ts b/test/typeclass/Applicative.ts
index 46d4c5da5..97e5610d5 100644
--- a/test/typeclass/Applicative.ts
+++ b/test/typeclass/Applicative.ts
@@ -1,7 +1,7 @@
 import { pipe } from "@fp-ts/core/internal/Function"
 import * as _ from "@fp-ts/core/typeclass/Applicative"
-import * as N from "../test-data/number"
-import * as O from "../test-data/Option"
+import * as N from "../data/number"
+import * as O from "../data/Option"
 import * as U from "../util"
 
 describe("Applicative", () => {
diff --git a/test/typeclass/Bicovariant.ts b/test/typeclass/Bicovariant.ts
index fc6799c33..712cf4352 100644
--- a/test/typeclass/Bicovariant.ts
+++ b/test/typeclass/Bicovariant.ts
@@ -1,8 +1,8 @@
-import type { EitherTypeLambda } from "@fp-ts/core/data/Either"
-import * as E from "@fp-ts/core/internal/Either"
 import { pipe } from "@fp-ts/core/internal/Function"
 import * as _ from "@fp-ts/core/typeclass/Bicovariant"
-import * as RA from "../test-data/ReadonlyArray"
+import type { EitherTypeLambda } from "../data/Either"
+import * as E from "../data/Either"
+import * as RA from "../data/ReadonlyArray"
 import * as U from "../util"
 
 export const Bicovariant: _.Bicovariant<EitherTypeLambda> = {
diff --git a/test/typeclass/Bounded.ts b/test/typeclass/Bounded.ts
index a39428177..7c02285dc 100644
--- a/test/typeclass/Bounded.ts
+++ b/test/typeclass/Bounded.ts
@@ -1,5 +1,5 @@
 import * as _ from "@fp-ts/core/typeclass/Bounded"
-import * as number from "../test-data/number"
+import * as number from "../data/number"
 import * as U from "../util"
 
 describe("Bounded", () => {
diff --git a/test/typeclass/Chainable.ts b/test/typeclass/Chainable.ts
index bd46997de..4fffd748f 100644
--- a/test/typeclass/Chainable.ts
+++ b/test/typeclass/Chainable.ts
@@ -1,6 +1,6 @@
 import { pipe } from "@fp-ts/core/internal/Function"
 import * as _ from "@fp-ts/core/typeclass/Chainable"
-import * as O from "../test-data/Option"
+import * as O from "../data/Option"
 import * as U from "../util"
 
 describe("Chainable", () => {
diff --git a/test/typeclass/Compactable.ts b/test/typeclass/Compactable.ts
deleted file mode 100644
index 737a16b35..000000000
--- a/test/typeclass/Compactable.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import * as either from "@fp-ts/core/internal/Either"
-import { pipe } from "@fp-ts/core/internal/Function"
-import * as _ from "@fp-ts/core/typeclass/Compactable"
-import * as O from "../test-data/Option"
-import * as RA from "../test-data/ReadonlyArray"
-import * as U from "../util"
-
-describe("Compactable", () => {
-  it("compactComposition", () => {
-    const compact = _.compactComposition(RA.Covariant, O.Compactable)
-    U.deepStrictEqual(pipe([], compact), [])
-    U.deepStrictEqual(pipe([O.none], compact), [O.none])
-    U.deepStrictEqual(pipe([O.some(O.none)], compact), [O.none])
-    U.deepStrictEqual(pipe([O.some(O.some(1))], compact), [O.some(1)])
-  })
-
-  it("separate", () => {
-    const separate = _.separate({ ...RA.Covariant, ...RA.Compactable })
-    U.deepStrictEqual(pipe([], separate), [[], []])
-    U.deepStrictEqual(pipe([either.right(1), either.left("e"), either.right(2)], separate), [
-      ["e"],
-      [1, 2]
-    ])
-  })
-})
diff --git a/test/typeclass/Contravariant.ts b/test/typeclass/Contravariant.ts
index 271ad07aa..a843e650b 100644
--- a/test/typeclass/Contravariant.ts
+++ b/test/typeclass/Contravariant.ts
@@ -1,8 +1,8 @@
 import { pipe } from "@fp-ts/core/internal/Function"
 import * as _ from "@fp-ts/core/typeclass/Contravariant"
 import * as order from "@fp-ts/core/typeclass/Order"
-import * as P from "../test-data/Predicate"
-import * as string from "../test-data/string"
+import * as P from "../data/Predicate"
+import * as string from "../data/string"
 import * as U from "../util"
 
 describe("Contravariant", () => {
diff --git a/test/typeclass/Coproduct.ts b/test/typeclass/Coproduct.ts
index a32a34266..2bc212210 100644
--- a/test/typeclass/Coproduct.ts
+++ b/test/typeclass/Coproduct.ts
@@ -1,6 +1,6 @@
 import { pipe } from "@fp-ts/core/internal/Function"
 import * as _ from "@fp-ts/core/typeclass/Coproduct"
-import * as O from "../test-data/Option"
+import * as O from "../data/Option"
 import * as U from "../util"
 
 describe("Coproduct", () => {
diff --git a/test/typeclass/Covariant.ts b/test/typeclass/Covariant.ts
index e713ab533..e2be796ff 100644
--- a/test/typeclass/Covariant.ts
+++ b/test/typeclass/Covariant.ts
@@ -1,7 +1,7 @@
 import { pipe } from "@fp-ts/core/internal/Function"
 import * as _ from "@fp-ts/core/typeclass/Covariant"
-import * as O from "../test-data/Option"
-import * as RA from "../test-data/ReadonlyArray"
+import * as O from "../data/Option"
+import * as RA from "../data/ReadonlyArray"
 import * as U from "../util"
 
 describe("Covariant", () => {
diff --git a/test/typeclass/CovariantWithIndex.ts b/test/typeclass/CovariantWithIndex.ts
index 4f7a288c4..c2f630bfb 100644
--- a/test/typeclass/CovariantWithIndex.ts
+++ b/test/typeclass/CovariantWithIndex.ts
@@ -1,6 +1,6 @@
 import { pipe } from "@fp-ts/core/internal/Function"
+import * as RA from "../data/ReadonlyArray"
 import * as _ from "../limbo/CovariantWithIndex"
-import * as RA from "../test-data/ReadonlyArray"
 import * as U from "../util"
 
 describe("FunctorWithIndex", () => {
diff --git a/test/typeclass/Filterable.ts b/test/typeclass/Filterable.ts
deleted file mode 100644
index ae957adec..000000000
--- a/test/typeclass/Filterable.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import * as either from "@fp-ts/core/internal/Either"
-import { pipe } from "@fp-ts/core/internal/Function"
-import * as _ from "@fp-ts/core/typeclass/Filterable"
-import * as O from "../test-data/Option"
-import * as RA from "../test-data/ReadonlyArray"
-import * as U from "../util"
-
-describe("Filterable", () => {
-  it("filterMapComposition", () => {
-    const filterMap = _.filterMapComposition(RA.Covariant, O.Filterable)
-    const f = filterMap((s: string) => s.length > 1 ? O.some(s.length) : O.none)
-    U.deepStrictEqual(pipe([], f), [])
-    U.deepStrictEqual(pipe([O.none], f), [O.none])
-    U.deepStrictEqual(pipe([O.some("a")], f), [O.none])
-    U.deepStrictEqual(pipe([O.some("aa")], f), [O.some(2)])
-  })
-
-  it("filter", () => {
-    const filter = _.filter(RA.Filterable)
-    const f = filter((n: number) => n > 0)
-    U.deepStrictEqual(pipe([], f), [])
-    U.deepStrictEqual(pipe([1], f), [1])
-    U.deepStrictEqual(pipe([-1], f), [])
-    U.deepStrictEqual(pipe([1, -1], f), [1])
-  })
-
-  it("partitionMap", () => {
-    const partitionMap = _.partitionMap(RA.Filterable)
-    const f = partitionMap((s: string) => s.length > 1 ? either.right(s.length) : either.left(s))
-    U.deepStrictEqual(pipe([], f), [[], []])
-    U.deepStrictEqual(pipe(["a"], f), [["a"], []])
-    U.deepStrictEqual(pipe(["aa"], f), [[], [2]])
-    U.deepStrictEqual(pipe(["aa", "a"], f), [["a"], [2]])
-  })
-
-  it("partition", () => {
-    const partition = _.partition(RA.Filterable)
-    const f = partition((n: number) => n > 0)
-    U.deepStrictEqual(pipe([], f), [[], []])
-    U.deepStrictEqual(pipe([1], f), [[], [1]])
-    U.deepStrictEqual(pipe([-1], f), [[-1], []])
-    U.deepStrictEqual(pipe([1, -1], f), [[-1], [1]])
-  })
-})
diff --git a/test/typeclass/FilterableWithIndex.ts b/test/typeclass/FilterableWithIndex.ts
deleted file mode 100644
index 4255eceef..000000000
--- a/test/typeclass/FilterableWithIndex.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import * as either from "@fp-ts/core/internal/Either"
-import { pipe } from "@fp-ts/core/internal/Function"
-import * as _ from "../limbo/FilterableWithIndex"
-import * as O from "../test-data/Option"
-import * as RA from "../test-data/ReadonlyArray"
-import * as U from "../util"
-
-describe("FilterableWithIndex", () => {
-  it("filterMapWithIndexComposition", () => {
-    const filterMapWithIndex = _.filterMapWithIndexComposition(RA.Covariant, RA.FilterableWithIndex)
-    const f = filterMapWithIndex((s: string, i: number) =>
-      s.length > 1 ? O.some(s.length + i) : O.none
-    )
-    U.deepStrictEqual(pipe([], f), [])
-    U.deepStrictEqual(pipe([["a"]], f), [[]])
-    U.deepStrictEqual(pipe([["aa"]], f), [[2]])
-    U.deepStrictEqual(pipe([["aa"], ["b"]], f), [[2], []])
-    U.deepStrictEqual(pipe([["aa"], ["bb"]], f), [[2], [2]])
-    U.deepStrictEqual(pipe([["a", "aa"], ["bb"]], f), [[3], [2]])
-  })
-
-  it("filterWithIndex", () => {
-    const filterWithIndex = _.filterWithIndex(RA.FilterableWithIndex)
-    const f = filterWithIndex((n: number, i: number) => n + i > 0)
-    U.deepStrictEqual(pipe([], f), [])
-    U.deepStrictEqual(pipe([1], f), [1])
-    U.deepStrictEqual(pipe([-1], f), [])
-    U.deepStrictEqual(pipe([1, -1], f), [1])
-    U.deepStrictEqual(pipe([1, 0], f), [1, 0])
-  })
-
-  it("partitionMapWithIndex", () => {
-    const partitionMapWithIndex = _.partitionMapWithIndex(RA.FilterableWithIndex)
-    const f = partitionMapWithIndex((s: string, i: number) =>
-      s.length > 1 ? either.right(s.length + i) : either.left(s)
-    )
-    U.deepStrictEqual(pipe([], f), [[], []])
-    U.deepStrictEqual(pipe(["a"], f), [["a"], []])
-    U.deepStrictEqual(pipe(["aa"], f), [[], [2]])
-    U.deepStrictEqual(pipe(["aa", "b"], f), [["b"], [2]])
-    U.deepStrictEqual(pipe(["aa", "bbb"], f), [[], [2, 4]])
-    U.deepStrictEqual(pipe(["aa", "a"], f), [["a"], [2]])
-    U.deepStrictEqual(pipe(["a", "aa", "bbb"], f), [["a"], [3, 5]])
-  })
-
-  it("partitionWithIndex", () => {
-    const partitionWithIndex = _.partitionWithIndex(RA.FilterableWithIndex)
-    const f = partitionWithIndex((n: number, i: number) => n + i > 0)
-    U.deepStrictEqual(pipe([], f), [[], []])
-    U.deepStrictEqual(pipe([1], f), [[], [1]])
-    U.deepStrictEqual(pipe([-1], f), [[-1], []])
-    U.deepStrictEqual(pipe([1, -1], f), [[-1], [1]])
-    U.deepStrictEqual(pipe([1, 0], f), [[], [1, 0]])
-  })
-})
diff --git a/test/typeclass/FlatMap.ts b/test/typeclass/FlatMap.ts
index c0de5c107..331606b5b 100644
--- a/test/typeclass/FlatMap.ts
+++ b/test/typeclass/FlatMap.ts
@@ -1,6 +1,6 @@
 import { pipe } from "@fp-ts/core/internal/Function"
 import * as _ from "@fp-ts/core/typeclass/FlatMap"
-import * as O from "../test-data/Option"
+import * as O from "../data/Option"
 import * as U from "../util"
 
 describe("FlatMap", () => {
diff --git a/test/typeclass/Foldable.ts b/test/typeclass/Foldable.ts
index 2cea599ae..4c0285898 100644
--- a/test/typeclass/Foldable.ts
+++ b/test/typeclass/Foldable.ts
@@ -1,8 +1,8 @@
 import { pipe } from "@fp-ts/core/internal/Function"
 import * as _ from "@fp-ts/core/typeclass/Foldable"
-import * as number from "../test-data/number"
-import * as O from "../test-data/Option"
-import * as RA from "../test-data/ReadonlyArray"
+import * as number from "../data/number"
+import * as O from "../data/Option"
+import * as RA from "../data/ReadonlyArray"
 import * as U from "../util"
 
 describe("Foldable", () => {
diff --git a/test/typeclass/FoldableWithIndex.ts b/test/typeclass/FoldableWithIndex.ts
index 221eb2010..b1ef8a1af 100644
--- a/test/typeclass/FoldableWithIndex.ts
+++ b/test/typeclass/FoldableWithIndex.ts
@@ -1,8 +1,8 @@
 import { pipe } from "@fp-ts/core/internal/Function"
+import * as number from "../data/number"
+import * as O from "../data/Option"
+import * as RA from "../data/ReadonlyArray"
 import * as foldableWithIndex from "../limbo/FoldableWithIndex"
-import * as number from "../test-data/number"
-import * as O from "../test-data/Option"
-import * as RA from "../test-data/ReadonlyArray"
 import * as U from "../util"
 
 describe("FoldableWithIndex", () => {
diff --git a/test/typeclass/Invariant.ts b/test/typeclass/Invariant.ts
index 7c4d67ec6..2c20678b1 100644
--- a/test/typeclass/Invariant.ts
+++ b/test/typeclass/Invariant.ts
@@ -1,9 +1,9 @@
 import { pipe } from "@fp-ts/core/internal/Function"
 import * as _ from "@fp-ts/core/typeclass/Invariant"
 import * as semigroup from "@fp-ts/core/typeclass/Semigroup"
-import * as O from "../test-data/Option"
-import * as P from "../test-data/Predicate"
-import * as string from "../test-data/string"
+import * as O from "../data/Option"
+import * as P from "../data/Predicate"
+import * as string from "../data/string"
 import * as U from "../util"
 
 describe("Invariant", () => {
diff --git a/test/typeclass/Monoid.ts b/test/typeclass/Monoid.ts
index 2581d492f..22a22d5b8 100644
--- a/test/typeclass/Monoid.ts
+++ b/test/typeclass/Monoid.ts
@@ -1,7 +1,7 @@
 import { pipe } from "@fp-ts/core/internal/Function"
 import * as monoid from "@fp-ts/core/typeclass/Monoid"
-import * as number from "../test-data/number"
-import * as string from "../test-data/string"
+import * as number from "../data/number"
+import * as string from "../data/string"
 import * as U from "../util"
 
 describe("Monoid", () => {
diff --git a/test/typeclass/NonEmptyTraversable.ts b/test/typeclass/NonEmptyTraversable.ts
index 8933a7175..ce901b412 100644
--- a/test/typeclass/NonEmptyTraversable.ts
+++ b/test/typeclass/NonEmptyTraversable.ts
@@ -1,6 +1,6 @@
 import * as _ from "@fp-ts/core/typeclass/NonEmptyTraversable"
-import * as NERA from "../test-data/NonEmptyReadonlyArray"
-import * as O from "../test-data/Option"
+import * as NERA from "../data/NonEmptyReadonlyArray"
+import * as O from "../data/Option"
 import * as U from "../util"
 
 describe("NonEmptyTraversable", () => {
diff --git a/test/typeclass/Of.ts b/test/typeclass/Of.ts
index c02b12997..8fb357fdd 100644
--- a/test/typeclass/Of.ts
+++ b/test/typeclass/Of.ts
@@ -1,6 +1,6 @@
 import * as _ from "@fp-ts/core/typeclass/Of"
-import * as O from "../test-data/Option"
-import * as RA from "../test-data/ReadonlyArray"
+import * as O from "../data/Option"
+import * as RA from "../data/ReadonlyArray"
 import * as U from "../util"
 
 describe("Of", () => {
diff --git a/test/typeclass/Order.ts b/test/typeclass/Order.ts
index 2d95857e9..e24e4f0d6 100644
--- a/test/typeclass/Order.ts
+++ b/test/typeclass/Order.ts
@@ -1,9 +1,9 @@
 import { pipe } from "@fp-ts/core/internal/Function"
 import * as _ from "@fp-ts/core/typeclass/Order"
-import * as boolean from "../test-data/boolean"
-import * as number from "../test-data/number"
-import { sort } from "../test-data/ReadonlyArray"
-import * as string from "../test-data/string"
+import * as boolean from "../data/boolean"
+import * as number from "../data/number"
+import { sort } from "../data/ReadonlyArray"
+import * as string from "../data/string"
 import * as U from "../util"
 
 describe("Order", () => {
diff --git a/test/typeclass/Product.ts b/test/typeclass/Product.ts
index e566043cb..787a127b6 100644
--- a/test/typeclass/Product.ts
+++ b/test/typeclass/Product.ts
@@ -1,10 +1,10 @@
 import { pipe } from "@fp-ts/core/internal/Function"
 import * as _ from "@fp-ts/core/typeclass/Product"
 import * as semigroup from "@fp-ts/core/typeclass/Semigroup"
-import * as number from "../test-data/number"
-import * as O from "../test-data/Option"
-import * as P from "../test-data/Predicate"
-import * as string from "../test-data/string"
+import * as number from "../data/number"
+import * as O from "../data/Option"
+import * as P from "../data/Predicate"
+import * as string from "../data/string"
 import * as U from "../util"
 
 describe("Product", () => {
diff --git a/test/typeclass/SemiApplicative.ts b/test/typeclass/SemiApplicative.ts
index 617212ad5..a5ed18cc2 100644
--- a/test/typeclass/SemiApplicative.ts
+++ b/test/typeclass/SemiApplicative.ts
@@ -1,7 +1,7 @@
 import { pipe } from "@fp-ts/core/internal/Function"
 import * as _ from "@fp-ts/core/typeclass/SemiApplicative"
-import * as O from "../test-data/Option"
-import * as string from "../test-data/string"
+import * as O from "../data/Option"
+import * as string from "../data/string"
 import * as U from "../util"
 
 describe("SemiApplicative", () => {
diff --git a/test/typeclass/SemiCoproduct.ts b/test/typeclass/SemiCoproduct.ts
index dbacea187..3692c8384 100644
--- a/test/typeclass/SemiCoproduct.ts
+++ b/test/typeclass/SemiCoproduct.ts
@@ -1,19 +1,9 @@
-import { left, right } from "@fp-ts/core/internal/Either"
 import { pipe } from "@fp-ts/core/internal/Function"
 import * as _ from "@fp-ts/core/typeclass/SemiCoproduct"
-import * as E from "../test-data/Either"
-import * as O from "../test-data/Option"
+import * as E from "../data/Either"
 import * as U from "../util"
 
 describe("SemiCoproduct", () => {
-  it("coproductEither", () => {
-    const coproductEither = _.coproductEither(O.SemiCoproduct)
-    U.deepStrictEqual(pipe(O.none, coproductEither(O.none)), O.none)
-    U.deepStrictEqual(pipe(O.none, coproductEither(O.some("a"))), O.some(right("a")))
-    U.deepStrictEqual(pipe(O.some(1), coproductEither(O.none)), O.some(left(1)))
-    U.deepStrictEqual(pipe(O.some(1), coproductEither(O.some("a"))), O.some(left(1)))
-  })
-
   it("getSemigroup", () => {
     const S = _.getSemigroup(E.SemiCoproduct)<unknown, never, string, number>()
     U.deepStrictEqual(pipe(E.right(1), S.combine(E.right(2))), E.right(1))
diff --git a/test/typeclass/SemiProduct.ts b/test/typeclass/SemiProduct.ts
index cff9a9eea..3f708d7ee 100644
--- a/test/typeclass/SemiProduct.ts
+++ b/test/typeclass/SemiProduct.ts
@@ -3,11 +3,11 @@ import { pipe } from "@fp-ts/core/internal/Function"
 import * as semiApplicative from "@fp-ts/core/typeclass/SemiApplicative"
 import * as semigroup from "@fp-ts/core/typeclass/Semigroup"
 import * as _ from "@fp-ts/core/typeclass/SemiProduct"
-import * as number from "../test-data/number"
-import * as O from "../test-data/Option"
-import * as P from "../test-data/Predicate"
-import * as RA from "../test-data/ReadonlyArray"
-import * as string from "../test-data/string"
+import * as number from "../data/number"
+import * as O from "../data/Option"
+import * as P from "../data/Predicate"
+import * as RA from "../data/ReadonlyArray"
+import * as string from "../data/string"
 import * as U from "../util"
 
 describe("SemiProduct", () => {
diff --git a/test/typeclass/Semigroup.ts b/test/typeclass/Semigroup.ts
index 57207427d..afd9cb9c5 100644
--- a/test/typeclass/Semigroup.ts
+++ b/test/typeclass/Semigroup.ts
@@ -1,8 +1,8 @@
 import { pipe } from "@fp-ts/core/internal/Function"
 import * as order from "@fp-ts/core/typeclass/Order"
 import * as _ from "@fp-ts/core/typeclass/Semigroup"
-import * as number from "../test-data/number"
-import * as string from "../test-data/string"
+import * as number from "../data/number"
+import * as string from "../data/string"
 import * as U from "../util"
 
 describe("Semigroup", () => {
diff --git a/test/typeclass/Traversable.ts b/test/typeclass/Traversable.ts
index 550f50dfa..2a78856f0 100644
--- a/test/typeclass/Traversable.ts
+++ b/test/typeclass/Traversable.ts
@@ -1,7 +1,7 @@
 import { pipe } from "@fp-ts/core/internal/Function"
 import * as _ from "@fp-ts/core/typeclass/Traversable"
-import * as O from "../test-data/Option"
-import * as RA from "../test-data/ReadonlyArray"
+import * as O from "../data/Option"
+import * as RA from "../data/ReadonlyArray"
 import * as U from "../util"
 
 describe("Traversable", () => {
diff --git a/test/typeclass/TraversableFilterable.ts b/test/typeclass/TraversableFilterable.ts
deleted file mode 100644
index 92df4d510..000000000
--- a/test/typeclass/TraversableFilterable.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import * as _ from "@fp-ts/core/typeclass/TraversableFilterable"
-import * as O from "../test-data/Option"
-import * as RA from "../test-data/ReadonlyArray"
-import * as U from "../util"
-
-describe("TraversableFilterable", () => {
-  it("traverseFilter", () => {
-    const traverseFilter = _.traverseFilter(
-      RA.TraversableFilterable
-    )(O.Applicative)
-    const f = traverseFilter((s: string) =>
-      s.length > 2 ? O.some(false) : s.length > 1 ? O.some(true) : O.none
-    )
-    U.deepStrictEqual(f([]), O.some([]))
-    U.deepStrictEqual(f(["a"]), O.none)
-    U.deepStrictEqual(f(["a", "aa"]), O.none)
-    U.deepStrictEqual(f(["aa"]), O.some(["aa"]))
-    U.deepStrictEqual(f(["aaa"]), O.some([]))
-    U.deepStrictEqual(f(["aaa", "aa"]), O.some(["aa"]))
-  })
-
-  it("traversePartition", () => {
-    const traversePartition = _.traversePartition(
-      RA.TraversableFilterable
-    )(O.Applicative)
-    const f = traversePartition((s: string) =>
-      s.length > 2 ? O.some(false) : s.length > 1 ? O.some(true) : O.none
-    )
-    U.deepStrictEqual(f([]), O.some([[], []] as const))
-    U.deepStrictEqual(f(["a"]), O.none)
-    U.deepStrictEqual(f(["a", "aa"]), O.none)
-    U.deepStrictEqual(f(["aa"]), O.some([[], ["aa"]] as const))
-    U.deepStrictEqual(f(["aaa"]), O.some([["aaa"], []] as const))
-    U.deepStrictEqual(f(["aaa", "aa"]), O.some([["aaa"], ["aa"]] as const))
-  })
-})
diff --git a/test/typeclass/TraversableWithIndex.ts b/test/typeclass/TraversableWithIndex.ts
index 57520493f..5a0cbbf1b 100644
--- a/test/typeclass/TraversableWithIndex.ts
+++ b/test/typeclass/TraversableWithIndex.ts
@@ -1,7 +1,7 @@
 import { pipe } from "@fp-ts/core/internal/Function"
+import * as O from "../data/Option"
+import * as RA from "../data/ReadonlyArray"
 import * as _ from "../limbo/TraversableWithIndex"
-import * as O from "../test-data/Option"
-import * as RA from "../test-data/ReadonlyArray"
 import * as U from "../util"
 
 describe("TraversableWithIndex", () => {
diff --git a/vitest.config.ts b/vitest.config.ts
index 8afef943f..9469eb3d4 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -7,7 +7,7 @@ export default defineConfig({
     include: ["./test/**/*.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"],
     exclude: [
       "./test/util.ts",
-      "./test/test-data/*.ts",
+      "./test/data/*.ts",
       "./test/limbo/*.ts"
     ],
     globals: true