Erkunden von Optionskonvertierungen in Effect-TS

Effect-TS bietet leistungsstarke Tools für die Handhabung von Option- und Both-Typen. In diesem Artikel untersuchen wir verschiedene Möglichkeiten zum Konvertieren und Bearbeiten dieser Typen mithilfe der Hilfsfunktionen der Bibliothek.

Beispiel 1: Konvertieren Sie ein Entweder in eine Option mit O.getRight

Die Funktion O.getRight wandelt ein Entweder in eine Option um und verwirft den Fehler. Wenn das Entweder richtig ist, wird O.some(value) zurückgegeben, andernfalls wird O.none.
zurückgegeben

import { Option as O, Either as E, pipe } from 'effect';

function conversions_ex01() {
  const eitherRight = E.right('ok'); // Create an Either containing the value 'ok'
  const eitherLeft = E.left('error'); // Create an Either representing an error

  console.log(O.getRight(eitherRight)); // Output: Some('ok')
  console.log(O.getRight(eitherLeft)); // Output: None
}

Beispiel 2: Konvertieren Sie ein Entweder in eine Option mit O.getLeft

Die Funktion O.getLeft wandelt ein Entweder in eine Option um und verwirft den Wert. Wenn das Entweder Left ist, wird O.some(error) zurückgegeben, andernfalls wird O.none.
zurückgegeben

import { Option as O, Either as E, pipe } from 'effect';

function conversions_ex02() {
  const eitherRight = E.right('ok'); // Create an Either containing the value 'ok'
  const eitherLeft = E.left('error'); // Create an Either representing an error

  console.log(O.getLeft(eitherRight)); // Output: None
  console.log(O.getLeft(eitherLeft)); // Output: Some('error')
}

Beispiel 3: Wert oder Standard mit O.getOrElse abrufen

Die Funktion O.getOrElse gibt den Wert innerhalb der Option zurück, wenn es Some ist, andernfalls gibt sie den bereitgestellten Standardwert zurück.

import { Option as O, pipe } from 'effect';

function conversions_ex03() {
  const some = O.some(1); // Create an Option containing the value 1
  const none = O.none(); // Create an Option representing no value

  console.log(
    pipe(
      some,
      O.getOrElse(() => 'default')
    )
  ); // Output: 1 (since some contains 1)
  console.log(
    pipe(
      none,
      O.getOrElse(() => 'default')
    )
  ); // Output: 'default' (since none is None)
}

Beispiel 4: Verkettungsoptionen mit O.orElse

Die Funktion O.orElse gibt die bereitgestellte Option zurück, dass, wenn self None ist, andernfalls self zurückgegeben wird. Diese Funktion ermöglicht die Verkettung von Optionen, wobei der Fallback eine andere Option ist.

import { Option as O, pipe } from 'effect';

function conversions_ex04() {
  const some1 = O.some(1); // Create an Option containing the value 1
  const some2 = O.some(2); // Create an Option containing the value 2
  const none = O.none(); // Create an Option representing no value

  console.log(
    pipe(
      some1,
      O.orElse(() => some2)
    )
  ); // Output: Some(1) (since some1 contains 1)
  console.log(
    pipe(
      none,
      O.orElse(() => some2)
    )
  ); // Output: Some(2) (since none is None and fallback is some2)
}

Beispiel 5: Fallback auf einen Standardwert mit O.orElseSome

Die Funktion O.orElseSome gibt den bereitgestellten Standardwert zurück, der in Some eingeschlossen ist, wenn self None ist, andernfalls gibt sie self zurück. Diese Funktion ermöglicht die Verkettung von Optionen, wobei der Fallback ein in Some.
eingeschlossener Standardwert ist

import { Option as O, pipe } from 'effect';

function conversions_ex05() {
  const some = O.some(1); // Create an Option containing the value 1
  const none = O.none(); // Create an Option representing no value

  console.log(
    pipe(
      some,
      O.orElseSome(() => 2)
    )
  ); // Output: Some(1) (since some contains 1)
  console.log(
    pipe(
      none,
      O.orElseSome(() => 2)
    )
  ); // Output: Some(2) (since none is None and fallback is 2)
}

