public void IdentityNonIdentityProjectionInequality()
{
var x = Monad.Create(1);
var y = x.Select(v => v + 1);
Assert.AreNotEqual(x, y);
}
private static Monad <dynamic> ValidationFailureCase(this string val)
{
Console.Beep();
val.WriteLine();
Console.ReadKey();
return(Monad.None <dynamic>());
}
public void SelectQuery()
{
var result = from x in Monad.Create(1)
select x.ToString();
Assert.AreEqual("1", result.Value);
}
public void BasicMonad()
{
var monad = new Monad <int>(1);
var monad2 = monad.Bind(v => new Monad <int>(v));
Assert.AreEqual(monad, monad2);
Assert.AreNotSame(monad, monad2);
}
public void SelectManyQuery()
{
var result = from x in Monad.Create(2)
from y in Monad.Create(3)
select x + y;
Assert.AreEqual(5, result.Value);
}
public void BasicMonadWithFactory()
{
var monad = Monad.Create(1);
var monad2 = monad.Bind(v => Monad.Create(v));
Assert.AreEqual(monad, monad2);
Assert.AreNotSame(monad, monad2);
}
public void IdentityEquivilence()
{
var x = Monad.Create(1);
var y = Monad.Create(1);
Assert.AreEqual(x, y);
Assert.AreNotSame(x, y);
}
public static Monad <A> MethodW <A>(this Monad <A> monad, Func <Monad <A>, Monad <A> > expr, bool updateNext = true)
{
monad.Concatenate(monad.MethodW2 <A, A>(expr, false));
if (updateNext)
{
monad.UpdateValue();
}
return(monad);
}
public static Monad <dynamic> Validate(string[] args)
{
if (!args.HasLength() || !(args.Length <= 2))
{
return
("Validation Failure: Two parameters are required: (1) the Directory path and (2) the filename pattern (filter)."
.ValidationFailureCase());
}
string path = args[0];
string filter = args[1];
if (!path.HasLength())
{
return("Validation Failure: A path parameter is required as the first parameter."
.ValidationFailureCase());
}
if (!filter.HasLength())
{
return("Validation Failure: A filter parameter is required as the second parameter."
.ValidationFailureCase());
}
bool isUNC = IsUNCPath(path);
if (!isUNC)
{
string fullPath = GetFullPath(path);
if (fullPath.HasLength())
{
path = fullPath;
}
else
{
return("Validation Failure: A valid (well-formed) path parameter is required."
.ValidationFailureCase());
}
}
string strDelay = ConfigurationManager.AppSettings["DelayForChecking"];
var delay = strDelay.ToInt();
if (!delay.HasValue() || delay.Value < 1)
{
"Validation Failure: There must be a specified delay in the config file (in milliseconds)."
.ValidationFailureCase();
}
dynamic retVal = new ExpandoObject();
retVal.Path = path;
retVal.Filter = filter;
retVal.Delay = delay.Value;
return(Monad.Create <dynamic>(retVal));
}
public void IdentityIdentityProjectionEquivilence()
{
var x = Monad.Create(1);
var y = x.Select(v => v);
var z = y.Select(a => a + 1);
Assert.AreEqual(x, y);
Assert.AreNotEqual(y, z);
Assert.AreNotSame(x, y);
}
public static Func <Monad <A>, Monad <B>, Monad <C>, Monad <D>, Monad <E> > LiftM <A, B, C, D, E>(this Monad <E> monad, Func <A, B, C, D, E> func)
{
ConstructorInfo constructor = monad.GetType().GetConstructor(new Type[] { });
Monad <E> m = (Monad <E>)constructor.Invoke(null);
return((a, b, c, d) =>
{
return m.Pure(func(a.Return(), b.Return(), c.Return(), d.Return()));
});
}
public static Func <Monad <A>, Monad <B> > LiftM <A, B>(this Monad <B> monad, Func <A, B> func)
{
ConstructorInfo constructor = monad.GetType().GetConstructor(new Type[] { });
Monad <B> m = (Monad <B>)constructor.Invoke(null);
return((a) =>
{
return m.Pure(func(a.Return()));
});
}
public static Monad <U> Select <T, U>(this Monad <T> self, Func <T, U> map)
{
return(() =>
{
var resT = self();
var resU = map(resT);
return resU;
});
}
public static void Write <T>(this Monad <T> id, T value)
{
id.Lock.EnterWriteLock();
try
{
id.Append(value);
}
finally
{
id.Lock.ExitWriteLock();
}
}
public override T Evaluate(object lv, object rv)
{
if (lv is string ls && rv is string rs)
{
if (!cache.TryGetValue(rs, out var regex))
{
regex = RegexHelper.CreateRegexPattern(rs);
cache[rs] = regex;
}
return(Monad.Lift(regex?.IsMatch(ls) ?? false));
}
return(Monad.Lift(false));
}
public static Monad <T> Exchange <T>(this Monad <T> thisMonad, Monad <T> monad)
{
monad.Lock.EnterReadLock();
try
{
thisMonad.Write(monad.Return());
}
finally
{
monad.Lock.ExitReadLock();
}
return(thisMonad);
}
public override Maybe <object> Evaluate(IContext <Maybe <object> > context)
{
var l = Left.Evaluate(context);
var r = Right.Evaluate(context);
return(Monad.Bind(l, r, Eval));
Maybe <object> Eval(object lv, object rv)
{
return(IsZeroOrNonNumeric(rv)
? Maybe <object> .None
: Evaluate(lv, rv));
}
}
public static Monad <int> ToInt(this string val)
{
int intVal = 0;
bool isValid = int.TryParse(val, out intVal);
if (isValid)
{
return(intVal.ToMonad());
}
else
{
return(Monad.None <int>());
}
}
public static HigherKind <W, ImmutableList <A> > sequence <A, W>(
this IEnumerable <HigherKind <W, A> > enumerable, Monad <W> M
)
{
var builderHKT = enumerable.Aggregate(
M.point(ImmutableList.CreateBuilder <A>()),
(listBuilderHKT, aHKT) => M.flatMap(listBuilderHKT, listBuilder => M.map(aHKT, a => {
listBuilder.Add(a);
return(listBuilder);
}))
);
return(M.map(builderHKT, _ => _.ToImmutable()));
}
public static bool Contains <A, D>(this Monad <A> monad, D dest, Func <A, D, bool> comparer)
{
bool result = false;
foreach (A element in monad)
{
if (comparer(element, dest))
{
result = true;
break;
}
}
return(result);
}
public static A GetItemBy <A, D>(this Monad <A> monad, D dest, Func <A, D, bool> comparer)
{
A result = default(A);
foreach (A element in monad)
{
if (comparer(element, dest))
{
result = element;
break;
}
}
return(result);
}
public static Monad <V> SelectMany <T, U, V>(
this Monad <T> self,
Func <T, Monad <U> > select,
Func <T, U, V> project
)
{
return(() =>
{
var resT = self();
var resU = select(resT)();
var resV = project(resT, resU);
return resV;
});
}
public static T Read <T>(this Monad <T> id)
{
T result = default(T);
id.Lock.EnterReadLock();
try
{
result = id.Return();
}
finally
{
id.Lock.ExitWriteLock();
}
return(result);
}
public static int IndexOfBy <A, D>(this Monad <A> monad, D dest, Func <A, D, bool> comparer)
{
int result = -1;
int index = 0;
foreach (A element in monad)
{
if (comparer(element, dest))
{
result = index;
break;
}
index++;
}
return(result);
}
public static bool All <A, D>(this Monad <A> monad, Monad <D> destMonad, Func <A, D, bool> comparer)
{
bool result = false;
foreach (A element in monad)
{
foreach (D value in destMonad)
{
if (!comparer(element, value))
{
result = false;
break;
}
}
}
return(result);
}
public static Monad <A> ActionR <A>(this Monad <A> monad, Action <A> action)
{
monad.Lock.EnterReadLock();
try
{
monad.Visit(action);
}
catch (Exception exception)
{
monad.UpdateValue(exception);
}
finally
{
monad.Lock.ExitReadLock();
}
return(monad);
}
public static Monad <A> Match <A, D>(this Monad <A> monad, Monad <D> destMonad, Func <A, D, bool> comparer)
{
Type[] arg = new Type[] { };
Monad <A> result = (Monad <A>)monad.GetType().GetConstructor(arg).Invoke(null);
foreach (A element in monad)
{
foreach (D value in destMonad)
{
if (comparer(element, value))
{
result.Append(element);
break;
}
}
}
return(result);
}
public static bool CompareExchange <T>(this Monad <T> thisMonad, T value, Func <bool> comparand)
{
bool result = false;
thisMonad.Lock.EnterWriteLock();
try
{
if ((result = comparand()))
{
thisMonad.Append(value);
}
}
finally
{
thisMonad.Lock.ExitWriteLock();
}
return(result);
}
public static bool CompareSet <T>(this Monad <T> monad, Func <T, bool> predicate, T value)
{
bool result = false;
monad.Lock.EnterWriteLock();
try
{
if ((result = predicate(monad.Return())))
{
monad.Pure(value);
}
}
finally
{
monad.Lock.ExitWriteLock();
}
return(result);
}
public IEnumerator Initialize()
{
var genTerrainMonad = new BlockMonad <float[]>(r =>
_terrainGen.GenerateHeightMap(
MAP_WIDTH,
MAP_HEIGHT,
Random.Range(0, 10000),
Random.Range(0, 10000),
new TerrainParameter(),
r));
var genTemperatureMonad = new BlockMonad <float[]>(r =>
_temperatureGen.GenerateWeatherMap(
MAP_WIDTH,
MAP_HEIGHT,
Random.Range(0, 10000),
Random.Range(0, 10000),
new WeatherParameter(),
r));
var genHumidityMonad = new BlockMonad <float[]>(r =>
_humidityGen.GenerateWeatherMap(
MAP_WIDTH,
MAP_HEIGHT,
Random.Range(0, 10000),
Random.Range(0, 10000),
new WeatherParameter(),
r));
var genManaMonad = new BlockMonad <float[]>(r =>
_manaGen.GenerateWeatherMap(
MAP_WIDTH,
MAP_HEIGHT,
Random.Range(0, 10000),
Random.Range(0, 10000),
new WeatherParameter(),
r));
var combineM = Monad.WhenAll(
genTerrainMonad,
genTemperatureMonad,
genHumidityMonad,
genManaMonad);
_executor.Add(combineM.Do());
yield return(_executor.Join());
}
private static void PublicConstructorSimpleUsage()
{
var m = new Monad<int>(128);
Console.WriteLine("The value of m is {0}.", m.Value);
}
