public void TestCallWithParameter()
{
var t_Result = Try.Call((i) => i * 2, 2);
t_Result.HasError().Should().BeFalse();
t_Result.Value.Should().Be(4);
}
private Either <IExpression> _AttemptCreate(CreateExprFunc CreateFunc,
IParseState OldState, IParseState NewState)
{
return(Try.Call(() => CreateFunc(
OldState.DiffTokens(NewState),
NewState.DiffExpressions(OldState))
));
}
protected virtual Either<IExpression> _CreateExpression(IEnumerable<Token> Tokens)
{
var t_Result = Try.Call(() => m_CreateExpression(Tokens));
return t_Result.HasError() ?
new Exception("This class is unable to create an expression", t_Result.Error) :
t_Result;
}
public Either <IParseState> Match(IParseState State)
{
return(m_Rules
.Select(R => Try.Call(() => R.Match(State)))
.Where(E => !E.HasError())
.Select(E => E.Value)
.Where(E => !E.HasError())
.OrderBy(S => S.Value.Tokens.Count)
.FirstOrDefault(E => !E.HasError())
??
new Exception("No match was found"));
}
protected virtual Either <IParseState> _MatchRules(IParseState State)
{
var t_CurrentState = State;
foreach (var t_Rule in m_Rules)
{
var t_TryCall = Try.Call(() => _MatchRule(t_Rule, t_CurrentState));
if (t_TryCall.HasError())
{
return(t_TryCall.Error);
}
var t_NewState = t_TryCall.Value;
if (t_NewState.HasError())
{
return(new Exception("Rule Match Error", t_NewState.Error));
}
t_CurrentState = t_NewState.Value;
}
return(new Either <IParseState>(t_CurrentState));
}
public void TestCallWithReturn()
{
var t_Result = Try.Call(() => 1);
t_Result.HasError().Should().BeFalse();
}
public void TestCall()
{
var t_Result = Try.Call(() => { });
t_Result.HasError().Should().BeFalse();
}