     /// A combined parser.
     associatedtype CombinedParser = Self
     
-    /// See `GenericParser` documentation.
+    /// Return a parser containing the result of mapping transform over `self`.
+    ///
+    /// This method has the synonym infix operator `<^>`.
+    ///
+    /// - parameter transform: A mapping function.
+    /// - returns: A new parser with the mapped content.
     func map<T>(transform: Result -> T) -> GenericParser<Stream, UserState, T>
     
     /// Infix operator for `ParsecType.map`. It has the same precedence as the equality operator (`==`).
+    ///
+    /// - parameters:
+    ///   - transform: A mapping function.
+    ///   - parser: The parser whose result is mapped.
+    /// - returns: A new parser with the mapped content.
     func <^><T>(transform: Result -> T, parser: Self) -> GenericParser<Stream, UserState, T>
     
-    /// See `ParsecType` extension documentation.
+    /// Return a parser by applying the function contained in the supplied parser to self.
+    ///
+    /// This method has the synonym infix operator `<*>`.
+    ///
+    /// - parameter parser: The parser containing the function to apply to self.
+    /// - returns: A parser with the applied function.
     func apply<T>(parser: GenericParser<Stream, UserState, Result -> T>) -> GenericParser<Stream, UserState, T>
     
     /// Infix operator for `ParsecType.apply`. It has the same precedence as the equality operator (`==`).
+    ///
+    /// - parameters:
+    ///   - leftParser: The parser containing the function to apply to the parser on the right.
+    ///   - rightParser: The parser on which the function is applied.
+    /// - returns: A parser with the applied function.
     func<*><T>(leftParser: GenericParser<Stream, UserState, Result -> T>, rightParser: Self) -> GenericParser<Stream, UserState, T>
     
     /// Sequence parsing, discarding the value of the first parser. It has the same precedence as the equality operator (`==`).


infix operator <*> { associativity left precedence 130 }

public func<*><Stream, UserState, Result, T>(leftParser: GenericParser<Stream, UserState, Result -> T>, rightParser: GenericParser<Stream, UserState, Result>) -> GenericParser<Stream, UserState, T> {
    
    return rightParser.apply(leftParser)


infix operator *> { associativity left precedence 130 }

/// Sequence parsing, discarding the value of the first parser. It has the same precedence as the equality operator (`==`).
///
/// - parameters:
///   - leftParser: The first parser executed.
///   - rightParser: The second parser executed.
/// - returns: A parser returning the result of the second parser.
public func *><Stream, UserState, Param1, Param2>(leftParser: GenericParser<Stream, UserState, Param1>, rightParser: GenericParser<Stream, UserState, Param2>) -> GenericParser<Stream, UserState, Param2> {
    
    return GenericParser.lift2({ $1 }, parser1: leftParser, parser2: rightParser)
