public Many1CharsTill(FSharpFunc <CharStream <TUserState>, Reply <char> > charParser1,
FSharpFunc <CharStream <TUserState>, Reply <char> > charParser,
FSharpFunc <CharStream <TUserState>, Reply <TEnd> > endParser,
FSharpFunc <string, FSharpFunc <TEnd, TResult> > mapping)
{
CharParser1 = charParser1;
CharParser = charParser;
EndParser = endParser;
Mapping = (OptimizedClosures.FSharpFunc <string, TEnd, TResult>)(object) OptimizedClosures.FSharpFunc <string, TEnd, TResult> .Adapt(mapping);
}
internal Operator(string leftString,
FSharpFunc <CharStream <TUserState>, Reply <TAfterString> > afterLeftStringParser,
string rightString,
FSharpFunc <CharStream <TUserState>, Reply <TAfterString> > afterRightStringParser,
int precedence,
Associativity associativity,
FSharpFunc <TAfterString, FSharpFunc <TAfterString, FSharpFunc <TTerm, FSharpFunc <TTerm, FSharpFunc <TTerm, TTerm> > > > > mapping)
{
Type = OperatorType.Infix;
if (string.IsNullOrEmpty(leftString))
{
throw new ArgumentException("leftString", "The operator strings must not be empty.");
}
String = leftString;
if (afterLeftStringParser == null)
{
throw new ArgumentNullException("afterLeftStringParser");
}
AfterStringParser = afterLeftStringParser;
if (string.IsNullOrEmpty(rightString))
{
throw new ArgumentException("rightString", "The operator strings must not be empty.");
}
TernaryRightString = rightString;
if (afterRightStringParser == null)
{
throw new ArgumentNullException("afterRightStringParser");
}
AfterTernaryRightStringParser = afterRightStringParser;
if (precedence < 1)
{
throw new ArgumentOutOfRangeException("precedence", "The operator precedence must be greater than 0.");
}
Precedence = precedence;
if (associativity < Associativity.None || associativity > Associativity.Right)
{
throw new ArgumentOutOfRangeException("associativity", "The associativity argument is invalid.");
}
Associativity = associativity;
if (mapping == null)
{
throw new ArgumentNullException("mapping");
}
Mapping3 = OptimizedClosures.FSharpFunc <TAfterString, TAfterString, TTerm, TTerm, TTerm, TTerm> .Adapt(mapping);
}
public Move FindBestMove(Game game)
{
FSharpFunc <Game, bool> gameOver = FuncConvert.FromFunc <Game, bool>(GameOver);
FSharpFunc <Game, FSharpFunc <Player, int> > heuristic = FuncConvert.FromFunc <Game, Player, int>(Heuristic);
FSharpFunc <Game, Player> getTurn = FuncConvert.FromFunc <Game, Player>(GetTurn);
FSharpFunc <Game, IEnumerable <Move> > moveGenerator = FuncConvert.FromFunc <Game, IEnumerable <Move> >(MoveGenerator);
FSharpFunc <Game, FSharpFunc <Move, Game> > applyMove = FuncConvert.FromFunc <Game, Move, Game>(ApplyMove);
OptimizedClosures.FSharpFunc <int, int, Game, Player, Tuple <FSharpOption <Move>, int> > mini =
(OptimizedClosures.FSharpFunc <int, int, Game, Player, Tuple <FSharpOption <Move>, int> >)GameTheory.MiniMaxWithAlphaBetaPruningGenerator(heuristic,
getTurn, gameOver, moveGenerator, applyMove);
NodeCounter.Reset();
Tuple <FSharpOption <Move>, int> best = mini.Invoke(int.MinValue, int.MaxValue, game, game.Turn);
Move move = best.Item1.Value;
return(move);
}
public NoAfterStringTernaryMappingAdapter(OptimizedClosures.FSharpFunc <TTerm, TTerm, TTerm, TTerm> mapping)
{
Mapping = mapping;
}
