public static void LinqRwsTest()
{
var cxt = new RwsCxt <Dictionary <int, int>, IList <string>, Monoid.ListAppendImmutableMonoid <string>, int>();
var computation =
from x in MaybeT.Lift(cxt.Get())
from _1 in MaybeT.Lift(cxt.Tell(FuncList.Make("function call 1")))
from _2 in MaybeT.Lift(cxt.Put(x + 3))
from env in MaybeT.Lift(cxt.GetEnvironment())
from _3 in MaybeT.Lift(cxt.Tell(FuncList.Make("function call 2")))
from twice in MaybeT.HoistRws(cxt, Maybe.JustIf(env.ContainsKey(x), () => env[x]))
from _4 in MaybeT.Lift(cxt.Tell(FuncList.Make("function call 3")))
from _5 in MaybeT.Lift(cxt.Put(x + 10))
from y in MaybeT.Lift(cxt.Get())
from _6 in MaybeT.Lift(cxt.Put(y + x))
from goodKey in MaybeT.HoistRws(cxt, Maybe.Just(1))
select x + twice;
var(value, state, output) = computation.Run.Run(new Dictionary <int, int> {
{ 1, 2 }, { 4, 8 }, { 16, 32 }
}, 16);
Assert.True(value.HasValue);
Assert.Equal(16 + 32, value.Value());
Assert.Equal(16 + 26, state);
Assert.Equal(new[] { "function call 1", "function call 2", "function call 3" }, (IEnumerable <string>)output);
(value, state, output) = computation.Run.Run(new Dictionary <int, int> {
{ 1, 2 }, { 4, 8 }, { 16, 32 }
}, 17);
Assert.False(value.HasValue);
Assert.Equal(20, state);
Assert.Equal(new[] { "function call 1", "function call 2" }, (IEnumerable <string>)output);
}
public void FoldTest()
{
var fl = FuncList.Make <int>();
var fold = L.Make.Folding <FuncList <int>, FuncList <int>, int>(x => x);
var actual = L.Fold <FuncList <int>, int, int, Group.IntAddGroup>(fold, x => x, fl);
Assert.Equal(0, actual);
actual = L.Fold(fold, x => new IntMult(x), fl).Value;
Assert.Equal(1, actual);
actual = L.Fold(fold, (x, y) => x * y, 1, fl);
Assert.Equal(1, actual);
fl = FuncList.Make(1, 2, 3, 4);
actual = L.Fold <FuncList <int>, int, int, Group.IntAddGroup>(fold, x => x, fl);
Assert.Equal(10, actual);
actual = L.Fold(fold, x => new IntMult(x), fl).Value;
Assert.Equal(24, actual);
actual = L.Fold(fold, (x, y) => x * y, 1, fl);
Assert.Equal(24, actual);
}
public static void LinqWriterTest()
{
var cxt = new WriterCxt <IList <string>, Monoid.ListAppendImmutableMonoid <string> >();
bool m = true;
var computation =
from _1 in MaybeT.Lift(cxt.Tell(FuncList.Make("function call 1")))
from _2 in MaybeT.Lift(cxt.Tell(FuncList.Make("function call 2")))
from _3 in MaybeT.HoistWriter(cxt, Maybe.JustIf(m, () => new Unit()))
from _4 in MaybeT.Lift(cxt.Tell(FuncList.Make("function call 3")))
select 5;
var value = computation.Run;
Assert.True(value.Result.HasValue);
Assert.Equal(5, value.Result.Value());
Assert.Equal(new[] { "function call 1", "function call 2", "function call 3" }, (IEnumerable <string>)value.State);
m = false;
computation =
from _1 in MaybeT.Lift(cxt.Tell(FuncList.Make("function call 1")))
from _2 in MaybeT.Lift(cxt.Tell(FuncList.Make("function call 2")))
from _3 in MaybeT.HoistWriter(cxt, Maybe.JustIf(m, () => new Unit()))
from _4 in MaybeT.Lift(cxt.Tell(FuncList.Make("function call 3")))
select 5;
value = computation.Run;
Assert.False(value.Result.HasValue);
Assert.Equal(new[] { "function call 1", "function call 2" }, (IEnumerable <string>)value.State);
}
public static void LinqFuncListTest()
{
var init = 5;
var computation =
from x in MaybeT.Lift(FuncList.Make("a", "b", "c"))
from y in MaybeT.Lift(FuncList.Make("c", "d", "e"))
from _ in MaybeT.HoistFuncList(Maybe.JustIf(init > 0, () => new Unit()))
from z in MaybeT.Lift(FuncList.Make("f"))
select x + y + z;
var value = computation.Run;
var expected = new[] { "acf", "adf", "aef", "bcf", "bdf", "bef", "ccf", "cdf", "cef" }.Select(x => Maybe.Just(x)).MakeFuncList();
Assert.Equal(expected, value);
init = 0;
computation =
from x in MaybeT.Lift(FuncList.Make("a", "b", "c"))
from y in MaybeT.Lift(FuncList.Make("c", "d", "e"))
from _ in MaybeT.HoistFuncList(Maybe.JustIf(init > 0, () => new Unit()))
from z in MaybeT.Lift(FuncList.Make("f"))
select x + y + z;
value = computation.Run;
expected = Enumerable.Repeat(Maybe.Nothing <string>(), 9).MakeFuncList();
Assert.Equal(expected, value);
}
public static async Task LinqSelectAsyncTest()
{
var res =
from x in Task.FromResult(FuncList.Make(4, 3, 2))
select x * 2;
Assert.Equal(new int[] { 8, 6, 4 }, await res);
}
public static void LinqSelectTest()
{
var res =
from x in FuncList.Make(4, 3, 2)
select x * 2;
Assert.Equal(new int[] { 8, 6, 4 }, res);
}
public static IEnumerable <object[]> Ap2Data()
{
yield return(new object[] {
FuncList.Make <Func <int, Func <int, int> > >(),
FuncList.Make <int>(),
FuncList.Make <int>(),
FuncList.Make <int>(),
});
yield return(new object[] {
FuncList.Make <Func <int, Func <int, int> > >(),
FuncList.Make(1),
FuncList.Make <int>(),
FuncList.Make <int>(),
});
yield return(new object[] {
FuncList.Make <Func <int, Func <int, int> > >(),
FuncList.Make(1),
FuncList.Make(1),
FuncList.Make <int>(),
});
yield return(new object[] {
FuncList.Make <Func <int, Func <int, int> > >(x => y => x + y),
FuncList.Make <int>(),
FuncList.Make <int>(),
FuncList.Make <int>(),
});
yield return(new object[] {
FuncList.Make <Func <int, Func <int, int> > >(x => y => x + y),
FuncList.Make(4),
FuncList.Make(6),
FuncList.Make(10),
});
yield return(new object[] {
FuncList.Make <Func <int, Func <int, int> > >(x => y => x + y),
FuncList.Make(1, 2, 3),
FuncList.Make(7, 8, 9),
FuncList.Make(8, 9, 10, 9, 10, 11, 10, 11, 12),
});
yield return(new object[] {
FuncList.Make <Func <int, Func <int, int> > >(x => y => x + y, x => y => x * y),
FuncList.Make(5),
FuncList.Make(8),
FuncList.Make(13, 40),
});
yield return(new object[] {
FuncList.Make <Func <int, Func <int, int> > >(x => y => x + y, x => y => x * y),
FuncList.Make(5, 6, 7),
FuncList.Make(10, 20, 30),
FuncList.Make(15, 25, 35, 16, 26, 36, 17, 27, 37, 50, 100, 150, 60, 120, 180, 70, 140, 210),
});
}
public static void LinqSelectManyTest()
{
var res =
from x in FuncList.Make(2, 3, 5)
from y in FuncList.Make(7, 11, 13)
select x *y;
Assert.Equal(new int[] { 14, 22, 26, 21, 33, 39, 35, 55, 65 }, res);
}
public static async Task LinqSelectManyAsyncTest()
{
var res =
from x in Task.FromResult(FuncList.Make(2, 3, 5))
from y in Task.FromResult(FuncList.Make(7, 11, 13))
select x *y;
Assert.Equal(new int[] { 14, 22, 26, 21, 33, 39, 35, 55, 65 }, await res);
}
public static IEnumerable <object[]> SetOperatorsData()
{
yield return(new object[]
{
FuncList.Make <Person>(),
FuncList.Make <Person>(),
Maybe.Just(0)
});
}
public static void SelectApForLists(IEnumerable <int> input, IEnumerable <IEnumerable <int> > output)
{
var res = input.SelectAp <int, int, FuncList <IEnumerable <int> > >(x => FuncList.Make(x, x * (-1)))
.ToFuncList()
.Select(x => string.Join(',', x)).ToHashSet();
var outputSet = output.Select(x => string.Join(',', x)).ToHashSet();
Assert.Equal(outputSet, res);
}
public static void TraverseTest()
{
var m = Identity.Make(7);
var actual1 = m.Traverse <FuncList <int>, int>(i => FuncList.Make(i + 1)).Map(x => x.ToIdentity()).ToFuncList();
var actual2 = m.Map(x => (x + 1).PureUnsafe <int, FuncList <int> >()).ToIdentity().Traverse <FuncList <int>, int>().Map(x => x.ToIdentity()).ToFuncList();
Assert.Single(actual1);
Assert.Equal(8, actual1[0].Value);
Assert.Single(actual2);
Assert.Equal(8, actual2[0].Value);
}
public static IEnumerable <object[]> EqualsData()
{
yield return(new object[] {
FuncList.Make <int>(),
FuncList.Make <int>(),
true
});
yield return(new object[] {
FuncList.Make(1),
FuncList.Make(1),
true
});
yield return(new object[] {
FuncList.Make(1, 2, 3),
FuncList.Make(1, 2, 3),
true
});
yield return(new object[] {
FuncList.Make(4),
FuncList.Make <int>(),
false
});
yield return(new object[] {
FuncList.Make <int>(),
FuncList.Make(7),
false
});
yield return(new object[] {
FuncList.Make(1, 2),
FuncList.Make(5, 6),
false
});
yield return(new object[] {
FuncList.Make(1, 2),
FuncList.Make(1),
false
});
yield return(new object[] {
FuncList.Make(1, 2, 3),
FuncList.Make(1, 2, 3, 4),
false
});
}
public void TraverseMaybeTest()
{
var m = Maybe.Nothing <int>();
var lens = L.Make.Traversal <Maybe <int>, Maybe <string>, int, string>();
var actual = L.Traverse(lens, typeof(FuncList <string>), a => FuncList.Make(a + ""), m).ToFuncList();
Assert.Single(actual);
Assert.False(actual[0].HasValue);
m = Maybe.Just(6);
actual = L.Traverse(lens, typeof(FuncList <string>), a => FuncList.Make(a + ""), m).ToFuncList();
Assert.Single(actual);
Assert.Equal("6", actual[0].Value());
}
public void ToListTest()
{
var fl = FuncList.Make <int>();
var fold = L.Make.Folding <FuncList <int>, FuncList <int>, int>(x => x);
var actual = L.ToList(fold, fl);
Assert.Empty(actual);
fl = FuncList.Make(1);
actual = L.ToList(fold, fl);
Assert.Equal(new int[] { 1 }, actual);
fl = FuncList.Make(1, 2, 3);
actual = L.ToList(fold, fl);
Assert.Equal(new int[] { 1, 2, 3 }, actual);
}
public void FoldThen()
{
var foldOuter = L.Make.Folding <FuncList <FuncList <int> >, FuncList <int> >();
var foldInner = L.Make.Folding <FuncList <int>, int>();
var fold = foldOuter.Then(foldInner);
var fl = FuncList.Make <FuncList <int> >();
var actual = L.Fold(fold, (x, y) => x + y, 0, fl);
Assert.Equal(0, actual);
fl = FuncList.Make(FuncList.Make <int>(), FuncList.Make(1, 2, 3), FuncList.Make <int>(), FuncList.Make(4, 5, 6));
actual = L.Fold(fold, (x, y) => x + y, 0, fl);
Assert.Equal(21, actual);
}
public static IEnumerable <object[]> Ap1Data()
{
yield return(new object[] {
FuncList.Make <Func <int, int> >(),
FuncList.Make <int>(),
FuncList.Make <int>(),
});
yield return(new object[] {
FuncList.Make <Func <int, int> >(),
FuncList.Make(1),
FuncList.Make <int>(),
});
yield return(new object[] {
FuncList.Make <Func <int, int> >(x => x + 1),
FuncList.Make <int>(),
FuncList.Make <int>(),
});
yield return(new object[] {
FuncList.Make <Func <int, int> >(x => x + 1),
FuncList.Make(4),
FuncList.Make(5),
});
yield return(new object[] {
FuncList.Make <Func <int, int> >(x => x + 1),
FuncList.Make(1, 2, 3),
FuncList.Make(2, 3, 4),
});
yield return(new object[] {
FuncList.Make <Func <int, int> >(x => x + 1, x => x * 2),
FuncList.Make(5),
FuncList.Make(6, 10),
});
yield return(new object[] {
FuncList.Make <Func <int, int> >(x => x + 1, x => x * 2),
FuncList.Make(5, 6, 7),
FuncList.Make(6, 7, 8, 10, 12, 14),
});
}
public static void TraverseTest()
{
var arr = FuncList.Make <int>();
var actual = arr.Traverse <Maybe <string>, string>(x => Maybe.JustIf(x % 2 == 0, () => x + "_" + x)).ToMaybe();
Assert.True(actual.HasValue);
Assert.Empty(actual.Value());
arr = FuncList.Make <int>(0, 2, 4, 10, 8);
actual = arr.Traverse <Maybe <string>, string>(x => Maybe.JustIf(x % 2 == 0, () => x + "_" + x)).ToMaybe();
Assert.True(actual.HasValue);
Assert.Equal(new string[] { "0_0", "2_2", "4_4", "10_10", "8_8" }, actual.Value());
arr = FuncList.Make <int>(0, 2, 5, 4, 10, 8);
actual = arr.Traverse <Maybe <string>, string>(x => Maybe.JustIf(x % 2 == 0, () => x + "_" + x)).ToMaybe();
Assert.False(actual.HasValue);
}
public void TraveseFuncListTest()
{
var m = FuncList.Make <int>();
var lens = L.Make.Traversal <FuncList <int>, FuncList <string>, int, string>();
var actual = L.Traverse(lens, typeof(Maybe <string>), a => Maybe.Just(a + "_" + a), m).ToMaybe();
Assert.Equal(Array.Empty <string>(), actual.Value());
m = FuncList.Make(1, 2, 3);
actual = L.Traverse(lens, typeof(Maybe <string>), a => Maybe.Just(a + "_" + a), m).ToMaybe();
Assert.Single(actual);
Assert.Equal(new string[] { "1_1", "2_2", "3_3" }, actual.Value());
actual = L.Traverse(lens, a => Maybe.Just(a + "_" + a), m).ToMaybe();
Assert.Equal(new string[] { "1_1", "2_2", "3_3" }, actual.Value());
actual = L.Traverse(lens, typeof(Maybe <string>), a => Maybe.JustIf(a % 2 == 0, () => a + "_" + a), m).ToMaybe();
Assert.False(actual.HasValue);
}
public static void TraverseTest()
{
var m = Maybe.Nothing <int>();
var actual1 = m.Traverse <FuncList <int>, int>(i => FuncList.Make(i + 1)).Map(x => x.ToMaybe()).ToFuncList();
var actual2 = m.Map(x => (x + 1).PureUnsafe <int, FuncList <int> >()).ToMaybe().Traverse <FuncList <int>, int>().Map(x => x.ToMaybe()).ToFuncList();
Assert.Single(actual1);
Assert.False(actual1[0].HasValue);
Assert.Single(actual2);
Assert.False(actual2[0].HasValue);
m = Maybe.Just(7);
actual1 = m.Traverse <FuncList <int>, int>(i => FuncList.Make(i + 1)).Map(x => x.ToMaybe()).ToFuncList();
actual2 = m.Map(x => (x + 1).PureUnsafe <int, FuncList <int> >()).ToMaybe().Traverse <FuncList <int>, int>().Map(x => x.ToMaybe()).ToFuncList();
Assert.Single(actual1);
Assert.Equal(8, actual1[0].Value());
Assert.Single(actual2);
Assert.Equal(8, actual2[0].Value());
}
public void WitherTest()
{
var lens = L.Make.Withering <FuncList <string>, FuncList <int>, string, int>();
var actual = L.TraverseMaybe(lens, typeof(Maybe <int>), s => Maybe.JustIf(s.Length % 2 == 0, () => s.Length), FuncList.Make <string>()).ToMaybe();
Assert.Equal(new int[] { }, actual.Value());
actual = L.TraverseMaybe(lens, typeof(Maybe <int>), s => Maybe.JustIf(s.Length % 2 == 0, () => s.Length), FuncList.Make("a")).ToMaybe();
Assert.Equal(new int[] { }, actual.Value());
actual = L.TraverseMaybe(lens, typeof(Maybe <int>), s => Maybe.JustIf(s.Length % 2 == 0, () => s.Length), FuncList.Make("bb")).ToMaybe();
Assert.Equal(new int[] { 2 }, actual.Value());
actual = L.TraverseMaybe(lens, typeof(Maybe <int>), s => Maybe.JustIf(s.Length % 2 == 0, () => s.Length), FuncList.Make("a", "bb", "cccc", "", "gg")).ToMaybe();
Assert.Equal(new int[] { 2, 4, 0, 2 }, actual.Value());
}
public async static void SelectApAsyncForLists(IEnumerable <int> input, IEnumerable <IEnumerable <int> > output)
{
var res = (await input.SelectApAsync <int, int, FuncList <IEnumerable <int> > >(async x => { await Task.Delay(500); return(FuncList.Make(x, x * (-1))); }))
.ToFuncList()
.Select(x => string.Join(',', x)).ToHashSet();
var outputSet = output.Select(x => string.Join(',', x)).ToHashSet();
Assert.Equal(outputSet, res);
}
public static void LinqTellIntSelectTest()
{
var rws =
from env in Rws.GetEnvironment <Dictionary <int, string>, IList <int>, Monoid.ListAppendImmutableMonoid <int>, int>()
from s in Rws.Get <Dictionary <int, string>, IList <int>, Monoid.ListAppendImmutableMonoid <int>, int>()
from _ in Rws.Put <Dictionary <int, string>, IList <int>, Monoid.ListAppendImmutableMonoid <int>, int>(s + 1)
from __ in Rws.Tell <Dictionary <int, string>, IList <int>, Monoid.ListAppendImmutableMonoid <int>, int>(FuncList.Make(28))
select env[s] + 2;
var dict = new Dictionary <int, string>
{
{ 5, "e" }
};
var(res, state, w) = rws.Run(dict, 5);
Assert.Equal("e2", res);
Assert.Equal(6, state);
Assert.Equal(new int[] { 28 }, w);
}
public async static void WhereApAsyncForLists(IEnumerable <int> input, IEnumerable <IEnumerable <int> > output)
{
var res = (await input.WhereApAsync <int, FuncList <bool>, FuncList <IEnumerable <int> > >(async _ => { await Task.Delay(500); return(FuncList.Make(false, true)); }))
.Select(x => string.Join(',', x)).ToHashSet();
var outputSet = output.Select(x => string.Join(',', x)).ToHashSet();
Assert.Equal(outputSet, res);
}
public static void WhereApForLists(IEnumerable <int> input, IEnumerable <IEnumerable <int> > output)
{
var res = input.WhereAp <int, FuncList <bool>, FuncList <IEnumerable <int> > >(_ => FuncList.Make(false, true))
.Select(x => string.Join(',', x)).ToHashSet();
var outputSet = output.Select(x => string.Join(',', x)).ToHashSet();
Assert.Equal(outputSet, res);
}
public void TraverseThenTest()
{
var outer = L.Make.Traversal <FuncList <FuncList <int> >, FuncList <FuncList <string> >, FuncList <int>, FuncList <string> >();
var inner = L.Make.Traversal <FuncList <int>, FuncList <string>, int, string>();
var combined = outer.Then(inner);
var actual = L.Traverse(combined, typeof(Maybe <string>), i => Maybe.Just(i + ""), FuncList.Make <FuncList <int> >()).ToMaybe();
Assert.Empty(actual.Value());
actual = L.Traverse(combined, typeof(Maybe <string>), i => Maybe.Just(i + ""), FuncList.Make(FuncList.Make <int>())).ToMaybe();
Assert.Single(actual.Value());
Assert.Empty(actual.Value()[0]);
actual = L.Traverse(combined, typeof(Maybe <string>), i => Maybe.JustIf(i % 2 == 0, () => i + ""), FuncList.Make(FuncList.Make(0, 2, 4, 6), FuncList.Make(10, 12))).ToMaybe();
Assert.Equal(2, actual.Value().Count);
Assert.Equal(new string[] { "0", "2", "4", "6" }, actual.Value()[0]);
Assert.Equal(new string[] { "10", "12" }, actual.Value()[1]);
actual = L.Traverse(combined, typeof(Maybe <string>), i => Maybe.JustIf(i % 2 == 0, () => i + ""), FuncList.Make(FuncList.Make(0, 1, 2, 4, 6), FuncList.Make(10, 12))).ToMaybe();
Assert.False(actual.HasValue);
}
public void WitherThenTest()
{
var lensOuter = L.Make.Withering <FuncList <FuncList <string> >, FuncList <FuncList <int> >, FuncList <string>, FuncList <int> >();
var lensInner = L.Make.Withering <FuncList <string>, FuncList <int>, string, int>();
var lens = lensOuter.Then(lensInner);
var actual = L.TraverseMaybe(lens, typeof(Maybe <int>), s => Maybe.JustIf(s.Length % 2 == 0, () => s.Length), FuncList.Make <FuncList <string> >()).ToMaybe();
Assert.Empty(actual.Value());
actual = L.TraverseMaybe(lens, typeof(Maybe <int>), s => Maybe.JustIf(s.Length % 2 == 0, () => s.Length), FuncList.Make(FuncList.Make <string>())).ToMaybe();
Assert.Single(actual.Value());
Assert.Equal(new int[] { }, actual.Value()[0]);
actual = L.TraverseMaybe(lens, typeof(Maybe <int>), s => Maybe.JustIf(s.Length % 2 == 0, () => s.Length), FuncList.Make(FuncList.Make("a", "bb", "cccc", "", "gg"), FuncList.Make <string>(), FuncList.Make("hhhh"))).ToMaybe();
Assert.Equal(3, actual.Value().Count);
Assert.Equal(new int[] { 2, 4, 0, 2 }, actual.Value()[0]);
Assert.Equal(new int[] { }, actual.Value()[1]);
Assert.Equal(new int[] { 4 }, actual.Value()[2]);
}
