1# Change Log 2 3## [Unreleased][unreleased] 4 5### Thanks 6 7### Added 8 9### Fixed 10 11## 5.1.1 - 2020-02-24 12 13### Thanks 14 15- @Alexhuszagh for float fixes 16- @AlexanderEkdahl, @JoshOrndorff, @akitsu-sanae for docs fixes 17- @ignatenkobrain: dependency update 18- @derekdreery: `map` implementation for errors 19- @Lucretiel for docs fixes and compilation fixes 20- adytzu2007: warning fixes 21- @lo48576: error management fixes 22 23### Fixed 24 25- C symbols compilation errors due to old lexical-core version 26 27### Added 28 29- `Err` now has a `map` function 30 31### Changed 32 33- Make `error::context()` available without `alloc` feature 34 35## 5.1.0 - 2020-01-07 36 37### Thanks 38 39- @Hywan, @nickmooney, @jplatte, @ngortheone, @ejmg, @SirWindfield, @demurgos, @spazm, @nyarly, @guedou, @adamnemecek, for docs fixes 40- @Alxandr for error management bugfixes 41- @Lucretiel for example fixes and optimizations 42- @adytzu2007 for optimizations 43- @audunhalland for utf8 fixes 44 45### Fixed 46 47- panic in `convert_error` 48- `compile_error` macro usage 49 50### Added 51 52- `std::error::Error`, `std::fmt::Display`, `Eq`, `ToOwned` implementations for errors 53- inline attribute for `ToUsize` 54 55### Changed 56 57- `convert_error` optimization 58- `alt` optimization 59 60## 5.0.1 - 2020-08-22 61 62### Thanks 63 64- @waywardmonkeys, @phaazon, @dalance for docs fixes 65- @kali for `many0_m_n` fixes 66- @ia0 for macros fixes 67 68### Fixed 69 70- `many0_m_n` now supports the n=1 case 71- relaxed trait requirements in `cut` 72- `peek!` macro reimplementation 73- type inference in `value!` 74 75## 5.0.0 - 2019-06-24 76 77This version comes with a complete rewrite of nom internals to use functions as a base 78for parsers, instead of macros. Macros have been updated to use functions under 79the hood, so that most existing parsers will work directly or require minimal changes. 80 81The `CompleteByteSlice` and `CompleteStr` input types were removed. To get different 82behaviour related to streaming or complete input, there are different versions of some 83parsers in different submodules, like `nom::character::streaming::alpha0` and 84`nom::character::complete::alpha0`. 85 86The `verbose-errors` feature is gone, now the error type is decided through a generic 87bound. To get equivalent behaviour to `verbose-errors`, check out `nom::error::VerboseError` 88 89### Thanks 90 91- @lowenheim helped in refactoring and error management 92- @Keruspe helped in refactoring and fixing tests 93- @pingiun, @Songbird0, @jeremystucki, @BeatButton, @NamsooCho, @Waelwindows, @rbtcollins, @MarkMcCaskey for a lot of help in rewriting the documentation and adding code examples 94- @GuillaumeGomez for documentation rewriting and checking 95- @iosmanthus for bug fixes 96- @lo48576 for error management fixes 97- @vaffeine for macros visibility fixes 98- @webholik and @Havvy for `escaped` and `escaped_transform` fixes 99- @proman21 for help on porting bits parsers 100 101### Added 102 103- the `VerboseError` type accumulates position info and error codes, and can generate a trace with span information 104- the `lexical-core` crate is now used by default (through the `lexical` compilation feature) to parse floats from text 105- documentation and code examples for all functions and macros 106 107### Changed 108 109- nom now uses functions instead of macros to generate parsers 110- macros now use the functions under the hood 111- the minimal Rust version is now 1.31 112- the verify combinator's condition function now takes its argument by reference 113- `cond` will now return the error of the parser instead of None 114- `alpha*`, `digit*`, `hex_digit*`, `alphanumeric*` now recognize only ASCII characters 115 116### Removed 117 118- deprecated string parsers (with the `_s` suffix), the normal version can be used instead 119- `verbose-errors` is not needed anymore, now the error type can be decided when writing the parsers, and parsers provided by nom are generic over the error type 120- `AtEof`, `CompleteByteSlice` and `CompleteStr` are gone, instead some parsers are specialized to work on streaming or complete input, and provided in different modules 121- character parsers that were aliases to their `*1` version: eol, alpha, digit, hex_digit, oct_digit, alphanumeric, space, multispace 122- `count_fixed` macro 123- `whitespace::sp` can be replaced by `character::complete::multispace0` 124- method combinators are now in the nom-methods crate 125- `take_until_either`, `take_until_either1`, `take_until_either_and_consume` and `take_until_either_and_consume1`: they can be replaced with `is_not` (possibly combined with something else) 126- `take_until_and_consume`, `take_until_and_consume1`: they can be replaced with `take_until` combined with `take` 127- `sized_buffer` and `length_bytes!`: they can be replaced with the `length_data` function 128- `non_empty`, `begin` and `rest_s` function 129- `cond_reduce!`, `cond_with_error!`, `closure!`, `apply`, `map_res_err!`, `expr_opt!`, `expr_res!` 130- `alt_complete`, `separated_list_complete`, `separated_nonempty_list_complete` 131 132## 4.2.3 - 2019-03-23 133 134### Fixed 135 136- add missing `build.rs` file to the package 137- fix code comparison links in changelog 138 139## 4.2.2 - 2019-03-04 140 141### Fixed 142 143- regression in do_parse macro import for edition 2018 144 145## 4.2.1 - 2019-02-27 146 147### Fixed 148 149- macro expansion error in `do_parse` due to `compile_error` macro usage 150 151## 4.2.0 - 2019-01-29 152 153### Thanks 154 155- @JoshMcguigan for unit test fixes 156- @oza for documentation fixes 157- @wackywendell for better error conversion 158- @Zebradil for documentation fixes 159- @tsraom for new combinators 160- @hcpl for minimum Rust version tests 161- @KellerFuchs for removing some unsafe uses in float parsing 162 163### Changed 164 165- macro import in edition 2018 code should work without importing internal macros now 166- the regex parsers do not require the calling code to have imported the regex crate anymore 167- error conversions are more ergonomic 168- method combinators are now deprecated. They might be moved to a separate crate 169- nom now specifies Rust 1.24.1 as minimum version. This was already the case before, now it is made explicit 170 171### Added 172 173- `many0_count` and `many1_count` to count applications of a parser instead of 174accumulating its results in a `Vec` 175 176### Fixed 177 178- overflow in the byte wrapper for bit level parsers 179- `f64` parsing does not use `transmute` anymore 180 181## 4.1.1 - 2018-10-14 182 183### Fixed 184 185- compilation issue in verbose-errors mode for `add_return_error` 186 187## 4.1.0 - 2018-10-06 188 189### Thanks 190 191- @xfix for fixing warnings, simplifying examples and performance fixes 192- @dvberkel for documentation fixes 193- @chifflier for fixing warnings 194- @myrrlyn for dead code elimination 195- @petrochenkov for removing redundant test macros 196- @tbelaire for documentation fixes 197- @khernyo for fixing warnings 198- @linkmauve for documentation fixes 199- @ProgVal for documentation fixes, warning fixes and error management 200- @Nemo157 for compilation fixes 201- @RReverser for documentation fixes 202- @xpayn for fixing warnings 203- Blas Rodriguez Irizar for documentation fixes 204- @badboy for documentation fixes 205- @kyrias for compilation fixes 206- @kurnevsky for the `rest_len` parser 207- @hjr3 for new documentation examples 208- @fengalin for error management 209- @ithinuel for the pcap example project 210- @phaazon for documentation fixes 211- @juchiast for documentation fixes 212- @jrakow for the `u128` and `i128` parsers 213- @smarnach for documentation fixes 214- @derekdreery for `pub(crate)` support 215- @YaLTeR for `map_res_err!` 216 217### Added 218 219- `rest_len` parser, returns the length of the remaining input 220- `parse_to` has its own error code now 221- `u128` and `i128` parsers in big and little endian modes 222- support for `pub(crate)` syntax 223- `map_res_err!` combinator that appends the error of its argument function in verbose errors mode 224 225### Fixed 226 227- lots of unused imports warnings were removed 228- the `bytes` combinator was not compiling in some cases 229- the big and little endian combinators now work without external imports 230- CI is now faster and uses less cache 231- in `add_return_error`, the provided error code is now evaluated only once 232 233### Changed 234 235- `fold_many1` will now transmit a `Failure` instead of transforming it to an `Error` 236- `float` and `double` now work on all of nom's input types (`&[u8]`, `&str`, `CompleteByteSlice`, `CompleteStr` and any type that implements the required traits). `float_s` and `double_s` got the same modification, but are now deprecated 237- `CompleteByteSlice` and `CompleteStr` get a small optimization by inlining some functions 238 239 240## 4.0.0 - 2018-05-14 241 242### Thanks 243 244- @jsgf for the new `AtEof` trait 245- @tmccombs for fixes on `escaped*` combinators 246- @s3bk for fixes around non Copy input types and documentation help 247- @kamarkiewicz for fixes to no_std and CI 248- @bheisler for documentation and examples 249- @target-san for simplifying the `InputIter` trait for `&[u8]` 250- @willmurphyscode for documentation and examples 251- @Chaitanya1416 for typo fixes 252- @fflorent for `input_len()` usage fixes 253- @dbrgn for typo fixes 254- @iBelieve for no_std fixes 255- @kpp for warning fixes and clippy fixes 256- @keruspe for fixes on FindToken 257- @dtrebbien for fixes on take_until_and_consume1 258- @Henning-K for typo fixes 259- @vthriller for documentation fixes 260- @federicomenaquintero and @veprbl for their help fixing the float parsers 261- @vmchale for new named_args versions 262- @hywan for documentation fixes 263- @fbenkstein for typo fixes 264- @CAD97 for catching missing trait implementations 265- @goldenlentils for &str optimizations 266- @passy for typo fixes 267- @ayrat555 for typo fixes 268- @GuillaumeGomez for documentation fixes 269- @jrakow for documentation fixes and fixes for `switch!` 270- @phlosioneer for documentation fixes 271- @creativcoder for typo fixes 272- @derekdreery for typo fixes 273- @lucasem for implementing `Deref` on `CompleteStr` and `CompleteByteSlice` 274- @lowenheim for `parse_to!` fixes 275- @myrrlyn for trait fixes around `CompleteStr` and `CompleteByteSlice` 276- @NotBad4U for fixing code coverage analysis 277- @murarth for code formatting 278- @glandium for fixing build in no_std 279- @csharad for regex compatibility with `CompleteStr` 280- @FauxFaux for implementing `AsRef<str>` on `CompleteStr` 281- @jaje for implementing `std::Error` on `nom:Err` 282- @fengalin for warning fixes 283- @@khernyo for doc formatting 284 285Special thanks to @corkami for the logo :) 286 287### Breaking changes 288 289- the `IResult` type now becomes a `Result` from the standard library 290- `Incomplete` now returns the additional data size needed, not the total data size needed 291- verbose-errors is now a superset of basic errors 292- all the errors now include the related input slice 293- the arguments from `error_position` and other such macros were swapped to be more consistent with the rest of nom 294- automatic error conversion: to fix error type inference issues, a custom error type must now implement `std::convert::From<u32>` 295- the `not!` combinator returns unit `()` 296- FindToken's calling convention was swapped 297- the `take_*` combinators are now more coherent and stricter, see commit 484f6724ea3ccb for more information 298- `many0` and other related parsers will now return `Incomplete` if the reach the end of input without an error of the child parser. They will also return `Incomplete` on an empty input 299- the `sep!` combinator for whitespace only consumes whitespace in the prefix, while the `ws!` combinator takes care of consuming the remaining whitespace 300 301### Added 302 303- the `AtEof` trait for input type: indicate if we can get more input data later (related to streaming parsers and `Incomplete` handling) 304- the `escaped*` parsers now support the `&str`input type 305- the `Failure` error variant represents an unrecoverable error, for which `alt` and other combinators will not try other branches. This error means we got in the right part of the code (like, a prefix was checked correctly), but there was an error in the following parts 306- the `CompleteByteSlice` and `CompleteStr` input types consider there will be no more refill of the input. They fixed the `Incomplete` related issues when we have all of the data 307- the `exact!()` combinator will fail if we did not consume the whole input 308- the `take_while_m_n!` combinator will match a specified number of characters 309- `ErrorKind::TakeUntilAndConsume1` 310- the `recognize_float` parser will match a float number's characters, but will not transform to a `f32` or `f64` 311- `alpha` and other basic parsers are now much stricter about partial inputs. We also introduce the `*0` and `*1` versions of those parsers 312- `named_args` can now specify the input type as well 313- `HexDisplay` is now implemented for `&str` 314- `alloc` feature 315- the `InputTakeAtposition` trait allows specialized implementations of parsers like `take_while!` 316 317### Removed 318 319- the producers and consumers were removed 320- the `error_code` and `error_node` macros are not used anymore 321 322### Fixed 323 324- `anychar!` now works correctly with multibyte characters 325- `take_until_and_consume1!` no longer results in "no method named \`find_substring\`" and "no method named \`slice\`" compilation errors 326- `take_until_and_consume1!` returns the correct Incomplete(Needed) amount 327- `no_std` compiles properly, and nom can work with `alloc` too 328- `parse_to!` now consumes its input 329 330### Changed 331 332- `alt` and other combinators will now clone the input if necessary. If the input is already `Copy` there is no performance impact 333- the `rest` parser now works on various input types 334- `InputIter::Item` for `&[u8]` is now a `u8` directly, not a reference 335- we now use the `compile_error` macro to return a compile time error if there was a syntax issue 336- the permutation combinator now supports optional child parsers 337- the float numbers parsers have been refactored to use one common implementation that is nearly 2 times faster than the previous one 338- the float number parsers now accept more variants 339 340 341## 3.2.1 - 2017-10-27 342 343### Thanks 344 345- @ordian for `alt_complete` fixes 346- @friedm for documentation fixes 347- @kali for improving error management 348 349### Fixed 350 351- there were cases where `alt_complete` could return `Incomplete` 352 353### Added 354 355- an `into_error_kind` method can be used to transform any error to a common value. This helps when the library is included multiple times as dependency with different feature sets 356 357 358## 3.2.0 - 2017-07-24 359 360### Thanks 361 362- @jedireza for documentation fixes 363- @gmorenz for the `bytes` combinator 364- @meh for character combinator fixes for UTF-8 365- @jethrogb for avoiding move issues in `separated_list` 366 367### Changed 368 369- new layout for the main page of documentation 370- `anychar` can now work on any input type 371- `length_bytes` is now an alias for `length_data` 372 373### Fixed 374 375- `one_of`, `none_of` and `char` will now index correctly UTF-8 characters 376- the `compiler_error` macro is now correctly exported 377 378 379### Added 380 381- the `bytes` combinator transforms a bit stream back to a byte slice for child parsers 382 383## 3.1.0 - 2017-06-16 384 385### Thanks 386 387- @sdroege: implementing be_i24 and le_i24 388- @Hywan: integrating faster substring search using memchr 389- @nizox: fixing type issues in bit stream parsing 390- @grissiom: documentation fixes 391- @doomrobo: implementing separated_list_complete and separated_nonempty_list_complete 392- @CWood1: fixing memchr integration in no_std 393- @lu_zero: integrating the compiler_error crate 394- @dtolnay: helping debug a type inference issue in map 395 396### Changed 397 398- memchr is used for substring search if possible 399- if building on nightly, some common syntax errors will display a specific error message. If building no stable, display the documentation to activate those messages 400- `count` no longer preallocates its vector 401 402### Fixed 403 404- better type inference in alt_complete 405- `alt` should now work with whitespace parsing 406- `map` should not make type inference errors anymore 407 408### Added 409 410- be_i24 and le_i24, parsing big endian and little endian signed 24 bit integers 411- `separated_list_complete` and `separated_nonempty_list_complete` will treat incomplete from sub parsers as error 412 413## 3.0.0 - 2017-05-12 414 415### Thanks 416 417- Chris Pick for some `Incomplete` related refactors 418- @dbrgn for documentation fixes 419- @valarauca for adding `be_u24` 420- @ithinuel for usability fixes 421- @evuez for README readability fixes and improvements to `IResult` 422- @s3bk for allowing non-`Copy` types as input 423- @keruspe for documentation fixes 424- @0xd34d10cc for trait fixes on `InputIter` 425- @sdleffler for lifetime shenanigans on `named_args` 426- @chengsun for type inference fixes in `alt` 427- @iBelieve for adding str to no_std 428- @Hywan for simplifying code in input traits 429- @azerupi for extensive documentation of `alt` and `alt_complete` 430 431### Breaking Changes 432 433- `escaped`, `separated_list` and `separated_nonempty_list` can now return `Incomplete` when necessary 434- `InputIter` does not require `AsChar` on its `Item` type anymore 435- the `core` feature that was putting nom in `no_std` mode has been removed. There is now a `std` feature, activated by default. If it is not activated, nom is in `no_std` 436- in `verbose-errors` mode, the error list is now stored in a `Vec` instead of a box based linked list 437- `chain!` has finally been removed 438 439### Changed 440 441- `Endianness` now implements `Debug`, `PartialEq`, `Eq`, `Clone` and `Copy` 442- custom input types can now be cloned if they're not `Copy` 443- the infamous 'Cannot infer type for E' error should happen less often now 444- `str` is now available in `no_std` mode 445 446### Fixed 447 448- `FileProducer` will be marked as `Eof` on full buffer 449- `named_args!` now has lifetimes that cannot conflict with the lifetimes from other arguments 450 451### Added 452 453- `be_u24`: big endian 24 bit unsigned integer parsing 454- `IResult` now has a `unwrap_or` method 455 456 457## 2.2.1 - 2017-04-03 458 459### Thanks 460 461- @Victor-Savu for formatting fixes in the README 462- @chifflier for detecting and fixing integer overflows 463- @utkarshkukreti for some performance improvements in benchmarks 464 465### Changed 466 467- when calculating how much data is needed in `IResult::Incomplete`, the addition could overflow (it is stored as a usize). This would apparently not result in any security vulnerability on release code 468 469## 2.2.0 - 2017-03-20 470 471### Thanks 472 473- @seppo0010 for fixing `named_args` 474- @keruspe for implementing or() on `IResult`, adding the option of default cases in `switch!`, adding support for `cargo-travis` 475- @timlyo for documentation fixes 476- @JayKickliter for extending `hex_u32` 477- @1011X for fixing regex integration 478- @Kerollmops for actually marking `chain!` as deprecated 479- @joliss for documentation fixes 480- @utkarshkukreti for tests refactoring and performance improvement 481- @tmccombs for documentation fixes 482 483### Added 484 485- `IResult` gets an `or()` method 486- `take_until1`, `take_until_and_consume1`, `take_till1!` and `take_till1_s!` require at least 1 character 487 488### Changed 489 490- `hex_u32` accepts uppercase digits as well 491- the character based combinators leverage the input traits 492- the whitespace parsers now work on &str and other types 493- `take_while1` returns `Incomplete` on empty input 494- `switch!` can now take a default case 495 496### Fixed 497 498- `named_args!` now imports `IResult` directly 499- the upgrade to regex 0.2 broke the regex combinators, they work now 500 501## 2.1.0 - 2017-01-27 502 503### Thanks 504 505- @nickbabcock for documentation fixes 506- @derekdreery for documentation fixes 507- @DirkyJerky for documentation fixes 508- @saschagrunert for documentation fixes 509- @lucab for documentation fixes 510- @hyone for documentation fixes 511- @tstorch for factoring `Slice` 512- @shepmaster for adding crate categories 513- @antoyo for adding `named_args!` 514 515### Added 516 517- `verify!` uses a first parser, then applies a function to check that its result satisfies some conditions 518- `named_args!` creates a parser function that can accept other arguments along with the input 519- `parse_to!` will use the `parse` method from `FromStr` to parse a value. It will automatically translate the input to a string if necessary 520- `float`, `float_s`, `double`, `double_s` can recognize floating point numbers in text 521 522### Changed 523 524- `escaped!` will now return `Incomplete` if needed 525- `permutation!` supports up to 20 child parsers 526 527## 2.0.1 - 2016-12-10 528 529Bugfix release 530 531*Warning*: there is a small breaking change, `add_error!` is renamed to `add_return_error!`. This was planned for the 2.0 release but was forgotten. This is a small change in a feature that not many people use, for a release that is not yet widely in use, so there will be no 3.0 release for that change. 532 533### Thanks 534 535- @nickbabcock for catching and fixing the `add_error!` mixup 536- @lucab for documentation fixes 537- @jtdowney for noticing that `tag_no_case!` was not working at all for byte slices 538 539### Fixed 540 541- `add_error!` has been renamed to `add_return_error!` 542- the `not!` combinator now accepts functions 543- `tag_no_case!` is now working as accepted (before, it accepted everything) 544 545 546## 2.0 - 2016-11-25 547 548The 2.0 release is one of the biggest yet. It was a good opportunity to clean up some badly named combinators and fix invalid behaviours. 549 550Since this version introduces a few breaking changes, an [upgrade documentation](https://github.com/Geal/nom/blob/master/doc/upgrading_to_nom_2.md) is available, detailing the steps to fix the most common migration issues. After testing on a set of 30 crates, most of them will build directly, a large part will just need to activate the "verbose-errors" compilation feature. The remaining fixes are documented. 551 552This version also adds a lot of interesting features, like the permutation combinator or whitespace separated formats support. 553 554### Thanks 555 556- @lu-zero for license help 557- @adamgreig for type inference fixes 558- @keruspe for documentation and example fixes, for the `IResult => Result` conversion work, making `AsChar`'s method more consistent, and adding `many_till!` 559- @jdeeny for implementing `Offset` on `&str` 560- @vickenty for documentation fixes and his refactoring of `length_value!` and `length_bytes!` 561- @overdrivenpotato for refactoring some combinators 562- @taralx for documentation fixes 563- @keeperofdakeys for fixing eol behaviour, writing documentation and adding `named_attr!` 564- @jturner314 for writing documentation 565- @bozaro for fixing compilation errors 566- @uniphil for adding a `crates.io` badge 567- @badboy for documentation fixes 568- @jugglerchris for fixing `take_s!` 569- @AndyShiue for implementing `Error` and `Display` on `ErrorKind` and detecting incorrect UTF-8 string indexing 570 571### Added 572 573- the "simple" error management system does not accumulates errors when backtracking. This is a big perf gain, and is activated by default in nom 2.0 574- nom can now work on any type that implement the traits defined in `src/traits.rs`: `InputLength`, `InputIter`, `InputTake`, `Compare`, `FindToken`, `FindSubstring`, `Slice` 575- the documentation from Github's wiki has been moved to the `doc/` directory. They are markdown files that you can build with [cargo-external-doc](https://crates.io/crates/cargo-external-doc) 576- whitespace separated format support: with the `ws!` combinator, you can automatically introduce whitespace parsers between all parsers and combinators 577- the `permutation!` combinator applies its child parsers in any order, as long as they all succeed once, and return a tuple of the results 578- `do_parse!` is a simpler alternative to `chain!`, which is now deprecated 579- you can now transform an `IResult` in a `std::result::Result` 580- `length_data!` parses a length, and returns a subslice of that length 581- `tag_no_case!` provides case independent comparison. It works nicely, without any allocation, for ASCII strings, but for UTF-8 strings, it defaults to an unsatisfying (and incorrect) comparison by lowercasing both strings 582- `named_attr!` creates functions like `named!` but can add attributes like documentation 583- `many_till!` applies repeatedly its first child parser until the second succeeds 584 585### Changed 586 587- the "verbose" error management that was available in previous versions is now activated by the "verbose-errors" compilation feature 588- code reorganization: most of the parsers were moved in separate files to make the source easier to navigate 589- most of the combinators are now independent from the input type 590- the `eof` function was replaced with the `eof!` macro 591- `error!` and `add_error!` were replaced with `return_error!` and `add_return_error!` to fix the name conflict with the log crate 592- the `offset()` method is now in the `Offset` trait 593- `length_value!` has been renamed to `length_count!`. The new `length_value!` selects a slice and applies the second parser once on that slice 594- `AsChar::is_0_to_9` is now `AsChar::is_dec_digit` 595- the combinators with configurable endianness now take an enum instead of a boolean as parameter 596 597### Fixed 598- the `count!`, `count_fixed!` and `length_*!` combinator calculate incomplete data needs correctly 599- `eol`, `line_ending` and `not_line_ending` now have a consistent behaviour that works correctly with incomplete data 600- `take_s!` didn't correctly handle the case when the slice is exactly the right length 601 602## 1.2.4 - 2016-07-20 603 604### Thanks 605- @Phlosioneer for documentation fixes 606- @sourrust for fixing offsets in `take_bits!` 607- @ChrisMacNaughton for the XFS crate 608- @pwoolcoc for `rest_s` 609- @fitzgen for more `IResult` methods 610- @gtors for the negative lookahead feature 611- @frk1 and @jeandudey for little endian float parsing 612- @jethrogb for fixing input usage in `many1` 613- @acatton for beating me at nom golf :D 614 615### Added 616- the `rest_s` method on `IResult` returns the remaining `&str` input 617- `unwrap_err` and `unwrap_inc` methods on `IResult` 618- `not!` will peek at the input and return `Done` if the underlying parser returned `Error` or `Incomplete`, without consuming the input 619- `le_f32` and `le_f64` parse little endian floating point numbers (IEEE 754) 620- 621 622### Fixed 623- documentation fixes 624- `take_bits!` is now more precise 625- `many1` inccorectly used the `len` function instead of `input_len` 626- the INI parser is simpler 627- `recognize!` had an early `return` that is removed now 628 629## 1.2.3 - 2016-05-10 630 631### Thanks 632- @lu-zero for the contribution guidelines 633- @GuillaumeGomez for fixes on `length_bytes` and some documentation 634- @Hywan for documentation and test fixes 635- @Xirdus for correct trait import issues 636- @mspiegel for the new AST example 637- @cholcombe973 for adding the `cond_with_error!` combinator 638- @tstorch for refactoring `many0!` 639- @panicbit for the folding combinators 640- @evestera for `separated_list!` fixes 641- @DanielKeep for correcting some enum imports 642 643### Added 644- Regular expression combinators starting with `re_bytes_` work on byte slices 645- example parsing arithmetic expressions to an AST 646- `cond_with_error!` works like `cond!` but will return `None` if the condition is false, and `Some(value)` if the underlying parser succeeded 647- `fold_many0!`, `fold_many1!` and `fold_many_m_n!` will take a parser, an initial value and a combining function, and fold over the successful applications of the parser 648 649### Fixed 650- `length_bytes!` converts the result of its child parser to usize 651- `take_till!` now imports `InputLength` instead of assuming it's in scope 652- `separated_list!` and `separated_nonempty_list!` will not consume the separator if there's no following successfully parsed value 653- no more warnings on build 654 655### Changed 656- simpler implementation of `many0!` 657 658## 1.2.2 - 2016-03-09 659 660### Thanks 661- @conradev for fixing `take_until_s!` 662- @GuillaumeGomez for some documentation fixes 663- @frewsxcv for some documentation fixes 664- @tstorch for some test refactorings 665 666### Added 667- `nom::Err` now implements `std::error::Error` 668 669### Fixed 670- `hex_u32` does not parses more than 8 chars now 671- `take_while!` and `take_while1!` will not perturb the behaviour of `recognize!` anymore 672 673## 1.2.1 - 2016-02-23 674 675### Thanks 676- @sourrust for adding methods to `IResult` 677- @tstorch for the test refactoring, and for adding methods to `IResult` and `Needed` 678- @joelself for fixing the method system 679 680### Added 681 682- mapping methods over `IResult` and `Needed` 683 684### Changed 685 686- `apply_rf` is renamed to `apply_m`. This will not warrant a major version, since it is part missing from the methods feture added in the 1.2.0 release 687- the `regexp_macros` feature that used `regex!` to precompile regular expressions has been replaced by the normal regex engine combined with `lazy_static` 688 689### Fixed 690 691- when a parser or combinator was returning an empty buffer as remaining part, it was generating one from a static empty string. This was messing with buffer offset calculation. Now, that empty slice is taken like this: `&input[input.len()..]`. 692- The `regexp_macros` and `no_std` feature build again and are now tested with Travis CI 693 694## 1.2.0 - 2016-02-08 695 696### Thanks 697- @zentner-kyle for type inference fixes 698- @joelself for his work on `&str` parsing and method parsers 699- @GuillaumeGomez for implementing methods on `IResult` 700- @dirk for the `alt_complete!` combinator 701- @tstorch for a lot of refactoring work and unit tests additions 702- @jansegre for the hex digit parsers 703- @belgum for some documentation fixes 704- @lwandrebeck for some documentation fixes and code fixes in `hex_digit` 705 706### Added 707- `take_until_and_consume_s!` for consumption of string data until a tag 708- more function patterns in `named!`. The error type can now be specified 709- `alt_complete!` works like the `alt!` combinator, but tries the next branch if the current one returned `Incomplete`, instead of returning directly 710- more unit tests for a lot of combinators 711- hexadecimal digit parsers 712- the `tuple!` combinator takes a list of parsers as argument, and applies them serially on the input. If all of them are successful, it willr eturn a tuple accumulating all the values. This combinator will (hopefully) replace most uses of `chain!` 713- parsers can now be implemented as a method for a struct thanks to the `method!`, `call_m!` and `apply_rf!` combinators 714 715### Fixed 716- there were type inference issues in a few combinators. They will now be easier to compile 717- `peek!` compilation with bare functions 718- `&str` parsers were splitting data at the byte level, not at the char level, which can result in inconsistencies in parsing UTF-8 characters. They now use character indexes 719- some method implementations were missing on `IResult<I,O,E>` (with specified error type instead of implicit) 720 721## 1.1.0 - 2016-01-01 722 723This release adds a lot of features related to `&str` parsing. The previous versions 724were focused on `&[u8]` and bit streams parsing, but there's a need for more text 725parsing with nom. The parsing functions like `alpha`, `digit` and others will now 726accept either a `&[u8]` or a `&str`, so there is no breaking change on that part. 727 728There are also a few performance improvements and documentation fixes. 729 730### Thanks 731- @Binero for pushing the work on `&str` parsing 732- @meh for fixing `Option` and `Vec` imports 733- @hoodie for a documentation fix 734- @joelself for some documentation fixes 735- @vberger for his traits magic making nom functions more generic 736 737### Added 738 739- string related parsers: `tag_s!`, `take_s!`, `is_a_s!`, `is_not_s!`, `take_while_s!`, `take_while1_s!`, `take_till_s!` 740- `value!` is a combinator that always returns the same value. If a child parser is passed as second argument, that value is returned when the child parser succeeds 741 742### Changed 743 744- `tag!` will now compare even on partial input. If it expects "abcd" but receives "ef", it will now return an `Error` instead of `Incomplete` 745- `many0!` and others will preallocate a larger vector to avoid some copies and reallocations 746- `alpha`, `digit`, `alphanumeric`, `space` and `multispace` now accept as input a `&[u8]` or a `&str`. Additionally, they return an error if they receive an empty input 747- `take_while!`, `take_while1!`, `take_while_s!`, `take_while1_s!` wilreturn an error on empty input 748 749### Fixed 750 751- if the child parser of `many0!` or `many1!` returns `Incomplete`, it will return `Incomplete` too, possibly updating the needed size 752- `Option,` `Some`, `None` and `Vec` are now used with full path imports 753 754## 1.0.1 - 2015-11-22 755 756This releases makes the 1.0 version compatible with Rust 1.2 and 1.3 757 758### Thanks 759- @steveklabnik for fixing lifetime issues in Producers and Consumers 760 761## 1.0.0 - 2015-11-16 762 763Stable release for nom. A lot of new features, a few breaking changes 764 765### Thanks 766- @ahenry for macro fixes 767- @bluss for fixing documentation 768- @sourrust for cleaning code and debugging the new streaming utilities 769- @meh for inline optimizations 770- @ccmtaylor for fixing function imports 771- @soro for improvements to the streaming utilities 772- @breard-r for catching my typos 773- @nelsonjchen for catching my typos too 774- @divarvel for hex string parsers 775- @mrordinaire for the `length_bytes!` combinator 776 777### Breaking changes 778- `IResult::Error` can now use custom error types, and is generic over the input type 779- Producers and consumers have been replaced. The new implementation uses less memory and integrates more with parsers 780- `nom::ErrorCode` is now `nom::ErrorKind` 781- `filter!` has been renamed to `take_while!` 782- `chain!` will count how much data is consumed and use that number to calculate how much data is needed if a parser returned `Incomplete` 783- `alt!` returns `Incomplete` if a child parser returned `Incomplete`, instead of skipping to the next parser 784- `IResult` does not require a lifetime tag anymore, yay! 785 786### Added 787 788- `complete!` will return an error if the child parser returned `Incomplete` 789- `add_error!` will wrap an error, but allow backtracking 790- `hex_u32` parser 791 792### Fixed 793- the behaviour around `Incomplete` is better for most parsers now 794 795## 0.5.0 - 2015-10-16 796 797This release fixes a few issues and stabilizes the code. 798 799### Thanks 800- @nox for documentation fixes 801- @daboross for linting fixes 802- @ahenry for fixing `tap!` and extending `dbg!` and `dbg_dmp!` 803- @bluss for tracking down and fixing issues with unsafe code 804- @meh for inlining parser functions 805- @ccmtaylor for fixing import of `str::from_utf8` 806 807### Fixed 808- `tap!`, `dbg!` and `dbg_dmp!` now accept function parameters 809 810### Changed 811- the type used in `count_fixed!` must be `Copy` 812- `chain!` calculates how much data is needed if one of the parsers returns `Incomplete 813- optional parsers in `chain!` can return `Incomplete` 814 815## 0.4.0 - 2015-09-08 816 817Considering the number of changes since the last release, this version can contain breaking changes, so the version number becomes 0.4.0. A lot of new features and performance improvements! 818 819### Thanks 820- @frewsxcv for documentation fixes 821- @ngrewe for his work on producers and consumers 822- @meh for fixes on `chain!` and for the `rest` parser 823- @daboross for refactoring `many0!` and `many1!` 824- @aleksander for the `switch!` combinator idea 825- @TechnoMancer for his help with bit level parsing 826- @sxeraverx for pointing out a bug in `is_a!` 827 828### Fixed 829- `count_fixed!` must take an explicit type as argument to generate the fixed-size array 830- optional parsing behaviour in `chain!` 831- `count!` can take 0 elements 832- `is_a!` and `is_not!` can now consume the whole input 833 834### Added 835- it is now possible to seek to the end of a `MemProducer` 836- `opt!` returns `Done(input, None)` if `the child parser returned `Incomplete` 837- `rest` will return the remaining input 838- consumers can now seek to and from the end of input 839- `switch!` applies a first parser then matches on its result to choose the next parser 840- bit-level parsers 841- character-level parsers 842- regular expression parsers 843- implementation of `take_till!`, `take_while!` and `take_while1!` 844 845### Changed 846- `alt!` can return `Incomplete` 847- the error analysis functions will now take references to functions instead of moving them 848- performance improvements on producers 849- performance improvement for `filter!` 850- performance improvement for `count!`: a `Vec` of the right size is directly allocated 851 852## 0.3.11 - 2015-08-04 853 854### Thanks 855- @bluss for remarking that the crate included random junk lying non commited in my local repository 856 857### Fixed 858- cleanup of my local repository will ship less files in the crates, resulting in a smaller download 859 860## 0.3.10 - 2015-08-03 861 862### Added 863 864- `bits!` for bit level parsing. It indicates that all child parsers will take a `(&[u8], usize)`as input, with the second parameter indicating the bit offset in the first byte. This allows viewing a byte slice as a bit stream. Most combinators can be used directly under `bits!` 865- `take_bits!` takes an integer type and a number of bits, consumes that number of bits and updates the offset, possibly by crossing byte boundaries 866- bit level parsers are all written in `src/bits.rs` 867 868### Changed 869 870- Parsers that specifically handle bytes have been moved to src/bytes.rs`. This applies to `tag!`, `is_not!`, `is_a!`, `filter!`, `take!`, `take_str!`, `take_until_and_consume!`, `take_until!`, `take_until_either_and_consume!`, `take_until_either!` 871 872## 0.3.9 - 2015-07-20 873 874### Thanks 875- @badboy for fixing `filter!` 876- @idmit for some documentation fixes 877 878### Added 879- `opt_res!` applies a parser and transform its result in a Result. This parser never fails 880- `cond_reduce!` takes an expression as parameter, applies the parser if the expression is true, and returns an error if the expression is false 881- `tap!` pass the result of a parser to a block to manipulate it, but do not affect the parser's result 882- `AccReader` is a Read+BufRead that supports data accumulation and partial consumption. The `consume` method must be called afterwardsto indicate how much was consumed 883- Arithmetic expression evaluation and parsing example 884- `u16!`, `u32!`, `u64!`, `i16!`, `i32!`, `i64!` take an expression as parameter, if the expression is true, apply the big endian integer parser, if false, the little endian version 885- type information for combinators. This will make the documentation a bit easier to navigate 886 887### Fixed 888- `map_opt!` and `map_res!` had issues with argument order due to bad macros 889- `delimited!` did not compile for certain combinations of arguments 890- `filter!` did not return a byte slice but a fixed array 891 892## 0.3.8 - 2015-07-03 893 894### Added 895- code coverage is now calculated automatically on Travis CI 896- `Stepper`: wrap a `Producer`, and call the method `step` with a parser. This method will buffer data if there is not enough, apply the parser if there is, and keep the rest of the input in memory for the next call 897- `ReadProducer`: takes something implementing `Read`, and makes a `Producer` out of it 898 899### Fixed 900- the combinators `separated_pair!` and `delimited!` did not work because an implementation macro was not exported 901- if a `MemProducer` reached its end, it should always return `Eof` 902- `map!` had issues with argument matching 903 904## 0.3.7 - 2015-06-24 905 906### Added 907- `expr_res!` and `expr_opt!` evaluate an expression returning a Result or Opt and convert it to IResult 908- `AsBytes` is implemented for fixed size arrays. This allows `tag!([41u8, 42u8])` 909 910### Fixed 911- `count_fixed!` argument parsing works again 912 913## 0.3.6 - 2015-06-15 914 915### Added 916- documentation for a few functions 917- the consumer trait now requires the `failed(&self, error_code)` method in case of parsing error 918- `named!` now handles thge alternative `named!(pub fun_name<OutputType>, ...)` 919 920### Fixed 921- `filter!` now returns the whole input if the filter function never returned false 922- `take!` casts its argument as usize, so it can accepts any integer type now 923 924## 0.3.5 - 2015-06-10 925 926### Thanks 927- @cmr for some documentation fixes 928 929### Added 930- `count_fixed!` returns a fixed array 931 932### Fixed 933- `count!` is back to the previous behaviour, returning a `Vec` for sizes known at runtime 934 935### Changed 936- functions and traits exported from `nom::util` are now directly in `nom::` 937 938## 0.3.4 - 2015-06-09 939 940### Thanks 941- @andrew-d for fixes on `cond!` 942- @keruspe for features in `chain!` 943 944### Added 945- `chain!` can now have mutable fields 946 947### Fixed 948- `cond!` had an infinite macro recursion 949 950### Changed 951- `chain!` generates less code now. No apprent compilation time improvement 952 953## 0.3.3 - 2015-06-09 954 955### Thanks 956- @andrew-d for the little endian signed integer parsers 957- @keruspe for fixes on `count!` 958 959### Added 960- `le_i8`, `le_i16`, `le_i32`, `le_i64`: little endian signed integer parsers 961 962### Changed 963- the `alt!` parser compiles much faster, even with more than 8 branches 964- `count!` can now return a fixed size array instead of a growable vector 965 966## 0.3.2 - 2015-05-31 967 968### Thanks 969- @keruspe for the `take_str` parser and the function application combinator 970 971### Added 972- `take_str!`: takes the specified number of bytes and return a UTF-8 string 973- `apply!`: do partial application on the parameters of a function 974 975### Changed 976- `Needed::Size` now contains a `usize` instead of a `u32` 977 978## 0.3.1 - 2015-05-21 979 980### Thanks 981- @divarvel for the big endian signed integer parsers 982 983### Added 984- `be_i8`, `be_i16`, `be_i32`, `be_i64`: big endian signed integer parsers 985- the `core` feature can be passed to cargo to build with `no_std` 986- colored hexdump can be generated from error chains 987 988## 0.3.0 - 2015-05-07 989 990### Thanks 991- @filipegoncalves for some documentation and the new eof parser 992- @CrimsonVoid for putting fully qualified types in the macros 993- @lu_zero for some documentation fixes 994 995### Added 996- new error types that can contain an error code, an input slice, and a list of following errors 997- `error!` will cut backtracking and return directly from the parser, with a specified error code 998- `eof` parser, successful if there is no more input 999- specific error codes for the parsers provided by nom 1000 1001### Changed 1002- fully qualified types in macros. A lot of imports are not needed anymore 1003 1004### Removed 1005- `FlatMap`, `FlatpMapOpt` and `Functor` traits (replaced by `map!`, `map_opt!` and `map_res!`) 1006 1007## 0.2.2 - 2015-04-12 1008 1009### Thanks 1010- @filipegoncalves and @thehydroimpulse for debugging an infinite loop in many0 and many1 1011- @thehydroimpulse for suggesting public named parsers 1012- @skade for removing the dependency on the collections gate 1013 1014### Added 1015- `named!` can now declare public functions like this: `named!(pub tst, tag!("abcd"));` 1016- `pair!(X,Y)` returns a tuple `(x, y)` 1017- `separated_pair!(X, sep, Y)` returns a tuple `(x, y)` 1018- `preceded!(opening, X)` returns `x` 1019- `terminated!(X, closing)` returns `x` 1020- `delimited(opening, X, closing)` returns `x` 1021- `separated_list(sep, X)` returns a `Vec<X>` 1022- `separated_nonempty_list(sep, X)` returns a `Vec<X>` of at list one element 1023 1024### Changed 1025- `many0!` and `many1!` forbid parsers that do not consume input 1026- `is_a!`, `is_not!`, `alpha`, `digit`, `space`, `multispace` will now return an error if they do not consume at least one byte 1027 1028## 0.2.1 - 2015-04-04 1029 1030### Thanks 1031- @mtsr for catching the remaining debug println! 1032- @jag426 who killed a lot of warnings 1033- @skade for removing the dependency on the core feature gate 1034 1035 1036### Added 1037- little endian unsigned int parsers le_u8, le_u16, le_u32, le_u64 1038- `count!` to apply a parser a specified number of times 1039- `cond!` applies a parser if the condition is met 1040- more parser development tools in `util::*` 1041 1042### Fixed 1043- in one case, `opt!` would not compile 1044 1045### Removed 1046- most of the feature gates are now removed. The only one still needed is `collections` 1047 1048## 0.2.0 - 2015-03-24 1049*works with `rustc 1.0.0-dev (81e2396c7 2015-03-19) (built 2015-03-19)`* 1050 1051### Thanks 1052- Ryman for the AsBytes implementation 1053- jag426 and jaredly for documentation fixes 1054- eternaleye on #rust IRC for his help on the new macro syntax 1055 1056### Changed 1057- the AsBytes trait improves readability, no more b"...", but "..." instead 1058- Incomplete will now hold either Needed;;Unknown, or Needed::Size(u32). Matching on Incomplete without caring for the value is done with `Incomplete(_)`, but if more granularity is mandatory, `Needed` can be matched too 1059- `alt!` can pass the result of the parser to a closure 1060- the `take_*` macros changed behaviour, the default case is now not to consume the separator. The macros have been renamed as follows: `take_until!` -> `take_until_and_consume!`, `take_until_and_leave!` -> `take_until!`, `take_until_either_and_leave!` -> `take_until_either!`, `take_until_either!` -> `take_until_either_and_consume!` 1061 1062### Added 1063- `peek!` macro: matches the future input but does not consume it 1064- `length_value!` macro: the first argument is a parser returning a `n` that can cast to usize, then applies the second parser `n` times. The macro has a variant with a third argument indicating the expected input size for the second parser 1065- benchmarks are available at https://github.com/Geal/nom_benchmarks 1066- more documentation 1067- **Unnamed parser syntax**: warning, this is a breaking change. With this new syntax, the macro combinators do not generate functions anymore, they create blocks. That way, they can be nested, for better readability. The `named!` macro is provided to create functions from parsers. Please be aware that nesting parsers comes with a small cost of compilation time, negligible in most cases, but can quickly get to the minutes scale if not careful. If this happens, separate your parsers in multiple subfunctions. 1068- `named!`, `closure!` and `call!` macros used to support the unnamed syntax 1069- `map!`, `map_opt!` and `map_res!` to combine a parser with a normal function, transforming the input directly, or returning an `Option` or `Result` 1070 1071### Fixed 1072- `is_a!` is now working properly 1073 1074### Removed 1075- the `o!` macro does less than `chain!`, so it has been removed 1076- the `fold0!` and `fold1!` macros were too complex and awkward to use, the `many*` combinators will be useful for most uses for now 1077 1078## 0.1.6 - 2015-02-24 1079### Changed 1080- consumers must have an end method that will be called after parsing 1081 1082### Added 1083- big endian unsigned int and float parsers: be_u8, be_u16, be_u32, be_u64, be_f32, be_f64 1084- producers can seek 1085- function and macros documentation 1086- README documentation 1087### Fixed 1088- lifetime declarations 1089- tag! can return Incomplete 1090 1091## 0.1.5 - 2015-02-17 1092### Changed 1093- traits were renamed: FlatMapper -> FlatMap, Mapper -> FlatMapOpt, Mapper2 -> Functor 1094 1095### Fixed 1096- woeks with rustc f1bb6c2f4 1097 1098## 0.1.4 - 2015-02-17 1099### Changed 1100- the chaining macro can take optional arguments with '?' 1101 1102## 0.1.3 - 2015-02-16 1103### Changed 1104- the chaining macro now takes the closure at the end of the argument list 1105 1106## 0.1.2 - 2015-02-16 1107### Added 1108- flat_map implementation for <&[u8], &[u8]> 1109- chaining macro 1110- partial MP4 parser example 1111 1112 1113## 0.1.1 - 2015-02-06 1114### Fixed 1115- closure syntax change 1116 1117## Compare code 1118 1119* [unreleased](https://github.com/Geal/nom/compare/5.1.1...HEAD) 1120* [5.1.1](https://github.com/Geal/nom/compare/5.1.0...5.1.1) 1121* [5.1.0](https://github.com/Geal/nom/compare/5.0.1...5.1.0) 1122* [5.0.1](https://github.com/Geal/nom/compare/5.0.0...5.0.1) 1123* [5.0.0](https://github.com/Geal/nom/compare/4.2.3...5.0.0) 1124* [4.2.3](https://github.com/Geal/nom/compare/4.2.2...4.2.3) 1125* [4.2.2](https://github.com/Geal/nom/compare/4.2.1...4.2.2) 1126* [4.2.1](https://github.com/Geal/nom/compare/4.2.0...4.2.1) 1127* [4.2.0](https://github.com/Geal/nom/compare/4.1.1...4.2.0) 1128* [4.1.1](https://github.com/Geal/nom/compare/4.1.0...4.1.1) 1129* [4.1.0](https://github.com/Geal/nom/compare/4.0.0...4.1.0) 1130* [4.0.0](https://github.com/Geal/nom/compare/3.2.1...4.0.0) 1131* [3.2.1](https://github.com/Geal/nom/compare/3.2.0...3.2.1) 1132* [3.2.0](https://github.com/Geal/nom/compare/3.1.0...3.2.0) 1133* [3.1.0](https://github.com/Geal/nom/compare/3.0.0...3.1.0) 1134* [3.0.0](https://github.com/Geal/nom/compare/2.2.1...3.0.0) 1135* [2.2.1](https://github.com/Geal/nom/compare/2.2.0...2.2.1) 1136* [2.2.0](https://github.com/Geal/nom/compare/2.1.0...2.2.0) 1137* [2.1.0](https://github.com/Geal/nom/compare/2.0.1...2.1.0) 1138* [2.0.1](https://github.com/Geal/nom/compare/2.0.0...2.0.1) 1139* [2.0.0](https://github.com/Geal/nom/compare/1.2.4...2.0.0) 1140* [1.2.4](https://github.com/Geal/nom/compare/1.2.3...1.2.4) 1141* [1.2.3](https://github.com/Geal/nom/compare/1.2.2...1.2.3) 1142* [1.2.2](https://github.com/Geal/nom/compare/1.2.1...1.2.2) 1143* [1.2.1](https://github.com/Geal/nom/compare/1.2.0...1.2.1) 1144* [1.2.0](https://github.com/Geal/nom/compare/1.1.0...1.2.0) 1145* [1.1.0](https://github.com/Geal/nom/compare/1.0.1...1.1.0) 1146* [1.0.1](https://github.com/Geal/nom/compare/1.0.0...1.0.1) 1147* [1.0.0](https://github.com/Geal/nom/compare/0.5.0...1.0.0) 1148* [0.5.0](https://github.com/geal/nom/compare/0.4.0...0.5.0) 1149* [0.4.0](https://github.com/geal/nom/compare/0.3.11...0.4.0) 1150* [0.3.11](https://github.com/geal/nom/compare/0.3.10...0.3.11) 1151* [0.3.10](https://github.com/geal/nom/compare/0.3.9...0.3.10) 1152* [0.3.9](https://github.com/geal/nom/compare/0.3.8...0.3.9) 1153* [0.3.8](https://github.com/Geal/nom/compare/0.3.7...0.3.8) 1154* [0.3.7](https://github.com/Geal/nom/compare/0.3.6...0.3.7) 1155* [0.3.6](https://github.com/Geal/nom/compare/0.3.5...0.3.6) 1156* [0.3.5](https://github.com/Geal/nom/compare/0.3.4...0.3.5) 1157* [0.3.4](https://github.com/Geal/nom/compare/0.3.3...0.3.4) 1158* [0.3.3](https://github.com/Geal/nom/compare/0.3.2...0.3.3) 1159* [0.3.2](https://github.com/Geal/nom/compare/0.3.1...0.3.2) 1160* [0.3.1](https://github.com/Geal/nom/compare/0.3.0...0.3.1) 1161* [0.3.0](https://github.com/Geal/nom/compare/0.2.2...0.3.0) 1162* [0.2.2](https://github.com/Geal/nom/compare/0.2.1...0.2.2) 1163* [0.2.1](https://github.com/Geal/nom/compare/0.2.0...0.2.1) 1164* [0.2.0](https://github.com/Geal/nom/compare/0.1.6...0.2.0) 1165* [0.1.6](https://github.com/Geal/nom/compare/0.1.5...0.1.6) 1166* [0.1.5](https://github.com/Geal/nom/compare/0.1.4...0.1.5) 1167* [0.1.4](https://github.com/Geal/nom/compare/0.1.3...0.1.4) 1168* [0.1.3](https://github.com/Geal/nom/compare/0.1.2...0.1.3) 1169* [0.1.2](https://github.com/Geal/nom/compare/0.1.1...0.1.2) 1170* [0.1.1](https://github.com/Geal/nom/compare/0.1.0...0.1.1) 1171