effect 2.0.0-next.47 → 2.0.0-next.49

package/internal/matcher.esm.js

@@ -0,0 +1,314 @@
+import { left, isEither, right, match } from '../Either/dist/effect-Either.esm.js';
+import { identity } from '../Function/dist/effect-Function.esm.js';
+import { none, some } from '../Option/dist/effect-Option.esm.js';
+import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+
+/** @internal */
+const TypeId = /*#__PURE__*/Symbol.for("@effect/matcher/Matcher");
+const TypeMatcherProto = {
+  [TypeId]: {
+    _input: identity,
+    _filters: identity,
+    _remaining: identity,
+    _result: identity
+  },
+  _tag: "TypeMatcher",
+  add(_case) {
+    return makeTypeMatcher([...this.cases, _case]);
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+function makeTypeMatcher(cases) {
+  const matcher = Object.create(TypeMatcherProto);
+  matcher.cases = cases;
+  return matcher;
+}
+const ValueMatcherProto = {
+  [TypeId]: {
+    _input: identity,
+    _filters: identity,
+    _result: identity
+  },
+  _tag: "ValueMatcher",
+  add(_case) {
+    if (this.value._tag === "Right") {
+      return this;
+    }
+    if (_case._tag === "When" && _case.guard(this.provided) === true) {
+      return makeValueMatcher(this.provided, right(_case.evaluate(this.provided)));
+    } else if (_case._tag === "Not" && _case.guard(this.provided) === false) {
+      return makeValueMatcher(this.provided, right(_case.evaluate(this.provided)));
+    }
+    return this;
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+function makeValueMatcher(provided, value) {
+  const matcher = Object.create(ValueMatcherProto);
+  matcher.provided = provided;
+  matcher.value = value;
+  return matcher;
+}
+const makeWhen = (guard, evaluate) => ({
+  _tag: "When",
+  guard,
+  evaluate
+});
+const makeNot = (guard, evaluate) => ({
+  _tag: "Not",
+  guard,
+  evaluate
+});
+const makePredicate = pattern => {
+  if (typeof pattern === "function") {
+    return pattern;
+  } else if (Array.isArray(pattern)) {
+    const predicates = pattern.map(makePredicate);
+    const len = predicates.length;
+    return u => {
+      if (!Array.isArray(u)) {
+        return false;
+      }
+      for (let i = 0; i < len; i++) {
+        if (predicates[i](u[i]) === false) {
+          return false;
+        }
+      }
+      return true;
+    };
+  } else if (pattern !== null && typeof pattern === "object") {
+    const keysAndPredicates = Object.entries(pattern).map(([k, p]) => [k, makePredicate(p)]);
+    const len = keysAndPredicates.length;
+    return u => {
+      if (typeof u !== "object" || u === null) {
+        return false;
+      }
+      for (let i = 0; i < len; i++) {
+        const [key, predicate] = keysAndPredicates[i];
+        if (!(key in u) || predicate(u[key]) === false) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+  return u => u === pattern;
+};
+const makeOrPredicate = patterns => {
+  const predicates = patterns.map(makePredicate);
+  const len = predicates.length;
+  return u => {
+    for (let i = 0; i < len; i++) {
+      if (predicates[i](u) === true) {
+        return true;
+      }
+    }
+    return false;
+  };
+};
+const makeAndPredicate = patterns => {
+  const predicates = patterns.map(makePredicate);
+  const len = predicates.length;
+  return u => {
+    for (let i = 0; i < len; i++) {
+      if (predicates[i](u) === false) {
+        return false;
+      }
+    }
+    return true;
+  };
+};
+
+/** @internal */
+const type = () => makeTypeMatcher([]);
+
+/** @internal */
+const value = i => makeValueMatcher(i, left(i));
+
+/** @internal */
+const valueTags = fields => {
+  const match = tagsExhaustive(fields)(makeTypeMatcher([]));
+  return input => match(input);
+};
+
+/** @internal */
+const typeTags = () => fields => {
+  const match = tagsExhaustive(fields)(makeTypeMatcher([]));
+  return input => match(input);
+};
+
+/** @internal */
+const when = (pattern, f) => self => self.add(makeWhen(makePredicate(pattern), f));
+
+/** @internal */
+const whenOr = (...args) => self => {
+  const onMatch = args[args.length - 1];
+  const patterns = args.slice(0, -1);
+  return self.add(makeWhen(makeOrPredicate(patterns), onMatch));
+};
+
+/** @internal */
+const whenAnd = (...args) => self => {
+  const onMatch = args[args.length - 1];
+  const patterns = args.slice(0, -1);
+  return self.add(makeWhen(makeAndPredicate(patterns), onMatch));
+};
+
+/** @internal */
+const discriminator = field => (...pattern) => {
+  const f = pattern[pattern.length - 1];
+  const values = pattern.slice(0, -1);
+  const pred = values.length === 1 ? _ => _[field] === values[0] : _ => values.includes(_[field]);
+  return self => self.add(makeWhen(pred, f));
+};
+
+/** @internal */
+const discriminatorStartsWith = field => (pattern, f) => {
+  const pred = _ => typeof _[field] === "string" && _[field].startsWith(pattern);
+  return self => self.add(makeWhen(pred, f));
+};
+
+/** @internal */
+const discriminators = field => fields => {
+  const predicates = [];
+  for (const key in fields) {
+    const pred = _ => _[field] === key;
+    const f = fields[key];
+    if (f) {
+      predicates.push(makeWhen(pred, f));
+    }
+  }
+  const len = predicates.length;
+  return self => {
+    let matcher = self;
+    for (let i = 0; i < len; i++) {
+      matcher = matcher.add(predicates[i]);
+    }
+    return matcher;
+  };
+};
+
+/** @internal */
+const discriminatorsExhaustive = field => fields => {
+  const addCases = discriminators(field)(fields);
+  return matcher => exhaustive(addCases(matcher));
+};
+
+/** @internal */
+const tag = /*#__PURE__*/discriminator("_tag");
+
+/** @internal */
+const tagStartsWith = /*#__PURE__*/discriminatorStartsWith("_tag");
+
+/** @internal */
+const tags = /*#__PURE__*/discriminators("_tag");
+
+/** @internal */
+const tagsExhaustive = /*#__PURE__*/discriminatorsExhaustive("_tag");
+
+/** @internal */
+const not = (pattern, f) => self => self.add(makeNot(makePredicate(pattern), f));
+
+/** @internal */
+const nonEmptyString = u => typeof u === "string" && u.length > 0;
+
+/** @internal */
+const is = (...literals) => {
+  const len = literals.length;
+  return u => {
+    for (let i = 0; i < len; i++) {
+      if (u === literals[i]) {
+        return true;
+      }
+    }
+    return false;
+  };
+};
+
+/** @internal */
+const any = () => true;
+
+/** @internal */
+const defined = u => u !== undefined && u !== null;
+
+/** @internal */
+const instanceOf = constructor => u => u instanceof constructor;
+
+/** @internal */
+const orElse = f => self => {
+  const result = either(self);
+  if (isEither(result)) {
+    // @ts-expect-error
+    return result._tag === "Right" ? result.right : f(result.left);
+  }
+
+  // @ts-expect-error
+  return input => {
+    const a = result(input);
+    return a._tag === "Right" ? a.right : f(a.left);
+  };
+};
+
+/** @internal */
+const orElseAbsurd = self => orElse(() => {
+  throw new Error("absurd");
+})(self);
+
+/** @internal */
+const either = self => {
+  if (self._tag === "ValueMatcher") {
+    return self.value;
+  }
+  const len = self.cases.length;
+  return input => {
+    for (let i = 0; i < len; i++) {
+      const _case = self.cases[i];
+      if (_case._tag === "When" && _case.guard(input) === true) {
+        return right(_case.evaluate(input));
+      } else if (_case._tag === "Not" && _case.guard(input) === false) {
+        return right(_case.evaluate(input));
+      }
+    }
+    return left(input);
+  };
+};
+
+/** @internal */
+const option = self => {
+  const toEither = either(self);
+  if (isEither(toEither)) {
+    return match(toEither, {
+      onLeft: () => none(),
+      onRight: some
+    });
+  }
+  return input => match(toEither(input), {
+    onLeft: () => none(),
+    onRight: some
+  });
+};
+
+/** @internal */
+const exhaustive = self => {
+  const toEither = either(self);
+  if (isEither(toEither)) {
+    if (toEither._tag === "Right") {
+      return toEither.right;
+    }
+    throw new Error("@effect/match: exhaustive absurd");
+  }
+  return u => {
+    // @ts-expect-error
+    const result = toEither(u);
+    if (result._tag === "Right") {
+      return result.right;
+    }
+    throw new Error("@effect/match: exhaustive absurd");
+  };
+};
+
+export { TypeId, any, defined, discriminator, discriminatorStartsWith, discriminators, discriminatorsExhaustive, either, exhaustive, instanceOf, is, nonEmptyString, not, option, orElse, orElseAbsurd, tag, tagStartsWith, tags, tagsExhaustive, type, typeTags, value, valueTags, when, whenAnd, whenOr };

package/internal/sink.esm.js

@@ -1,22 +1,22 @@
 import { die as die$1, RuntimeException } from '../Cause/dist/effect-Cause.esm.js';
-import { appendAll, empty, append, toReadonlyArray, unsafeFromArray, drop as drop$1, isEmpty, flatten, map as map$3, dropWhile as dropWhile$1, filter, of, unsafeGet as unsafeGet$1, splitAt, isNonEmpty, last as last$1, reduce } from '../Chunk/dist/effect-Chunk.esm.js';
+import { appendAll, splitAt, isEmpty, empty, append, toReadonlyArray, unsafeFromArray, drop as drop$1, flatten, map as map$3, dropWhile as dropWhile$1, filter, isNonEmpty, unsafeGet as unsafeGet$1, of, last as last$1, reduce } from '../Chunk/dist/effect-Chunk.esm.js';
 import { currentTimeMillis } from '../Clock/dist/effect-Clock.esm.js';
 import { millis } from '../Duration/dist/effect-Duration.esm.js';
-import { takeWhile, map as map$1, zip as zip$1, forEach as forEach$1, context as context$1, contextWith as contextWith$1, filter as filter$1, succeed as succeed$2, dieMessage as dieMessage$1, acquireRelease, never as never$1, gen, suspend as suspend$2, isEffect, failCause as failCause$2, dropUntil as dropUntil$1, dropWhile as dropWhile$2, flatMap as flatMap$2 } from '../Effect/dist/effect-Effect.esm.js';
-import { match, merge, left, right } from '../Either/dist/effect-Either.esm.js';
+import { takeWhile, map as map$1, zip as zip$1, forEach as forEach$1, dropUntil as dropUntil$1, dropWhile as dropWhile$2, context as context$1, contextWith as contextWith$1, filter as filter$1, succeed as succeed$2, flatMap as flatMap$2, dieMessage as dieMessage$1, acquireRelease, never as never$1, gen, suspend as suspend$2, isEffect, failCause as failCause$2 } from '../Effect/dist/effect-Effect.esm.js';
+import { match as match$1, merge, left, right } from '../Either/dist/effect-Either.esm.js';
 import { match as match$2 } from '../Exit/dist/effect-Exit.esm.js';
 import { dual, pipe, constTrue, identity } from '../Function/dist/effect-Function.esm.js';
 import { empty as empty$1, has, unsafeGet, set } from '../HashMap/dist/effect-HashMap.esm.js';
 import { empty as empty$2, has as has$1, add } from '../HashSet/dist/effect-HashSet.esm.js';
-import { some as some$1, none, match as match$1, isNone, orElse as orElse$2 } from '../Option/dist/effect-Option.esm.js';
+import { some as some$1, none, match, isNone, orElse as orElse$2 } from '../Option/dist/effect-Option.esm.js';
 import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
 import { bounded } from '../PubSub/dist/effect-PubSub.esm.js';
 import { shutdown, offerAll } from '../Queue/dist/effect-Queue.esm.js';
 import { span } from '../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
 import { make, set as set$1, get } from '../Ref/dist/effect-Ref.esm.js';
-import { zipRight as zipRight$1, as as as$1, bufferChunk, foldChannel, doneCollect, map as map$2, pipeToOrFail, drain as drain$1, identityChannel, ensuring as ensuring$1, unwrap as unwrap$1, catchAll, unwrapScoped as unwrapScoped$1, mapEffect as mapEffect$1, mapError as mapError$1, mapOut, orElse as orElse$1, fromPubSubScoped, toPubSub, mergeWith, writeChunk } from './channel.esm.js';
+import { zipRight as zipRight$1, as as as$1, bufferChunk, foldChannel, doneCollect, map as map$2, pipeToOrFail, drain as drain$1, identityChannel, unwrap as unwrap$1, ensuring as ensuring$1, writeChunk, catchAll, unwrapScoped as unwrapScoped$1, mapEffect as mapEffect$1, mapError as mapError$1, mapOut, orElse as orElse$1, fromPubSubScoped, toPubSub, mergeWith } from './channel.esm.js';
 import { Done, Await } from './channel/mergeDecision.esm.js';
-import { suspend as suspend$1, readWithCause, failCause as failCause$1, succeed as succeed$1, readWith, write, fail as fail$1, flatMap as flatMap$1, fromEffect as fromEffect$1, pipeTo, collectElements, succeedNow, ensuringWith as ensuringWith$1, failSync as failSync$1, failCauseSync as failCauseSync$1, unit, provideContext as provideContext$1, sync as sync$1 } from './core-stream.esm.js';
+import { suspend as suspend$1, readWithCause, failCause as failCause$1, succeed as succeed$1, flatMap as flatMap$1, write, readWith, fail as fail$1, fromEffect as fromEffect$1, pipeTo, collectElements, unit, succeedNow, ensuringWith as ensuringWith$1, failSync as failSync$1, failCauseSync as failCauseSync$1, sync as sync$1, provideContext as provideContext$1 } from './core-stream.esm.js';
 
 /** @internal */
 const SinkTypeId = /*#__PURE__*/Symbol.for("effect/Sink");
@@ -465,7 +465,7 @@ const foldEffectReader = (s, contFn, f) => {
     return succeedNow(s);
   }
   return readWith({
-    onInput: input => pipe(fromEffect$1(foldChunkSplitEffect(s, input, contFn, f)), flatMap$1(([nextS, leftovers]) => pipe(leftovers, match$1({
+    onInput: input => pipe(fromEffect$1(foldChunkSplitEffect(s, input, contFn, f)), flatMap$1(([nextS, leftovers]) => pipe(leftovers, match({
       onNone: () => foldEffectReader(nextS, contFn, f),
       onSome: leftover => pipe(write(leftover), as$1(nextS))
     })))),
@@ -679,7 +679,7 @@ const fromPubSub = (pubsub, options) => fromQueue(pubsub, options);
 const fromPush = push => new SinkImpl(unwrapScoped$1(pipe(push, map$1(fromPushPull))));
 const fromPushPull = push => readWith({
   onInput: input => foldChannel(fromEffect$1(push(some$1(input))), {
-    onFailure: ([either, leftovers]) => match(either, {
+    onFailure: ([either, leftovers]) => match$1(either, {
       onLeft: error => pipe(write(leftovers), zipRight$1(fail$1(error))),
       onRight: z => pipe(write(leftovers), zipRight$1(succeedNow(z)))
     }),
@@ -687,7 +687,7 @@ const fromPushPull = push => readWith({
   }),
   onFailure: fail$1,
   onDone: () => foldChannel(fromEffect$1(push(none())), {
-    onFailure: ([either, leftovers]) => match(either, {
+    onFailure: ([either, leftovers]) => match$1(either, {
       onLeft: error => pipe(write(leftovers), zipRight$1(fail$1(error))),
       onRight: z => pipe(write(leftovers), zipRight$1(succeedNow(z)))
     }),
@@ -699,7 +699,7 @@ const fromPushPull = push => readWith({
 const fromQueue = (queue, options) => options?.shutdown ? unwrapScoped(map$1(acquireRelease(succeed$2(queue), shutdown), fromQueue)) : forEachChunk(input => pipe(offerAll(queue, input)));
 
 /** @internal */
-const head = () => fold(none(), isNone, (option, input) => match$1(option, {
+const head = () => fold(none(), isNone, (option, input) => match(option, {
   onNone: () => some$1(input),
   onSome: () => option
 }));
@@ -774,7 +774,7 @@ const refineOrDie = /*#__PURE__*/dual(2, (self, pf) => pipe(self, refineOrDieWit
 
 /** @internal */
 const refineOrDieWith = /*#__PURE__*/dual(3, (self, pf, f) => {
-  const newChannel = pipe(self, toChannel, catchAll(error => match$1(pf(error), {
+  const newChannel = pipe(self, toChannel, catchAll(error => match(pf(error), {
     onNone: () => failCauseSync$1(() => die$1(f(error))),
     onSome: fail$1
   })));

package/internal/stream.esm.js

@@ -1,11 +1,11 @@
 import { flipCauseOption, failureOrCause, map as map$3, isInterrupted, die as die$2, IllegalArgumentException, RuntimeException, isDieType, isRuntimeException, squash } from '../Cause/dist/effect-Cause.esm.js';
 import { Done, Await } from '../ChannelMergeDecision/dist/effect-ChannelMergeDecision.esm.js';
-import { empty as empty$1, isNonEmpty, of, map as map$2, range as range$1, unsafeFromArray, reduceRight, prepend as prepend$1, isEmpty, dropWhile as dropWhile$1, filter as filter$1, filterMap as filterMap$1, filterMapWhile as filterMapWhile$1, findFirst, fromIterable as fromIterable$1, flatMap as flatMap$3, takeWhile as takeWhile$1, take as take$3, drop as drop$1, appendAll, unsafeLast, zipWith as zipWith$2, reduce, append, last as last$1, splitWhere, head as head$1, mapAccum as mapAccum$1, make as make$7, unsafeGet as unsafeGet$1, flatten as flatten$2, isChunk, splitAt, takeRight as takeRight$1 } from '../Chunk/dist/effect-Chunk.esm.js';
+import { empty as empty$1, isNonEmpty, of, map as map$2, range as range$1, unsafeFromArray, reduceRight, prepend as prepend$1, isEmpty, dropWhile as dropWhile$1, filter as filter$1, filterMap as filterMap$1, filterMapWhile as filterMapWhile$1, findFirst, fromIterable as fromIterable$1, flatMap as flatMap$3, takeWhile as takeWhile$1, take as take$3, drop as drop$1, appendAll, unsafeLast, zipWith as zipWith$2, reduce, append, last as last$1, splitWhere, head as head$1, isChunk, mapAccum as mapAccum$1, unsafeGet as unsafeGet$1, make as make$7, flatten as flatten$2, splitAt, appendAllNonEmpty, takeRight as takeRight$1 } from '../Chunk/dist/effect-Chunk.esm.js';
 import { sleep, currentTimeMillis } from '../Clock/dist/effect-Clock.esm.js';
 import { add, unsafeGet } from '../Context/dist/effect-Context.esm.js';
 import { make as make$4, succeed as succeed$2, await as _await, failCause as failCause$3, poll, fail as fail$4 } from '../Deferred/dist/effect-Deferred.esm.js';
 import { toMillis, millis, greaterThan, zero } from '../Duration/dist/effect-Duration.esm.js';
-import { acquireRelease as acquireRelease$1, all, when as when$1, flatMap as flatMap$2, zipRight as zipRight$1, succeed as succeed$1, map as map$1, forkScoped, scope, runtime, match as match$1, sync as sync$1, as as as$1, unit as unit$2, onError as onError$1, tap as tap$1, gen, suspend as suspend$1, transplant, die as die$1, dieSync as dieSync$1, dieMessage as dieMessage$1, makeSemaphore, matchCauseEffect, flatten as flatten$1, forEach, catchAllCause as catchAllCause$2, dropUntil as dropUntil$1, dropWhile as dropWhile$2, context as context$1, fail as fail$3, failSync as failSync$1, failCause as failCause$4, failCauseSync as failCauseSync$1, findFirst as findFirst$1, tryPromise, promise, isEffect, mapError as mapError$1, zip as zip$1, never as never$1, orDie as orDie$1, matchEffect, scoped as scoped$1, asUnit, forkDaemon, ensuring as ensuring$2, timeoutFail as timeoutFail$1, timeoutFailCause as timeoutFailCause$1, runSync, catchTags as catchTags$1, tapErrorCause as tapErrorCause$1, runPromise, withSpanScoped, raceWith, zipWith as zipWith$1, forkIn, reduce as reduce$1, catchSomeCause as catchSomeCause$1, orElse as orElse$2, zipLeft as zipLeft$1, catchAll as catchAll$2, asSome, succeedNone, fork } from '../Effect/dist/effect-Effect.esm.js';
+import { acquireRelease as acquireRelease$1, all, when as when$1, flatMap as flatMap$2, zipRight as zipRight$1, succeed as succeed$1, map as map$1, forkScoped, scope, runtime, match as match$1, sync as sync$1, as as as$1, unit as unit$2, onError as onError$1, tap as tap$1, gen, suspend as suspend$1, transplant, die as die$1, dieSync as dieSync$1, dieMessage as dieMessage$1, makeSemaphore, matchCauseEffect, flatten as flatten$1, forEach, catchAllCause as catchAllCause$2, dropUntil as dropUntil$1, dropWhile as dropWhile$2, context as context$1, fail as fail$3, failSync as failSync$1, failCause as failCause$4, failCauseSync as failCauseSync$1, findFirst as findFirst$1, tryPromise, promise, isEffect, mapError as mapError$1, zip as zip$1, never as never$1, orDie as orDie$1, matchEffect, scoped as scoped$1, asUnit, forkDaemon, ensuring as ensuring$2, timeoutFail as timeoutFail$1, timeoutFailCause as timeoutFailCause$1, runSync, catchTags as catchTags$1, tapErrorCause as tapErrorCause$1, runPromise, setSpan, raceWith, zipWith as zipWith$1, forkIn, reduce as reduce$1, catchSomeCause as catchSomeCause$1, orElse as orElse$2, zipLeft as zipLeft$1, catchAll as catchAll$2, asSome, succeedNone, fork } from '../Effect/dist/effect-Effect.esm.js';
 import { match, left, right } from '../Either/dist/effect-Either.esm.js';
 import { equals } from '../Equal/dist/effect-Equal.esm.js';
 import { match as match$3, failCause as failCause$2, fail as fail$2, isSuccess, succeed as succeed$4, unit as unit$3, isFailure } from '../Exit/dist/effect-Exit.esm.js';
@@ -25,7 +25,7 @@ import { unwrap as unwrap$1, zipRight as zipRight$2, pipeToOrFail, unwrapScoped
 import { run as run$1, runScoped as runScoped$1 } from './channel/channelExecutor.esm.js';
 import { BufferSliding } from './channel/mergeStrategy.esm.js';
 import { make as make$5 } from './channel/singleProducerAsyncInput.esm.js';
-import { readWithCause, flatMap as flatMap$1, fromEffect as fromEffect$1, write, failCause as failCause$1, unit as unit$1, pipeTo, collectElements, fail as fail$1, catchAllCause as catchAllCause$1, readWith, suspend as suspend$2, succeedNow, ensuringWith as ensuringWith$1, succeed as succeed$3, provideContext as provideContext$1, foldCauseChannel, embedInput, sync as sync$2 } from './core-stream.esm.js';
+import { readWithCause, flatMap as flatMap$1, fromEffect as fromEffect$1, write, failCause as failCause$1, unit as unit$1, pipeTo, collectElements, fail as fail$1, catchAllCause as catchAllCause$1, readWith, suspend as suspend$2, succeedNow, ensuringWith as ensuringWith$1, succeed as succeed$3, provideContext as provideContext$1, foldCauseChannel, sync as sync$2, embedInput } from './core-stream.esm.js';
 import { RingBuffer } from './ringBuffer.esm.js';
 import { toChannel as toChannel$1, collectAllN, mkString as mkString$1, foldSink, collectLeftover, zipRight as zipRight$3, fromEffect as fromEffect$2, fail as fail$5, fromChannel as fromChannel$1, collectAll, count, drain as drain$2, fold, foldEffect, forEach as forEach$1, forEachChunk, forEachWhile, head, last, sum } from './sink.esm.js';
 import { OP_CURRENT, OP_PREVIOUS, current, OP_NOT_STARTED, notStarted, previous } from './stream/debounceState.esm.js';
@@ -880,10 +880,7 @@ const flatMap = /*#__PURE__*/dual(args => typeof args[0] !== "function", (self,
   if (options?.switch) {
     return matchConcurrency(options?.concurrency, () => flatMapParSwitchBuffer(self, 1, bufferSize, f), n => flatMapParSwitchBuffer(self, n, bufferSize, f));
   }
-  return matchConcurrency(options?.concurrency, () => new StreamImpl(concatMap(toChannel(self), as => pipe(as, map$2(a => toChannel(f(a))), reduce(unit$1, (left, right) => pipe(left, zipRight$2(right)))))), n => new StreamImpl(pipe(toChannel(self), concatMap(writeChunk), mergeMap(out => toChannel(f(out)), {
-    concurrency: n,
-    bufferSize
-  }))));
+  return matchConcurrency(options?.concurrency, () => new StreamImpl(concatMap(toChannel(self), as => pipe(as, map$2(a => toChannel(f(a))), reduce(unit$1, (left, right) => pipe(left, zipRight$2(right)))))), _ => new StreamImpl(pipe(toChannel(self), concatMap(writeChunk), mergeMap(out => toChannel(f(out)), options))));
 });
 
 /** @internal */
@@ -892,7 +889,7 @@ const matchConcurrency = (concurrency, sequential, bounded) => {
     case undefined:
       return sequential();
     case "unbounded":
-      return bounded(Number.POSITIVE_INFINITY);
+      return bounded(Number.MAX_SAFE_INTEGER);
     default:
       return concurrency > 1 ? bounded(concurrency) : sequential();
   }
@@ -1041,10 +1038,13 @@ const fromIteratorSucceed = (iterator, maxChunkSize = DefaultChunkSize) => {
       }
       builder = [];
       let count = 0;
-      while (count < maxChunkSize && !next.done) {
+      while (next.done === false) {
         builder.push(next.value);
-        next = iterator.next();
         count = count + 1;
+        if (count >= maxChunkSize) {
+          break;
+        }
+        next = iterator.next();
       }
       if (count > 0) {
         return pipe(write(unsafeFromArray(builder)), flatMap$1(() => loop(iterator)));
@@ -1117,7 +1117,10 @@ const groupAdjacentBy = /*#__PURE__*/dual(2, (self, f) => {
             const input = unsafeGet$1(chunk, until);
             const updatedKey = f(input);
             if (!equals(key, updatedKey)) {
-              builder.push([key, unsafeFromArray(Array.from(tuple[1]).slice(from, until))]);
+              const previousChunk = tuple[1];
+              const additionalChunk = unsafeFromArray(Array.from(chunk).slice(from, until));
+              const group = appendAllNonEmpty(previousChunk, additionalChunk);
+              builder.push([key, group]);
               key = updatedKey;
               from = until;
               loop = false;
@@ -2470,7 +2473,7 @@ const whenCaseEffect = /*#__PURE__*/dual(2, (self, pf) => pipe(fromEffect(self),
 const whenEffect = /*#__PURE__*/dual(2, (self, effect) => pipe(fromEffect(effect), flatMap(bool => bool ? self : empty)));
 
 /** @internal */
-const withSpan = /*#__PURE__*/dual(3, (self, name, options) => unwrapScoped(as$1(withSpanScoped(name, options), self)));
+const withSpan = /*#__PURE__*/dual(3, (self, name, options) => unwrapScoped(as$1(setSpan(name, options), self)));
 
 /** @internal */
 const zip = /*#__PURE__*/dual(2, (self, that) => pipe(self, zipWith(that, (a, a2) => [a, a2])));

package/internal/tracer.esm.js

@@ -1,4 +1,4 @@
-import { Tag } from '../Context/dist/effect-Context.esm.js';
+import { Tag, empty } from '../Context/dist/effect-Context.esm.js';
 import { globalValue } from '../GlobalValue/dist/effect-GlobalValue.esm.js';
 import { incrementAndGet, make as make$1 } from '../MutableRef/dist/effect-MutableRef.esm.js';
 
@@ -23,11 +23,12 @@ class NativeSpan {
   _tag = "Span";
   traceId = "native";
   events = [];
-  constructor(name, parent, context, links, startTime) {
+  constructor(name, parent, context, links, sampled, startTime) {
     this.name = name;
     this.parent = parent;
     this.context = context;
     this.links = links;
+    this.sampled = sampled;
     this.startTime = startTime;
     this.status = {
       _tag: "Started",
@@ -54,8 +55,17 @@ class NativeSpan {
 
 /** @internal */
 const nativeTracer = /*#__PURE__*/make({
-  span: (name, parent, context, links, startTime) => new NativeSpan(name, parent, context, links, startTime),
+  span: (name, parent, context, links, sampled, startTime) => new NativeSpan(name, parent, context, links, sampled, startTime),
   context: f => f()
 });
 
-export { NativeSpan, TracerTypeId, make, nativeTracer, tracerTag };
+/** @internal */
+const externalSpan = options => ({
+  _tag: "ExternalSpan",
+  spanId: options.spanId,
+  traceId: options.traceId,
+  sampled: options.sampled ?? true,
+  context: options.context ?? empty()
+});
+
+export { NativeSpan, TracerTypeId, externalSpan, make, nativeTracer, tracerTag };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "2.0.0-next.47",
+  "version": "2.0.0-next.49",
   "packageManager": "pnpm@8.7.3",
   "publishConfig": {
     "access": "public"
@@ -34,7 +34,7 @@
     "src",
     "dist",
     "internal",
-    "Bigint",
+    "BigInt",
     "Boolean",
     "Brand",
     "Cache",
@@ -89,6 +89,7 @@
     "LogLevel",
     "LogSpan",
     "Logger",
+    "Match",
     "Metric",
     "MetricBoundaries",
     "MetricHook",
@@ -186,11 +187,11 @@
       "default": "./dist/effect.cjs.js"
     },
     "./package.json": "./package.json",
-    "./Bigint": {
-      "types": "./dist/declarations/src/Bigint.d.ts",
-      "module": "./Bigint/dist/effect-Bigint.esm.js",
-      "import": "./Bigint/dist/effect-Bigint.cjs.mjs",
-      "default": "./Bigint/dist/effect-Bigint.cjs.js"
+    "./BigInt": {
+      "types": "./dist/declarations/src/BigInt.d.ts",
+      "module": "./BigInt/dist/effect-BigInt.esm.js",
+      "import": "./BigInt/dist/effect-BigInt.cjs.mjs",
+      "default": "./BigInt/dist/effect-BigInt.cjs.js"
     },
     "./Boolean": {
       "types": "./dist/declarations/src/Boolean.d.ts",
@@ -516,6 +517,12 @@
       "import": "./Logger/dist/effect-Logger.cjs.mjs",
       "default": "./Logger/dist/effect-Logger.cjs.js"
     },
+    "./Match": {
+      "types": "./dist/declarations/src/Match.d.ts",
+      "module": "./Match/dist/effect-Match.esm.js",
+      "import": "./Match/dist/effect-Match.cjs.mjs",
+      "default": "./Match/dist/effect-Match.cjs.js"
+    },
     "./Metric": {
       "types": "./dist/declarations/src/Metric.d.ts",
       "module": "./Metric/dist/effect-Metric.esm.js",
@@ -1049,20 +1056,20 @@
     "@changesets/changelog-github": "^0.4.8",
     "@changesets/cli": "^2.26.2",
     "@definitelytyped/dtslint": "^0.0.182",
-    "@effect/build-utils": "^0.1.5",
-    "@effect/docgen": "^0.1.8",
+    "@effect/build-utils": "^0.1.9",
+    "@effect/docgen": "^0.2.0",
     "@effect/eslint-plugin": "^0.1.2",
     "@effect/language-service": "^0.0.21",
     "@preconstruct/cli": "^2.8.1",
     "@types/chai": "^4.3.6",
-    "@types/node": "^20.8.2",
-    "@typescript-eslint/eslint-plugin": "^6.7.4",
-    "@typescript-eslint/parser": "^6.7.4",
+    "@types/node": "^20.8.4",
+    "@typescript-eslint/eslint-plugin": "^6.7.5",
+    "@typescript-eslint/parser": "^6.7.5",
     "@vitejs/plugin-react": "^4.1.0",
     "@vitest/coverage-v8": "^0.34.6",
     "@vitest/expect": "^0.34.6",
     "babel-plugin-annotate-pure-calls": "^0.4.0",
-    "eslint": "^8.50.0",
+    "eslint": "^8.51.0",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-codegen": "0.17.0",
     "eslint-plugin-deprecation": "^2.0.0",
@@ -1074,7 +1081,7 @@
     "prettier": "^3.0.3",
     "ts-node": "^10.9.1",
     "typescript": "^5.2.2",
-    "vite": "^4.4.10",
+    "vite": "^4.4.11",
     "vitest": "0.34.6"
   },
   "scripts": {
@@ -1084,11 +1091,13 @@
     "test": "vitest",
     "check": "tsc -p tsconfig.json",
     "coverage": "vitest run --coverage",
-    "circular": "madge --ts-config ./tsconfig.json --circular --no-color --no-spinner --warning src",
+    "circular": "madge --extensions ts --circular --no-color --no-spinner --warning src",
     "update-version": "changeset version && pnpm install --no-frozen-lockfile",
     "lint": "eslint src test",
+    "lint-fix": "eslint src test --fix",
     "fix": "preconstruct fix",
     "docgen": "docgen",
-    "dtslint": "dtslint --expectOnly dtslint"
+    "dtslint": "dtslint --expectOnly dtslint",
+    "dtslint-clean": "dtslint --installAll"
   }
 }