effect 4.0.0-beta.21 → 4.0.0-beta.23

package/src/Iterable.ts

@@ -32,7 +32,6 @@
 
 import type { NonEmptyArray } from "./Array.ts"
 import * as Equal from "./Equal.ts"
-import type * as Filter from "./Filter.ts"
 import { dual } from "./Function.ts"
 import type { Option } from "./Option.ts"
 import * as O from "./Option.ts"
@@ -3205,7 +3204,7 @@ export const filterMap: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B, X>(f: Filter.Filter<A, B, X, [i: number]>): (self: Iterable<A>) => Iterable<B>
+  <A, B, X>(f: (input: A, i: number) => Result<B, X>): (self: Iterable<A>) => Iterable<B>
   /**
    * Transforms elements of an iterable using a function that returns a `Result`, keeping only successful values.
    *
@@ -3251,10 +3250,10 @@ export const filterMap: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B, X>(self: Iterable<A>, f: Filter.Filter<A, B, X, [i: number]>): Iterable<B>
+  <A, B, X>(self: Iterable<A>, f: (input: A, i: number) => Result<B, X>): Iterable<B>
 } = dual(
   2,
-  <A, B, X>(self: Iterable<A>, f: Filter.Filter<A, B, X, [i: number]>): Iterable<B> => ({
+  <A, B, X>(self: Iterable<A>, f: (input: A, i: number) => Result<B, X>): Iterable<B> => ({
     [Symbol.iterator]() {
       const iterator = self[Symbol.iterator]()
       let i = 0
@@ -3348,7 +3347,7 @@ export const filterMapWhile: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B, X>(f: Filter.Filter<A, B, X, [i: number]>): (self: Iterable<A>) => Iterable<B>
+  <A, B, X>(f: (input: A, i: number) => Result<B, X>): (self: Iterable<A>) => Iterable<B>
   /**
    * Transforms all elements of the `Iterable` for as long as the specified function succeeds.
    *
@@ -3385,8 +3384,8 @@ export const filterMapWhile: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B, X>(self: Iterable<A>, f: Filter.Filter<A, B, X, [i: number]>): Iterable<B>
-} = dual(2, <A, B, X>(self: Iterable<A>, f: Filter.Filter<A, B, X, [i: number]>) => ({
+  <A, B, X>(self: Iterable<A>, f: (input: A, i: number) => Result<B, X>): Iterable<B>
+} = dual(2, <A, B, X>(self: Iterable<A>, f: (input: A, i: number) => Result<B, X>) => ({
   [Symbol.iterator]() {
     const iterator = self[Symbol.iterator]()
     let i = 0

package/src/Record.ts

@@ -7,7 +7,6 @@
 import type * as Combiner from "./Combiner.ts"
 import * as Equal from "./Equal.ts"
 import type { Equivalence } from "./Equivalence.ts"
-import type * as Filter from "./Filter.ts"
 import { dual, identity } from "./Function.ts"
 import type { TypeLambda } from "./HKT.ts"
 import * as Option from "./Option.ts"
@@ -1037,7 +1036,7 @@ export const filterMap: {
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A, B, X>(f: Filter.Filter<A, B, X, [key: K]>): (self: ReadonlyRecord<K, A>) => Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  <K extends string, A, B, X>(f: (input: A, key: K) => Result<B, X>): (self: ReadonlyRecord<K, A>) => Record<ReadonlyRecord.NonLiteralKey<K>, B>
   /**
    * Transforms a record by applying the function `f` to each key and value in the original record.
    * If the function succeeds, the key-value pair is included in the output record.
@@ -1055,12 +1054,12 @@ export const filterMap: {
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A, B, X>(self: ReadonlyRecord<K, A>, f: Filter.Filter<A, B, X, [key: K]>): Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  <K extends string, A, B, X>(self: ReadonlyRecord<K, A>, f: (input: A, key: K) => Result<B, X>): Record<ReadonlyRecord.NonLiteralKey<K>, B>
 } = dual(
   2,
   <K extends string, A, B, X>(
     self: ReadonlyRecord<K, A>,
-    f: Filter.Filter<A, B, X, [key: K]>
+    f: (input: A, key: K) => Result<B, X>
   ): Record<ReadonlyRecord.NonLiteralKey<K>, B> => {
     const out: Record<string, B> = empty()
     for (const key of keys(self)) {
@@ -1304,7 +1303,7 @@ export const partition: {
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A, B, C>(f: Filter.Filter<A, C, B, [key: K]>): (
+  <K extends string, A, B, C>(f: (input: A, key: K) => Result<C, B>): (
     self: ReadonlyRecord<K, A>
   ) => [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>]
   /**
@@ -1323,12 +1322,12 @@ export const partition: {
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A, B, C>(self: ReadonlyRecord<K, A>, f: Filter.Filter<A, C, B, [key: K]>): [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>]
+  <K extends string, A, B, C>(self: ReadonlyRecord<K, A>, f: (input: A, key: K) => Result<C, B>): [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>]
 } = dual(
   2,
   <K extends string, A, B, C>(
     self: ReadonlyRecord<K, A>,
-    f: Filter.Filter<A, C, B, [key: K]>
+    f: (input: A, key: K) => Result<C, B>
   ): [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>] => {
     const left: Record<string, B> = empty()
     const right: Record<string, C> = empty()

package/src/Runtime.ts

@@ -29,7 +29,7 @@
 import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import * as Exit from "effect/Exit"
-import { dual } from "effect/Function"
+import { constVoid, dual } from "effect/Function"
 import type * as Fiber from "./Fiber.ts"
 
 /**
@@ -212,6 +212,12 @@ export const makeRunMain = (
           return Effect.logError(cause)
         })
       )
+    try {
+      const keepAlive = globalThis.setInterval(constVoid, 2_147_483_647)
+      fiber.addObserver(() => {
+        clearInterval(keepAlive)
+      })
+    } catch {}
     const teardown = options?.teardown ?? defaultTeardown
     return f({ fiber, teardown })
   })

package/src/SchemaAST.ts

@@ -2640,6 +2640,11 @@ export function replaceContext<A extends AST>(ast: A, context: Context | undefin
   })
 }
 
+/** @internal */
+export function getLastEncoding(ast: AST): AST {
+  return ast.encoding ? getLastEncoding(ast.encoding[ast.encoding.length - 1].to) : ast
+}
+
 /** @internal */
 export function annotate<A extends AST>(ast: A, annotations: Schema.Annotations.Annotations): A {
   if (ast.checks) {

package/src/Stream.ts

@@ -963,6 +963,10 @@ export const fromIteratorSucceed = <A>(iterator: IterableIterator<A>, maxChunkSi
 /**
  * Creates a new `Stream` from an iterable collection of values.
  *
+ * **Options**
+ *
+ * - `chunkSize`: Maximum number of values emitted per chunk.
+ *
  * @example
  * ```ts
  * import { Console, Effect, Stream } from "effect"
@@ -982,10 +986,15 @@ export const fromIteratorSucceed = <A>(iterator: IterableIterator<A>, maxChunkSi
  * @since 2.0.0
  * @category Constructors
  */
-export const fromIterable = <A>(iterable: Iterable<A>): Stream<A> =>
-  Array.isArray(iterable)
+export const fromIterable = <A>(
+  iterable: Iterable<A>,
+  options?: {
+    readonly chunkSize?: number | undefined
+  }
+): Stream<A> =>
+  Array.isArray(iterable) && options?.chunkSize === undefined
     ? fromArray(iterable)
-    : fromChannel(Channel.fromIterableArray(iterable))
+    : fromChannel(Channel.fromIterableArray(iterable, options?.chunkSize))
 
 /**
  * Creates a stream from an effect producing an iterable of values.

package/src/Trie.ts

@@ -16,11 +16,11 @@
  * @since 2.0.0
  */
 import type { Equal } from "./Equal.ts"
-import type * as Filter from "./Filter.ts"
 import type { Inspectable } from "./Inspectable.ts"
 import * as TR from "./internal/trie.ts"
 import type { Option } from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
+import type { Result } from "./Result.ts"
 import type { Covariant, NoInfer } from "./Types.ts"
 
 const TypeId = TR.TrieTypeId
@@ -1585,7 +1585,7 @@ export const filterMap: {
    * @since 2.0.0
    * @category filtering
    */
-  <A, B, X>(f: Filter.Filter<A, B, X, [key: string]>): (self: Trie<A>) => Trie<B>
+  <A, B, X>(f: (input: A, key: string) => Result<B, X>): (self: Trie<A>) => Trie<B>
   /**
    * Maps over the entries of the `Trie` using the specified filter and keeps
    * only successful results.
@@ -1634,7 +1634,7 @@ export const filterMap: {
    * @since 2.0.0
    * @category filtering
    */
-  <A, B, X>(self: Trie<A>, f: Filter.Filter<A, B, X, [key: string]>): Trie<B>
+  <A, B, X>(self: Trie<A>, f: (input: A, key: string) => Result<B, X>): Trie<B>
 } = TR.filterMap
 
 /**

package/src/TxHashMap.ts

@@ -3,7 +3,6 @@
  */
 
 import * as Effect from "./Effect.ts"
-import type * as Filter from "./Filter.ts"
 import { format } from "./Formatter.ts"
 import { dual } from "./Function.ts"
 import * as HashMap from "./HashMap.ts"
@@ -12,6 +11,7 @@ import { NodeInspectSymbol, toJson } from "./Inspectable.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
+import type { Result } from "./Result.ts"
 import * as TxRef from "./TxRef.ts"
 
 const TypeId = "~effect/transactions/TxHashMap"
@@ -2835,7 +2835,7 @@ export const filterMap: {
    * @since 2.0.0
    * @category combinators
    */
-  <V, K, A, X>(f: Filter.Filter<V, A, X, [key: K]>): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
+  <V, K, A, X>(f: (input: V, key: K) => Result<A, X>): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
   /**
    * Combines filtering and mapping in a single operation. Applies a filter to each
    * entry, keeping only successful results and transforming them.
@@ -2893,12 +2893,12 @@ export const filterMap: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V, A, X>(self: TxHashMap<K, V>, f: Filter.Filter<V, A, X, [key: K]>): Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
+  <K, V, A, X>(self: TxHashMap<K, V>, f: (input: V, key: K) => Result<A, X>): Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
 } = dual(
   2,
   <K, V, A, X>(
     self: TxHashMap<K, V>,
-    f: Filter.Filter<V, A, X, [key: K]>
+    f: (input: V, key: K) => Result<A, X>
   ): Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction> =>
     Effect.gen(function*() {
       const currentMap = yield* TxRef.get(self.ref)

package/src/internal/effect.ts

@@ -493,40 +493,6 @@ const fiberIdStore = { id: 0 }
 /** @internal */
 export const getCurrentFiber = (): Fiber.Fiber<any, any> | undefined => (globalThis as any)[currentFiberTypeId]
 
-const keepAlive = (() => {
-  let isAvailable: boolean | undefined
-  const start = () => {
-    if (isAvailable === true) return setInterval(constVoid, 2_147_483_647)
-    else if (isAvailable === false) return undefined
-
-    try {
-      const running = setInterval(constVoid, 2_147_483_647)
-      isAvailable = true
-      return running
-    } catch {
-      isAvailable = false
-      return undefined
-    }
-  }
-  let count = 0
-  let running: ReturnType<typeof globalThis.setInterval> | undefined = undefined
-  return ({
-    increment() {
-      count++
-      if (running === undefined) {
-        running = start()
-      }
-    },
-    decrement() {
-      count--
-      if (count === 0 && running !== undefined) {
-        clearInterval(running)
-        running = undefined
-      }
-    }
-  })
-})()
-
 /** @internal */
 export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
   constructor(
@@ -1056,10 +1022,8 @@ const callbackOptions: <A, E = never, R = never>(
     }, controller?.signal)
     if (yielded !== false) return yielded
     yielded = true
-    keepAlive.increment()
     fiber._yielded = () => {
       resumed = true
-      keepAlive.decrement()
     }
     if (controller === undefined && onCancel === undefined) {
       return Yield
@@ -1133,7 +1097,7 @@ export const fnUntraced: Effect.fn.Untraced = (
   body: Function,
   ...pipeables: Array<any>
 ) => {
-  return pipeables.length === 0
+  const fn = pipeables.length === 0
     ? function(this: any) {
       return suspend(() => fromIteratorUnsafe(body.apply(this, arguments)))
     }
@@ -1144,8 +1108,15 @@ export const fnUntraced: Effect.fn.Untraced = (
       }
       return effect
     }
+  return defineFunctionLength(body.length, fn)
 }
 
+const defineFunctionLength = <F extends Function>(length: number, fn: F): F =>
+  Object.defineProperty(fn, "length", {
+    value: length,
+    configurable: true
+  })
+
 const fnStackCleaner = makeStackCleaner(2)
 
 /** @internal */
@@ -1186,7 +1157,7 @@ const makeFn = (
     ? bodyOrOptions
     : (pipeables.pop()!).bind(bodyOrOptions.self)
 
-  return function(this: any, ...args: Array<any>) {
+  return defineFunctionLength(body.length, function(this: any, ...args: Array<any>) {
     let result = suspend(() => {
       const iter = body.apply(this, arguments)
       return isEffect(iter) ? iter : fromIteratorUnsafe(iter)
@@ -1216,7 +1187,7 @@ const makeFn = (
         }
       })
     )
-  }
+  })
 }
 
 /** @internal */
@@ -1224,17 +1195,20 @@ export const fnUntracedEager: Effect.fn.Untraced = (
   body: Function,
   ...pipeables: Array<any>
 ) =>
-  pipeables.length === 0
-    ? function(this: any) {
-      return fromIteratorEagerUnsafe(() => body.apply(this, arguments))
-    }
-    : function(this: any) {
-      let effect = fromIteratorEagerUnsafe(() => body.apply(this, arguments))
-      for (const pipeable of pipeables) {
-        effect = pipeable(effect)
+  defineFunctionLength(
+    body.length,
+    pipeables.length === 0
+      ? function(this: any) {
+        return fromIteratorEagerUnsafe(() => body.apply(this, arguments))
       }
-      return effect
-    }
+      : function(this: any) {
+        let effect = fromIteratorEagerUnsafe(() => body.apply(this, arguments))
+        for (const pipeable of pipeables) {
+          effect = pipeable(effect)
+        }
+        return effect
+      }
+  )
 
 const fromIteratorEagerUnsafe = (
   evaluate: () => Iterator<Effect.Yieldable<any, any, any, any>>
@@ -4334,17 +4308,17 @@ const findFirstLoop = <A, E, R>(
 /** @internal */
 export const findFirstFilter: {
   <A, B, X, E, R>(
-    filter: Filter.FilterEffect<NoInfer<A>, B, X, E, R, [i: number]>
+    filter: (input: NoInfer<A>, i: number) => Effect.Effect<Result.Result<B, X>, E, R>
   ): (elements: Iterable<A>) => Effect.Effect<Option.Option<B>, E, R>
   <A, B, X, E, R>(
     elements: Iterable<A>,
-    filter: Filter.FilterEffect<NoInfer<A>, B, X, E, R, [i: number]>
+    filter: (input: NoInfer<A>, i: number) => Effect.Effect<Result.Result<B, X>, E, R>
   ): Effect.Effect<Option.Option<B>, E, R>
 } = dual(
   (args) => isIterable(args[0]) && !isEffect(args[0]),
   <A, B, X, E, R>(
     elements: Iterable<A>,
-    filter: Filter.FilterEffect<A, B, X, E, R, [i: number]>
+    filter: (input: A, i: number) => Effect.Effect<Result.Result<B, X>, E, R>
   ): Effect.Effect<Option.Option<B>, E, R> =>
     suspend(() => {
       const iterator = elements[Symbol.iterator]()
@@ -4359,7 +4333,7 @@ export const findFirstFilter: {
 const findFirstFilterLoop = <A, B, X, E, R>(
   iterator: Iterator<A>,
   index: number,
-  filter: Filter.FilterEffect<A, B, X, E, R, [i: number]>,
+  filter: (input: A, i: number) => Effect.Effect<Result.Result<B, X>, E, R>,
   value: A
 ): Effect.Effect<Option.Option<B>, E, R> =>
   flatMap(filter(value, index), (result) => {

package/src/internal/hashMap.ts

@@ -3,7 +3,6 @@
  */
 
 import * as Equal_ from "../Equal.ts"
-import type * as Filter from "../Filter.ts"
 import { format } from "../Formatter.ts"
 import { dual, pipe } from "../Function.ts"
 import * as Hash from "../Hash.ts"
@@ -1257,9 +1256,9 @@ export const compact = <K, A>(self: HashMap<K, Option.Option<A>>): HashMap<K, A>
 
 /** @internal */
 export const filterMap = dual<
-  <A, K, B, X>(f: Filter.Filter<A, B, X, [key: K]>) => (self: HashMap<K, A>) => HashMap<K, B>,
-  <K, A, B, X>(self: HashMap<K, A>, f: Filter.Filter<A, B, X, [key: K]>) => HashMap<K, B>
->(2, <K, A, B, X>(self: HashMap<K, A>, f: Filter.Filter<A, B, X, [key: K]>): HashMap<K, B> => {
+  <A, K, B, X>(f: (input: A, key: K) => Result.Result<B, X>) => (self: HashMap<K, A>) => HashMap<K, B>,
+  <K, A, B, X>(self: HashMap<K, A>, f: (input: A, key: K) => Result.Result<B, X>) => HashMap<K, B>
+>(2, <K, A, B, X>(self: HashMap<K, A>, f: (input: A, key: K) => Result.Result<B, X>): HashMap<K, B> => {
   let result = empty<K, B>()
   for (const [key, value] of self) {
     const mapped = f(value, key)

package/src/internal/schema/representation.ts

@@ -24,80 +24,13 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
 
   const referenceMap = new Map<AST.AST, string>()
   const uniqueReferences = new Set<string>()
-  const usedReferences = new Set<string>()
+  const visiting = new Set<AST.AST>()
 
   const schemas = Arr.map(asts, (ast) => recur(ast))
 
   return {
-    representations: Arr.map(schemas, compact),
-    references: Rec.map(Rec.filter(references, (_, k) => !isCompactable(k)), compact)
-  }
-
-  function isCompactable($ref: string): boolean {
-    return !usedReferences.has($ref)
-  }
-
-  function compact(s: SchemaRepresentation.Representation): SchemaRepresentation.Representation {
-    switch (s._tag) {
-      default:
-        return s
-      case "Declaration":
-        return {
-          ...s,
-          typeParameters: s.typeParameters.map(compact),
-          encodedSchema: compact(s.encodedSchema)
-        }
-      case "Reference": {
-        if (isCompactable(s.$ref)) {
-          return compact(references[s.$ref])
-        }
-        return s
-      }
-      case "Suspend":
-        return { ...s, thunk: compact(s.thunk) }
-      case "String":
-        return {
-          ...s,
-          ...(s.contentSchema ? { contentSchema: compact(s.contentSchema) } : undefined)
-        }
-      case "TemplateLiteral":
-        return { ...s, parts: s.parts.map(compact) }
-      case "Arrays":
-        return {
-          ...s,
-          elements: s.elements.map((e) => ({ ...e, type: compact(e.type) })),
-          rest: s.rest.map(compact)
-        }
-      case "Objects":
-        return {
-          ...s,
-          checks: s.checks.map(compactCheck),
-          propertySignatures: s.propertySignatures.map((ps) => ({ ...ps, type: compact(ps.type) })),
-          indexSignatures: s.indexSignatures.map((is) => ({
-            ...is,
-            parameter: compact(is.parameter),
-            type: compact(is.type)
-          }))
-        }
-      case "Union":
-        return { ...s, types: s.types.map(compact) }
-    }
-  }
-
-  function compactCheck<M extends SchemaRepresentation.Meta>(
-    check: SchemaRepresentation.Check<M>
-  ): SchemaRepresentation.Check<M> {
-    switch (check._tag) {
-      case "Filter":
-        return {
-          ...check,
-          meta: check.meta._tag === "isPropertyNames"
-            ? { _tag: "isPropertyNames", propertyNames: compact(check.meta.propertyNames) } as M
-            : check.meta
-        }
-      case "FilterGroup":
-        return { ...check, checks: Arr.map(check.checks, compactCheck) }
-    }
+    representations: schemas,
+    references
   }
 
   function gen(prefix: string = "_"): string {
@@ -115,32 +48,45 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
   function recur(ast: AST.AST, prefix?: string): SchemaRepresentation.Representation {
     const found = referenceMap.get(ast)
     if (found !== undefined) {
-      usedReferences.add(found)
       return { _tag: "Reference", $ref: found }
     }
 
-    const last = getLastEncoding(ast)
-
-    if (ast === last) {
-      const reference = ast._tag === "Declaration"
-        ? gen(ast._tag)
-        : gen(InternalAnnotations.resolveIdentifier(ast) ?? prefix ?? `${ast._tag}_`)
+    const last = AST.getLastEncoding(ast)
+    const identifier = InternalAnnotations.resolveIdentifier(ast) ?? prefix
 
-      const encodedSchemaPrefix = ast._tag === "Declaration"
-        ? InternalAnnotations.resolveIdentifier(ast) ?? prefix
-        : prefix
+    if (ast !== last) {
+      return recur(last, identifier)
+    }
 
+    // Has identifier → always create reference
+    if (identifier !== undefined) {
+      const reference = gen(identifier)
       referenceMap.set(ast, reference)
-      const out = on(ast, encodedSchemaPrefix)
+      const out = on(ast)
       references[reference] = out
       return { _tag: "Reference", $ref: reference }
-    } else {
-      return recur(last, InternalAnnotations.resolveIdentifier(ast) ?? prefix)
     }
-  }
 
-  function getLastEncoding(ast: AST.AST): AST.AST {
-    return ast.encoding ? ast.encoding[ast.encoding.length - 1].to : ast
+    // Recursion detected → create reference
+    if (visiting.has(ast)) {
+      const reference = gen(`${ast._tag}_`)
+      referenceMap.set(ast, reference)
+      return { _tag: "Reference", $ref: reference }
+    }
+
+    // Normal case → inline
+    visiting.add(ast)
+    const out = on(ast)
+    visiting.delete(ast)
+
+    // A descendant triggered reference creation (recursion)
+    const ref = referenceMap.get(ast)
+    if (ref !== undefined) {
+      references[ref] = out
+      return { _tag: "Reference", $ref: ref }
+    }
+
+    return out
   }
 
   function getEncodedSchema(last: AST.Declaration): AST.AST {
@@ -153,12 +99,12 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
     return AST.null
   }
 
-  function on(last: AST.AST, encodedSchemaPrefix?: string): SchemaRepresentation.Representation {
+  function on(last: AST.AST): SchemaRepresentation.Representation {
     const annotations = fromASTAnnotations(last.annotations)
     switch (last._tag) {
       case "Declaration": {
         // this must be executed before transforming the type parameters
-        const encodedSchema = recur(getEncodedSchema(last), encodedSchemaPrefix)
+        const encodedSchema = recur(getEncodedSchema(last))
         return {
           _tag: "Declaration",
           typeParameters: last.typeParameters.map((ast) => recur(ast)),
@@ -228,7 +174,7 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
         return {
           _tag: last._tag,
           elements: last.elements.map((e) => {
-            const last = getLastEncoding(e)
+            const last = AST.getLastEncoding(e)
             return {
               isOptional: AST.isOptional(last),
               type: recur(e),
@@ -243,7 +189,7 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
         return {
           _tag: last._tag,
           propertySignatures: last.propertySignatures.map((ps) => {
-            const last = getLastEncoding(ps.type)
+            const last = AST.getLastEncoding(ps.type)
             return {
               name: ps.name,
               type: recur(ps.type),

package/src/internal/trie.ts

@@ -1,5 +1,4 @@
 import * as Equal from "../Equal.ts"
-import type * as Filter from "../Filter.ts"
 import { format } from "../Formatter.ts"
 import { dual, pipe } from "../Function.ts"
 import * as Hash from "../Hash.ts"
@@ -312,10 +311,10 @@ export const filter: {
 /** @internal */
 export const filterMap = dual<
   <A, B, X>(
-    f: Filter.Filter<A, B, X, [key: string]>
+    f: (input: A, key: string) => Result.Result<B, X>
   ) => (self: TR.Trie<A>) => TR.Trie<B>,
-  <A, B, X>(self: TR.Trie<A>, f: Filter.Filter<A, B, X, [key: string]>) => TR.Trie<B>
->(2, <A, B, X>(self: TR.Trie<A>, f: Filter.Filter<A, B, X, [key: string]>): TR.Trie<B> =>
+  <A, B, X>(self: TR.Trie<A>, f: (input: A, key: string) => Result.Result<B, X>) => TR.Trie<B>
+>(2, <A, B, X>(self: TR.Trie<A>, f: (input: A, key: string) => Result.Result<B, X>): TR.Trie<B> =>
   reduce(
     self,
     empty<B>(),