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