async Task <Option <int> > AddAsync(int x)
{
await Task.Delay(100).ConfigureAwait(false);
Debug.Assert(SynchronizationContext.Current == null);
return(OptionModule.Some(x + 1));
}
public void Test5_1_Collections()
{
var m1 = new MegaType(
new[] { 0, 1 },
new FSharpMap <string, int>(new List <Tuple <string, int> > {
new Tuple <string, int>("key", 10)
}),
new FSharpSet <int>(new[] { 1 }),
new FSharpList <FSharpOption <int> >(new FSharpOption <int>(22), FSharpList <FSharpOption <int> > .Empty),
new[] { new[] { 0, 1 } },
new int[, ] {
}
);
Assert.True(MapModule.ContainsKey("key", m1.Maps));
var newSet = SetModule.Add(2, m1.Sets); //does not mutate set
Assert.NotEqual(newSet, m1.Sets);
if (OptionModule.IsSome(ListModule.Head(m1.Lists)))
{
Assert.Equal(22, ListModule.Head(m1.Lists).Value);
}
//Lists are linked lists, immutable and have structural equality
Assert.Equal(m1.Arrays, m1.ArrayofArrays[0]); //Structural equality
m1.Arrays[0] = 1;
Assert.Equal(m1.Arrays, new[] { 1, 1 }); //Arrays are mutable
}
public void OptionCountWhenSome()
{
Option <int> optionValue = 35;
int result = OptionModule.Count(optionValue);
Assert.AreEqual(1, result);
}
public void OptionFilterWhenFalse()
{
Option <int> optionValue = 35;
Option <int> result = OptionModule.Filter(_isEven, optionValue);
Assert.IsTrue(result.IsNone);
}
public static V Max <K, V>(this Series <K, V> series)
{
Series <K, V> series1 = series;
FSharpFunc <V, FSharpFunc <V, V> > fsharpFunc = (FSharpFunc <V, FSharpFunc <V, V> >) new SeriesStatsExtensions.Max <V>();
Series <K, V> series2 = series1;
V v = default(V);
bool flag = false;
IEnumerator <OptionalValue <V> > enumerator = FVectorextensionscore.IVector ` 1get_DataSequence < V > (series2.Vector).GetEnumerator();
try
{
while (enumerator.MoveNext())
{
OptionalValue <V> current = enumerator.Current;
if (current.HasValue)
{
v = !flag ? current.Value : (V)FSharpFunc <V, V> .InvokeFast <V>((FSharpFunc <V, FSharpFunc <V, M0> >) fsharpFunc, v, current.Value);
flag = true;
}
}
}
finally
{
(enumerator as IDisposable)?.Dispose();
}
return((V)OptionModule.GetValue <V>(!flag ? (FSharpOption <M0>)null : (FSharpOption <M0>)FSharpOption <V> .Some(v)));
}
public void OptionAsEnumerableWhenSome()
{
Option <int> optionValue = 35;
IEnumerable <int> result = OptionModule.AsEnumerable(optionValue);
Assert.AreEqual(1, result.Count());
}
public void OptionToListWhenSome()
{
Option <int> optionValue = 35;
List <int> result = OptionModule.ToList(optionValue);
Assert.AreEqual(1, result.Count);
}
public static FSharpOption <T2> Map <T1, T2>(this FSharpOption <T1> opt, Func <T1, T2> f)
{
return(OptionModule.Map(
FSharpFunc <T1, T2> .FromConverter(a => f(a)),
opt
));
}
public void OptionCountWhenNone()
{
Option <int> optionValue = Option <int> .None();
int result = OptionModule.Count(optionValue);
Assert.AreEqual(0, result);
}
public void OptionToListWhenNone()
{
Option <int> optionValue = Option <int> .None();
List <int> result = OptionModule.ToList(optionValue);
Assert.AreEqual(0, result.Count);
}
public void OptionOfNullableWhenNull()
{
int? value = null;
Option <int> optionValue =
OptionModule.OfNullable(value);
Assert.IsTrue(optionValue.IsNone);
}
public void OptionMapWhenNone()
{
Option <int> optionValue = Option <int> .None();
Option <bool> optionResult = OptionModule.Map(_isEven, optionValue);
Assert.IsTrue(optionResult.IsNone);
}
public void OptionToArrayWhenSome()
{
Option <int> optionValue = 35;
int[] result = OptionModule.ToArray(optionValue);
Assert.AreEqual(1, result.Length);
}
MapOptionAsync <X, Y>(this Task <Option <X> > @this, Func <X, Y> func)
{
foreach (var x in await @this.ConfigureAwait(false))
{
return(OptionModule.Some(func(x)));
}
return(Option <Y> .None);
}
public void OptionExistsWhenTrue()
{
bool expected = true;
Option <int> optionValue = 36;
bool result = OptionModule.Exists(_isEven, optionValue);
Assert.AreEqual(expected, result);
}
public void OptionToArrayWhenNone()
{
Option <int> optionValue = Option <int> .None();
int[] result = OptionModule.ToArray(optionValue);
Assert.AreEqual(0, result.Length);
}
public void OptionAsEnumerableWhenNone()
{
Option <int> optionValue = Option <int> .None();
IEnumerable <int> result = OptionModule.AsEnumerable(optionValue);
Assert.AreEqual(0, result.Count());
}
public void OptionToNullableWhenNone()
{
Option <int> optionValue = Option <int> .None();
int?result = OptionModule.ToNullable(optionValue);
Assert.IsFalse(result.HasValue);
}
public void OptionBindWhenNone()
{
Option <int> optionValue = Option <int> .None();
Option <int> optionResult = OptionModule.Bind(_squareWhenEven, optionValue);
Assert.IsTrue(optionResult.IsNone);
}
public void OptionToNullableWhenSome()
{
int expected = 35;
Option <int> optionValue = expected;
int? result = OptionModule.ToNullable(optionValue);
Assert.IsTrue(result.HasValue);
Assert.AreEqual(expected, result.Value);
}
public void OptionBindWhenSomeTrue()
{
int expected = 36;
Option <int> optionValue = 6;
Option <int> optionResult = OptionModule.Bind(_squareWhenEven, optionValue);
int result = optionResult.Match(value => value, () => 0);
Assert.AreEqual(expected, result);
}
public void OptionMapWhenSomeTrue()
{
Option <int> optionValue = 36;
Option <bool> optionResult = OptionModule.Map(_isEven, optionValue);
bool result = optionResult.Match(value => value, () => false);
Assert.IsTrue(optionResult.IsSome && result);
}
public void OptionIterateWhenSome()
{
Option <int> optionValue = 35;
int result = 0;
OptionModule.Iterate(value => result += value, optionValue);
Assert.AreEqual(35, result);
}
DoOptionAsync <X>(this Task <Option <X> > @this, Action <X> action)
{
foreach (var x in await @this.ConfigureAwait(false))
{
action(x);
return(OptionModule.Some(x));
}
return(Option <X> .None);
}
public void OptionExistsWhenNone()
{
bool expected = false;
Option <int> optionValue = Option <int> .None();
bool result = OptionModule.Exists(_isEven, optionValue);
Assert.AreEqual(expected, result);
}
MapOptionAsync <X, Y>(this Task <Option <X> > @this, Func <X, SynchronizationContext, Y> func)
{
var context = SynchronizationContext.Current;
foreach (var x in await @this.ConfigureAwait(false))
{
return(OptionModule.Some(func(x, context)));
}
return(Option <Y> .None);
}
public void OptionIterateWhenNone()
{
Option <int> optionValue = Option <int> .None();
int result = 0;
OptionModule.Iterate(value => result += value, optionValue);
Assert.AreEqual(0, result);
}
public void OptionFilterWhenTrue()
{
int expected = 36;
Option <int> optionValue = expected;
Option <int> optionResult = OptionModule.Filter(_isEven, optionValue);
int result = optionResult.Match(value => value, () => 0);
Assert.AreEqual(expected, result);
}
public void OptionMapWhenSomeFalse()
{
string expected = "Odd";
Option <int> optionValue = 35;
Option <string> optionResult = OptionModule.Map((value) => _isEven(value) ? "Even" : "Odd", optionValue);
string result = optionResult.Match(value => value, () => string.Empty);
Assert.AreEqual(expected, result);
}
public static FsCodec.IEventCodec <TEvent, byte[], object> Create <TEvent>(
Func <TEvent, Tuple <string, byte[]> > encode,
Func <string, byte[], TEvent> tryDecode) where TEvent : class
{
return(FsCodec.Codec.Create(
FuncConvert.FromFunc(encode),
FuncConvert.FromFunc((Func <Tuple <string, byte[]>, FSharpOption <TEvent> >)TryDecodeImpl)));
FSharpOption <TEvent> TryDecodeImpl(Tuple <string, byte[]> encoded) => OptionModule.OfObj(tryDecode(encoded.Item1, encoded.Item2));
}