Beispiel 6: Verkettung von Optionen mit einem beliebigen Kontext mithilfe von O.orElseEither

Die Funktion O.orElseEither gibt eine Option zurück, die ein Entweder enthält, wobei Left von der Fallback-Option und Right von der ursprünglichen Option stammt. Diese Funktion ermöglicht die Verkettung von Optionen, wobei der Fallback ein Entweder für mehr Kontext bereitstellt.

import { Option as O, Either as E, pipe } from 'effect';

function conversions_ex06() {
  const some1 = O.some(1); // Create an Option containing the value 1
  const some2 = O.some(2); // Create an Option containing the value 2
  const none = O.none(); // Create an Option representing no value

  console.log(
    pipe(
      some1,
      O.orElseEither(() => some2)
    )
  ); // Output: Some(Right(1)) (since some1 contains 1)
  console.log(
    pipe(
      none,
      O.orElseEither(() => some2)
    )
  ); // Output: Some(Left(2)) (since none is None and fallback is some2)
}

Beispiel 7: Finden Sie das erste Some in einem Iterable mit O.firstSomeOf

Die Funktion O.firstSomeOf gibt das erste Some zurück, das in einer Iterable von Optionen gefunden wird. Wenn alle None sind, wird None zurückgegeben.

import { Option as O } from 'effect';

function conversions_ex07() {
  const options = [O.none(), O.some(1), O.some(2)]; // Create an iterable of Options
  const optionsAllNone = [O.none(), O.none()]; // Create an iterable of None Options

  console.log(O.firstSomeOf(options)); // Output: Some(1) (since the first non-None Option is Some(1))
  console.log(O.firstSomeOf(optionsAllNone)); // Output: None (since all Options are None)
}

Beispiel 8: Konvertieren einer Funktion, die eine Option zurückgibt, in einen Type Guard mit O.toRefinement

Die O.toRefinement-Funktion wandelt eine Funktion, die eine Option zurückgibt, in einen Typschutz um und ermöglicht so eine spezifischere Typprüfung.

import { Option as O } from 'effect';

function conversions_ex08() {
  const isPositive = (n: number): O.Option<number> => n > 0 ? O.some(n) : O.none();
  const isPositiveRefinement = O.toRefinement(isPositive);

  console.log(isPositiveRefinement(1)); // Output: true (since 1 is positive)
  console.log(isPositiveRefinement(-1)); // Output: false (since -1 is not positive)
}

Beispiel 9: Konvertieren Sie eine Option in ein Array mit O.toArray

Die Funktion O.toArray konvertiert eine Option in ein Array. Wenn die Option Some ist, wird ein Array zurückgegeben, das den Wert enthält. Wenn es None ist, wird ein leeres Array zurückgegeben.

import { Option as O } from 'effect';

function conversions_ex09() {
  const some = O.some(1); // Create an Option containing the value 1
  const none = O.none(); // Create an Option representing no value

  console.log(O.toArray(some)); // Output: [1] (since some contains 1)
  console.log(O.toArray(none)); // Output: [] (since none is None)
}

Abschluss

In diesem Artikel haben wir verschiedene von Effect-TS bereitgestellte Funktionen zum Konvertieren und Bearbeiten von Option- und Both-Typen untersucht. Diese Funktionen erhöhen die Flexibilität und Ausdruckskraft Ihres Codes und ermöglichen Ihnen einen eleganteren Umgang mit optionalen und fehleranfälligen Werten. Unabhängig davon, ob Sie ein Entweder in eine Option konvertieren, mehrere Optionswerte verketten oder typsichere Operationen ausführen müssen, bietet Effect-TS einen robusten Satz an Tools, um diese Aufgaben zu vereinfachen. Durch die Nutzung dieser Dienstprogramme können Sie saubereren, wartbareren Code schreiben, der effektiv mit dem Vorhandensein oder Fehlen von Werten umgeht.

Das obige ist der detaillierte Inhalt vonErkunden von Optionskonvertierungen in Effect-TS. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!