hello world
\n"); ``` ## Why a pull parser? There are many parsers for Markdown and its variants, but to my knowledge none use pull parsing. Pull parsing has become popular for XML, especially for memory-conscious applications, because it uses dramatically less memory than constructing a document tree, but is much easier to use than push parsers. Push parsers are notoriously difficult to use, and also often error-prone because of the need for user to delicately juggle state in a series of callbacks. In a clean design, the parsing and rendering stages are neatly separated, but this is often sacrificed in the name of performance and expedience. Many Markdown implementations mix parsing and rendering together, and even designs that try to separate them (such as the popular [hoedown](https://github.com/hoedown/hoedown)), make the assumption that the rendering process can be fully represented as a serialized string. Pull parsing is in some sense the most versatile architecture. It's possible to drive a push interface, also with minimal memory, and quite straightforward to construct an AST. Another advantage is that source-map information (the mapping between parsed blocks and offsets within the source text) is readily available; you can call `into_offset_iter()` to create an iterator that yields `(Event, Range)` pairs, where the second element is the event's corresponding range in the source document. While manipulating ASTs is the most flexible way to transform documents, operating on iterators is surprisingly easy, and quite efficient. Here, for example, is the code to transform soft line breaks into hard breaks: ```rust let parser = parser.map(|event| match event { Event::SoftBreak => Event::HardBreak, _ => event }); ``` Or expanding an abbreviation in text: ```rust let parser = parser.map(|event| match event { Event::Text(text) => Event::Text(text.replace("abbr", "abbreviation").into()), _ => event }); ``` Another simple example is code to determine the max nesting level: ```rust let mut max_nesting = 0; let mut level = 0; for event in parser { match event { Event::Start(_) => { level += 1; max_nesting = std::cmp::max(max_nesting, level); } Event::End(_) => level -= 1, _ => () } } ``` There are some basic but fully functional examples of the usage of the crate in the `examples` directory of this repository. ## Using Rust idiomatically A lot of the internal scanning code is written at a pretty low level (it pretty much scans byte patterns for the bits of syntax), but the external interface is designed to be idiomatic Rust. Pull parsers are at heart an iterator of events (start and end tags, text, and other bits and pieces). The parser data structure implements the Rust Iterator trait directly, and Event is an enum. Thus, you can use the full power and expressivity of Rust's iterator infrastructure, including for loops and `map` (as in the examples above), collecting the events into a vector (for recording, playback, and manipulation), and more. Further, the `Text` event (representing text) is a small copy-on-write string. The vast majority of text fragments are just slices of the source document. For these, copy-on-write gives a convenient representation that requires no allocation or copying, but allocated strings are available when they're needed. Thus, when rendering text to HTML, most text is copied just once, from the source document to the HTML buffer. When using the pulldown-cmark's own HTML renderer, make sure to write to a buffered target like a `Vec