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);
