effect 2.1.2 → 2.2.1

package/src/FiberMap.ts

@@ -7,11 +7,13 @@ import type { NoSuchElementException } from "./Cause.js"
 import * as Fiber from "./Fiber.js"
 import * as FiberId from "./FiberId.js"
 import { dual } from "./Function.js"
+import type { FiberMap } from "./index.js"
 import * as Inspectable from "./Inspectable.js"
 import * as MutableHashMap from "./MutableHashMap.js"
 import * as Option from "./Option.js"
 import { type Pipeable, pipeArguments } from "./Pipeable.js"
 import * as Predicate from "./Predicate.js"
+import * as Runtime from "./Runtime.js"
 
 /**
  * @since 2.0.0
@@ -98,6 +100,26 @@ const unsafeMake = <K, E = unknown, A = unknown>(): FiberMap<K, E, A> => {
 export const make = <K, E = unknown, A = unknown>(): Effect.Effect<Scope.Scope, never, FiberMap<K, E, A>> =>
   Effect.acquireRelease(Effect.sync(() => unsafeMake<K, E, A>()), clear)
 
+/**
+ * Create an Effect run function that is backed by a FiberMap.
+ *
+ * @since 2.0.0
+ * @categories constructors
+ */
+export const makeRuntime = <R, K, E = unknown, A = unknown>(): Effect.Effect<
+  Scope.Scope | R,
+  never,
+  <XE extends E, XA extends A>(
+    key: K,
+    effect: Effect.Effect<R, XE, XA>,
+    options?: Runtime.RunForkOptions | undefined
+  ) => Fiber.RuntimeFiber<XE, XA>
+> =>
+  Effect.flatMap(
+    make<K, E, A>(),
+    (self) => runtime(self)<R>()
+  )
+
 /**
  * Add a fiber to the FiberMap. When the fiber completes, it will be removed from the FiberMap.
  * If the key already exists in the FiberMap, the previous fiber will be interrupted.
@@ -263,30 +285,89 @@ export const clear = <K, E, A>(self: FiberMap<K, E, A>): Effect.Effect<never, ne
  * @categories combinators
  */
 export const run: {
-  <K, E, A, R, XE extends E, XA extends A>(
-    key: K,
-    effect: Effect.Effect<R, XE, XA>
-  ): (self: FiberMap<K, E, A>) => Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
-  <K, E, A, R, XE extends E, XA extends A>(
+  <K, E, A>(
     self: FiberMap<K, E, A>,
-    key: K,
-    effect: Effect.Effect<R, XE, XA>
-  ): Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
-} = dual<
-  <K, E, A, R, XE extends E, XA extends A>(
-    key: K,
+    key: K
+  ): <R, XE extends E, XA extends A>(
     effect: Effect.Effect<R, XE, XA>
-  ) => (self: FiberMap<K, E, A>) => Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>,
+  ) => Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
   <K, E, A, R, XE extends E, XA extends A>(
     self: FiberMap<K, E, A>,
     key: K,
     effect: Effect.Effect<R, XE, XA>
-  ) => Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
->(3, (self, key, effect) =>
-  Effect.tap(
+  ): Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
+} = function() {
+  if (arguments.length === 2) {
+    const self = arguments[0] as FiberMap<any>
+    const key = arguments[1]
+    return (effect: Effect.Effect<any, any, any>) =>
+      Effect.tap(
+        Effect.forkDaemon(effect),
+        (fiber) => set(self, key, fiber)
+      )
+  }
+  const self = arguments[0] as FiberMap<any>
+  const key = arguments[1]
+  const effect = arguments[2] as Effect.Effect<any, any, any>
+  return Effect.tap(
     Effect.forkDaemon(effect),
     (fiber) => set(self, key, fiber)
-  ))
+  ) as any
+}
+
+/**
+ * Capture a Runtime and use it to fork Effect's, adding the forked fibers to the FiberMap.
+ *
+ * @example
+ * import { Context, Effect, FiberMap } from "effect"
+ *
+ * interface Users {
+ *   readonly _: unique symbol
+ * }
+ * const Users = Context.Tag<Users, {
+ *    getAll: Effect.Effect<never, never, Array<unknown>>
+ * }>()
+ *
+ * Effect.gen(function*(_) {
+ *   const map = yield* _(FiberMap.make<string>())
+ *   const run = yield* _(FiberMap.runtime(map)<Users>())
+ *
+ *   // run some effects and add the fibers to the map
+ *   run("effect-a", Effect.andThen(Users, _ => _.getAll))
+ *   run("effect-b", Effect.andThen(Users, _ => _.getAll))
+ * }).pipe(
+ *   Effect.scoped // The fibers will be interrupted when the scope is closed
+ * )
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+export const runtime: <K, E, A>(
+  self: FiberMap<K, E, A>
+) => <R>() => Effect.Effect<
+  R,
+  never,
+  <XE extends E, XA extends A>(
+    key: K,
+    effect: Effect.Effect<R, XE, XA>,
+    options?: Runtime.RunForkOptions | undefined
+  ) => Fiber.RuntimeFiber<XE, XA>
+> = <K, E, A>(self: FiberMap<K, E, A>) => <R>() =>
+  Effect.map(
+    Effect.runtime<R>(),
+    (runtime) => {
+      const runFork = Runtime.runFork(runtime)
+      return <XE extends E, XA extends A>(
+        key: K,
+        effect: Effect.Effect<R, XE, XA>,
+        options?: Runtime.RunForkOptions | undefined
+      ) => {
+        const fiber = runFork(effect, options)
+        unsafeSet(self, key, fiber)
+        return fiber
+      }
+    }
+  )
 
 /**
  * @since 2.0.0

package/src/FiberSet.ts

@@ -8,6 +8,7 @@ import { dual } from "./Function.js"
 import * as Inspectable from "./Inspectable.js"
 import { type Pipeable, pipeArguments } from "./Pipeable.js"
 import * as Predicate from "./Predicate.js"
+import * as Runtime from "./Runtime.js"
 
 /**
  * @since 2.0.0
@@ -94,6 +95,25 @@ const unsafeMake = <E = unknown, A = unknown>(): FiberSet<E, A> => {
 export const make = <E = unknown, A = unknown>(): Effect.Effect<Scope.Scope, never, FiberSet<E, A>> =>
   Effect.acquireRelease(Effect.sync(() => unsafeMake<E, A>()), clear)
 
+/**
+ * Create an Effect run function that is backed by a FiberSet.
+ *
+ * @since 2.0.0
+ * @categories constructors
+ */
+export const makeRuntime = <R, E = unknown, A = unknown>(): Effect.Effect<
+  Scope.Scope | R,
+  never,
+  <XE extends E, XA extends A>(
+    effect: Effect.Effect<R, XE, XA>,
+    options?: Runtime.RunForkOptions | undefined
+  ) => Fiber.RuntimeFiber<XE, XA>
+> =>
+  Effect.flatMap(
+    make<E, A>(),
+    (self) => runtime(self)<R>()
+  )
+
 /**
  * Add a fiber to the FiberSet. When the fiber completes, it will be removed.
  *
@@ -165,26 +185,79 @@ export const clear = <E, A>(self: FiberSet<E, A>): Effect.Effect<never, never, v
  * @categories combinators
  */
 export const run: {
-  <E, A, R, XE extends E, XA extends A>(
+  <E, A>(self: FiberSet<E, A>): <R, XE extends E, XA extends A>(
     effect: Effect.Effect<R, XE, XA>
-  ): (self: FiberSet<E, A>) => Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
+  ) => Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
   <E, A, R, XE extends E, XA extends A>(
     self: FiberSet<E, A>,
     effect: Effect.Effect<R, XE, XA>
   ): Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
-} = dual<
-  <E, A, R, XE extends E, XA extends A>(
-    effect: Effect.Effect<R, XE, XA>
-  ) => (self: FiberSet<E, A>) => Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>,
-  <E, A, R, XE extends E, XA extends A>(
-    self: FiberSet<E, A>,
-    effect: Effect.Effect<R, XE, XA>
-  ) => Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
->(2, (self, effect) =>
-  Effect.tap(
+} = function() {
+  const self = arguments[0] as FiberSet<any>
+  if (arguments.length === 1) {
+    return (effect: Effect.Effect<any, any, any>) =>
+      Effect.tap(
+        Effect.forkDaemon(effect),
+        (fiber) => add(self, fiber)
+      )
+  }
+  const effect = arguments[1] as Effect.Effect<any, any, any>
+  return Effect.tap(
     Effect.forkDaemon(effect),
     (fiber) => add(self, fiber)
-  ))
+  ) as any
+}
+
+/**
+ * Capture a Runtime and use it to fork Effect's, adding the forked fibers to the FiberSet.
+ *
+ * @example
+ * import { Context, Effect, FiberSet } from "effect"
+ *
+ * interface Users {
+ *   readonly _: unique symbol
+ * }
+ * const Users = Context.Tag<Users, {
+ *    getAll: Effect.Effect<never, never, Array<unknown>>
+ * }>()
+ *
+ * Effect.gen(function*(_) {
+ *   const set = yield* _(FiberSet.make())
+ *   const run = yield* _(FiberSet.runtime(set)<Users>())
+ *
+ *   // run some effects and add the fibers to the set
+ *   run(Effect.andThen(Users, _ => _.getAll))
+ * }).pipe(
+ *   Effect.scoped // The fibers will be interrupted when the scope is closed
+ * )
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+export const runtime: <E, A>(
+  self: FiberSet<E, A>
+) => <R>() => Effect.Effect<
+  R,
+  never,
+  <XE extends E, XA extends A>(
+    effect: Effect.Effect<R, XE, XA>,
+    options?: Runtime.RunForkOptions | undefined
+  ) => Fiber.RuntimeFiber<XE, XA>
+> = <E, A>(self: FiberSet<E, A>) => <R>() =>
+  Effect.map(
+    Effect.runtime<R>(),
+    (runtime) => {
+      const runFork = Runtime.runFork(runtime)
+      return <XE extends E, XA extends A>(
+        effect: Effect.Effect<R, XE, XA>,
+        options?: Runtime.RunForkOptions | undefined
+      ) => {
+        const fiber = runFork(effect, options)
+        unsafeAdd(self, fiber)
+        return fiber
+      }
+    }
+  )
 
 /**
  * @since 2.0.0

package/src/GroupBy.ts

@@ -7,7 +7,7 @@ import type { Predicate } from "./Predicate.js"
 import type * as Queue from "./Queue.js"
 import type * as Stream from "./Stream.js"
 import type * as Take from "./Take.js"
-import type * as Types from "./Types.js"
+import type { Covariant, NoInfer } from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -43,10 +43,10 @@ export declare namespace GroupBy {
    */
   export interface Variance<out R, out E, out K, out V> {
     readonly [GroupByTypeId]: {
-      readonly _R: Types.Covariant<R>
-      readonly _E: Types.Covariant<E>
-      readonly _K: Types.Covariant<K>
-      readonly _V: Types.Covariant<V>
+      readonly _R: Covariant<R>
+      readonly _E: Covariant<E>
+      readonly _K: Covariant<K>
+      readonly _V: Covariant<V>
     }
   }
 }
