Added initial documentation for the parser and removed and unused struct for the game result.

Author: tigerpixel

PGNParser/DraughtsMove.swift

@@ -9,6 +9,9 @@
 import Foundation
 import ParserCombinator
 
+/**
+ Describes a single move performed by one player.
+ */
 public struct DraughtsPieceMove {
 
     let from: Int
@@ -19,6 +22,18 @@ public struct DraughtsPieceMove {
 
 extension DraughtsPieceMove {
 
+    /**
+     A constructor with the parameters in the order of draughts portable game notation.
+     
+     This constructor simplifies the creation of a parser for the move.
+     It should remain in an extension so that it does not replace the default constructor.
+     
+     - parameter from: The location of the piece that is to be moved.
+     
+     - parameter hasCapture: True if the piece captures another piece, false if none are captured.
+     
+     - parameter to: The location at which the piece resides after the move.
+     */
     init(from: Int, hasCapture: Bool, to: Int) {
         self.from = from
         self.to = to
@@ -27,24 +42,30 @@ extension DraughtsPieceMove {
 
 }
 
+/**
+ A description of the movement of pieces by both players.
+ 
+ Black is optional as it may not have moved in this round.
+ A move in technical draughts terms refers to a round of moves by both players.
+ */
 public struct DraughtsMove {
 
     let white: DraughtsPieceMove
     let black: DraughtsPieceMove?
 
 }
 
-public enum Winner {
-    
-    case black
-    case white
-    case draw
-    
-}
-
 extension DraughtsMove {
 
-    /** */
+    /**
+     Parse the input draughts portable game notation string into an array of draughts moves.
+     
+     Can apply functions to values that are wrapped in a parser context.
+     
+     - parameter fromPortableGameNotation: The pgn string describing the moves for a draughts game.
+     
+     - returns: A result of the parse. If successful it will contain the move objects.
+     */
     public static func parse(fromPortableGameNotation notation: String) -> ParseResult<[DraughtsMove]> {
 
         return DraughtsNotationParser.portableGameNotation().run(withInput: notation)

PGNParser/DraughtsNotationParser.swift

@@ -9,18 +9,20 @@
 import ParserCombinator
 import Currier
 
-/** */
+/**
+ Creates a parser to parse a description a draughts game in portable game notation to DraughtsMove objects.
+ */
 struct DraughtsNotationParser {
 
-    /** A function to create a parser which handles the parseing of portable game notation for draughts. */
+    /**
+     Create a parser which performs the parseing of portable game notation for draughts.
+     
+     Once created the parser can be called multiple times for multiple input game strings.
+     
+     - returns: A parser which creates a list of draughts moves from a string in the correct type.
+     */
     static func portableGameNotation() -> Parser<[DraughtsMove]> {
 
-        let lowercaseXIsTrue = character(isEqualTo: "x").map() { _ in return true }
-        let hyphenIsFalse = character(isEqualTo: "-").map() { _ in return false }
-        let fullStop = character(isEqualTo: ".")
-        
-        let numberWithPoint = whitespace.zeroOneOrMany *> digit.oneOrMany *> fullStop
-        
         let singlePieceMove = curry(DraughtsPieceMove.init) <^> integerNumber
                                                             <*> lowercaseXIsTrue <|> hyphenIsFalse
                                                             <*> integerNumber
@@ -30,7 +32,25 @@ struct DraughtsNotationParser {
         return moveRound.oneOrMany
     }
 
-    /** */
+    /// A parser which resolves lowercase x to a boolean true and fails on all other input strings.
+    private static let lowercaseXIsTrue = character(isEqualTo: "x").map() { _ in return true }
+    
+    /// A parser which resolves a hyphen to a boolean false and fails on all other input strings.
+    private static let hyphenIsFalse = character(isEqualTo: "-").map() { _ in return false }
+    
+    /// A parser which resolves a full stop to a success and fails on all other input strings.
+    private static let fullStop = character(isEqualTo: ".")
+    
+    /// A parser which resolves numbers followed by a fullStop and fails on all other input strings.
+    private static let numberWithPoint = whitespace.zeroOneOrMany *> digit.oneOrMany *> fullStop
+    
+    /**
+     Combine a description of a single player turn into a full move with up to two player turns.
+     
+     - parameter turn: A parser for a single turn performed by one player.
+     
+     - returns: A parser for a draughts move object describing both playes turn for a move.
+     */
     private static func twoPlayerTurn(_ turn: Parser<DraughtsPieceMove>) -> Parser<DraughtsMove> {
 
         let singleMove = whitespace.zeroOneOrMany *> turn