public ILazyStatus Next(ILazyStatus status)
{
try
{
return(status.IsAccepted ? Accepted.New(predicate.Invoke(status.Object).IsTrue ? lambda.Invoke(status.Object) : status.Object) : status);
}
catch (Exception exception)
{
return(new Failed(exception));
}
}
public ILazyStatus Next(ILazyStatus status)
{
if (status.IsAccepted && taking)
{
if (!predicate.Invoke(status.Object).IsTrue)
{
return(status);
}
taking = false;
}
return(new Ended());
}
public ILazyStatus Next(ILazyStatus status)
{
if (status.IsAccepted && skipping)
{
if (predicate.Invoke(status.Object).IsTrue)
{
return(new Skipped());
}
skipping = false;
}
return(status);
}
public bool Match(IObject comparisand, Hash <string, IObject> bindings)
{
lambda.CopyFields(fields);
var result = lambda.Invoke(comparisand);
switch (result)
{
case Boolean boolean when arguments.Length == 0:
return(boolean.Value);
case Boolean boolean when arguments.Length == 1:
return(match(boolean, arguments[0], bindings));
case Some some when arguments.Length == 1:
return(match(some.Value, arguments[0], bindings));
default:
if (result is Some {
Value : Tuple tuple
} && tuple.Length.Value == arguments.Length)
{
return(tuple.Value.Zip(arguments, (l, r) => match(l, r, bindings)).All(b => b));
}
break;
}
public IMaybe <IObject> Next(int index)
{
var result = current;
current = lambda.Invoke(current);
return(result.Some());
}
public virtual IObject FlatMap(Lambda lambda)
{
var className = ((BaseClass)collectionClass).Name;
var enumerable = List().ToList().Select(value => lambda.Invoke(value));
var flattened = flatten(enumerable, className);
return(collectionClass.Revert(flattened));
}
public IObject First(Lambda predicate)
{
foreach (var value in List().ToList().Where(value => predicate.Invoke(value).IsTrue))
{
return(new Some(value));
}
return(Objects.None.NoneValue);
}
public IObject Max(Lambda lambda)
{
var result = Unassigned.Value;
if (lambda.Invokable.Parameters.Length == 2)
{
foreach (var value in List().ToList())
{
if (result is Unassigned)
{
result = value;
}
else if (((Int)lambda.Invoke(value, result)).Value < 0)
{
result = value;
}
}
}
else
{
var list = List().ToList();
result = list[0];
var compareResult = lambda.Invoke(result);
foreach (var value in list.Skip(1))
{
var valueResult = lambda.Invoke(value);
if (valueResult is IObjectCompare oc)
{
if (oc.Compare(compareResult) > 0)
{
result = value;
compareResult = valueResult;
}
}
else
{
throw incompatibleClasses(valueResult, "Object compare");
}
}
}
return(result);
}
public IObject Replace(Lambda predicate, Lambda lambda)
{
var list = new List <IObject>();
foreach (var item in List().ToList())
{
list.Add(predicate.Invoke(item).IsTrue ? lambda.Invoke(item) : item);
}
return(collectionClass.Revert(list));
}
public IObject Last(Lambda predicate)
{
var list = List().ToList();
list.Reverse();
foreach (var value in list.Where(value => predicate.Invoke(value).IsTrue))
{
return(new Some(value));
}
return(Objects.None.NoneValue);
}
public IObject Sort(Lambda lambda, bool ascending)
{
switch (lambda.Invokable.Parameters.Length)
{
case 1:
List <IObject> result;
result = ascending ? List().ToList().OrderBy(i => lambda.Invoke(i)).ToList()
: List().ToList().OrderByDescending(i => lambda.Invoke(i)).ToList();
return(collectionClass.Revert(result));
case 2:
var array = List().ToArray();
System.Array.Sort(array, (i, j) => ((Int)lambda.Invoke(i, j)).Value);
return(collectionClass.Revert(array));
default:
return((IObject)collection);
}
}
public IObject ReduceLeft(IObject initialValue, Lambda lambda)
{
var current = initialValue;
var result = new List <IObject> {
current
};
foreach (var value in List().ToList())
{
current = lambda.Invoke(current, value);
result.Add(current);
}
return(collectionClass.Revert(result));
}
public IObject Index(Lambda predicate)
{
var i = 0;
foreach (var value in List().ToList())
{
if (predicate.Invoke(value).IsTrue)
{
return(new Some((Int)i));
}
i++;
}
return(Objects.None.NoneValue);
}
public IObject Indexes(Lambda predicate)
{
var i = 0;
var result = new List <IObject>();
foreach (var value in List().ToList())
{
if (predicate.Invoke(value).IsTrue)
{
result.Add((Int)i);
}
i++;
}
return(collectionClass.Revert(result));
}
public IObject ReduceRight(IObject initialValue, Lambda lambda)
{
var current = initialValue;
var result = new List <IObject> {
current
};
var list = List().ToList();
list.Reverse();
foreach (var value in list)
{
current = lambda.Invoke(value, current);
result.Add(current);
}
return(collectionClass.Revert(result));
}
public Boolean One(Lambda predicate)
{
var one = false;
foreach (var _ in List().ToList().Where(value => predicate.Invoke(value).IsTrue))
{
if (one)
{
return(new Boolean(false));
}
else
{
one = true;
}
}
return(new Boolean(true));
}
public IObject FoldLeft(Lambda lambda)
{
var firstObtained = false;
var current = Unassigned.Value;
foreach (var value in List().ToList())
{
if (firstObtained)
{
current = lambda.Invoke(current, value);
}
else
{
current = value;
firstObtained = true;
}
}
return(current);
}
public IObject Split(Lambda predicate)
{
var ifTrue = new List <IObject>();
var ifFalse = new List <IObject>();
foreach (var value in List().ToList())
{
if (predicate.Invoke(value).IsTrue)
{
ifTrue.Add(value);
}
else
{
ifFalse.Add(value);
}
}
return(collectionClass.Revert(new List <IObject> {
collectionClass.Revert(ifTrue), collectionClass.Revert(ifFalse)
}));
}
public IObject FoldRight(Lambda lambda)
{
var firstObtained = false;
var current = Unassigned.Value;
var list = List().ToList();
list.Reverse();
foreach (var value in list)
{
if (firstObtained)
{
current = lambda.Invoke(value, current);
}
else
{
current = value;
firstObtained = true;
}
}
return(current);
}
public virtual IObject GroupBy(Lambda lambda)
{
var hash = new AutoHash <IObject, List <IObject> >(_ => new List <IObject>())
{
AutoAddDefault = true
};
foreach (var item in List().ToList())
{
var key = lambda.Invoke(item);
hash[key].Add(item);
}
var result = new Hash <IObject, IObject>();
foreach (var key in hash.KeyArray())
{
result[key] = collectionClass.Revert(hash[key]);
}
return(new Dictionary(result));
}
public IObject ReduceRight(Lambda lambda)
{
var firstObtained = false;
var current = Unassigned.Value;
var result = new List <IObject>();
foreach (var value in List().ToList())
{
if (firstObtained)
{
current = lambda.Invoke(value, current);
result.Add(current);
}
else
{
current = value;
result.Add(current);
firstObtained = true;
}
}
return(collectionClass.Revert(result));
}
public IObject Zip(ICollection collection, Lambda lambda)
{
var rightList = collection.GetIterator(false).List().ToList();
return(collectionClass.Revert(List().ToList().Zip(rightList, (x, y) => lambda.Invoke(x, y))));
}
public Int Count(Lambda predicate) => List().Count(value => predicate.Invoke(value).IsTrue);
public IObject Cross(ICollection collection, Lambda lambda)
{
var result = new List <IObject>();
foreach (var left in List().ToList())
{
result.AddRange(collection.GetIterator(false).List().ToList().Select(right => lambda.Invoke(left, right)));
}
return(collectionClass.Revert(result));
}
public Boolean All(Lambda predicate) => List().ToList().All(value => predicate.Invoke(value).IsTrue);
public Boolean None(Lambda predicate)
{
return(List().ToList().All(value => !predicate.Invoke(value).IsTrue));
}
public virtual IObject Map(Lambda lambda) => collectionClass.Revert(List().ToList().Select(value => lambda.Invoke(value)));
public virtual IObject IfNot(Lambda predicate) => collectionClass.Revert(List().ToList().Where(value => !predicate.Invoke(value).IsTrue));
public virtual IObject SkipWhile(Lambda predicate)
{
return(collectionClass.Revert(List().ToList().SkipWhile(value => predicate.Invoke(value).IsTrue)));
}
public virtual IObject TakeUntil(Lambda predicate)
{
return(collectionClass.Revert(List().ToList().TakeWhile(value => !predicate.Invoke(value).IsTrue)));
}
