Parser<String> noneOf(String chars) =>
   pred((c) => !chars.contains(c)).expecting("none of '$chars'");

Parser<String> oneOf(String chars) =>
   pred((c) => chars.contains(c)).expecting("one of '$chars'");

Parser choice(List<Parser> ps) {
 // Imperative version for efficiency
 return new Parser((s, pos) {
   var exps = _emptyExpectation(pos);
   for (final p in ps) {
     final res = p._run(s, pos);
     exps = exps.best(res.expectations);
     if (res.isSuccess) {
       return res.copy(expectations: exps);
     } else if (res.isCommitted) {
       return res;
     }
   }
   return _failure(s, pos, exps);
 });
}

Parser rec(Parser f()) => new Parser((s, pos) => f()._run(s, pos));

Parser string(String str) {
 // Primitive version for efficiency
 return new Parser((s, pos) {
   final int offset = pos.offset;
   final int max = offset + str.length;

   int newline = pos.line;
   int newchar = pos.character;
   // This replicates Position#addChar for efficiency purposes.
   void update(c) {
     final isNewLine = c == '\n';
     newline = newline + (isNewLine ? 1 : 0);
     newchar = isNewLine ? 1 : newchar + 1;
   }

   bool match = s.length >= max;
   for (int i = 0; i < str.length && match; i++) {
     final c = s[offset + i];
     match = match && c == str[i];
     update(c);
   }
   if (match) {
     return _success(str, s, new Position(max, newline, newchar));
   } else {
     return _failure(s, pos, _singleExpectation("'$str'", pos));
   }
 });
}

Parser char(String chr) => pred((c) => c == chr) % "'$chr'";

Parser pred(bool p(String char)) {
 return new Parser((s, pos) {
   if (pos.offset >= s.length) return _failure(s, pos);
   else {
     String c = s[pos.offset];
     return p(c) ? _success(c, s, pos.addChar(c))
                 : _failure(s, pos);
   }
 });
}

Parser success(value) => new Parser((s, pos) => _success(value, s, pos));