@@ -81,7 +81,7 @@ export const evaluate: {
  * @category utils
  */
 export const filter: {
-  <K>(predicate: Predicate<K>): <R, E, V>(self: GroupBy<R, E, K, V>) => GroupBy<R, E, K, V>
+  <K>(predicate: Predicate<NoInfer<K>>): <R, E, V>(self: GroupBy<R, E, K, V>) => GroupBy<R, E, K, V>
   <R, E, V, K>(self: GroupBy<R, E, K, V>, predicate: Predicate<K>): GroupBy<R, E, K, V>
 } = internal.filter
 

package/src/HashMap.ts

@@ -9,6 +9,7 @@ import * as HM from "./internal/hashMap.js"
 import * as _keySet from "./internal/hashMap/keySet.js"
 import type { Option } from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
+import type { NoInfer } from "./Types.js"
 
 const TypeId: unique symbol = HM.HashMapTypeId as TypeId
 
@@ -380,8 +381,8 @@ export const reduce: {
  * @category filtering
  */
 export const filter: {
-  <K, A, B extends A>(f: (a: A, k: K) => a is B): (self: HashMap<K, A>) => HashMap<K, B>
-  <K, B extends A, A = B>(f: (a: A, k: K) => boolean): (self: HashMap<K, B>) => HashMap<K, B>
+  <K, A, B extends A>(f: (a: NoInfer<A>, k: K) => a is B): (self: HashMap<K, A>) => HashMap<K, B>
+  <K, A>(f: (a: NoInfer<A>, k: K) => boolean): (self: HashMap<K, A>) => HashMap<K, A>
   <K, A, B extends A>(self: HashMap<K, A>, f: (a: A, k: K) => a is B): HashMap<K, B>
   <K, A>(self: HashMap<K, A>, f: (a: A, k: K) => boolean): HashMap<K, A>
 } = HM.filter
@@ -414,8 +415,8 @@ export const filterMap: {
  * @since 2.0.0
  */
 export const findFirst: {
-  <K, A, B extends A>(predicate: (a: A, k: K) => a is B): (self: HashMap<K, A>) => Option<[K, B]>
-  <K, B extends A, A = B>(predicate: (a: A, k: K) => boolean): (self: HashMap<K, B>) => Option<[K, B]>
+  <K, A, B extends A>(predicate: (a: NoInfer<A>, k: K) => a is B): (self: HashMap<K, A>) => Option<[K, B]>
+  <K, A>(predicate: (a: NoInfer<A>, k: K) => boolean): (self: HashMap<K, A>) => Option<[K, A]>
   <K, A, B extends A>(self: HashMap<K, A>, predicate: (a: A, k: K) => a is B): Option<[K, B]>
   <K, A>(self: HashMap<K, A>, predicate: (a: A, k: K) => boolean): Option<[K, A]>
 } = HM.findFirst

package/src/HashSet.ts

@@ -7,6 +7,7 @@ import type { Inspectable } from "./Inspectable.js"
 import * as HS from "./internal/hashSet.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
+import type { NoInfer } from "./Types.js"
 
 const TypeId: unique symbol = HS.HashSetTypeId as TypeId
 
@@ -86,7 +87,7 @@ export const some: {
  * @category elements
  */
 export const every: {
-  <A, B extends A>(refinement: Refinement<A, B>): (self: HashSet<A>) => self is HashSet<B>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: HashSet<A>) => self is HashSet<B>
   <A>(predicate: Predicate<A>): (self: HashSet<A>) => boolean
   <A, B extends A>(self: HashSet<A>, refinement: Refinement<A, B>): self is HashSet<B>
   <A>(self: HashSet<A>, predicate: Predicate<A>): boolean
@@ -271,8 +272,8 @@ export const reduce: {
  * @category filtering
  */
 export const filter: {
-  <A, B extends A>(refinement: Refinement<A, B>): (self: HashSet<A>) => HashSet<B>
-  <B extends A, A = B>(predicate: Predicate<A>): (self: HashSet<B>) => HashSet<B>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: HashSet<A>) => HashSet<B>
+  <A>(predicate: Predicate<NoInfer<A>>): (self: HashSet<A>) => HashSet<A>
   <A, B extends A>(self: HashSet<A>, refinement: Refinement<A, B>): HashSet<B>
   <A>(self: HashSet<A>, predicate: Predicate<A>): HashSet<A>
 } = HS.filter
@@ -288,10 +289,10 @@ export const filter: {
  * @category partitioning
  */
 export const partition: {
-  <C extends A, B extends A, A = C>(
-    refinement: Refinement<A, B>
-  ): (self: HashSet<C>) => [excluded: HashSet<Exclude<C, B>>, satisfying: HashSet<B>]
-  <B extends A, A = B>(predicate: Predicate<A>): (self: HashSet<B>) => [excluded: HashSet<B>, satisfying: HashSet<B>]
+  <A, B extends A>(
+    refinement: Refinement<NoInfer<A>, B>
+  ): (self: HashSet<A>) => [excluded: HashSet<Exclude<A, B>>, satisfying: HashSet<B>]
+  <A>(predicate: Predicate<NoInfer<A>>): (self: HashSet<A>) => [excluded: HashSet<A>, satisfying: HashSet<A>]
   <A, B extends A>(
     self: HashSet<A>,
     refinement: Refinement<A, B>

package/src/List.ts

@@ -33,6 +33,7 @@ import type { Pipeable } from "./Pipeable.js"
 import { pipeArguments } from "./Pipeable.js"
 import { hasProperty, type Predicate, type Refinement } from "./Predicate.js"
 import * as ReadonlyArray from "./ReadonlyArray.js"
+import type { NoInfer } from "./Types.js"
 
 /**
  * Represents an immutable linked list of elements of type `A`.
@@ -441,7 +442,7 @@ export const drop: {
  * @category elements
  */
 export const every: {
-  <A, B extends A>(refinement: Refinement<A, B>): (self: List<A>) => self is List<B>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: List<A>) => self is List<B>
   <A>(predicate: Predicate<A>): (self: List<A>) => boolean
   <A, B extends A>(self: List<A>, refinement: Refinement<A, B>): self is List<B>
   <A>(self: List<A>, predicate: Predicate<A>): boolean
@@ -461,7 +462,7 @@ export const every: {
  * @category elements
  */
 export const some: {
-  <B extends A, A = B>(predicate: Predicate<A>): (self: List<B>) => self is Cons<B>
+  <A>(predicate: Predicate<NoInfer<A>>): (self: List<A>) => self is Cons<A>
   <A>(self: List<A>, predicate: Predicate<A>): self is Cons<A>
 } = dual(2, <A>(self: List<A>, predicate: Predicate<A>): self is Cons<A> => {
   let these = self
@@ -481,8 +482,8 @@ export const some: {
  * @category combinators
  */
 export const filter: {
-  <A, B extends A>(refinement: Refinement<A, B>): (self: List<A>) => List<B>
-  <B extends A, A = B>(predicate: Predicate<A>): (self: List<B>) => List<B>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: List<A>) => List<B>
+  <A>(predicate: Predicate<NoInfer<A>>): (self: List<A>) => List<A>
   <A, B extends A>(self: List<A>, refinement: Refinement<A, B>): List<B>
   <A>(self: List<A>, predicate: Predicate<A>): List<A>
 } = dual(2, <A>(self: List<A>, predicate: Predicate<A>): List<A> => noneIn(self, predicate, false))
@@ -617,8 +618,8 @@ export const compact = <A>(self: List<Option.Option<A>>): List<A> => filterMap(s
  * @since 2.0.0
  */
 export const findFirst: {
-  <A, B extends A>(refinement: Refinement<A, B>): (self: List<A>) => Option.Option<B>
-  <B extends A, A = B>(predicate: Predicate<A>): (self: List<B>) => Option.Option<B>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: List<A>) => Option.Option<B>
+  <A>(predicate: Predicate<NoInfer<A>>): (self: List<A>) => Option.Option<A>
   <A, B extends A>(self: List<A>, refinement: Refinement<A, B>): Option.Option<B>
   <A>(self: List<A>, predicate: Predicate<A>): Option.Option<A>
 } = dual(2, <A>(self: List<A>, predicate: Predicate<A>): Option.Option<A> => {
@@ -769,10 +770,10 @@ export const map: {
  * @category combinators
  */
 export const partition: {
-  <C extends A, B extends A, A = C>(
-    refinement: Refinement<A, B>
-  ): (self: List<C>) => [excluded: List<Exclude<C, B>>, satisfying: List<B>]
-  <B extends A, A = B>(predicate: Predicate<A>): (self: List<B>) => [excluded: List<B>, satisfying: List<B>]
+  <A, B extends A>(
+    refinement: Refinement<NoInfer<A>, B>
+  ): (self: List<A>) => [excluded: List<Exclude<A, B>>, satisfying: List<B>]
+  <A>(predicate: Predicate<NoInfer<A>>): (self: List<A>) => [excluded: List<A>, satisfying: List<A>]
   <A, B extends A>(self: List<A>, refinement: Refinement<A, B>): [excluded: List<Exclude<A, B>>, satisfying: List<B>]
   <A>(self: List<A>, predicate: Predicate<A>): [excluded: List<A>, satisfying: List<A>]
 } = dual(2, <A>(self: List<A>, predicate: Predicate<A>): [excluded: List<A>, satisfying: List<A>] => {

package/src/Option.ts

@@ -15,7 +15,7 @@ import type { Order } from "./Order.js"
 import * as order from "./Order.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
-import type * as Types from "./Types.js"
+import type { Covariant, NoInfer } from "./Types.js"
 import type * as Unify from "./Unify.js"
 import * as Gen from "./Utils.js"
 
@@ -45,7 +45,7 @@ export interface None<out A> extends Data.Case, Pipeable, Inspectable {
   readonly _tag: "None"
   readonly _op: "None"
   readonly [TypeId]: {
-    readonly _A: Types.Covariant<A>
+    readonly _A: Covariant<A>
   }
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: OptionUnify<this>
@@ -61,7 +61,7 @@ export interface Some<out A> extends Data.Case, Pipeable, Inspectable {
   readonly _op: "Some"
   readonly value: A
   readonly [TypeId]: {
-    readonly _A: Types.Covariant<A>
+    readonly _A: Covariant<A>
   }
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: OptionUnify<this>
@@ -983,8 +983,8 @@ export const filterMap: {
  * @since 2.0.0
  */
 export const filter: {
-  <A, B extends A>(refinement: Refinement<A, B>): (self: Option<A>) => Option<B>
-  <B extends A, A = B>(predicate: Predicate<A>): (self: Option<B>) => Option<B>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: Option<A>) => Option<B>
+  <A>(predicate: Predicate<NoInfer<A>>): (self: Option<A>) => Option<A>
   <A, B extends A>(self: Option<A>, refinement: Refinement<A, B>): Option<B>
   <A>(self: Option<A>, predicate: Predicate<A>): Option<A>
 } = dual(
@@ -1066,7 +1066,7 @@ export const lift2 = <A, B, C>(f: (a: A, b: B) => C): {
  * @category lifting
  * @since 2.0.0
  */
-export const liftPredicate: {
+export const liftPredicate: { // Note: I intentionally avoid using the NoInfer pattern here.
   <A, B extends A>(refinement: Refinement<A, B>): (a: A) => Option<B>
   <B extends A, A = B>(predicate: Predicate<A>): (b: B) => Option<B>
 } = <B extends A, A = B>(predicate: Predicate<A>) => (b: B): Option<B> => predicate(b) ? some(b) : none()
@@ -1127,8 +1127,8 @@ export const contains: {
  * @since 2.0.0
  */
 export const exists: {
-  <A, B extends A>(refinement: Refinement<A, B>): (self: Option<A>) => self is Option<B>
-  <B extends A, A = B>(predicate: Predicate<A>): (self: Option<B>) => boolean
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: Option<A>) => self is Option<B>
+  <A>(predicate: Predicate<NoInfer<A>>): (self: Option<A>) => boolean
   <A, B extends A>(self: Option<A>, refinement: Refinement<A, B>): self is Option<B>
   <A>(self: Option<A>, predicate: Predicate<A>): boolean
 } = dual(