FsToolkit.ErrorHandling by FsToolkit.ErrorHandling

<PackageReference Include="FsToolkit.ErrorHandling" Version="4.0.0" />

---

API Diff between 4.0.0 and 1.1.0

224 Additions 98 Removals

FsToolkit.ErrorHandling

• public static class Async
  • public static FSharpAsync<b> apply<a, b>(FSharpAsync<FSharpFunc<a, b>> f, FSharpAsync<a> x)
  • public static FSharpAsync<b> bind<a, b>(FSharpFunc<a, FSharpAsync<b>> f, FSharpAsync<a> x)
  • public static FSharpAsync<b> map<a, b>(FSharpFunc<a, b> f, FSharpAsync<a> x)
  • public static FSharpAsync<c> map2<a, b, c>(FSharpFunc<a, FSharpFunc<b, c>> f, FSharpAsync<a> x, FSharpAsync<b> y)
  • public static FSharpAsync<d> map3<a, b, c, d>(FSharpFunc<a, FSharpFunc<b, FSharpFunc<c, d>>> f, FSharpAsync<a> x, FSharpAsync<b> y, FSharpAsync<c> z)
  • public static FSharpAsync<a> singleton<a>(a value)
  • public static FSharpAsync<output> apply<input, output>(FSharpAsync<FSharpFunc<input, output>> applier, FSharpAsync<input> input)
  • public static FSharpAsync<output> bind<input, output>(FSharpFunc<input, FSharpAsync<output>> binder, FSharpAsync<input> input)
  • public static FSharpAsync<output> map<input, output>(FSharpFunc<input, output> mapper, FSharpAsync<input> input)
  • public static FSharpAsync<output> map2<input1, input2, output>(FSharpFunc<input1, FSharpFunc<input2, output>> mapper, FSharpAsync<input1> input1, FSharpAsync<input2> input2)
  • public static FSharpAsync<output> map3<input1, input2, input3, output>(FSharpFunc<input1, FSharpFunc<input2, FSharpFunc<input3, output>>> mapper, FSharpAsync<input1> input1, FSharpAsync<input2> input2, FSharpAsync<input3> input3)
  • public static FSharpAsync<value> retn<value>(value value)
  • public static FSharpAsync<value> singleton<value>(value value)
  • public static FSharpAsync<Tuple<left, right>> zip<left, right>(FSharpAsync<left> left, FSharpAsync<right> right)
• public static class AsyncOperators
  • public static FSharpAsync<b> op_GreaterGreaterEquals<a, b>(FSharpAsync<a> x, FSharpFunc<a, FSharpAsync<b>> f)
  • public static FSharpAsync<b> op_LessBangGreater<a, b>(FSharpFunc<a, b> f, FSharpAsync<a> x)
  • public static FSharpAsync<b> op_LessMultiplyGreater<a, b>(FSharpAsync<FSharpFunc<a, b>> f, FSharpAsync<a> x)
  • public static FSharpAsync<output> op_GreaterGreaterEquals<input, output>(FSharpAsync<input> input, FSharpFunc<input, FSharpAsync<output>> binder)
  • public static FSharpAsync<output> op_LessBangGreater<input, output>(FSharpFunc<input, output> mapper, FSharpAsync<input> input)
  • public static FSharpAsync<output> op_LessMultiplyGreater<input, output>(FSharpAsync<FSharpFunc<input, output>> applier, FSharpAsync<input> input)
• public static class AsyncOption
  • public static FSharpAsync<FSharpOption<output>> apply<input, output>(FSharpAsync<FSharpOption<FSharpFunc<input, output>>> applier, FSharpAsync<FSharpOption<input>> input)
  • public static FSharpAsync<FSharpOption<output>> bind<input, output>(FSharpFunc<input, FSharpAsync<FSharpOption<output>>> binder, FSharpAsync<FSharpOption<input>> input)
  • public static FSharpAsync<output> either<input, output>(FSharpFunc<input, FSharpAsync<output>> onSome, FSharpAsync<output> onNone, FSharpAsync<FSharpOption<input>> input)
  • public static FSharpAsync<FSharpOption<output>> map<input, output>(FSharpFunc<input, output> mapper, FSharpAsync<FSharpOption<input>> input)
  • public static FSharpAsync<FSharpOption<value>> retn<value>(value value)
  • public static FSharpAsync<FSharpOption<value>> some<value>(value value)
• public static class AsyncOptionCE
  • public class AsyncOptionBuilder
  • public static AsyncOptionBuilder asyncOption { get; }
• public static class AsyncOptionCEExtensions
  • public static a AsyncOptionBuilder.Source<a, b>(AsyncOptionBuilder _, a s) where a : IEnumerable<b>
  • public static FSharpAsync<FSharpOption<value>> AsyncOptionBuilder.Source<value>(AsyncOptionBuilder _, FSharpOption<value> r)
  • public static FSharpAsync<FSharpOption<value>> AsyncOptionBuilder.Source<value>(AsyncOptionBuilder _, FSharpAsync<value> a)
  • public static FSharpAsync<FSharpOption<value>> AsyncOptionBuilder.Source<value>(AsyncOptionBuilder _, Task<value> a)
