public void Select2() { var a = FSharpResult.NewError <int, string>("hello"); var b = a.Select(i => i + 2); b.Match(_ => Assert.Fail("is int"), s => Assert.AreEqual("hello", s)); }
/// <summary> /// Fetches a business data snapshot from blob storage. /// </summary> /// <param name="cancellationToken">the CancellationToken.</param> /// <returns>the most recent snapshot.</returns> public async Task <FSharpResult <BusinessData <TBusinessData>, BusinessDataUpdateError> > FetchBusinessDataSnapshot(CancellationToken cancellationToken) { try { FSharpOption <(Watermark, string)> someWatermarkAndName = await this.GetLatestSnapshotID(cancellationToken); if (FSharpOption <(Watermark, string)> .get_IsNone(someWatermarkAndName)) { var emptyBusinessData = new BusinessData <TBusinessData>( data: this.createEmptyBusinessData(), watermark: Watermark.NewWatermark(-1)); return(FSharpResult <BusinessData <TBusinessData>, BusinessDataUpdateError> .NewOk(emptyBusinessData)); } var(watermark, blobName) = someWatermarkAndName.Value; await Console.Out.WriteLineAsync($"Loading snapshot watermark {watermark.Item} from {blobName}"); var blobClient = this.snapshotContainerClient.GetBlobClient(blobName: blobName); var result = await blobClient.DownloadAsync(cancellationToken : cancellationToken); var val = await result.Value.Content.ReadJSON <BusinessData <TBusinessData> >(); return(FSharpResult <BusinessData <TBusinessData>, BusinessDataUpdateError> .NewOk(val)); } catch (Exception ex) { return(FSharpResult <BusinessData <TBusinessData>, BusinessDataUpdateError> .NewError( BusinessDataUpdateError.NewSnapshotDownloadError(ex))); } }
private void ThrowIfError <T>(FSharpResult <T, string> result) { if (result.IsError) { errorThrower(Error.General(result.ErrorValue)); } }
public void Select() { var a = FSharpResult.NewOk <int, string>(5); var b = a.Select(i => i + 2); b.Match(i => Assert.AreEqual(7, i), _ => Assert.Fail("is string")); }
/// <summary> /// Converts a compile-time unknown <see cref="FSharpResult{T, TError}"/> into an <c>FSharpResult<TResult, string></c>. /// </summary> /// <typeparam name="TResult">The type of result you expect.</typeparam> /// <param name="result">An unknown instance of a <see cref="FSharpResult{T, TError}"/></param> /// <returns>An <c>FSharpResult<TResult, string></c> where <typeparamref name="TResult"/> is your expected result type and the error is a <see cref="string"/></returns> /// <exception cref="ArgumentNullException">The result is null.</exception> /// <exception cref="NotSupportedException">The result is not one of the supported conversions.</exception> public static FSharpResult <TResult, string> ResultFromFSharp <TResult>(this object result) { if (result is null) { throw new ArgumentNullException(nameof(result)); } switch (result) { case FSharpResult <TResult, string> typedResult: return(typedResult); case FSharpResult <TResult, object> typedResult: if (typedResult.IsOk) { return(FSharpResult <TResult, string> .NewOk(typedResult.ResultValue)); } else { throw new NotSupportedException($"Error value is not a 'string' it is a '{typedResult.ErrorValue.GetType().Name}'."); } case FSharpResult <object, string> typedResult: if (typedResult.IsError) { return(FSharpResult <TResult, string> .NewError(typedResult.ErrorValue)); } else { throw new NotSupportedException($"Result value is not a '{typeof(TResult).Name}' it is a '{typedResult.ErrorValue.GetType().Name}'."); } default: throw new NotSupportedException($"Unknown result type '{result.GetType().Name}'."); } }
public void CanConvertToAndFromAnFSharpResult() { Error <int, string>("didn't work").ToFs().ShouldBe(FSharpResult <int, string> .NewError("didn't work")); Ok <int, string>(10).ToFs().ShouldBe(FSharpResult <int, string> .NewOk(10)); Result.FromFs(Error <int, string>("didn't work").ToFs()).ShouldBe(Error <int, string>("didn't work")); Result.FromFs(Ok <int, string>(10).ToFs()).ShouldBe(Ok <int, string>(10)); }
public void Cast_OK() { object a = 40; FSharpResult.Cast <int>(a) .Match(i => Assert.AreEqual(40, i), e => Assert.Fail(e.Message)); }
public void Cast_Exception() { object a = "hello"; FSharpResult.Cast <int>(a) .Match(i => Assert.Fail("should not have succeeded with value {0}", i), e => {}); }
public void Match() { var a = FSharpResult <int, string> .NewOk(1); var c = a.Match(i => 0, _ => 1); Assert.AreEqual(0, c); }
public void ChoiceToOption() { object a = 40; const string b = "60"; var r = from i in FSharpOption.ParseInt(b) from j in FSharpResult.Cast <int>(a).ToFSharpOption() select i + j; Assert.AreEqual(100.Some(), r); }
public void OptionToChoice() { object a = 40; const string b = "60"; var r = from i in FSharpOption.ParseInt(b).ToFSharpResult(new Exception()) from j in FSharpResult.Cast <int>(a) select i + j; r.Match(i => Assert.AreEqual(100, i), e => Assert.Fail(e.Message)); }
// public string Name; // public Visa.Status StatusC; // public Person.Person Person; // public PersonC2(Person.Person person){ // Name = person.Name; // StatusC = person.Status; // } // public Visa.Status status2 = Visa.Status.Student; public static FSharpResult <Person.Person, string> ValidateStudentC(Person.Person person) { if (person.Status == Visa.Status.Student) { return(FSharpResult <Person.Person, string> .NewOk(person)); } else { return(FSharpResult <Person.Person, string> .NewError("Tourist")); } }
public void SelectSecond_OK() { object a = 40; const string b = "60"; var r = from i in FSharpOption.ParseInt(b).ToFSharpResult("Invalid value b") from j in FSharpResult.Cast <int>(a).SelectError(_ => "Invalid value a") select i + j; r.Match(i => Assert.AreEqual(100, i), Assert.Fail); }
public void SelectSecond_Error() { object a = 40; const string b = "xx"; var r = from i in FSharpOption.ParseInt(b).ToFSharpResult("Invalid value b") from j in FSharpResult.Cast <int>(a).SelectError(_ => "Invalid value a") select i + j; r.Match(i => Assert.Fail("should not have succeeded with value {0}", i), e => Assert.AreEqual("Invalid value b", e)); }
public FSharpResult <int, string> WorkflowStep1(int input) { if (input % 2 == 0) { return(FSharpResult <int, string> .NewError("Sholud be odd")); } else { var result = input * 356; return(FSharpResult <int, string> .NewOk(result)); } }
public static FSharpResult <TOk1, TError> Map <TOk, TError, TOk1>(this FSharpResult <TOk, TError> result, Func <TOk, TOk1> continuation) { if (result.IsError) { return(FSharpResult <TOk1, TError> .NewError(result.ErrorValue)); } else { return(FSharpResult <TOk1, TError> .NewOk(continuation(result.ResultValue))); } }
public FSharpResult <decimal, string> WorkflowStep2(int input) { if (input % 3 == 0) { return(FSharpResult <decimal, string> .NewError("Sholud not be dividable by 3")); } else { var result = input * 100.0m / 356; return(FSharpResult <decimal, string> .NewOk(result)); } }
public void New() { var a = FSharpResult.NewOk <int, string>(1); var b = FSharpResult <int, string> .NewOk(1); Assert.AreEqual(a, b); var c = FSharpResult.NewError <int, string>("a"); var d = FSharpResult <int, string> .NewError("a"); Assert.AreEqual(c, d); }
public static void Handle <TOk>(this FSharpResult <TOk, string> r, IToastService toastService, ref TOk ok, ref string error) { if (r.IsOk) { ok = r.ResultValue; } else { error = string.IsNullOrWhiteSpace(error) ? r.ErrorValue : $"{error} {r.ErrorValue}"; toastService.ShowError(error); } }
public void Controller_Error_Is_Thrown() { sut.ModelUpdateRequired += delegate(Action <IPreferencesStateController> action) { var prefsController = Mock.Of <IPreferencesStateController>(); Mock.Get(prefsController) .Setup(x => x.SetEnginesPathConfig(It.IsAny <string>())) .Returns(FSharpResult <Unit, string> .NewError("Something went very very wrong!")); action(prefsController); }; sut.GeneralConfig.EnginesPathConfig.SetValue(new DirectoryInfo("path/to/exile")); Assert.That(thrownErrors.Count, Is.EqualTo(1)); Assert.That(thrownErrors[0].Message, Is.EqualTo("Something went very very wrong!")); }
public async Task <IObservable <BusinessData <TBusinessData> > > CreateObservable(CancellationToken cancellationToken = default) { this.cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); this.deletetionTask = Task.Run(() => this.DeleteOldSnapshots( maxAge: TimeSpan.FromDays(1), sleepTime: TimeSpan.FromMinutes(1), cancellationToken: this.cts.Token)); var updateFunc = this.applyUpdate.ToFSharpFunc(); FSharpResult <BusinessData <TBusinessData>, BusinessDataUpdateError> snapshotResult = await this.FetchBusinessDataSnapshot(this.cts.Token); if (snapshotResult.IsError) { return(Observable.Throw <BusinessData <TBusinessData> >(((BusinessDataUpdateError.SnapshotDownloadError)snapshotResult.ErrorValue).Item)); } var snapshot = snapshotResult.ResultValue; IConnectableObservable <BusinessData <TBusinessData> > connectableObservable = this.updateMessagingClient .CreateWatermarkObervable( startingPosition: SeekPosition.NewFromWatermark( snapshot.Watermark.Add(1)), cancellationToken: this.cts.Token) .Scan( seed: snapshotResult, accumulator: (businessData, updateMessage) => updateBusinessData(updateFunc, businessData, updateMessage)) // .Where(d => d.IsOk) .Select(d => d.ResultValue) .StartWith(snapshot) .Publish(initialValue: snapshot); _ = connectableObservable.Connect(); return(connectableObservable.AsObservable()); }
public void FSharpResultsHaveAnExtensionMethodToConvertToTheCSharpResultType() { FSharpResult <int, string> .NewOk(5).ToCs().ShouldSatisfy(it => it is Result <int, string>); }
public void MatchAction() { var a = FSharpResult <int, string> .NewOk(1); a.Match(Console.WriteLine, _ => Assert.Fail("is string")); }
public sealed override bool Equals(FSharpResult<T, TError> obj);
public sealed override int CompareTo(FSharpResult<T, TError> obj);
private ContentResult _Back(int index, FSharpResult <RevisionView, string> view) => (view.IsError ? view.ErrorValue : view.ResultValue.FrontBackFrontSynthBackSynthIndex(index).IsError ? view.ResultValue.FrontBackFrontSynthBackSynthIndex(index).ErrorValue : view.ResultValue.FrontBackFrontSynthBackSynthIndex(index).ResultValue.Item2).ToTextHtmlContent(this);