ParserCombinator | Simple ParserCombinator framework for Swift

You need to place eof at the end.

The Haskell report has a section on do notation and how to "desugar" these do blocks.

If you write a do block as:

You can define this with (<$) :: Functor f => a -> f b -> f a. This thus performs a functor mapping with x <$ u = fmap (const x) u:

Did you check if your graph contains negative weights? LightGraphs.betweenness_centrality() uses Dijkstra's shortest paths to calculate betweenness centrality, and thus expect non-negative weights.

LightGraphs.betweenness_centrality() doesn't check for illegal/nonsensical graphs. That's why it didn't throw an error. The issue is already reported here, but for now, check your own graphs if your not sure they are legal.

I was under the impression that many x parses x until it fails and then stops.

This is only the case if x fails without consuming any input. If x fails after consuming input, the whole parse will fail unless there's a try somewhere (this isn't just specific to many: x <|> y would also fail in that case even if y would succeed). In your case delimP fails on the notFollowedBy (char '\n') after already consuming the first \n, so the whole parse fails.

To change this behaviour, you need to explicitly enable backtracking using try like this:

The meaning of "backtracking" in the Attoparsec documentation is different than the meaning of backtracking for the other backtracking parsers.

It helps to review what "backtracking" means when using try for a Parsec or Megaparsec parser. These parsers have a concept of failing after consuming input ("consume err" = cerr) versus failing after consuming nothing ("empty err" = eerr). For these parsers, the p <|> q alternative operator treats failure of p differently if it's cerr (fail the whole p <|> q immediately) versus eerr (try the alternative q instead). The try function backtracks by converting cerr to eerr. That is, try p <|> q will "backtrack" an erroneous consumption of the input stream in the event p fails with cerr. It's a single step of backtracking on failure within alternatives (though with nested try calls, multiple steps of backtracking can be performed in a sequence/cascade of parse failures).

Attoparsec doesn't differentiate betweeen cerr and eerr, so it's as if all parsers are surrounded by try calls. This means that it automatically performs multiple steps of backtracking on failure within alternatives.

ReadP backtracks implicitly by simultaneously evaluating every possible parse in parallel, discarding those that ever fail, and picking the "first" one that remains. It "backtracks" failures over a tree of all possible parses, whether the failures were generated in the context of an alternative or not.

It turns out that "multiple steps of backtracking on failure within alternatives" is a more modest form of backtracking than "backtracking over a tree of all possible parses".

A couple of simplified examples may help show the difference. Consider the parser:

The parser looks fine. The problem here is that main currently runs the parser on a single line at a time. You need to accumulate the whole input before running the parser.

Note that I get the same error whether or not line 1 is commented out, so:

One parser which satisfies the constraints is parsec.