• public static class AsyncResult
  • public static FSharpAsync<FSharpResult<b, c>> apply<a, b, c>(FSharpAsync<FSharpResult<FSharpFunc<a, b>, c>> fAR, FSharpAsync<FSharpResult<a, c>> xAR)
  • public static FSharpAsync<FSharpResult<b, c>> bind<a, b, c>(FSharpFunc<a, FSharpAsync<FSharpResult<b, c>>> f, FSharpAsync<FSharpResult<a, c>> ar)
  • public static FSharpAsync<a> defaultValue<a, b>(a ifError, FSharpAsync<FSharpResult<a, b>> asyncResult)
  • public static FSharpAsync<a> defaultWith<a, b>(FSharpFunc<Unit, a> ifErrorThunk, FSharpAsync<FSharpResult<a, b>> asyncResult)
  • public static FSharpAsync<b> foldResult<a, b, c>(FSharpFunc<a, b> onSuccess, FSharpFunc<c, b> onError, FSharpAsync<FSharpResult<a, c>> ar)
  • public static FSharpAsync<Unit> ignoreError<a>(FSharpAsync<FSharpResult<Unit, a>> result)
  • public static FSharpAsync<FSharpResult<b, c>> map<a, b, c>(FSharpFunc<a, b> f, FSharpAsync<FSharpResult<a, c>> ar)
  • public static FSharpAsync<FSharpResult<c, d>> map2<a, b, c, d>(FSharpFunc<a, FSharpFunc<b, c>> f, FSharpAsync<FSharpResult<a, d>> xR, FSharpAsync<FSharpResult<b, d>> yR)
  • public static FSharpAsync<FSharpResult<d, e>> map3<a, b, c, d, e>(FSharpFunc<a, FSharpFunc<b, FSharpFunc<c, d>>> f, FSharpAsync<FSharpResult<a, e>> xR, FSharpAsync<FSharpResult<b, e>> yR, FSharpAsync<FSharpResult<c, e>> zR)
  • public static FSharpAsync<FSharpResult<c, b>> mapError<a, b, c>(FSharpFunc<a, b> f, FSharpAsync<FSharpResult<c, a>> ar)
  • public static FSharpAsync<FSharpResult<a, Exception>> ofTask<a>(Task<a> aTask)
  • public static FSharpAsync<FSharpResult<output, error>> apply<input, output, error>(FSharpAsync<FSharpResult<FSharpFunc<input, output>, error>> applier, FSharpAsync<FSharpResult<input, error>> input)
  • public static FSharpAsync<FSharpResult<output, error>> bind<input, output, error>(FSharpFunc<input, FSharpAsync<FSharpResult<output, error>>> binder, FSharpAsync<FSharpResult<input, error>> input)
  • public static FSharpAsync<FSharpResult<Unit, a>> bindRequireNone<a, b>(a error, FSharpAsync<FSharpResult<FSharpOption<b>, a>> x)
  • public static FSharpAsync<FSharpResult<b, a>> bindRequireSome<a, b>(a error, FSharpAsync<FSharpResult<FSharpOption<b>, a>> x)
  • public static FSharpAsync<FSharpResult<ok, error>> catch<error, ok>(FSharpFunc<Exception, error> exnMapper, FSharpAsync<FSharpResult<ok, error>> input)
  • public static FSharpAsync<error> defaultError<error, ok>(error ifOk, FSharpAsync<FSharpResult<ok, error>> asyncResult)
  • public static FSharpAsync<ok> defaultValue<ok, error>(ok ifError, FSharpAsync<FSharpResult<ok, error>> asyncResult)
  • public static FSharpAsync<ok> defaultWith<error, ok>(FSharpFunc<error, ok> ifErrorThunk, FSharpAsync<FSharpResult<ok, error>> asyncResult)
  • public static FSharpAsync<FSharpResult<b, d>> eitherMap<a, b, c, d>(FSharpFunc<a, b> onSuccess, FSharpFunc<c, d> onError, FSharpAsync<FSharpResult<a, c>> input)
  • public static FSharpAsync<FSharpResult<ok, error>> error<error, ok>(error error)
  • public static FSharpAsync<output> foldResult<input, output, inputError>(FSharpFunc<input, output> onSuccess, FSharpFunc<inputError, output> onError, FSharpAsync<FSharpResult<input, inputError>> input)
  • public static FSharpAsync<FSharpResult<Unit, error>> ignore<ok, error>(FSharpAsync<FSharpResult<ok, error>> value)
  • public static FSharpAsync<Unit> ignoreError<error>(FSharpAsync<FSharpResult<Unit, error>> result)
  • public static FSharpAsync<FSharpResult<output, error>> map<input, output, error>(FSharpFunc<input, output> mapper, FSharpAsync<FSharpResult<input, error>> input)
  • public static FSharpAsync<FSharpResult<output, error>> map2<input1, input2, output, error>(FSharpFunc<input1, FSharpFunc<input2, output>> mapper, FSharpAsync<FSharpResult<input1, error>> input1, FSharpAsync<FSharpResult<input2, error>> input2)
  • public static FSharpAsync<FSharpResult<output, error>> map3<input1, input2, input3, output, error>(FSharpFunc<input1, FSharpFunc<input2, FSharpFunc<input3, output>>> mapper, FSharpAsync<FSharpResult<input1, error>> input1, FSharpAsync<FSharpResult<input2, error>> input2, FSharpAsync<FSharpResult<input3, error>> input3)
  • public static FSharpAsync<FSharpResult<ok, outputError>> mapError<inputError, outputError, ok>(FSharpFunc<inputError, outputError> mapper, FSharpAsync<FSharpResult<ok, inputError>> input)
  • public static FSharpAsync<FSharpResult<ok, error>> ofAsync<ok, error>(FSharpAsync<ok> value)
  • public static FSharpAsync<FSharpResult<ok, error>> ofResult<ok, error>(FSharpResult<ok, error> x)
  • public static FSharpAsync<FSharpResult<ok, Exception>> ofTask<ok>(Task<ok> aTask)
  • public static FSharpAsync<FSharpResult<Unit, a>> requireEmpty<a, b, c>(a error, FSharpAsync<b> xs) where b : IEnumerable<c>
  • public static FSharpAsync<FSharpResult<Unit, b>> requireEqual<a, b>(a x1, FSharpAsync<a> x2, b error)
  • public static FSharpAsync<FSharpResult<Unit, b>> requireEqualTo<a, b>(a other, b error, FSharpAsync<a> this)
  • public static FSharpAsync<FSharpResult<Unit, a>> requireFalse<a>(a error, FSharpAsync<bool> value)
  • public static FSharpAsync<FSharpResult<c, a>> requireHead<a, b, c>(a error, FSharpAsync<b> xs) where b : IEnumerable<c>
  • public static FSharpAsync<FSharpResult<Unit, a>> requireNone<a, b>(a error, FSharpAsync<FSharpOption<b>> option)
  • public static FSharpAsync<FSharpResult<Unit, a>> requireNotEmpty<a, b, c>(a error, FSharpAsync<b> xs) where b : IEnumerable<c>
  • public static FSharpAsync<FSharpResult<b, a>> requireSome<a, b>(a error, FSharpAsync<FSharpOption<b>> option)
  • public static FSharpAsync<FSharpResult<Unit, a>> requireTrue<a>(a error, FSharpAsync<bool> value)
  • public static FSharpAsync<FSharpResult<a, b>> retn<a, b>(a x)
  • public static FSharpAsync<FSharpResult<b, a>> returnError<a, b>(a x)
  • public static FSharpAsync<FSharpResult<b, a>> setError<a, b, c>(a error, FSharpAsync<FSharpResult<b, c>> asyncResult)
  • public static FSharpAsync<FSharpResult<a, b>> tee<a, b>(FSharpFunc<a, Unit> f, FSharpAsync<FSharpResult<a, b>> asyncResult)
  • public static FSharpAsync<FSharpResult<b, a>> teeError<a, b>(FSharpFunc<a, Unit> f, FSharpAsync<FSharpResult<b, a>> asyncResult)
  • public static FSharpAsync<FSharpResult<b, a>> teeErrorIf<a, b>(FSharpFunc<a, bool> predicate, FSharpFunc<a, Unit> f, FSharpAsync<FSharpResult<b, a>> asyncResult)
  • public static FSharpAsync<FSharpResult<a, b>> teeIf<a, b>(FSharpFunc<a, bool> predicate, FSharpFunc<a, Unit> f, FSharpAsync<FSharpResult<a, b>> asyncResult)
  • public static FSharpAsync<FSharpResult<b, a>> withError<a, b>(a error, FSharpAsync<FSharpResult<b, Unit>> asyncResult)
  • public static FSharpAsync<FSharpResult<ok, error>> ok<ok, error>(ok value)
  • public static FSharpAsync<FSharpResult<ok, errorOutput>> orElse<ok, errorOutput, errorInput>(FSharpAsync<FSharpResult<ok, errorOutput>> ifError, FSharpAsync<FSharpResult<ok, errorInput>> input)
  • public static FSharpAsync<FSharpResult<ok, errorOutput>> orElseWith<errorInput, ok, errorOutput>(FSharpFunc<errorInput, FSharpAsync<FSharpResult<ok, errorOutput>>> ifErrorFunc, FSharpAsync<FSharpResult<ok, errorInput>> input)
  • public static FSharpAsync<FSharpResult<Unit, error>> requireEmpty<error, a, ok>(error error, FSharpAsync<a> values) where a : IEnumerable<ok>
  • public static FSharpAsync<FSharpResult<Unit, error>> requireEqual<value, error>(value value1, FSharpAsync<value> value2, error error)
  • public static FSharpAsync<FSharpResult<Unit, error>> requireEqualTo<value, error>(value other, error error, FSharpAsync<value> this)
  • public static FSharpAsync<FSharpResult<Unit, error>> requireFalse<error>(error error, FSharpAsync<bool> value)
  • public static FSharpAsync<FSharpResult<ok, error>> requireHead<error, a, ok>(error error, FSharpAsync<a> values) where a : IEnumerable<ok>
  • public static FSharpAsync<FSharpResult<Unit, error>> requireNone<error, ok>(error error, FSharpAsync<FSharpOption<ok>> value)
  • public static FSharpAsync<FSharpResult<Unit, error>> requireNotEmpty<error, a, ok>(error error, FSharpAsync<a> values) where a : IEnumerable<ok>
  • public static FSharpAsync<FSharpResult<ok, error>> requireSome<error, ok>(error error, FSharpAsync<FSharpOption<ok>> value)
  • public static FSharpAsync<FSharpResult<Unit, error>> requireTrue<error>(error error, FSharpAsync<bool> value)
  • public static FSharpAsync<FSharpResult<ok, error>> retn<ok, error>(ok value)
  • public static FSharpAsync<FSharpResult<ok, error>> returnError<error, ok>(error error)
  • public static FSharpAsync<FSharpResult<ok, errorOutput>> setError<errorOutput, ok, errorInput>(errorOutput error, FSharpAsync<FSharpResult<ok, errorInput>> asyncResult)
  • public static FSharpAsync<FSharpResult<ok, error>> tee<ok, error>(FSharpFunc<ok, Unit> inspector, FSharpAsync<FSharpResult<ok, error>> asyncResult)
  • public static FSharpAsync<FSharpResult<ok, error>> teeError<error, ok>(FSharpFunc<error, Unit> teeFunction, FSharpAsync<FSharpResult<ok, error>> asyncResult)
  • public static FSharpAsync<FSharpResult<ok, error>> teeErrorIf<error, ok>(FSharpFunc<error, bool> predicate, FSharpFunc<error, Unit> teeFunction, FSharpAsync<FSharpResult<ok, error>> asyncResult)
  • public static FSharpAsync<FSharpResult<ok, error>> teeIf<ok, error>(FSharpFunc<ok, bool> predicate, FSharpFunc<ok, Unit> inspector, FSharpAsync<FSharpResult<ok, error>> asyncResult)
  • public static FSharpAsync<FSharpResult<ok, errorOutput>> withError<errorOutput, ok>(errorOutput error, FSharpAsync<FSharpResult<ok, Unit>> asyncResult)
  • public static FSharpAsync<FSharpResult<Tuple<leftOk, rightOk>, error>> zip<leftOk, error, rightOk>(FSharpAsync<FSharpResult<leftOk, error>> left, FSharpAsync<FSharpResult<rightOk, error>> right)
  • public static FSharpAsync<FSharpResult<ok, Tuple<leftError, rightError>>> zipError<ok, leftError, rightError>(FSharpAsync<FSharpResult<ok, leftError>> left, FSharpAsync<FSharpResult<ok, rightError>> right)
