chore(@tsplus/stdlib): finish renaming of option to maybe

.changeset/long-fans-clean.md

@@ -0,0 +1,5 @@
+---
+"@tsplus/stdlib": patch
+---
+
+Finish renaming of Option => Maybe

packages/stdlib/_examples/main.ts

@@ -1,7 +1,8 @@
 console.log(ImmutableArray.from(List(0, 1, 2)) == ImmutableArray(0, 1, 2))
 console.log([0, 1, 2].immutable == ImmutableArray(0, 1, 2))
 console.log(
-  Maybe(0)(
+  pipe(
+    Maybe(0),
     Maybe.$.map((n) => n + 1),
     Maybe.$.map((n) => `res: ${n}`)
   ) == Maybe("res: 1")

packages/stdlib/_src/collections/ImmutableArray/dsl/gen.ts

@@ -6,7 +6,7 @@ const adapter: {
 } = (_: () => any) =>
   new GenLazyHKT(() => {
     const x = _()
-    if (Maybe.isOption(x)) {
+    if (Maybe.isMaybe(x)) {
       return x._tag === "None" ? ImmutableArray.empty() : ImmutableArray(x.value)
     }
     return x

packages/stdlib/_src/collections/SortedMap.ts

@@ -6,7 +6,7 @@ export * from "@tsplus/stdlib/collections/SortedMap/from"
 export * from "@tsplus/stdlib/collections/SortedMap/get"
 export * from "@tsplus/stdlib/collections/SortedMap/getOrd"
 export * from "@tsplus/stdlib/collections/SortedMap/has"
-export * from "@tsplus/stdlib/collections/SortedMap/headOption"
+export * from "@tsplus/stdlib/collections/SortedMap/headMaybe"
 export * from "@tsplus/stdlib/collections/SortedMap/isEmpty"
 export * from "@tsplus/stdlib/collections/SortedMap/isNonEmpty"
 export * from "@tsplus/stdlib/collections/SortedMap/keys"

packages/stdlib/_src/collections/SortedMap/headOption.ts → packages/stdlib/_src/collections/SortedMap/headMaybe.ts

@@ -1,9 +1,9 @@
 import { concreteSortedMap } from "@tsplus/stdlib/collections/SortedMap/_internal/SortedMapInternal"
 
 /**
- * @tsplus getter SortedMap headOption
+ * @tsplus getter SortedMap headMaybe
  */
-export function headOption<K, V>(self: SortedMap<K, V>): Maybe<Tuple<[K, V]>> {
+export function headMaybe<K, V>(self: SortedMap<K, V>): Maybe<Tuple<[K, V]>> {
   concreteSortedMap(self)
   return self.tree.first
 }

packages/stdlib/_src/collections/weak/IterableWeakMap.ts

@@ -33,16 +33,16 @@ export const IterableWeakMap: IterableWeakMapOps = {}
 
 /**
  * @tsplus index IterableWeakMap
- * @tsplus fluent IterableWeakMap getOption
+ * @tsplus fluent IterableWeakMap getMaybe
  */
-export function getOption_<K extends object, V>(
+export function getMaybe_<K extends object, V>(
   self: IterableWeakMap<K, V>,
   key: K
 ): Maybe<V> {
   return self.has(key) ? Maybe.some(self.get(key)!) : Maybe.none
 }
 
-export const getOption = Pipeable(getOption_)
+export const getMaybe = Pipeable(getMaybe_)
 
 /**
  * @tsplus static IterableWeakMapOps make

packages/stdlib/_src/data/Duration.ts

@@ -148,9 +148,3 @@ export function equals_(self: Duration, that: Duration) {
 }
 
 export const equals = Pipeable(equals_)
-
-/**
- * @tsplus macro pipe
- * @tsplus fluent Duration __call
- */
-export const durationPipe: typeof pipe = pipe

packages/stdlib/_src/data/Either.ts

@@ -2,7 +2,7 @@
 export * from "@tsplus/stdlib/data/Either/ap"
 export * from "@tsplus/stdlib/data/Either/catchAll"
 export * from "@tsplus/stdlib/data/Either/compact"
-export * from "@tsplus/stdlib/data/Either/compactOption"
+export * from "@tsplus/stdlib/data/Either/compactMaybe"
 export * from "@tsplus/stdlib/data/Either/definition"
 export * from "@tsplus/stdlib/data/Either/dsl"
 export * from "@tsplus/stdlib/data/Either/duplicate"
@@ -14,8 +14,8 @@ export * from "@tsplus/stdlib/data/Either/flatten"
 export * from "@tsplus/stdlib/data/Either/fold"
 export * from "@tsplus/stdlib/data/Either/foldMap"
 export * from "@tsplus/stdlib/data/Either/forEachF"
+export * from "@tsplus/stdlib/data/Either/fromMaybe"
 export * from "@tsplus/stdlib/data/Either/fromNullable"
-export * from "@tsplus/stdlib/data/Either/fromOption"
 export * from "@tsplus/stdlib/data/Either/fromPredicate"
 export * from "@tsplus/stdlib/data/Either/getAssociative"
 export * from "@tsplus/stdlib/data/Either/getCompact"

packages/stdlib/_src/data/Either/compactOption.ts → packages/stdlib/_src/data/Either/compactMaybe.ts

@@ -2,16 +2,16 @@
  * Compact an `Either<E, Maybe<A>>`  to an `Either<E, A>` given an
  * `AssociativeIdentity<E>`.
  *
- * @tsplus fluent Either compactOption
+ * @tsplus fluent Either compactMaybe
  */
-export function compactOption_<E, A>(self: Either<E, Maybe<A>>, M: AssociativeIdentity<E>): Either<E, A> {
+export function compactMaybe_<E, A>(self: Either<E, Maybe<A>>, M: AssociativeIdentity<E>): Either<E, A> {
   return self.isLeft() ? self : self.right._tag === "None" ? Either.left(M.identity) : Either.right(self.right.value)
 }
 
 /**
  * Compact an `Either<E, Maybe<A>>`  to an `Either<E, A>` given an
  * `AssociativeIdentity<E>`.
  *
- * @tsplus static Either/Aspects compactOption
+ * @tsplus static Either/Aspects compactMaybe
  */
-export const compactOption = Pipeable(compactOption_)
+export const compactMaybe = Pipeable(compactMaybe_)

packages/stdlib/_src/data/Either/definition.ts

@@ -222,9 +222,3 @@ export function widenA<A1>() {
     <E, A>(self: Either<E, A>): Either<E, A | A1> => self
   )
 }
-
-/**
- * @tsplus macro pipe
- * @tsplus fluent Either __call
- */
-export const eitherPipe: typeof pipe = pipe

packages/stdlib/_src/data/Either/dsl/getCompactF.ts

@@ -5,7 +5,7 @@
  * @tsplus static Either/Ops getCompactF
  */
 export function getCompactF<E>(M: AssociativeIdentity<E>): Wither<Either.FixedLeftHKT<E>> {
-  const compact = Either.$.compactOption(M)
+  const compact = Either.$.compactMaybe(M)
   return HKT.instance(
     <G extends HKT>(G: Applicative<G>) =>
       <GR, GE, A, B>(f: (a: A) => HKT.Kind<G, GR, GE, Maybe<B>>) =>

packages/stdlib/_src/data/Either/fromOption.ts → packages/stdlib/_src/data/Either/fromMaybe.ts

@@ -1,8 +1,8 @@
 /**
  * Construct `Either<E, A>` from `Maybe<A>` constructing `E` with `onNone`.
  *
- * @tsplus static Either/Ops fromOption
+ * @tsplus static Either/Ops fromMaybe
  */
-export function fromOption<A, E>(maybe: Maybe<A>, onNone: LazyArg<E>): Either<E, A> {
+export function fromMaybe<A, E>(maybe: Maybe<A>, onNone: LazyArg<E>): Either<E, A> {
   return maybe.isNone() ? Either.left(onNone()) : Either.right(maybe.value)
 }

packages/stdlib/_src/data/Either/getCompact.ts

@@ -5,7 +5,7 @@
  * @tsplus static Either/Ops getCompact
  */
 export function getCompact<E>(M: AssociativeIdentity<E>) {
-  const compact = Either.$.compactOption(M)
+  const compact = Either.$.compactMaybe(M)
   return HKT.instance<Compact<Either.FixedLeftHKT<E>>>({
     compact
   })

packages/stdlib/_src/data/Maybe/definition.ts

@@ -4,28 +4,28 @@
  */
 export type Maybe<A> = None | Some<A>
 
-export interface OptionF extends HKT {
+export interface MaybeF extends HKT {
   readonly type: Maybe<this["A"]>
 }
 
+export declare namespace Maybe {
+  export type HKT = MaybeF
+}
+
 /**
  * @tsplus type Maybe/Ops
  */
-export interface OptionOps {
-  $: OptionAspects
+export interface MaybeOps {
+  $: MaybeAspects
 }
-export const Maybe: OptionOps = {
+export const Maybe: MaybeOps = {
   $: {}
 }
 
 /**
  * @tsplus type Maybe/Aspects
  */
-export interface OptionAspects {}
-
-export declare namespace Maybe {
-  export type HKT = OptionF
-}
+export interface MaybeAspects {}
 
 const _noneHash = Hash.string("Maybe/None")
 const _someHash = Hash.string("Maybe/Some")
@@ -67,13 +67,13 @@ export class Some<A> implements Equals {
  * @tsplus unify Maybe/Some
  * @tsplus unify Maybe/None
  */
-export function unifyOption<X extends Maybe<any>>(
+export function unifyMaybe<X extends Maybe<any>>(
   self: X
 ): Maybe<[X] extends [Maybe<infer A>] ? A : never> {
   return self
 }
 
-export type ArrayOfOptions<Ts extends Maybe<any>[]> = {
+export type ArrayOfMaybies<Ts extends Maybe<any>[]> = {
   [k in keyof Ts]: Ts[k] extends Maybe<infer A> ? A : never
 }[number]
 
@@ -121,19 +121,13 @@ export function isSome<A>(fa: Maybe<A>): fa is Some<A> {
 }
 
 /**
- * @tsplus static Maybe/Ops isOption
+ * @tsplus static Maybe/Ops isMaybe
  */
-export function isOption(u: unknown): u is Maybe<unknown> {
+export function isMaybe(u: unknown): u is Maybe<unknown> {
   return (
     typeof u === "object" &&
     u != null &&
     "_tag" in u &&
     (u["_tag"] === "Some" || u["_tag"] === "None")
   )
 }
-
-/**
- * @tsplus macro pipe
- * @tsplus fluent Maybe __call
- */
-export const optionPipe: typeof pipe = pipe

packages/stdlib/_src/data/Maybe/getRefinement.ts

@@ -6,6 +6,6 @@
  *
  * @tsplus static Maybe/Ops getRefinement
  */
-export function getRefinement<A, B extends A>(getOption: (a: A) => Maybe<B>): Refinement<A, B> {
-  return (a: A): a is B => getOption(a).isSome()
+export function getRefinement<A, B extends A>(getMaybe: (a: A) => Maybe<B>): Refinement<A, B> {
+  return (a: A): a is B => getMaybe(a).isSome()
 }

packages/stdlib/_src/data/Tuple/definition.ts

@@ -52,9 +52,3 @@ export function unifyTuple<X extends Tuple<any>>(
 export function isTuple(self: unknown): self is Tuple<unknown[]> {
   return typeof self === "object" && self != null && TupleSym in self
 }
-
-/**
- * @tsplus macro pipe
- * @tsplus fluent Tuple __call
- */
-export const tuplePipe: typeof pipe = pipe

packages/stdlib/_src/runtime/Decoder.ts

@@ -359,19 +359,15 @@ export function deriveArray<A extends Array<any>>(
 
 type EitherStructural<E, A> = { _tag: "Left"; left: E } | { _tag: "Right"; right: A }
 
-function deriveEitherInternal<E, A>(
-  /** @tsplus implicit local */ left: Decoder<E>,
-  /** @tsplus implicit local */ right: Decoder<A>
-): Decoder<EitherStructural<E, A>> {
+function deriveEitherInternal<E, A>(left: Decoder<E>, right: Decoder<A>): Decoder<EitherStructural<E, A>> {
   return Derive()
 }
 
 /**
  * @tsplus derive Decoder[Either]<_> 10
  */
 export function deriveEither<A extends Either<any, any>>(
-  ...[left, right]: [A] extends [Either<infer _E, infer _A>] ? [left: Decoder<_E>, right: Decoder<_A>]
-    : never
+  ...[left, right]: [A] extends [Either<infer _E, infer _A>] ? [left: Decoder<_E>, right: Decoder<_A>] : never
 ): Decoder<A> {
   const structural = deriveEitherInternal(left, right)
   return Decoder((u) =>
@@ -381,20 +377,20 @@ export function deriveEither<A extends Either<any, any>>(
 
 type OptionStructural<A> = { _tag: "None" } | { _tag: "Some"; value: A }
 
-function deriveOptionInternal<A>(
-  /** @tsplus implicit local */ value: Decoder<A>
+function deriveMaybeInternal<A>(
+  value: Decoder<A>
 ): Decoder<OptionStructural<A>> {
   return Derive()
 }
 
 /**
  * @tsplus derive Decoder[Maybe]<_> 10
  */
-export function deriveOption<A extends Maybe<any>>(
+export function deriveMaybe<A extends Maybe<any>>(
   ...[value]: [A] extends [Maybe<infer _A>] ? [value: Decoder<_A>]
     : never
 ): Decoder<A> {
-  const structural = deriveOptionInternal(value)
+  const structural = deriveMaybeInternal(value)
   return Decoder((u) =>
     structural.decodeResult(u).map((e) => e._tag === "Some" ? Maybe.some(e.value) as A : Maybe.none as A)
   )

packages/stdlib/_src/service/Env.ts

@@ -24,7 +24,7 @@ function methodGet<R, S>(this: Env<R>, tag: Tag<S>): S {
   return this.unsafeMap.get(tag)! as S
 }
 
-function methodGetOption<R, S>(this: Env<R>, tag: Tag<S>): Maybe<S> {
+function methodGetMaybe<R, S>(this: Env<R>, tag: Tag<S>): Maybe<S> {
   return this.unsafeMap.has(tag) ? Maybe.some(this.unsafeMap.get(tag)! as S) : Maybe.none
 }
 
@@ -72,7 +72,7 @@ function createEnv<R>(unsafeMap: Env<R>["unsafeMap"]) {
     add: methodAdd,
     get: methodGet,
     unsafeGet: methodGet,
-    getOption: methodGetOption,
+    getMaybe: methodGetMaybe,
     merge: methodMerge,
     prune: pruneMethod,
     unsafeMap
@@ -90,7 +90,7 @@ export interface Env<R> {
   add<R, S, H extends S = S>(this: Env<R>, tag: Tag<S>, service: H): Env<R | S>
   get<R, T extends Tags<R>>(this: Env<R>, tag: T): T extends Tag<infer S> ? S : never
   unsafeGet<R, S>(this: Env<R>, tag: Tag<S>): S
-  getOption<R, S>(this: Env<R>, tag: Tag<S>): Maybe<S>
+  getMaybe<R, S>(this: Env<R>, tag: Tag<S>): Maybe<S>
   merge<R, R1>(this: Env<R>, that: Env<R1>): Env<R | R1>
   prune<R, S extends Tags<R>[]>(this: Env<R>, ...tags: S): Env<{ [k in keyof S]: Tag.TagType<S[k]> }[number]>
 }

packages/stdlib/_test/Either.test.ts

@@ -47,9 +47,9 @@ describe.concurrent("Either", () => {
   })
 
   it("compactOption", () => {
-    assert.isTrue(Either.left("hello").compactOption(AssociativeIdentity.string) == Either.left("hello"))
-    assert.isTrue(Either.right(Maybe.none).compactOption(AssociativeIdentity.string) == Either.left(""))
-    assert.isTrue(Either.right(Maybe.some(0)).compactOption(AssociativeIdentity.string) == Either.right(0))
+    assert.isTrue(Either.left("hello").compactMaybe(AssociativeIdentity.string) == Either.left("hello"))
+    assert.isTrue(Either.right(Maybe.none).compactMaybe(AssociativeIdentity.string) == Either.left(""))
+    assert.isTrue(Either.right(Maybe.some(0)).compactMaybe(AssociativeIdentity.string) == Either.right(0))
   })
 
   it("do", () => {
@@ -162,8 +162,8 @@ describe.concurrent("Either", () => {
   })
 
   it("fromOption", () => {
-    assert.isTrue(Either.fromOption(Maybe.some(0), () => 1) == Either.right(0))
-    assert.isTrue(Either.fromOption(Maybe.none, () => 1) == Either.left(1))
+    assert.isTrue(Either.fromMaybe(Maybe.some(0), () => 1) == Either.right(0))
+    assert.isTrue(Either.fromMaybe(Maybe.none, () => 1) == Either.left(1))
   })
 
   it("fromPredicate", () => {

packages/stdlib/_test/Maybe.test.ts

@@ -286,12 +286,12 @@ describe.concurrent("Maybe", () => {
   })
 
   it("aspects", () => {
-    const result = Maybe(0)(
+    const result = pipe(
+      Maybe(0),
       Maybe.$.map((n) => n + 1),
       Maybe.$.map((n) => n + 1),
       Maybe.$.flatMap((n) => Maybe(`ok: ${n}`))
     )
-
     assert.isTrue(
       result == Maybe("ok: 2")
     )

packages/stdlib/_test/Service.test.ts

@@ -18,17 +18,17 @@ describe.concurrent("Environment", () => {
     const env = Service.Env(A, { a: 0 }).add(B, { b: 1 })
 
     assert.deepEqual(env.get(A), { a: 0 })
-    assert.deepEqual(env.getOption(B).value, { b: 1 })
-    assert.isTrue(env.getOption(C).isNone())
+    assert.deepEqual(env.getMaybe(B).value, { b: 1 })
+    assert.isTrue(env.getMaybe(C).isNone())
     assert.throw(() => env.unsafeGet(C))
   })
 
   it("prunes services in env and merges", () => {
     const env = Service.Env(A, { a: 0 }).merge(Service.Env(B, { b: 1 }).add(C, { c: 2 }))
     const pruned = env.prune(A, B)
     assert.deepEqual(pruned.get(A), { a: 0 })
-    assert.deepEqual(pruned.getOption(B).value, { b: 1 })
-    assert.isTrue(pruned.getOption(C).isNone())
+    assert.deepEqual(pruned.getMaybe(B).value, { b: 1 })
+    assert.isTrue(pruned.getMaybe(C).isNone())
     assert.throw(() => pruned.unsafeGet(C))
     assert.deepEqual(env.get(C), { c: 2 })
   })
@@ -44,9 +44,9 @@ describe.concurrent("Environment", () => {
 
       const result = patch.patch(oldEnv)
 
-      assert.isTrue(result.getOption(A).isSome())
-      assert.isTrue(result.getOption(B).isSome())
-      assert.isTrue(result.getOption(C).isNone())
+      assert.isTrue(result.getMaybe(A).isSome())
+      assert.isTrue(result.getMaybe(B).isSome())
+      assert.isTrue(result.getMaybe(C).isNone())
       assert.strictEqual(result.get(B).b, 3)
     })