S>-- p_sym - парсер, принимающий заданный символ
S>-- p_string - парсер, принимающий заданную строку
S>p_string = mapM p_sym -- mapM - стандартная функция, которой
S>-- достаточно только того, что p_sym - монада
S>

using Nemerle.Peg;
using System;
using System.Collections.Generic;
using System.Console;

[PegGrammar(
  start,
  grammar 
  {
    any             = ['\u0000'..'\uFFFF'];
    s     : void    = ' ';
    dot   : void    = '.';
    num   : double  = '-'? ['0'..'9']+ dot ['0'..'9']+ s;
    start : double  = num+ !any;
  }
)]
public partial class Parser
{
  _str : string;
  public this(str : string) { _str = str; }

  // Генератор парсеров не рассчитан на дурные битодробильные тесты, а рассчитан на генерацию AST.
  // По сему помещает результат циклических правил в список, что не здорово для подобных задач.
  start(nums : List[double]) : double
  {
    mutable res = 0.0;
    foreach (n in nums)
      res += n;
    res
  }

  num(minus : NToken, num1 : NToken, num2 : NToken) : double
  {
    if (minus.IsEmpty)
      ToLong(num1) + GetFrac(num2)
    else
      -1.0 * (ToLong(num1) + GetFrac(num2));
  }

  // Рукопашная реализация так как стандартная дотнетная функция на таких скоростях выглядит тормозом.
  ToLong(num : NToken) : long 
  {
    mutable res : long = 0;
    
    for (mutable i = num.StartPos; i < num.EndPos; i++)
      res = res * 10 + (_str[i] - '0' : int);
      
    res
  }

  GetFrac(num : NToken) : double
  {
    mutable res : double = 0.0;
    
    for (mutable i = num.EndPos - 1; i >= num.StartPos; i--)
      res = res * 0.1 + (_str[i] - '0' : int);
      
    res * 0.1
  }
}

module Program
{
  Main() : void
  {
    def data    = IO.File.ReadAllText(@"e:\temp\numbers_large.txt");
    def parser  = Parser(data);
    def timer   = Diagnostics.Stopwatch.StartNew();
    
    match (parser.Parse(data))
    {
      | Some(res) => WriteLine($"Result: $res  Test took: $(timer.Elapsed)");
      | None      => WriteLine("Parsing failed");
    }
  }
}

VD>Хуже кода для столь простой задачи придумать просто невозможно .

{- number - разбор числового значения -}
number = do
  spaces
  s <- sign
  i <- p_try intPart
  f <- p_try fracPart
  exp <- liftM (fromMaybe 1.0) $ p_try expn
  case (i, f) of
    (Nothing, Nothing) -> mzero
    _ -> return $! exp * s * (fmay i + fmay f)
         where fmay = fromMaybe 0.0

whitespaces <- whitespace+
sign <- ('-' / '+')?
int <- [0-9]+
dot <- '.' / ','
frac <- dot int
exp <- ('e' / 'E') sign int
num <- int / (int frac) / frac
float <- sign num exp? whitespaces
floats <- float*

VD>Причем не самопалами с объемом кода на 5 экранов, а самым что ни наесть штатным образом.

{- digit - парсер, принимающий символы от '0' до '9'
   и возвращающий уже их числовое значение -}
digit = fmap digitToInt $ p_pred isDigit

spaces = many $ p_pred isSpace
dot = p_sym2 ',' '.'

{- sign - парсер, опционально принимающий знаки '+' и '-',
   возвращающий Double-множитель, -1.0 для '-',
   1.0 в противном случае -}
sign = fmap getSign $ p_try (p_sym2 '-' '+')
       where getSign (Just '-') = -1.0
             getSign _ = 1.0

data IntAcc = IntAcc { getInt ::  {-# UNPACK #-} !Double }
instance Accumulator IntAcc Int where
    a_empty = IntAcc 0.0
    a_append i (IntAcc a) = IntAcc $ a * 10.0 + fromIntegral i

{- intPart - разбор целой части -}
intPart = many1 (writing digit)  |>| getInt

data FrAcc = FrAcc { mult :: {-# UNPACK #-} !Double,
                     getFrac :: {-# UNPACK #-} !Double }

instance Accumulator FrAcc Int where
    a_empty = FrAcc 0.1 0.0
    a_append i (FrAcc m a) = FrAcc (m * 0.1) (a + m * fromIntegral i)

{- fracPart - разбор дробной части -}
fracPart = dot >> many1 (writing digit) |>| getFrac

{- expn - разбор экспоненты  -}
expn = do
  p_sym2 'e' 'E'
  s <- sign
  i <- intPart
  return $ 10 ** (s * i)

{- number - разбор числового значения -}
number = do
  spaces
  s <- sign
  i <- p_try intPart
  f <- p_try fracPart
  exp <- liftM (fromMaybe 1.0) $ p_try expn
  case (i, f) of
    (Nothing, Nothing) -> mzero
    _ -> return $! exp * s * (fmay i + fmay f)
         where fmay = fromMaybe 0.0


data Sum a = Sum {getSum :: {-# UNPACK #-} !a}

instance Num a => Accumulator (Sum a) a where
    a_empty = Sum $ fromIntegral 0
    a_append e (Sum a) = Sum $ e + a

sumNumbers = many (writing number) |>| getSum