• public static class AsyncResultCE
  • public static AsyncResultBuilder asyncResult { get; }
• public static class AsyncResultCEExtensions
  • public static AsyncResultBuilder asyncResult { get; }
  • public static FSharpAsync<FSharpResult<U, TError>> AsyncResultBuilder.Bind<T, U, TError>(AsyncResultBuilder this, FSharpAsync<T> async', FSharpFunc<T, FSharpAsync<FSharpResult<U, TError>>> binder)
  • public static FSharpAsync<FSharpResult<U, TError>> AsyncResultBuilder.Bind<T, U, TError>(AsyncResultBuilder this, Task<T> task, FSharpFunc<T, FSharpAsync<FSharpResult<U, TError>>> binder)
  • public static FSharpAsync<FSharpResult<T, TError>> AsyncResultBuilder.Bind<T, TError>(AsyncResultBuilder this, Task task, FSharpFunc<Unit, FSharpAsync<FSharpResult<T, TError>>> binder)
  • public static FSharpAsync<FSharpResult<T, TError>> AsyncResultBuilder.ReturnFrom<T, TError>(AsyncResultBuilder __, FSharpAsync<T> async')
  • public static FSharpAsync<FSharpResult<T, TError>> AsyncResultBuilder.ReturnFrom<T, TError>(AsyncResultBuilder __, Task<T> task)
  • public static FSharpAsync<FSharpResult<Unit, TError>> AsyncResultBuilder.ReturnFrom<TError>(AsyncResultBuilder __, Task task)
  • public static a AsyncResultBuilder.Source<a, value>(AsyncResultBuilder _, a s) where a : IEnumerable<value>
  • public static FSharpAsync<FSharpResult<ok, error>> AsyncResultBuilder.Source<ok, error>(AsyncResultBuilder _, FSharpResult<ok, error> result)
  • public static FSharpAsync<FSharpResult<ok, error>> AsyncResultBuilder.Source<ok, error>(AsyncResultBuilder _, FSharpChoice<ok, error> choice)
  • public static FSharpAsync<FSharpResult<ok, error>> AsyncResultBuilder.Source<ok, error>(AsyncResultBuilder _, FSharpAsync<ok> asyncComputation)
  • public static FSharpAsync<FSharpResult<ok, error>> AsyncResultBuilder.Source<ok, error>(AsyncResultBuilder _, Task<ok> task)
  • public static FSharpAsync<FSharpResult<Unit, error>> AsyncResultBuilder.Source<error>(AsyncResultBuilder _, Task task)
• public static class AsyncResultOption
  • public static FSharpAsync<FSharpResult<FSharpOption<b>, c>> apply<a, b, c>(FSharpAsync<FSharpResult<FSharpOption<FSharpFunc<a, b>>, c>> fARO, FSharpAsync<FSharpResult<FSharpOption<a>, c>> xARO)
  • public static FSharpAsync<FSharpResult<FSharpOption<b>, c>> bind<a, b, c>(FSharpFunc<a, FSharpAsync<FSharpResult<FSharpOption<b>, c>>> f, FSharpAsync<FSharpResult<FSharpOption<a>, c>> aro)
  • public static FSharpAsync<FSharpResult<FSharpOption<b>, c>> map<a, b, c>(FSharpFunc<a, b> f, FSharpAsync<FSharpResult<FSharpOption<a>, c>> aro)
  • public static FSharpAsync<FSharpResult<FSharpOption<c>, d>> map2<a, b, c, d>(FSharpFunc<a, FSharpFunc<b, c>> f, FSharpAsync<FSharpResult<FSharpOption<a>, d>> arox, FSharpAsync<FSharpResult<FSharpOption<b>, d>> aroy)
  • public static FSharpAsync<FSharpResult<FSharpOption<d>, e>> map3<a, b, c, d, e>(FSharpFunc<a, FSharpFunc<b, FSharpFunc<c, d>>> f, FSharpAsync<FSharpResult<FSharpOption<a>, e>> arox, FSharpAsync<FSharpResult<FSharpOption<b>, e>> aroy, FSharpAsync<FSharpResult<FSharpOption<c>, e>> aroz)
  • public static FSharpAsync<FSharpResult<FSharpOption<a>, b>> retn<a, b>(a value)
  • public static FSharpAsync<FSharpResult<FSharpOption<okOutput>, error>> apply<okInput, okOutput, error>(FSharpAsync<FSharpResult<FSharpOption<FSharpFunc<okInput, okOutput>>, error>> applier, FSharpAsync<FSharpResult<FSharpOption<okInput>, error>> input)
  • public static FSharpAsync<FSharpResult<FSharpOption<okOutput>, error>> bind<okInput, okOutput, error>(FSharpFunc<okInput, FSharpAsync<FSharpResult<FSharpOption<okOutput>, error>>> binder, FSharpAsync<FSharpResult<FSharpOption<okInput>, error>> input)
  • public static FSharpAsync<FSharpResult<FSharpOption<Unit>, error>> ignore<ok, error>(FSharpAsync<FSharpResult<FSharpOption<ok>, error>> value)
  • public static FSharpAsync<FSharpResult<FSharpOption<okOutput>, error>> map<okInput, okOutput, error>(FSharpFunc<okInput, okOutput> mapper, FSharpAsync<FSharpResult<FSharpOption<okInput>, error>> input)
  • public static FSharpAsync<FSharpResult<FSharpOption<okOutput>, error>> map2<okInput1, okInput2, okOutput, error>(FSharpFunc<okInput1, FSharpFunc<okInput2, okOutput>> mapper, FSharpAsync<FSharpResult<FSharpOption<okInput1>, error>> input1, FSharpAsync<FSharpResult<FSharpOption<okInput2>, error>> input2)
  • public static FSharpAsync<FSharpResult<FSharpOption<okOutput>, error>> map3<okInput1, okInput2, okInput3, okOutput, error>(FSharpFunc<okInput1, FSharpFunc<okInput2, FSharpFunc<okInput3, okOutput>>> mapper, FSharpAsync<FSharpResult<FSharpOption<okInput1>, error>> input1, FSharpAsync<FSharpResult<FSharpOption<okInput2>, error>> input2, FSharpAsync<FSharpResult<FSharpOption<okInput3>, error>> input3)
  • public static FSharpAsync<FSharpResult<FSharpOption<ok>, error>> retn<ok, error>(ok value)
• public static class List
  • public static FSharpResult<FSharpList<a>, FSharpList<b>> traverseValidationA'<a, b, c>(FSharpResult<FSharpList<a>, FSharpList<b>> state, FSharpFunc<c, FSharpResult<a, FSharpList<b>>> f, FSharpList<c> xs)
• public static class Option
  • public static FSharpResult<FSharpOption<a>, b> sequenceResult<a, b>(FSharpOption<FSharpResult<a, b>> opt)
  • public static FSharpResult<FSharpOption<b>, c> traverseResult<a, b, c>(FSharpFunc<a, FSharpResult<b, c>> f, FSharpOption<a> opt)
  • public static FSharpOption<b> bind<a, b>(FSharpFunc<a, FSharpOption<b>> f, FSharpOption<a> x)
  • public static FSharpOption<nullableValue> bindNull<value, nullableValue>(FSharpFunc<value, nullableValue> binder, FSharpOption<value> option)
  • public static output either<a, output>(FSharpFunc<a, output> onSome, FSharpFunc<Unit, output> onNone, FSharpOption<a> input)
  • public static FSharpOption<b> map<a, b>(FSharpFunc<a, b> f, FSharpOption<a> x)
  • public static FSharpOption<nullableValue> ofNull<nullableValue>(nullableValue value)
  • public static FSharpOption<ok> ofResult<ok, error>(FSharpResult<ok, error> r)
  • public static FSharpOption<value> ofValueOption<value>(FSharpValueOption<value> vopt)
  • public static FSharpResult<FSharpOption<ok>, error> sequenceResult<ok, error>(FSharpOption<FSharpResult<ok, error>> opt)
  • public static FSharpValueOption<value> toValueOption<value>(FSharpOption<value> opt)
  • public static FSharpResult<FSharpOption<okOutput>, error> traverseResult<input, okOutput, error>(FSharpFunc<input, FSharpResult<okOutput, error>> binder, FSharpOption<input> input)
  • public static FSharpOption<value> tryGetValue<key, Dictionary, value>(key key, Dictionary dictionary)
  • public static FSharpOption<value> tryGetValue$W<key, Dictionary, value>(FSharpFunc<Dictionary, FSharpFunc<key, FSharpFunc<ref value, bool>>> tryGetValue, key key, Dictionary dictionary)
  • public static FSharpOption<value> tryParse<value>(string valueToParse)
  • public static FSharpOption<value> tryParse$W<value>(FSharpFunc<string, FSharpFunc<ref value, bool>> tryParse, string valueToParse)
  • public static FSharpOption<Tuple<left, right>> zip<left, right>(FSharpOption<left> left, FSharpOption<right> right)
• public static class OptionCE
  • public class OptionBuilder
  • public static OptionBuilder option { get; }
• public static class OptionExtensions
  • public static a OptionBuilder.Source<a, value>(OptionBuilder _, a s) where a : IEnumerable<value>
  • public static FSharpOption<value> OptionBuilder.Source<value>(OptionBuilder _, value? nullable) where value : struct
• public static class OptionExtensionsLower
  • public static FSharpOption<Tuple<left, right>> OptionBuilder.MergeSources<left, right>(OptionBuilder _, left nullableObj1, FSharpOption<right> option2)
  • public static FSharpOption<Tuple<left, right>> OptionBuilder.MergeSources<left, right>(OptionBuilder _, FSharpOption<left> option1, right nullableObj2)
  • public static FSharpOption<Tuple<left, right>> OptionBuilder.MergeSources<left, right>(OptionBuilder _, left nullableObj1, right nullableObj2)
  • public static FSharpOption<value> OptionBuilder.Source<value>(OptionBuilder _, value nullableObj)
  • public static FSharpOption<string> OptionBuilder.Source(OptionBuilder _, string m)
• public static class Result
  • public static FSharpResult<b, c> apply<a, b, c>(FSharpResult<FSharpFunc<a, b>, c> f, FSharpResult<a, c> x)
  • public static a defaultValue<a, b>(a ifError, FSharpResult<a, b> result)
  • public static a defaultWith<a, b>(FSharpFunc<Unit, a> ifErrorThunk, FSharpResult<a, b> result)
  • public static b either<a, b, c>(FSharpFunc<a, b> okF, FSharpFunc<c, b> errorF, FSharpResult<a, c> x)
  • public static FSharpResult<b, d> eitherMap<a, b, c, d>(FSharpFunc<a, b> okF, FSharpFunc<c, d> errorF, FSharpResult<a, c> x)
  • public static b fold<a, b, c>(FSharpFunc<a, b> onOk, FSharpFunc<c, b> onError, FSharpResult<a, c> r)
  • public static void ignoreError<a>(FSharpResult<Unit, a> result)
  • public static bool isError<a, b>(FSharpResult<a, b> x)
  • public static bool isOk<a, b>(FSharpResult<a, b> x)
  • public static FSharpResult<c, d> map2<a, b, c, d>(FSharpFunc<a, FSharpFunc<b, c>> f, FSharpResult<a, d> x, FSharpResult<b, d> y)
  • public static FSharpResult<d, e> map3<a, b, c, d, e>(FSharpFunc<a, FSharpFunc<b, FSharpFunc<c, d>>> f, FSharpResult<a, e> x, FSharpResult<b, e> y, FSharpResult<c, e> z)
  • public static FSharpResult<a, b> ofChoice<a, b>(FSharpChoice<a, b> c)
  • public static FSharpResult<Unit, a> requireEmpty<a, b>(a error, IEnumerable<b> xs)
  • public static FSharpResult<Unit, b> requireEqual<a, b>(a x1, a x2, b error)
  • public static FSharpResult<Unit, b> requireEqualTo<a, b>(a other, b err, a this)
  • public static FSharpResult<Unit, a> requireFalse<a>(a error, bool value)
  • public static FSharpResult<b, a> requireHead<a, b>(a error, IEnumerable<b> xs)
  • public static FSharpResult<Unit, a> requireNone<a, b>(a error, FSharpOption<b> option)
  • public static FSharpResult<Unit, a> requireNotEmpty<a, b>(a error, IEnumerable<b> xs)
  • public static FSharpResult<b, a> requireSome<a, b>(a error, FSharpOption<b> option)
  • public static FSharpResult<Unit, a> requireTrue<a>(a error, bool value)
  • public static FSharpResult<b, a> setError<a, b, c>(a error, FSharpResult<b, c> result)
  • public static FSharpResult<a, b> tee<a, b>(FSharpFunc<a, Unit> f, FSharpResult<a, b> result)
  • public static FSharpResult<b, a> teeError<a, b>(FSharpFunc<a, Unit> f, FSharpResult<b, a> result)
  • public static FSharpResult<b, a> teeErrorIf<a, b>(FSharpFunc<a, bool> predicate, FSharpFunc<a, Unit> f, FSharpResult<b, a> result)
  • public static FSharpResult<a, b> teeIf<a, b>(FSharpFunc<a, bool> predicate, FSharpFunc<a, Unit> f, FSharpResult<a, b> result)
  • public static FSharpResult<okOutput, error> apply<okInput, okOutput, error>(FSharpResult<FSharpFunc<okInput, okOutput>, error> applier, FSharpResult<okInput, error> input)
  • public static FSharpResult<okOutput, error> bind<okInput, okOutput, error>(FSharpFunc<okInput, FSharpResult<okOutput, error>> binder, FSharpResult<okInput, error> input)
  • public static error defaultError<error, ok>(error ifOk, FSharpResult<ok, error> result)
  • public static ok defaultValue<ok, error>(ok ifError, FSharpResult<ok, error> result)
  • public static ok defaultWith<error, ok>(FSharpFunc<error, ok> ifErrorThunk, FSharpResult<ok, error> result)
  • public static output either<okInput, output, errorInput>(FSharpFunc<okInput, output> onOk, FSharpFunc<errorInput, output> onError, FSharpResult<okInput, errorInput> input)
  • public static FSharpResult<okOutput, errorOutput> eitherMap<okInput, okOutput, errorInput, errorOutput>(FSharpFunc<okInput, okOutput> onOk, FSharpFunc<errorInput, errorOutput> onError, FSharpResult<okInput, errorInput> input)
  • public static FSharpResult<Unit, error> ignore<ok, error>(FSharpResult<ok, error> result)
  • public static void ignoreError<error>(FSharpResult<Unit, error> result)
  • public static bool isError<ok, error>(FSharpResult<ok, error> value)
  • public static bool isOk<ok, error>(FSharpResult<ok, error> value)
  • public static FSharpResult<okOutput, error> map<okInput, okOutput, error>(FSharpFunc<okInput, okOutput> mapper, FSharpResult<okInput, error> input)
  • public static FSharpResult<okOutput, error> map2<okInput1, okInput2, okOutput, error>(FSharpFunc<okInput1, FSharpFunc<okInput2, okOutput>> mapper, FSharpResult<okInput1, error> input1, FSharpResult<okInput2, error> input2)
  • public static FSharpResult<okOutput, error> map3<okInput1, okInput2, okInput3, okOutput, error>(FSharpFunc<okInput1, FSharpFunc<okInput2, FSharpFunc<okInput3, okOutput>>> mapper, FSharpResult<okInput1, error> input1, FSharpResult<okInput2, error> input2, FSharpResult<okInput3, error> input3)
  • public static FSharpResult<ok, errorOutput> mapError<errorInput, errorOutput, ok>(FSharpFunc<errorInput, errorOutput> errorMapper, FSharpResult<ok, errorInput> input)
  • public static FSharpResult<ok, error> ofChoice<ok, error>(FSharpChoice<ok, error> input)
  • public static FSharpResult<ok, errorOutput> orElse<ok, errorOutput, error>(FSharpResult<ok, errorOutput> ifError, FSharpResult<ok, error> result)
  • public static FSharpResult<ok, errorOutput> orElseWith<error, ok, errorOutput>(FSharpFunc<error, FSharpResult<ok, errorOutput>> ifErrorFunc, FSharpResult<ok, error> result)
  • public static FSharpResult<Unit, error> requireEmpty<error, a, value>(error error, a xs) where a : IEnumerable<value>
  • public static FSharpResult<Unit, error> requireEqual<value, error>(value x1, value x2, error error)
  • public static FSharpResult<Unit, error> requireEqualTo<value, error>(value other, error error, value this)
  • public static FSharpResult<Unit, error> requireFalse<error>(error error, bool value)
  • public static FSharpResult<ok, error> requireHead<error, a, ok>(error error, a xs) where a : IEnumerable<ok>
  • public static FSharpResult<Unit, error> requireNone<error, value>(error error, FSharpOption<value> option)
  • public static FSharpResult<Unit, error> requireNotEmpty<error, a, value>(error error, a xs) where a : IEnumerable<value>
  • public static FSharpResult<ok, error> requireNotNull<error, ok>(error error, ok value)
  • public static FSharpResult<ok, error> requireSome<error, ok>(error error, FSharpOption<ok> option)
  • public static FSharpResult<Unit, error> requireTrue<error>(error error, bool value)
  • public static FSharpAsync<FSharpResult<ok, error>> sequenceAsync<ok, error>(FSharpResult<FSharpAsync<ok>, error> resAsync)
  • public static FSharpResult<ok, error> setError<error, ok, errorIgnored>(error error, FSharpResult<ok, errorIgnored> result)
  • public static FSharpResult<ok, error> tee<ok, error>(FSharpFunc<ok, Unit> inspector, FSharpResult<ok, error> result)
  • public static FSharpResult<ok, error> teeError<error, ok>(FSharpFunc<error, Unit> inspector, FSharpResult<ok, error> result)
  • public static FSharpResult<ok, error> teeErrorIf<error, ok>(FSharpFunc<error, bool> predicate, FSharpFunc<error, Unit> inspector, FSharpResult<ok, error> result)
  • public static FSharpResult<ok, error> teeIf<ok, error>(FSharpFunc<ok, bool> predicate, FSharpFunc<ok, Unit> inspector, FSharpResult<ok, error> result)
  • public static FSharpAsync<FSharpResult<okOutput, error>> traverseAsync<okInput, okOutput, error>(FSharpFunc<okInput, FSharpAsync<okOutput>> f, FSharpResult<okInput, error> res)
  • public static FSharpResult<b, a> withError<a, b>(a error, FSharpResult<b, Unit> result)
  • public static FSharpResult<b, Tuple<string, c>> tryCreate$W<a, b, c>(FSharpFunc<a, FSharpResult<b, c>> tryCreate, string fieldName, a x)
  • public static ok valueOr<error, ok>(FSharpFunc<error, ok> f, FSharpResult<ok, error> res)
  • public static FSharpResult<ok, error> withError<error, ok>(error error, FSharpResult<ok, Unit> result)
  • public static FSharpResult<Tuple<leftOk, rightOk>, error> zip<leftOk, error, rightOk>(FSharpResult<leftOk, error> left, FSharpResult<rightOk, error> right)
  • public static FSharpResult<ok, Tuple<leftError, rightError>> zipError<ok, leftError, rightError>(FSharpResult<ok, leftError> left, FSharpResult<ok, rightError> right)
• public static class ResultCEChoiceExtensions
  • public static FSharpResult<ok, error> ResultBuilder.Source<ok, error>(ResultBuilder _, FSharpChoice<ok, error> choice)
• public static class ResultCEExtensions
  • public static a ResultBuilder.Source<a, b>(ResultBuilder _, a s) where a : IEnumerable<b>
• public static class ResultOption
  • public static FSharpResult<FSharpOption<Unit>, error> ignore<ok, error>(FSharpResult<FSharpOption<ok>, error> ro)
• public static class Seq
  • public static FSharpResult<IEnumerable<t>, e> sequenceResultM<t, e>(IEnumerable<FSharpResult<t, e>> xs)
• public static class Validation
  • public static FSharpResult<b, FSharpList<c>> apply<a, b, c>(FSharpResult<FSharpFunc<a, b>, FSharpList<c>> f, FSharpResult<a, FSharpList<c>> x)
  • public static FSharpResult<c, FSharpList<d>> map2<a, b, c, d>(FSharpFunc<a, FSharpFunc<b, c>> f, FSharpResult<a, FSharpList<d>> x, FSharpResult<b, FSharpList<d>> y)
  • public static FSharpResult<d, FSharpList<e>> map3<a, b, c, d, e>(FSharpFunc<a, FSharpFunc<b, FSharpFunc<c, d>>> f, FSharpResult<a, FSharpList<e>> x, FSharpResult<b, FSharpList<e>> y, FSharpResult<c, FSharpList<e>> z)
  • public static FSharpResult<a, FSharpList<b>> ofResult<a, b>(FSharpResult<a, b> x)
  • public static FSharpResult<a, FSharpList<b>> retn<a, b>(a x)
  • public static FSharpResult<okOutput, FSharpList<error>> apply<okInput, okOutput, error>(FSharpResult<FSharpFunc<okInput, okOutput>, FSharpList<error>> applier, FSharpResult<okInput, FSharpList<error>> input)
  • public static FSharpResult<okOutput, FSharpList<error>> bind<okInput, okOutput, error>(FSharpFunc<okInput, FSharpResult<okOutput, FSharpList<error>>> binder, FSharpResult<okInput, FSharpList<error>> input)
  • public static FSharpResult<ok, FSharpList<error>> error<error, ok>(error error)
  • public static FSharpResult<okOutput, FSharpList<error>> map<okInput, okOutput, error>(FSharpFunc<okInput, okOutput> mapper, FSharpResult<okInput, FSharpList<error>> input)
  • public static FSharpResult<okOutput, FSharpList<error>> map2<okInput1, okInput2, okOutput, error>(FSharpFunc<okInput1, FSharpFunc<okInput2, okOutput>> mapper, FSharpResult<okInput1, FSharpList<error>> input1, FSharpResult<okInput2, FSharpList<error>> input2)
  • public static FSharpResult<okOutput, FSharpList<error>> map3<okInput1, okInput2, okInput3, okOutput, error>(FSharpFunc<okInput1, FSharpFunc<okInput2, FSharpFunc<okInput3, okOutput>>> mapper, FSharpResult<okInput1, FSharpList<error>> input1, FSharpResult<okInput2, FSharpList<error>> input2, FSharpResult<okInput3, FSharpList<error>> input3)
  • public static FSharpResult<ok, FSharpList<errorOutput>> mapError<errorInput, errorOutput, ok>(FSharpFunc<errorInput, errorOutput> errorMapper, FSharpResult<ok, FSharpList<errorInput>> input)
  • public static FSharpResult<ok, FSharpList<errorOutput>> mapErrors<errorInput, errorOutput, ok>(FSharpFunc<FSharpList<errorInput>, FSharpList<errorOutput>> errorMapper, FSharpResult<ok, FSharpList<errorInput>> input)
  • public static FSharpResult<ok, FSharpList<error>> ofChoice<ok, error>(FSharpChoice<ok, error> choice)
  • public static FSharpResult<ok, FSharpList<error>> ofResult<ok, error>(FSharpResult<ok, error> result)
  • public static FSharpResult<ok, FSharpList<error>> ok<ok, error>(ok value)
  • public static FSharpResult<ok, FSharpList<errorOutput>> orElse<ok, errorOutput, errorInput>(FSharpResult<ok, FSharpList<errorOutput>> ifError, FSharpResult<ok, FSharpList<errorInput>> result)
  • public static FSharpResult<ok, FSharpList<errorOutput>> orElseWith<errorInput, ok, errorOutput>(FSharpFunc<FSharpList<errorInput>, FSharpResult<ok, FSharpList<errorOutput>>> ifErrorFunc, FSharpResult<ok, FSharpList<errorInput>> result)
  • public static FSharpResult<ok, FSharpList<error>> retn<ok, error>(ok value)
  • public static FSharpResult<ok, FSharpList<error>> returnError<error, ok>(error error)
  • public static FSharpResult<Tuple<left, right>, FSharpList<error>> zip<left, error, right>(FSharpResult<left, FSharpList<error>> left, FSharpResult<right, FSharpList<error>> right)
• public static class ValidationCE
  • public class ValidationBuilder
  • public static ValidationBuilder validation { get; }
• public static class ValidationCEExtensions
  • public static a ValidationBuilder.Source<a, b>(ValidationBuilder _, a s) where a : IEnumerable<b>
  • public static FSharpResult<ok, FSharpList<error>> ValidationBuilder.Source<ok, error>(ValidationBuilder _, FSharpResult<ok, error> s)
  • public static FSharpResult<ok, FSharpList<error>> ValidationBuilder.Source<ok, error>(ValidationBuilder _, FSharpChoice<ok, error> choice)
• public static class ValueOption
  • public static FSharpValueOption<b> bind<a, b>(FSharpFunc<a, FSharpValueOption<b>> f, FSharpValueOption<a> x)
  • public static FSharpValueOption<nullableValue> bindNull<value, nullableValue>(FSharpFunc<value, nullableValue> binder, FSharpValueOption<value> voption)
  • public static output either<a, output>(FSharpFunc<a, output> onSome, FSharpFunc<Unit, output> onNone, FSharpValueOption<a> input)
  • public static FSharpValueOption<b> map<a, b>(FSharpFunc<a, b> f, FSharpValueOption<a> x)
  • public static FSharpValueOption<nullableValue> ofNull<nullableValue>(nullableValue value)
  • public static FSharpValueOption<value> ofOption<value>(FSharpOption<value> opt)
  • public static FSharpValueOption<ok> ofResult<ok, error>(FSharpResult<ok, error> result)
  • public static FSharpResult<FSharpValueOption<okOutput>, error> sequenceResult<okOutput, error>(FSharpValueOption<FSharpResult<okOutput, error>> opt)
  • public static FSharpOption<value> toOption<value>(FSharpValueOption<value> vopt)
  • public static FSharpResult<FSharpValueOption<okOutput>, error> traverseResult<okInput, okOutput, error>(FSharpFunc<okInput, FSharpResult<okOutput, error>> binder, FSharpValueOption<okInput> input)
  • public static FSharpValueOption<value> tryGetValue<key, Dictionary, value>(key key, Dictionary dictionary)
  • public static FSharpValueOption<value> tryGetValue$W<key, Dictionary, value>(FSharpFunc<Dictionary, FSharpFunc<key, FSharpFunc<ref value, bool>>> tryGetValue, key key, Dictionary dictionary)
  • public static FSharpValueOption<value> tryParse<value>(string valueToParse)
  • public static FSharpValueOption<value> tryParse$W<value>(FSharpFunc<string, FSharpFunc<ref value, bool>> tryParse, string valueToParse)
  • public static FSharpValueOption<Tuple<left, right>> zip<left, right>(FSharpValueOption<left> left, FSharpValueOption<right> right)
• public static class ValueOptionCE
  • public class ValueOptionBuilder
  • public static ValueOptionBuilder voption { get; }
• public static class ValueOptionExtensions
  • public static a ValueOptionBuilder.Source<a, b>(ValueOptionBuilder _, a s) where a : IEnumerable<b>
  • public static FSharpValueOption<a> ValueOptionBuilder.Source<a>(ValueOptionBuilder _, a? nullable) where a : struct
• public static class ValueOptionExtensionsLower
  • public static FSharpValueOption<Tuple<e, f>> ValueOptionBuilder.MergeSources<e, f>(ValueOptionBuilder _, e nullableObj1, FSharpValueOption<f> option2)
  • public static FSharpValueOption<Tuple<c, d>> ValueOptionBuilder.MergeSources<c, d>(ValueOptionBuilder _, FSharpValueOption<c> option1, d nullableObj2)
  • public static FSharpValueOption<Tuple<a, b>> ValueOptionBuilder.MergeSources<a, b>(ValueOptionBuilder _, a nullableObj1, b nullableObj2)
  • public static FSharpValueOption<a> ValueOptionBuilder.Source<a>(ValueOptionBuilder _, a nullableObj)
  • public static FSharpValueOption<string> ValueOptionBuilder.Source(ValueOptionBuilder _, string m)

FsToolkit.ErrorHandling.Operator.AsyncOption

• public static class AsyncOption
  • public static FSharpAsync<FSharpOption<output>> op_GreaterGreaterEquals<input, output>(FSharpAsync<FSharpOption<input>> input, FSharpFunc<input, FSharpAsync<FSharpOption<output>>> binder)
  • public static FSharpAsync<FSharpOption<output>> op_LessBangGreater<input, output>(FSharpFunc<input, output> mapper, FSharpAsync<FSharpOption<input>> input)
  • public static FSharpAsync<FSharpOption<output>> op_LessMultiplyGreater<input, output>(FSharpAsync<FSharpOption<FSharpFunc<input, output>>> applier, FSharpAsync<FSharpOption<input>> input)

FsToolkit.ErrorHandling.Operator.AsyncResult

• public static class AsyncResult
  • public static FSharpAsync<FSharpResult<c, b>> op_GreaterGreaterEquals<a, b, c>(FSharpAsync<FSharpResult<a, b>> x, FSharpFunc<a, FSharpAsync<FSharpResult<c, b>>> f)
  • public static FSharpAsync<FSharpResult<b, c>> op_LessBangGreater<a, b, c>(FSharpFunc<a, b> f, FSharpAsync<FSharpResult<a, c>> x)
  • public static FSharpAsync<FSharpResult<b, c>> op_LessMultiplyGreater<a, b, c>(FSharpAsync<FSharpResult<FSharpFunc<a, b>, c>> f, FSharpAsync<FSharpResult<a, c>> x)
  • public static FSharpAsync<FSharpResult<okOutput, error>> op_GreaterGreaterEquals<input, error, okOutput>(FSharpAsync<FSharpResult<input, error>> input, FSharpFunc<input, FSharpAsync<FSharpResult<okOutput, error>>> binder)
  • public static FSharpAsync<FSharpResult<okOutput, error>> op_LessBangGreater<okInput, okOutput, error>(FSharpFunc<okInput, okOutput> mapper, FSharpAsync<FSharpResult<okInput, error>> input)
  • public static FSharpAsync<FSharpResult<okOutput, error>> op_LessMultiplyGreater<okInput, okOutput, error>(FSharpAsync<FSharpResult<FSharpFunc<okInput, okOutput>, error>> applier, FSharpAsync<FSharpResult<okInput, error>> input)

FsToolkit.ErrorHandling.Operator.AsyncResultOption

• public static class AsyncResultOption
  • public static FSharpAsync<FSharpResult<FSharpOption<c>, b>> op_GreaterGreaterEquals<a, b, c>(FSharpAsync<FSharpResult<FSharpOption<a>, b>> x, FSharpFunc<a, FSharpAsync<FSharpResult<FSharpOption<c>, b>>> f)
  • public static FSharpAsync<FSharpResult<FSharpOption<b>, c>> op_LessBangGreater<a, b, c>(FSharpFunc<a, b> f, FSharpAsync<FSharpResult<FSharpOption<a>, c>> x)
  • public static FSharpAsync<FSharpResult<FSharpOption<b>, c>> op_LessMultiplyGreater<a, b, c>(FSharpAsync<FSharpResult<FSharpOption<FSharpFunc<a, b>>, c>> f, FSharpAsync<FSharpResult<FSharpOption<a>, c>> x)
  • public static FSharpAsync<FSharpResult<FSharpOption<okOutput>, error>> op_GreaterGreaterEquals<okInput, error, okOutput>(FSharpAsync<FSharpResult<FSharpOption<okInput>, error>> input, FSharpFunc<okInput, FSharpAsync<FSharpResult<FSharpOption<okOutput>, error>>> binder)
  • public static FSharpAsync<FSharpResult<FSharpOption<okOutput>, error>> op_LessBangGreater<okInput, okOutput, error>(FSharpFunc<okInput, okOutput> mapper, FSharpAsync<FSharpResult<FSharpOption<okInput>, error>> input)
  • public static FSharpAsync<FSharpResult<FSharpOption<okOutput>, error>> op_LessMultiplyGreater<okInput, okOutput, error>(FSharpAsync<FSharpResult<FSharpOption<FSharpFunc<okInput, okOutput>>, error>> applier, FSharpAsync<FSharpResult<FSharpOption<okInput>, error>> input)

FsToolkit.ErrorHandling.Operator.Result

• public static class Result
  • public static FSharpResult<c, b> op_GreaterGreaterEquals<a, b, c>(FSharpResult<a, b> x, FSharpFunc<a, FSharpResult<c, b>> f)
  • public static FSharpResult<b, c> op_LessBangGreater<a, b, c>(FSharpFunc<a, b> f, FSharpResult<a, c> x)
  • public static FSharpResult<b, c> op_LessMultiplyGreater<a, b, c>(FSharpResult<FSharpFunc<a, b>, c> f, FSharpResult<a, c> x)
  • public static FSharpResult<okOutput, error> op_GreaterGreaterEquals<input, error, okOutput>(FSharpResult<input, error> input, FSharpFunc<input, FSharpResult<okOutput, error>> binder)
  • public static FSharpResult<okOutput, error> op_LessBangGreater<okInput, okOutput, error>(FSharpFunc<okInput, okOutput> mapper, FSharpResult<okInput, error> input)
  • public static FSharpResult<okOutput, error> op_LessMultiplyGreater<okInput, okOutput, error>(FSharpResult<FSharpFunc<okInput, okOutput>, error> applier, FSharpResult<okInput, error> input)

FsToolkit.ErrorHandling.Operator.Validation

• public static class Validation
  • public static FSharpResult<a, FSharpList<b>> op_LessBangGreater<a, a, b>(FSharpFunc<a, a> f, FSharpResult<a, FSharpList<b>> x)
  • public static FSharpResult<b, FSharpList<c>> op_LessBangHatGreater<a, b, c>(FSharpFunc<a, b> f, FSharpResult<a, c> x)
  • public static FSharpResult<b, FSharpList<c>> op_LessMultiplyGreater<a, b, c>(FSharpResult<FSharpFunc<a, b>, FSharpList<c>> f, FSharpResult<a, FSharpList<c>> x)
  • public static FSharpResult<b, FSharpList<c>> op_LessMultiplyHatGreater<a, b, c>(FSharpResult<FSharpFunc<a, b>, FSharpList<c>> f, FSharpResult<a, c> x)
  • public static FSharpResult<okOutput, FSharpList<error>> op_LessBangGreater<okInput, okOutput, error>(FSharpFunc<okInput, okOutput> mapper, FSharpResult<okInput, FSharpList<error>> input)
  • public static FSharpResult<okOutput, FSharpList<error>> op_LessBangHatGreater<okInput, okOutput, error>(FSharpFunc<okInput, okOutput> mapper, FSharpResult<okInput, error> input)
  • public static FSharpResult<okOutput, FSharpList<error>> op_LessMultiplyGreater<okInput, okOutput, error>(FSharpResult<FSharpFunc<okInput, okOutput>, FSharpList<error>> applier, FSharpResult<okInput, FSharpList<error>> input)
  • public static FSharpResult<okOutput, FSharpList<error>> op_LessMultiplyHatGreater<okInput, okOutput, error>(FSharpResult<FSharpFunc<okInput, okOutput>, FSharpList<error>> applier, FSharpResult<okInput, error> input)