@nunofyobiz/effect-extras 0.0.2 → 2.0.0

package/dist/index.js

@@ -23,7 +23,7 @@ __export(ArrayX_exports, {
   slice: () => slice,
   takeFirstWhere: () => takeFirstWhere2,
   takeLastWhere: () => takeLastWhere2,
-  zipWithThese: () => zipWithThese
+  zipWithWarnings: () => zipWithWarnings
 });
 
 // src/RecordX/RecordX.ts
@@ -93,195 +93,201 @@ var collectBy = dual(
   )
 );
 
-// src/These/These.ts
-var These_exports = {};
-__export(These_exports, {
-  LeftAndRight: () => LeftAndRight,
-  LeftOnly: () => LeftOnly,
-  RightOnly: () => RightOnly,
-  WithLeft: () => WithLeft,
-  WithRight: () => WithRight,
-  flatMapLeft: () => flatMapLeft,
-  flatMapLeftEffect: () => flatMapLeftEffect,
-  flatMapRight: () => flatMapRight,
-  flatMapRightEffect: () => flatMapRightEffect,
+// src/WarnResult/WarnResult.ts
+var WarnResult_exports = {};
+__export(WarnResult_exports, {
+  SuccessOnly: () => SuccessOnly,
+  SuccessWithWarnings: () => SuccessWithWarnings,
+  WarningsOnly: () => WarningsOnly,
+  WithSuccess: () => WithSuccess,
+  WithWarnings: () => WithWarnings,
+  flatMapSuccess: () => flatMapSuccess,
+  flatMapSuccessEffect: () => flatMapSuccessEffect,
+  flatMapWarnings: () => flatMapWarnings,
+  flatMapWarningsEffect: () => flatMapWarningsEffect,
   fromNullables: () => fromNullables,
   is: () => is,
-  leftOption: () => leftOption,
-  leftOrElse: () => leftOrElse,
-  leftOrUndefined: () => leftOrUndefined,
   mapBoth: () => mapBoth,
   mapBothEffect: () => mapBothEffect,
-  mapLeft: () => mapLeft,
-  mapLeftEffect: () => mapLeftEffect,
-  mapRight: () => mapRight,
-  mapRightEffect: () => mapRightEffect,
+  mapSuccess: () => mapSuccess,
+  mapSuccessEffect: () => mapSuccessEffect,
+  mapWarnings: () => mapWarnings,
+  mapWarningsEffect: () => mapWarningsEffect,
   match: () => match,
-  matchLeft: () => matchLeft,
-  matchRight: () => matchRight,
+  matchSuccess: () => matchSuccess,
+  matchWarnings: () => matchWarnings,
   optionFromNullables: () => optionFromNullables,
   orElse: () => orElse,
   orUndefined: () => orUndefined,
-  rightOption: () => rightOption,
-  rightOrElse: () => rightOrElse,
-  rightOrUndefined: () => rightOrUndefined
+  successOption: () => successOption,
+  successOrElse: () => successOrElse,
+  successOrUndefined: () => successOrUndefined,
+  warningsOption: () => warningsOption,
+  warningsOrElse: () => warningsOrElse,
+  warningsOrUndefined: () => warningsOrUndefined
 });
 var taggedEnum = Data.taggedEnum();
-var LeftOnly = taggedEnum.LeftOnly;
-var RightOnly = taggedEnum.RightOnly;
-var LeftAndRight = taggedEnum.LeftAndRight;
+var WarningsOnly = taggedEnum.WarningsOnly;
+var SuccessOnly = taggedEnum.SuccessOnly;
+var SuccessWithWarnings = taggedEnum.SuccessWithWarnings;
 var is = taggedEnum.$is;
 var match = taggedEnum.$match;
-var WithLeft = ({
-  left,
-  right
-}) => Predicate.isNotNullish(right) ? LeftAndRight({ left, right }) : LeftOnly({ left });
-var WithRight = ({
-  left,
-  right
-}) => Predicate.isNotNullish(left) ? LeftAndRight({ left, right }) : RightOnly({ right });
+var WithWarnings = ({
+  warnings,
+  success
+}) => Predicate.isNotNullish(success) ? SuccessWithWarnings({ warnings, success }) : WarningsOnly({ warnings });
+var WithSuccess = ({
+  warnings,
+  success
+}) => Predicate.isNotNullish(warnings) ? SuccessWithWarnings({ warnings, success }) : SuccessOnly({ success });
 var optionFromNullables = ({
-  left,
-  right
+  warnings,
+  success
 }) => {
-  if (Predicate.isNotNullish(left) && Predicate.isNotNullish(right)) {
-    return Option.some(LeftAndRight({ left, right }));
+  if (Predicate.isNotNullish(warnings) && Predicate.isNotNullish(success)) {
+    return Option.some(SuccessWithWarnings({ warnings, success }));
   }
-  if (Predicate.isNotNullish(left)) {
-    return Option.some(LeftOnly({ left }));
+  if (Predicate.isNotNullish(warnings)) {
+    return Option.some(WarningsOnly({ warnings }));
   }
-  if (Predicate.isNotNullish(right)) {
-    return Option.some(RightOnly({ right }));
+  if (Predicate.isNotNullish(success)) {
+    return Option.some(SuccessOnly({ success }));
   }
   return Option.none();
 };
 var fromNullables = ({
-  left,
-  right,
+  warnings,
+  success,
   orElse: orElse2 = () => {
-    throw new Error("Both left and right are nullable");
+    throw new Error("Both warnings and success are nullish");
   }
-}) => pipe(optionFromNullables({ left, right }), Option.getOrElse(orElse2));
-var matchLeft = ({
-  Left,
-  RightOnly: RightOnly2
-}) => (these) => pipe(
-  these,
+}) => pipe(optionFromNullables({ warnings, success }), Option.getOrElse(orElse2));
+var matchWarnings = ({
+  Warnings,
+  SuccessOnly: SuccessOnly2
+}) => (warnResult) => pipe(
+  warnResult,
   match({
-    LeftOnly: ({ left }) => Left(left),
-    RightOnly: ({ right }) => RightOnly2(right),
-    LeftAndRight: ({ left }) => Left(left)
+    WarningsOnly: ({ warnings }) => Warnings(warnings),
+    SuccessOnly: ({ success }) => SuccessOnly2(success),
+    SuccessWithWarnings: ({ warnings }) => Warnings(warnings)
   }),
   // Make Typescript happy
   (a) => a
 );
-var matchRight = ({
-  LeftOnly: LeftOnly2,
-  Right
-}) => (these) => pipe(
-  these,
+var matchSuccess = ({
+  WarningsOnly: WarningsOnly2,
+  Success
+}) => (warnResult) => pipe(
+  warnResult,
   match({
-    LeftOnly: ({ left }) => LeftOnly2(left),
-    RightOnly: ({ right }) => Right(right),
-    LeftAndRight: ({ right }) => Right(right)
+    WarningsOnly: ({ warnings }) => WarningsOnly2(warnings),
+    SuccessOnly: ({ success }) => Success(success),
+    SuccessWithWarnings: ({ success }) => Success(success)
   }),
   // Make Typescript happy
   (a) => a
 );
 var orElse = ({
-  orElseLeft,
-  orElseRight
+  orElseWarnings,
+  orElseSuccess
 }) => match({
-  LeftOnly: ({ left }) => LeftAndRight({ left, right: orElseRight() }),
-  RightOnly: ({ right }) => LeftAndRight({ left: orElseLeft(), right }),
-  LeftAndRight: ({ left, right }) => LeftAndRight({ left, right })
+  WarningsOnly: ({ warnings }) => SuccessWithWarnings({ warnings, success: orElseSuccess() }),
+  SuccessOnly: ({ success }) => SuccessWithWarnings({ warnings: orElseWarnings(), success }),
+  SuccessWithWarnings: ({ warnings, success }) => SuccessWithWarnings({ warnings, success })
 });
 var orUndefined = orElse({
-  orElseLeft: () => void 0,
-  orElseRight: () => void 0
+  orElseWarnings: () => void 0,
+  orElseSuccess: () => void 0
 });
-var leftOrElse = (orElseReturn) => (these) => pipe(
-  these,
+var warningsOrElse = (orElseReturn) => (warnResult) => pipe(
+  warnResult,
   orElse({
-    orElseLeft: orElseReturn,
-    orElseRight: constUndefined
+    orElseWarnings: orElseReturn,
+    orElseSuccess: constUndefined
   }),
-  Struct.get("left")
+  Struct.get("warnings")
 );
-var leftOrUndefined = leftOrElse(() => void 0);
-var rightOrElse = (orElseReturn) => (these) => pipe(
-  these,
+var warningsOrUndefined = warningsOrElse(() => void 0);
+var successOrElse = (orElseReturn) => (warnResult) => pipe(
+  warnResult,
   orElse({
-    orElseLeft: constUndefined,
-    orElseRight: orElseReturn
+    orElseWarnings: constUndefined,
+    orElseSuccess: orElseReturn
   }),
-  Struct.get("right")
-);
-var rightOrUndefined = rightOrElse(() => void 0);
-var rightOption = (these) => pipe(
-  these,
-  matchRight({
-    LeftOnly: () => Option.none(),
-    Right: Option.some
+  Struct.get("success")
+);
+var successOrUndefined = successOrElse(() => void 0);
+var successOption = (warnResult) => pipe(
+  warnResult,
+  matchSuccess({
+    WarningsOnly: () => Option.none(),
+    Success: Option.some
   })
 );
-var leftOption = (these) => pipe(
-  these,
-  matchLeft({
-    Left: Option.some,
-    RightOnly: () => Option.none()
+var warningsOption = (warnResult) => pipe(
+  warnResult,
+  matchWarnings({
+    Warnings: Option.some,
+    SuccessOnly: () => Option.none()
   })
 );
 var mapBoth = ({
-  mapLeft: mapLeft2,
-  mapRight: mapRight2
+  mapWarnings: mapWarnings2,
+  mapSuccess: mapSuccess2
 }) => match({
-  LeftOnly: ({ left }) => LeftOnly({ left: mapLeft2(left) }),
-  RightOnly: ({ right }) => RightOnly({ right: mapRight2(right) }),
-  LeftAndRight: ({ left, right }) => LeftAndRight({ left: mapLeft2(left), right: mapRight2(right) })
+  WarningsOnly: ({ warnings }) => WarningsOnly({ warnings: mapWarnings2(warnings) }),
+  SuccessOnly: ({ success }) => SuccessOnly({ success: mapSuccess2(success) }),
+  SuccessWithWarnings: ({ warnings, success }) => SuccessWithWarnings({
+    warnings: mapWarnings2(warnings),
+    success: mapSuccess2(success)
+  })
 });
 var mapBothEffect = ({
-  mapLeft: mapLeft2,
-  mapRight: mapRight2
+  mapWarnings: mapWarnings2,
+  mapSuccess: mapSuccess2
 }) => match({
-  LeftOnly: ({ left }) => pipe(
-    mapLeft2(left),
-    Effect.map((left2) => LeftOnly({ left: left2 }))
+  WarningsOnly: ({ warnings }) => pipe(
+    mapWarnings2(warnings),
+    Effect.map((warnings2) => WarningsOnly({ warnings: warnings2 }))
   ),
-  RightOnly: ({ right }) => pipe(
-    mapRight2(right),
-    Effect.map((right2) => RightOnly({ right: right2 }))
+  SuccessOnly: ({ success }) => pipe(
+    mapSuccess2(success),
+    Effect.map((success2) => SuccessOnly({ success: success2 }))
   ),
-  LeftAndRight: ({ left, right }) => pipe(
-    Effect.all({ left: mapLeft2(left), right: mapRight2(right) }),
+  SuccessWithWarnings: ({ warnings, success }) => pipe(
+    Effect.all({
+      warnings: mapWarnings2(warnings),
+      success: mapSuccess2(success)
+    }),
     Effect.map(
-      ({ left: left2, right: right2 }) => LeftAndRight({ left: left2, right: right2 })
+      ({ warnings: warnings2, success: success2 }) => SuccessWithWarnings({ warnings: warnings2, success: success2 })
     )
   )
 });
-var mapLeft = (mapLeft2) => mapBoth({ mapLeft: mapLeft2, mapRight: identity });
-var flatMapLeft = (mapLeft2) => match({
-  LeftOnly: ({ left }) => mapLeft2(left),
-  RightOnly: ({ right }) => RightOnly({ right }),
-  LeftAndRight: ({ left }) => mapLeft2(left)
-});
-var mapLeftEffect = (mapLeft2) => mapBothEffect({ mapLeft: mapLeft2, mapRight: Effect.succeed });
-var flatMapLeftEffect = (mapLeft2) => match({
-  LeftOnly: ({ left }) => mapLeft2(left),
-  RightOnly: ({ right }) => Effect.succeed(RightOnly({ right })),
-  LeftAndRight: ({ left }) => mapLeft2(left)
-});
-var mapRight = (mapRight2) => mapBoth({ mapLeft: identity, mapRight: mapRight2 });
-var flatMapRight = (mapRight2) => match({
-  LeftOnly: ({ left }) => LeftOnly({ left }),
-  RightOnly: ({ right }) => mapRight2(right),
-  LeftAndRight: ({ right }) => mapRight2(right)
-});
-var mapRightEffect = (mapRight2) => mapBothEffect({ mapLeft: Effect.succeed, mapRight: mapRight2 });
-var flatMapRightEffect = (mapRight2) => match({
-  LeftOnly: ({ left }) => Effect.succeed(LeftOnly({ left })),
-  RightOnly: ({ right }) => mapRight2(right),
-  LeftAndRight: ({ right }) => mapRight2(right)
+var mapWarnings = (mapWarnings2) => mapBoth({ mapWarnings: mapWarnings2, mapSuccess: identity });
+var flatMapWarnings = (mapWarnings2) => match({
+  WarningsOnly: ({ warnings }) => mapWarnings2(warnings),
+  SuccessOnly: ({ success }) => SuccessOnly({ success }),
+  SuccessWithWarnings: ({ warnings }) => mapWarnings2(warnings)
+});
+var mapWarningsEffect = (mapWarnings2) => mapBothEffect({ mapWarnings: mapWarnings2, mapSuccess: Effect.succeed });
+var flatMapWarningsEffect = (mapWarnings2) => match({
+  WarningsOnly: ({ warnings }) => mapWarnings2(warnings),
+  SuccessOnly: ({ success }) => Effect.succeed(SuccessOnly({ success })),
+  SuccessWithWarnings: ({ warnings }) => mapWarnings2(warnings)
+});
+var mapSuccess = (mapSuccess2) => mapBoth({ mapWarnings: identity, mapSuccess: mapSuccess2 });
+var flatMapSuccess = (mapSuccess2) => match({
+  WarningsOnly: ({ warnings }) => WarningsOnly({ warnings }),
+  SuccessOnly: ({ success }) => mapSuccess2(success),
+  SuccessWithWarnings: ({ success }) => mapSuccess2(success)
+});
+var mapSuccessEffect = (mapSuccess2) => mapBothEffect({ mapWarnings: Effect.succeed, mapSuccess: mapSuccess2 });
+var flatMapSuccessEffect = (mapSuccess2) => match({
+  WarningsOnly: ({ warnings }) => Effect.succeed(WarningsOnly({ warnings })),
+  SuccessOnly: ({ success }) => mapSuccess2(success),
+  SuccessWithWarnings: ({ success }) => mapSuccess2(success)
 });
 
 // src/ResultX/ResultX.ts
@@ -296,7 +302,7 @@ var slice = dual(
   3,
   (array, start, end) => array.slice(start, end)
 );
-var zipWithThese = dual(
+var zipWithWarnings = dual(
   3,
   (array1, array2, f) => {
     const newLength = Math.max(array1.length, array2.length);
@@ -306,23 +312,23 @@ var zipWithThese = dual(
     return Array.makeBy(newLength, (index) => {
       if (index < array1.length && index < array2.length) {
         return f(
-          These_exports.LeftAndRight({
-            left: array1[index],
-            right: array2[index]
+          WarnResult_exports.SuccessWithWarnings({
+            warnings: array1[index],
+            success: array2[index]
           })
         );
       }
       if (index < array1.length) {
         return f(
-          These_exports.LeftOnly({
-            left: array1[index]
+          WarnResult_exports.WarningsOnly({
+            warnings: array1[index]
           })
         );
       }
       if (index < array2.length) {
         return f(
-          These_exports.RightOnly({
-            right: array2[index]
+          WarnResult_exports.SuccessOnly({
+            success: array2[index]
           })
         );
       }
@@ -1001,6 +1007,6 @@ var hasNotNullableProperty = dual(
   (object, key) => Predicate.hasProperty(object, key) && Predicate.isNotNullish(object[key])
 );
 
-export { ArrayX_exports as ArrayX, BigIntX_exports as BigIntX, BooleanX_exports as BooleanX, DurationX_exports as DurationX, EffectX_exports as EffectX, FormDataX_exports as FormDataX, MapX_exports as MapX, NonNullableX_exports as NonNullableX, NumberX_exports as NumberX, OptionX_exports as OptionX, OrderX_exports as OrderX, PredicateX_exports as PredicateX, PromiseX_exports as PromiseX, RecordX_exports as RecordX, ResultX_exports as ResultX, SchemaX_exports as SchemaX, SetX_exports as SetX, StringX_exports as StringX, StructX_exports as StructX, These_exports as These, fromNullableOrThrow as nn };
+export { ArrayX_exports as ArrayX, BigIntX_exports as BigIntX, BooleanX_exports as BooleanX, DurationX_exports as DurationX, EffectX_exports as EffectX, FormDataX_exports as FormDataX, MapX_exports as MapX, NonNullableX_exports as NonNullableX, NumberX_exports as NumberX, OptionX_exports as OptionX, OrderX_exports as OrderX, PredicateX_exports as PredicateX, PromiseX_exports as PromiseX, RecordX_exports as RecordX, ResultX_exports as ResultX, SchemaX_exports as SchemaX, SetX_exports as SetX, StringX_exports as StringX, StructX_exports as StructX, WarnResult_exports as WarnResult, fromNullableOrThrow as nn };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map