diff --git a/CHANGELOG.md b/CHANGELOG.md index b3285ca8c0..e06ce823bf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,7 @@ # 12.0.0-alpha.6 (Unreleased) - Fix exponential notation syntax. https://github.com/rescript-lang/rescript/pull/7174 +- Add `Option.all` & `Result.all` helpers. https://github.com/rescript-lang/rescript/pull/7181 #### :bug: Bug fix - Fix bug where a ref assignment is moved ouside a conditional. https://github.com/rescript-lang/rescript/pull/7176 diff --git a/lib/es6/Option.js b/lib/es6/Option.js index d869bbcd7b..98e8467077 100644 --- a/lib/es6/Option.js +++ b/lib/es6/Option.js @@ -97,6 +97,106 @@ function compare(a, b, cmp) { } } +function all(options) { + let acc = []; + let hasNone = false; + let index = 0; + while (hasNone === false && index < options.length) { + let value = options[index]; + if (value !== undefined) { + acc.push(Primitive_option.valFromOption(value)); + index = index + 1 | 0; + } else { + hasNone = true; + } + }; + if (hasNone) { + return; + } else { + return acc; + } +} + +function all2(param) { + let b = param[1]; + let a = param[0]; + if (a !== undefined && b !== undefined) { + return [ + Primitive_option.valFromOption(a), + Primitive_option.valFromOption(b) + ]; + } + +} + +function all3(param) { + let c = param[2]; + let b = param[1]; + let a = param[0]; + if (a !== undefined && b !== undefined && c !== undefined) { + return [ + Primitive_option.valFromOption(a), + Primitive_option.valFromOption(b), + Primitive_option.valFromOption(c) + ]; + } + +} + +function all4(param) { + let d = param[3]; + let c = param[2]; + let b = param[1]; + let a = param[0]; + if (a !== undefined && b !== undefined && c !== undefined && d !== undefined) { + return [ + Primitive_option.valFromOption(a), + Primitive_option.valFromOption(b), + Primitive_option.valFromOption(c), + Primitive_option.valFromOption(d) + ]; + } + +} + +function all5(param) { + let e = param[4]; + let d = param[3]; + let c = param[2]; + let b = param[1]; + let a = param[0]; + if (a !== undefined && b !== undefined && c !== undefined && d !== undefined && e !== undefined) { + return [ + Primitive_option.valFromOption(a), + Primitive_option.valFromOption(b), + Primitive_option.valFromOption(c), + Primitive_option.valFromOption(d), + Primitive_option.valFromOption(e) + ]; + } + +} + +function all6(param) { + let f = param[5]; + let e = param[4]; + let d = param[3]; + let c = param[2]; + let b = param[1]; + let a = param[0]; + if (a !== undefined && b !== undefined && c !== undefined && d !== undefined && e !== undefined && f !== undefined) { + return [ + Primitive_option.valFromOption(a), + Primitive_option.valFromOption(b), + Primitive_option.valFromOption(c), + Primitive_option.valFromOption(d), + Primitive_option.valFromOption(e), + Primitive_option.valFromOption(f) + ]; + } + +} + let mapWithDefault = mapOr; let getWithDefault = getOr; @@ -116,5 +216,11 @@ export { isNone, equal, compare, + all, + all2, + all3, + all4, + all5, + all6, } /* No side effect */ diff --git a/lib/es6/Result.js b/lib/es6/Result.js index 9fc4536c9e..65aebf9e8e 100644 --- a/lib/es6/Result.js +++ b/lib/es6/Result.js @@ -98,6 +98,250 @@ function mapError(r, f) { } } +function all(results) { + let acc = []; + let returnValue; + let index = 0; + while (returnValue === undefined && index < results.length) { + let err = results[index]; + if (err.TAG === "Ok") { + acc.push(err._0); + index = index + 1 | 0; + } else { + returnValue = err; + } + }; + let error = returnValue; + if (error !== undefined) { + return error; + } else { + return { + TAG: "Ok", + _0: acc + }; + } +} + +function all2(param) { + let b = param[1]; + let a = param[0]; + if (a.TAG === "Ok") { + if (b.TAG === "Ok") { + return { + TAG: "Ok", + _0: [ + a._0, + b._0 + ] + }; + } else { + return { + TAG: "Error", + _0: b._0 + }; + } + } else { + return { + TAG: "Error", + _0: a._0 + }; + } +} + +function all3(param) { + let c = param[2]; + let b = param[1]; + let a = param[0]; + if (a.TAG === "Ok") { + if (b.TAG === "Ok") { + if (c.TAG === "Ok") { + return { + TAG: "Ok", + _0: [ + a._0, + b._0, + c._0 + ] + }; + } else { + return { + TAG: "Error", + _0: c._0 + }; + } + } else { + return { + TAG: "Error", + _0: b._0 + }; + } + } else { + return { + TAG: "Error", + _0: a._0 + }; + } +} + +function all4(param) { + let d = param[3]; + let c = param[2]; + let b = param[1]; + let a = param[0]; + if (a.TAG === "Ok") { + if (b.TAG === "Ok") { + if (c.TAG === "Ok") { + if (d.TAG === "Ok") { + return { + TAG: "Ok", + _0: [ + a._0, + b._0, + c._0, + d._0 + ] + }; + } else { + return { + TAG: "Error", + _0: d._0 + }; + } + } else { + return { + TAG: "Error", + _0: c._0 + }; + } + } else { + return { + TAG: "Error", + _0: b._0 + }; + } + } else { + return { + TAG: "Error", + _0: a._0 + }; + } +} + +function all5(param) { + let e = param[4]; + let d = param[3]; + let c = param[2]; + let b = param[1]; + let a = param[0]; + if (a.TAG === "Ok") { + if (b.TAG === "Ok") { + if (c.TAG === "Ok") { + if (d.TAG === "Ok") { + if (e.TAG === "Ok") { + return { + TAG: "Ok", + _0: [ + a._0, + b._0, + c._0, + d._0, + e._0 + ] + }; + } else { + return { + TAG: "Error", + _0: e._0 + }; + } + } else { + return { + TAG: "Error", + _0: d._0 + }; + } + } else { + return { + TAG: "Error", + _0: c._0 + }; + } + } else { + return { + TAG: "Error", + _0: b._0 + }; + } + } else { + return { + TAG: "Error", + _0: a._0 + }; + } +} + +function all6(param) { + let f = param[5]; + let e = param[4]; + let d = param[3]; + let c = param[2]; + let b = param[1]; + let a = param[0]; + if (a.TAG === "Ok") { + if (b.TAG === "Ok") { + if (c.TAG === "Ok") { + if (d.TAG === "Ok") { + if (e.TAG === "Ok") { + if (f.TAG === "Ok") { + return { + TAG: "Ok", + _0: [ + a._0, + b._0, + c._0, + d._0, + e._0, + f._0 + ] + }; + } else { + return { + TAG: "Error", + _0: f._0 + }; + } + } else { + return { + TAG: "Error", + _0: e._0 + }; + } + } else { + return { + TAG: "Error", + _0: d._0 + }; + } + } else { + return { + TAG: "Error", + _0: c._0 + }; + } + } else { + return { + TAG: "Error", + _0: b._0 + }; + } + } else { + return { + TAG: "Error", + _0: a._0 + }; + } +} + let mapWithDefault = mapOr; let getWithDefault = getOr; @@ -116,5 +360,11 @@ export { compare, forEach, mapError, + all, + all2, + all3, + all4, + all5, + all6, } /* No side effect */ diff --git a/lib/js/Option.js b/lib/js/Option.js index 221ab3fbba..ffa98d5746 100644 --- a/lib/js/Option.js +++ b/lib/js/Option.js @@ -97,6 +97,106 @@ function compare(a, b, cmp) { } } +function all(options) { + let acc = []; + let hasNone = false; + let index = 0; + while (hasNone === false && index < options.length) { + let value = options[index]; + if (value !== undefined) { + acc.push(Primitive_option.valFromOption(value)); + index = index + 1 | 0; + } else { + hasNone = true; + } + }; + if (hasNone) { + return; + } else { + return acc; + } +} + +function all2(param) { + let b = param[1]; + let a = param[0]; + if (a !== undefined && b !== undefined) { + return [ + Primitive_option.valFromOption(a), + Primitive_option.valFromOption(b) + ]; + } + +} + +function all3(param) { + let c = param[2]; + let b = param[1]; + let a = param[0]; + if (a !== undefined && b !== undefined && c !== undefined) { + return [ + Primitive_option.valFromOption(a), + Primitive_option.valFromOption(b), + Primitive_option.valFromOption(c) + ]; + } + +} + +function all4(param) { + let d = param[3]; + let c = param[2]; + let b = param[1]; + let a = param[0]; + if (a !== undefined && b !== undefined && c !== undefined && d !== undefined) { + return [ + Primitive_option.valFromOption(a), + Primitive_option.valFromOption(b), + Primitive_option.valFromOption(c), + Primitive_option.valFromOption(d) + ]; + } + +} + +function all5(param) { + let e = param[4]; + let d = param[3]; + let c = param[2]; + let b = param[1]; + let a = param[0]; + if (a !== undefined && b !== undefined && c !== undefined && d !== undefined && e !== undefined) { + return [ + Primitive_option.valFromOption(a), + Primitive_option.valFromOption(b), + Primitive_option.valFromOption(c), + Primitive_option.valFromOption(d), + Primitive_option.valFromOption(e) + ]; + } + +} + +function all6(param) { + let f = param[5]; + let e = param[4]; + let d = param[3]; + let c = param[2]; + let b = param[1]; + let a = param[0]; + if (a !== undefined && b !== undefined && c !== undefined && d !== undefined && e !== undefined && f !== undefined) { + return [ + Primitive_option.valFromOption(a), + Primitive_option.valFromOption(b), + Primitive_option.valFromOption(c), + Primitive_option.valFromOption(d), + Primitive_option.valFromOption(e), + Primitive_option.valFromOption(f) + ]; + } + +} + let mapWithDefault = mapOr; let getWithDefault = getOr; @@ -115,4 +215,10 @@ exports.isSome = isSome; exports.isNone = isNone; exports.equal = equal; exports.compare = compare; +exports.all = all; +exports.all2 = all2; +exports.all3 = all3; +exports.all4 = all4; +exports.all5 = all5; +exports.all6 = all6; /* No side effect */ diff --git a/lib/js/Result.js b/lib/js/Result.js index bee54d5b2f..24b8c0cb29 100644 --- a/lib/js/Result.js +++ b/lib/js/Result.js @@ -98,6 +98,250 @@ function mapError(r, f) { } } +function all(results) { + let acc = []; + let returnValue; + let index = 0; + while (returnValue === undefined && index < results.length) { + let err = results[index]; + if (err.TAG === "Ok") { + acc.push(err._0); + index = index + 1 | 0; + } else { + returnValue = err; + } + }; + let error = returnValue; + if (error !== undefined) { + return error; + } else { + return { + TAG: "Ok", + _0: acc + }; + } +} + +function all2(param) { + let b = param[1]; + let a = param[0]; + if (a.TAG === "Ok") { + if (b.TAG === "Ok") { + return { + TAG: "Ok", + _0: [ + a._0, + b._0 + ] + }; + } else { + return { + TAG: "Error", + _0: b._0 + }; + } + } else { + return { + TAG: "Error", + _0: a._0 + }; + } +} + +function all3(param) { + let c = param[2]; + let b = param[1]; + let a = param[0]; + if (a.TAG === "Ok") { + if (b.TAG === "Ok") { + if (c.TAG === "Ok") { + return { + TAG: "Ok", + _0: [ + a._0, + b._0, + c._0 + ] + }; + } else { + return { + TAG: "Error", + _0: c._0 + }; + } + } else { + return { + TAG: "Error", + _0: b._0 + }; + } + } else { + return { + TAG: "Error", + _0: a._0 + }; + } +} + +function all4(param) { + let d = param[3]; + let c = param[2]; + let b = param[1]; + let a = param[0]; + if (a.TAG === "Ok") { + if (b.TAG === "Ok") { + if (c.TAG === "Ok") { + if (d.TAG === "Ok") { + return { + TAG: "Ok", + _0: [ + a._0, + b._0, + c._0, + d._0 + ] + }; + } else { + return { + TAG: "Error", + _0: d._0 + }; + } + } else { + return { + TAG: "Error", + _0: c._0 + }; + } + } else { + return { + TAG: "Error", + _0: b._0 + }; + } + } else { + return { + TAG: "Error", + _0: a._0 + }; + } +} + +function all5(param) { + let e = param[4]; + let d = param[3]; + let c = param[2]; + let b = param[1]; + let a = param[0]; + if (a.TAG === "Ok") { + if (b.TAG === "Ok") { + if (c.TAG === "Ok") { + if (d.TAG === "Ok") { + if (e.TAG === "Ok") { + return { + TAG: "Ok", + _0: [ + a._0, + b._0, + c._0, + d._0, + e._0 + ] + }; + } else { + return { + TAG: "Error", + _0: e._0 + }; + } + } else { + return { + TAG: "Error", + _0: d._0 + }; + } + } else { + return { + TAG: "Error", + _0: c._0 + }; + } + } else { + return { + TAG: "Error", + _0: b._0 + }; + } + } else { + return { + TAG: "Error", + _0: a._0 + }; + } +} + +function all6(param) { + let f = param[5]; + let e = param[4]; + let d = param[3]; + let c = param[2]; + let b = param[1]; + let a = param[0]; + if (a.TAG === "Ok") { + if (b.TAG === "Ok") { + if (c.TAG === "Ok") { + if (d.TAG === "Ok") { + if (e.TAG === "Ok") { + if (f.TAG === "Ok") { + return { + TAG: "Ok", + _0: [ + a._0, + b._0, + c._0, + d._0, + e._0, + f._0 + ] + }; + } else { + return { + TAG: "Error", + _0: f._0 + }; + } + } else { + return { + TAG: "Error", + _0: e._0 + }; + } + } else { + return { + TAG: "Error", + _0: d._0 + }; + } + } else { + return { + TAG: "Error", + _0: c._0 + }; + } + } else { + return { + TAG: "Error", + _0: b._0 + }; + } + } else { + return { + TAG: "Error", + _0: a._0 + }; + } +} + let mapWithDefault = mapOr; let getWithDefault = getOr; @@ -115,4 +359,10 @@ exports.equal = equal; exports.compare = compare; exports.forEach = forEach; exports.mapError = mapError; +exports.all = all; +exports.all2 = all2; +exports.all3 = all3; +exports.all4 = all4; +exports.all5 = all5; +exports.all6 = all6; /* No side effect */ diff --git a/runtime/Option.res b/runtime/Option.res index 4fcc8cfbb2..6f4cafb477 100644 --- a/runtime/Option.res +++ b/runtime/Option.res @@ -104,3 +104,53 @@ let compare = (a, b, cmp) => | (Some(_), None) => Ordering.greater | (None, None) => Ordering.equal } + +let all = options => { + let acc = [] + let hasNone = ref(false) + let index = ref(0) + while hasNone.contents == false && index.contents < options->Array.length { + switch options->Array.getUnsafe(index.contents) { + | None => hasNone.contents = true + | Some(value) => + acc->Array.push(value) + index.contents = index.contents + 1 + } + } + hasNone.contents ? None : Some(acc) +} + +let all2 = ((a, b)) => { + switch (a, b) { + | (Some(a), Some(b)) => Some((a, b)) + | _ => None + } +} + +let all3 = ((a, b, c)) => { + switch (a, b, c) { + | (Some(a), Some(b), Some(c)) => Some((a, b, c)) + | _ => None + } +} + +let all4 = ((a, b, c, d)) => { + switch (a, b, c, d) { + | (Some(a), Some(b), Some(c), Some(d)) => Some((a, b, c, d)) + | _ => None + } +} + +let all5 = ((a, b, c, d, e)) => { + switch (a, b, c, d, e) { + | (Some(a), Some(b), Some(c), Some(d), Some(e)) => Some((a, b, c, d, e)) + | _ => None + } +} + +let all6 = ((a, b, c, d, e, f)) => { + switch (a, b, c, d, e, f) { + | (Some(a), Some(b), Some(c), Some(d), Some(e), Some(f)) => Some((a, b, c, d, e, f)) + | _ => None + } +} diff --git a/runtime/Option.resi b/runtime/Option.resi index 16efdba52c..346eb1cd1e 100644 --- a/runtime/Option.resi +++ b/runtime/Option.resi @@ -253,3 +253,53 @@ Option.compare(None, None, clockCompare) // 0. ``` */ let compare: (option<'a>, option<'b>, ('a, 'b) => Ordering.t) => Ordering.t + +/** +`all(options)` returns an option of array if all options are Some, otherwise returns None. + +## Examples + +```rescript +Option.all([Some(1), Some(2), Some(3)]) // Some([1, 2, 3]) +Option.all([Some(1), None]) // None +``` +*/ +let all: array> => option> + +/** +`all2((o1, o2))`. Like `all()`, but with a fixed size tuple of 2 +*/ +let all2: ((option<'a>, option<'b>)) => option<('a, 'b)> + +/** +`all3((o1, o2, o3))`. Like `all()`, but with a fixed size tuple of 2 +*/ +let all3: ((option<'a>, option<'b>, option<'c>)) => option<('a, 'b, 'c)> + +/** +`all4((o1, o2, o3, o4))`. Like `all()`, but with a fixed size tuple of 2 +*/ +let all4: ((option<'a>, option<'b>, option<'c>, option<'d>)) => option<('a, 'b, 'c, 'd)> + +/** +`all5((o1, o2, o3, o4, o5))`. Like `all()`, but with a fixed size tuple of 2 +*/ +let all5: ((option<'a>, option<'b>, option<'c>, option<'d>, option<'e>)) => option<( + 'a, + 'b, + 'c, + 'd, + 'e, +)> + +/** +`all6((o1, o2, o3, o4, o5, o6))`. Like `all()`, but with a fixed size tuple of 2 +*/ +let all6: ((option<'a>, option<'b>, option<'c>, option<'d>, option<'e>, option<'f>)) => option<( + 'a, + 'b, + 'c, + 'd, + 'e, + 'f, +)> diff --git a/runtime/Result.res b/runtime/Result.res index f9307b59f4..158a6c7612 100644 --- a/runtime/Result.res +++ b/runtime/Result.res @@ -95,3 +95,71 @@ let mapError = (r, f) => | Ok(_) as result => result | Error(e) => Error(f(e)) } + +let all = results => { + let acc = [] + let returnValue = ref(None) + let index = ref(0) + while returnValue.contents == None && index.contents < results->Array.length { + switch results->Array.getUnsafe(index.contents) { + | Error(_) as err => returnValue.contents = Some(err) + | Ok(value) => + acc->Array.push(value) + index.contents = index.contents + 1 + } + } + switch returnValue.contents { + | Some(error) => error + | None => Ok(acc) + } +} + +let all2 = ((a, b)) => { + switch (a, b) { + | (Ok(a), Ok(b)) => Ok((a, b)) + | (Error(a), _) => Error(a) + | (_, Error(b)) => Error(b) + } +} + +let all3 = ((a, b, c)) => { + switch (a, b, c) { + | (Ok(a), Ok(b), Ok(c)) => Ok((a, b, c)) + | (Error(a), _, _) => Error(a) + | (_, Error(b), _) => Error(b) + | (_, _, Error(c)) => Error(c) + } +} + +let all4 = ((a, b, c, d)) => { + switch (a, b, c, d) { + | (Ok(a), Ok(b), Ok(c), Ok(d)) => Ok((a, b, c, d)) + | (Error(a), _, _, _) => Error(a) + | (_, Error(b), _, _) => Error(b) + | (_, _, Error(c), _) => Error(c) + | (_, _, _, Error(d)) => Error(d) + } +} + +let all5 = ((a, b, c, d, e)) => { + switch (a, b, c, d, e) { + | (Ok(a), Ok(b), Ok(c), Ok(d), Ok(e)) => Ok((a, b, c, d, e)) + | (Error(a), _, _, _, _) => Error(a) + | (_, Error(b), _, _, _) => Error(b) + | (_, _, Error(c), _, _) => Error(c) + | (_, _, _, Error(d), _) => Error(d) + | (_, _, _, _, Error(e)) => Error(e) + } +} + +let all6 = ((a, b, c, d, e, f)) => { + switch (a, b, c, d, e, f) { + | (Ok(a), Ok(b), Ok(c), Ok(d), Ok(e), Ok(f)) => Ok((a, b, c, d, e, f)) + | (Error(a), _, _, _, _, _) => Error(a) + | (_, Error(b), _, _, _, _) => Error(b) + | (_, _, Error(c), _, _, _) => Error(c) + | (_, _, _, Error(d), _, _) => Error(d) + | (_, _, _, _, Error(e), _) => Error(e) + | (_, _, _, _, _, Error(f)) => Error(f) + } +} diff --git a/runtime/Result.resi b/runtime/Result.resi index ac31649e7c..f63a167dc0 100644 --- a/runtime/Result.resi +++ b/runtime/Result.resi @@ -234,3 +234,52 @@ Result.mapError(Ok("abc"), format) // Ok("abc") ``` */ let mapError: (result<'a, 'b>, 'b => 'c) => result<'a, 'c> + +/** +`all(results)` returns a result of array if all options are Ok, otherwise returns Error. +## Examples +```rescript +Result.all([Ok(1), Ok(2), Ok(3)]) // Ok([1, 2, 3]) +Result.all([Ok(1), Error(1)]) // Error(1) +``` +*/ +let all: array> => result, 'b> + +/** +`all2((r1, r2))`. Like `all()`, but with a fixed size tuple of 2 +*/ +let all2: ((result<'r1, 'e>, result<'r2, 'e>)) => result<('r1, 'r2), 'e> + +/** +`all3((r1, r2, r3))`. Like `all()`, but with a fixed size tuple of 2 +*/ +let all3: ((result<'r1, 'e>, result<'r2, 'e>, result<'r3, 'e>)) => result<('r1, 'r2, 'r3), 'e> + +/** +`all4((r1, r2, r3, r4))`. Like `all()`, but with a fixed size tuple of 2 +*/ +let all4: ((result<'r1, 'e>, result<'r2, 'e>, result<'r3, 'e>, result<'r4, 'e>)) => result< + ('r1, 'r2, 'r3, 'r4), + 'e, +> + +/** +`all5((r1, r2, r3, r4, r5))`. Like `all()`, but with a fixed size tuple of 2 +*/ +let all5: ( + (result<'r1, 'e>, result<'r2, 'e>, result<'r3, 'e>, result<'r4, 'e>, result<'r5, 'e>) +) => result<('r1, 'r2, 'r3, 'r4, 'r5), 'e> + +/** +`all6((r1, r2, r3, r4, r5, r6))`. Like `all()`, but with a fixed size tuple of 2 +*/ +let all6: ( + ( + result<'r1, 'e>, + result<'r2, 'e>, + result<'r3, 'e>, + result<'r4, 'e>, + result<'r5, 'e>, + result<'r6, 'e>, + ) +) => result<('r1, 'r2, 'r3, 'r4, 'r5, 'r6), 'e> diff --git a/tests/tests/src/core/Core_ResultTests.mjs b/tests/tests/src/core/Core_ResultTests.mjs index 1179e2210e..149b1a1d6c 100644 --- a/tests/tests/src/core/Core_ResultTests.mjs +++ b/tests/tests/src/core/Core_ResultTests.mjs @@ -84,6 +84,239 @@ Test.run([ _0: 15 }); +Test.run([ + [ + "Core_ResultTests.res", + 34, + 20, + 25 + ], + "all" +], Result.all([]), eq, { + TAG: "Ok", + _0: [] +}); + +Test.run([ + [ + "Core_ResultTests.res", + 35, + 20, + 25 + ], + "all" +], Result.all([ + { + TAG: "Ok", + _0: 1 + }, + { + TAG: "Ok", + _0: 2 + }, + { + TAG: "Ok", + _0: 3 + } +]), eq, { + TAG: "Ok", + _0: [ + 1, + 2, + 3 + ] +}); + +Test.run([ + [ + "Core_ResultTests.res", + 36, + 20, + 25 + ], + "all" +], Result.all([ + { + TAG: "Ok", + _0: 1 + }, + { + TAG: "Error", + _0: 2 + } +]), eq, { + TAG: "Error", + _0: 2 +}); + +Test.run([ + [ + "Core_ResultTests.res", + 37, + 20, + 25 + ], + "all" +], Result.all2([ + { + TAG: "Ok", + _0: 1 + }, + { + TAG: "Ok", + _0: 2 + } +]), eq, { + TAG: "Ok", + _0: [ + 1, + 2 + ] +}); + +Test.run([ + [ + "Core_ResultTests.res", + 38, + 20, + 25 + ], + "all" +], Result.all2([ + { + TAG: "Ok", + _0: 1 + }, + { + TAG: "Error", + _0: 2 + } +]), eq, { + TAG: "Error", + _0: 2 +}); + +Test.run([ + [ + "Core_ResultTests.res", + 39, + 20, + 25 + ], + "all" +], Result.all3([ + { + TAG: "Ok", + _0: 1 + }, + { + TAG: "Ok", + _0: 2 + }, + { + TAG: "Ok", + _0: 3 + } +]), eq, { + TAG: "Ok", + _0: [ + 1, + 2, + 3 + ] +}); + +Test.run([ + [ + "Core_ResultTests.res", + 40, + 20, + 25 + ], + "all" +], Result.all3([ + { + TAG: "Ok", + _0: 1 + }, + { + TAG: "Error", + _0: 2 + }, + { + TAG: "Ok", + _0: 3 + } +]), eq, { + TAG: "Error", + _0: 2 +}); + +Test.run([ + [ + "Core_ResultTests.res", + 41, + 20, + 25 + ], + "all" +], Result.all4([ + { + TAG: "Ok", + _0: 1 + }, + { + TAG: "Ok", + _0: 2 + }, + { + TAG: "Ok", + _0: 3 + }, + { + TAG: "Ok", + _0: 4 + } +]), eq, { + TAG: "Ok", + _0: [ + 1, + 2, + 3, + 4 + ] +}); + +Test.run([ + [ + "Core_ResultTests.res", + 42, + 20, + 25 + ], + "all" +], Result.all4([ + { + TAG: "Ok", + _0: 1 + }, + { + TAG: "Error", + _0: 2 + }, + { + TAG: "Ok", + _0: 3 + }, + { + TAG: "Ok", + _0: 4 + } +]), eq, { + TAG: "Error", + _0: 2 +}); + export { eq, forEachIfOkCallFunction, diff --git a/tests/tests/src/core/Core_ResultTests.res b/tests/tests/src/core/Core_ResultTests.res index 54395a5a3b..d76c1a3b36 100644 --- a/tests/tests/src/core/Core_ResultTests.res +++ b/tests/tests/src/core/Core_ResultTests.res @@ -30,3 +30,13 @@ Test.run( eq, Error(15), ) + +Test.run(__POS_OF__("all"), Result.all([]), eq, Ok([])) +Test.run(__POS_OF__("all"), Result.all([Ok(1), Ok(2), Ok(3)]), eq, Ok([1, 2, 3])) +Test.run(__POS_OF__("all"), Result.all([Ok(1), Error(2)]), eq, Error(2)) +Test.run(__POS_OF__("all"), Result.all2((Ok(1), Ok(2))), eq, Ok((1, 2))) +Test.run(__POS_OF__("all"), Result.all2((Ok(1), Error(2))), eq, Error(2)) +Test.run(__POS_OF__("all"), Result.all3((Ok(1), Ok(2), Ok(3))), eq, Ok((1, 2, 3))) +Test.run(__POS_OF__("all"), Result.all3((Ok(1), Error(2), Ok(3))), eq, Error(2)) +Test.run(__POS_OF__("all"), Result.all4((Ok(1), Ok(2), Ok(3), Ok(4))), eq, Ok((1, 2, 3, 4))) +Test.run(__POS_OF__("all"), Result.all4((Ok(1), Error(2), Ok(3), Ok(4))), eq, Error(2))