Log message:
miller: update to 5.8.0.

ChangeLog:

Features

    The new count verb is a keystroke-saver for stats1 -a count -f
    {some field name}.

    --jsonx and --ojsonx are keystroke-savers for --json --jvstack
    and --ojson --jvstack, which is to say, multi-line pretty-printed
    JSON format.

    The new -s name=value feature for mlr put and mlr filter gives
    you simpler access to environment variables in your Miller
    script, as requested in #315.

Bugfixes

    mlr format-values is no longer SEGVing on CSV/TSV input. This
    was reported on #330.

    #313 fixes a corner case when field names within command-line
    arguments have embedded newlines.

    Line/column indicators for JSON-formatting error messages are
    now correct (previously they were showing up as 0).

    end {print NF} no longer SEGVs. This was reported in #330.

    Several broken doc links were fixed up as reported on #329.

Log message:
miller: update to 5.7.0.

ChangeLog:

Features

    The new remove-empty-columns and skip-trivial-records are
    keystroke-savers for things which would other require DSL
    syntax, as tracked in #274.

Bugfixes

    A bug regarding optional regex-pattern groups was fixed in
    #277.

    As of #294 you can now specify --implicit-csv-header for the
    join-file in mlr join.

    A bug with spaces in XTAB-file values was fixed on #296.

    A bug with missing final newline for XTAB-formatted files
    using MMAP files was fixed on #301.

Documentation

    Look-and-feel at http://johnkerl.org/miller/doc/ is (hopefully)
    improved, including clearer visual indication of which section/page
    you're currently looking at. Note that this change has been
    live for a few weeks, as look-and-feel-related doc-mods from
    post-5.6.2 were backported to http://johnkerl.org/miller/doc/.

    #282 improves DSL-function documentation at
    \ 
http://johnkerl.org/miller/doc/reference-dsl.html#Built-in_functions_for_filter_and_put,_summary

Note

Support for mmap mode has been entirely discontinued. This is an
invisible change and should not affect you at all. For anyone
interested in lower-level details, though, the summary is as follows:

    For an incremental performance gain (perhaps 10-20% run time
    at most, but see below), within the C source code one can use
    the mmap system call to access input files via pointer arithmetic
    rather than malloc-and-memcopy using stdio.

    However mmap is not available when reading from standard
    input -- it cannot be memory-mapped.

    This means all file-format readers are implemented twice
    within the Miller source code.

    While I try to regression-test Miller thoroughly, running
    all canned tests through mmap and stdio mode, I've nonetheless
    found my mmap implementations liable to corner-cases which I
    miss but users find: for example #29, #102, and #296.

    As tracked on #160, various operating systems do not release
    mmapped pages after use as one might intuit, meaning that for
    large files and/or large numbers of files, I've for a long time
    now needed to have Miller opt out of mmap usage for precisely
    those cases which most need the performance gain: see #160,
    #181, and #256.

    Additionally, mmap is not used at all for Windows/MSYS2 so
    there is nothing to lose there.

For these reasons, keeping mmap mode isn't worth the development
overhead.

As of release 5.6.3, the mlr executable will still accept the --mmap
and --no-mmap command-line flags as no-ops, for backward compatibility.

The caveat for you is that for everyday small files, the default
was previously mmap mode and is now stdio (except mlr ... < filename
or ... | mlr ... which have always used stdio). There is the off
chance that this will newly reveal an old, latent bug or two
somewhere.

I've re-run regressions in valgrind mode to aggressively catch any
errors, but, please let me know ASAP via GitHub issue of any
unexpected behavior in 5.7.0.

Log message:
miller: update to 5.6.2.

ChangeLog:

v5.6.2

Bug fixes:

    #271 fixes a corner-case bug with more than 100 CSV/TSV files with
    headers of varying lengths.

Documentation:

    The new http://johnkerl.org/miller/doc/whyc-details.html is an
    elaboration on http://johnkerl.org/miller/doc/whyc.html which answers
    a question posed by @BurntSushi on Reddit a couple years ago which
    I did not address in detail at the time.

v5.6.1

    The only change is that http://johnkerl.org/miller/doc is now
    more mobile-friendly.  All build artifacts are the same as at
    https://github.com/johnkerl/miller/releases/tag/v5.6.0

v5.6.0

    The new system DSL function allows you to run arbitrary shell commands
    and store them in field values. Some example usages are documented
    here. This is in response to issues #246 and #209.

    There is now support for ASV and USV file formats. This is in response
    to issue #245.

    The new format-values verb allows you to apply numerical formatting
    across all record values. This is in response to issue #252.

Documentation:

    The new DKVP I/O in Python sample code now works for Python 2 as
    well as Python 3.

    There is a new cookbook entry on doing multiple joins. This is in
    response to issue #235.

Bugfixes:

    The toupper, tolower, and capitalize DSL functions
    are now UTF-8 aware, thanks to @sheredom's marvelous
    https://github.com/sheredom/utf8.h. The internationalization page
    has also been expanded. This is in response to issue #254.

    #250 fixes a bug using in-place mode in conjunction with verbs
    (such as rename or sort) which take field-name lists as arguments.

    #253 fixes a bug in the label when one or more names are common
    between old and new.

    #251 fixes a corner-case bug when (a) input is CSV; (b) the last
    field ends with a comma and no newline; (c) input is from standard
    input and/or --no-mmap is supplied.

v5.5.0

    The new positional-indexing feature resolves #236 from @aborruso. You
    can now get the name of the 3rd field of each record via $[[3]], and
    its value by $[[[3]]]. These are both usable on either the left-hand
    or right-hand side of assignment statements, so you can more easily
    do things like renaming fields progrmatically within the DSL.

    There is a new capitalize DSL function, complementing the
    already-existing toupper. This stems from #236.

    There is a new skip-trivial-records verb, resolving #197. Similarly,
    there is a new remove-empty-columns verb, resolving #206. Both are
    useful for data-cleaning use-cases.

    Another pair is #181 and #256. While Miller uses mmap internally
    (and invisibily) to get approximately a 20% performance boost over
    not using it, this can cause out-of-memory issues with reading either
    large files, or too many small ones. Now, Miller automatically avoids
    mmap in these cases. You can still use --mmap or --no-mmap if you
    want manual control of this.

    There is a new --ivar option for the nest verb which complements
    the already-existing --evar. This is from #260 thanks to @jgreely.

    There is a new keystroke-saving urandrange DSL function:
    urandrange(low, high) is the same as low + (high - low) *
    urand(). This arose from #243.

    There is a new -v option for the cat verb which writes a low-level
    record-structure dump to standard error.

    There is a new -N option for mlr which is a keystroke-saver for
    --implicit-csv-header --headerless-csv-output.

Documentation:

    The new FAQ entry
    http://johnkerl.org/miller/doc/faq.html#How_to_escape_'%3F'_in_regexes%3F
    resolves #203.

    The new FAQ entry
    http://johnkerl.org/miller/doc/faq.html#How_can_I_filter_by_date%3F
    resolves #208.

    #244 fixes a documentation issue while highlighting the need for #241.

Bugfixes:

    There was a SEGV using nest within then-chains, fixed in response
    to #220.

    Quotes and backslashes weren't being escaped in JSON output with
    --jvquoteall; reported on #222.

v5.4.0

    The new clean-whitespace verb resolves #190 from @aborruso. Along with
    the new functions strip, lstrip, rstrip, collapse_whitespace, and
    clean_whitespace, there is now both coarse-grained and fine-grained
    control over whitespace within field names and/or values. See the
    linked-to documentation for examples.

    The new altkv verb resolves #184 which was originally opened via an
    email request. This supports mapping value-lists such as a,b,c,d to
    alternating key-value pairs such as a=b,c=d.

    The new fill-down verb resolves #189 by @aborruso. See the linked-to
    documentation for examples.

    The uniq verb now has a uniq -a which resolves #168 from @sjackman.

    The new regextract and regextract_or_else functions resolve #183
    by @aborruso.

    The new ssub function arises from #171 by @dohse, as a simplified way
    to avoid escaping characters which are special to regular-expression
    parsers.

    There are new localtime functions in response to #170 by
    @sitaramc. However note that as discussed on #170 these do
    not undo one another in all circumstances. This is a non-issue
    for timezones which do not do DST. Otherwise, please use with
    disclaimers: localdate, localtime2sec, sec2localdate, sec2localtime,
    strftime_local, and strptime_local.

Builds:

    Windows build-artifacts are now available in Appveyor at
    https://ci.appveyor.com/project/johnkerl/miller/build/artifacts,
    and will be attached to this and future releases. This resolves #167,
    #148, and #109.

    Travis builds at https://travis-ci.org/johnkerl/miller/builds now
    run on OSX as well as Linux.

    An Ubuntu 17 build issue was fixed by @singalen on #164.

Documentation:

    put/filter documentation was confusing as reported by @NikosAlexandris
    on #169.

    The new FAQ entry
    \ 
http://johnkerl.org/miller-releases/miller-head/doc/faq.html#How_to_rectangularize_after_joins_with_unpaired?
    resolves #193 by @aborruso.

    The new cookbook entry
    \ 
http://johnkerl.org/miller/doc/cookbook.html#Options_for_dealing_with_duplicate_rows
    arises from #168 from @sjackman.

    The unsparsify documentation had some words missing as reported by
    @tst2005 on #194.

    There was a typo in the cookpage page
    http://johnkerl.org/miller/doc/cookbook.html#Full_field_renames_and_reassigns
    as fixed by @tst2005 in #192.

Bugfixes:

    There was a memory leak for TSV-format files only as reported by
    @treynr on #181.

    Dollar sign in regular expressions were not being escaped properly
    as reported by @dohse on #171.

v5.3.0

    Comment strings in data files: mlr --skip-comments allows
    you to filter out input lines starting with #, for all file
    formats. Likewise, mlr --skip-comments-with X lets you specify
    the comment-string X. Comments are only supported at start of data
    line. mlr --pass-comments and mlr --pass-comments-with X allow you
    to forward comments to program output as they are read.

    The count-similar verb lets you compute cluster sizes by cluster
    labels.

    While Miller DSL arithmetic gracefully overflows from 64-integer
    to double-precision float (see also here), there are now the
    integer-preserving arithmetic operators .+ .- .* ./ .// for those
    times when you want integer overflow.

    There is a new bitcount function: for example, echo x=0xf0000206 |
    mlr put '$y=bitcount($x)' produces x=0xf0000206,y=7.

    Issue 158: mlr -T is an alias for --nidx --fs tab, and mlr -t is an
    alias for mlr --tsvlite.

    The mathematical constants π and e have been renamed from PI and
    E to M_PI and M_E, respectively. (It's annoying to get a syntax
    error when you try to define a variable named E in the DSL, when
    A through D work just fine.) This is a backward incompatibility,
    but not enough of us to justify calling this release Miller 6.0.0.

Documentation:

    As noted here, while Miller has its own DSL there will always be
    things better expressible in a general-purpose language. The new page
    Sharing data with other languages shows how to seamlessly share data
    back and forth between Miller, Ruby, and Python. SQL-input examples
    and SQL-output examples contain detailed information the interplay
    between Miller and SQL.

    Issue 150 raised a question about suppressing numeric conversion. This
    resulted in a new FAQ entry How do I suppress numeric conversion?,
    as well as the longer-term follow-on issue 151 which will make
    numeric conversion happen on a just-in-time basis.

    To my surprise, csvlite format options weren’t listed in mlr --help
    or the manpage. This has been fixed.

    Documentation for auxiliary commands has been expanded, including
    within the manpage.

Bugfixes:

    Issue 159 fixes regex-match of literal dot.

    Issue 160 fixes out-of-memory cases for huge files. This is an old
    bug, as old as Miller, and is due to inadequate testing of huge-file
    cases. The problem is simple: Miller prefers memory-mapped I/O
    (using mmap) over stdio since mmap is fractionally faster. Yet as
    any processing (even mlr cat) steps through an input file, more and
    more pages are faulted in -- and, unfortunately, previous pages are
    not paged out once memory pressure increases. (This despite gallant
    attempts with madvise.) Once all processing is done, the memory is
    released; there is no leak per se. But the Miller process can crash
    before the entire file is read. The solution is equally simple: to
    prefer stdio over mmap for files over 4GB in size. (This 4GB threshold
    is tunable via the --mmap-below flag as described in the manpage.)

    Issue 161 fixes a CSV-parse error (with error message "unwrapped
    double quote at line 0") when a CSV file starts with the UTF-8
    byte-order-mark ("BOM") sequence 0xef 0xbb 0xbf and the header line
    has double-quoted fields. (Release 5.2.0 introduced handling for
    UTF-8 BOMs, but missed the case of double-quoted header line.)

    Issue 162 fixes a corner case doing multi-emit of aggregate variables
    when the first variable name is a typo.

    The Miller JSON parser used to error with Unable to parse JSON data:
    Line 1 column 0: Unexpected 0x00 when seeking value on empty input,
    or input with trailing whitespace; this has been fixed.

Log message:
miller: Add flex as tool dependency

(flex is explicitly needed in c/parsing/Makefile for mlr_dsl_lexer.c.)

Log message:
Updated miller to 5.2.2.

5.2.2

This bugfix release delivers a fix for #147 where a memory allocation failed \ 
beyond 4GB.

5.2.1

Fix non-x86/gcc7 build error

Log message:
Switch github HOMEPAGEs to https.

Log message:
Updated miller to 5.2.0.

This release contains mostly feature requests.

Features:

    The stats1 verb now lets you use regular expressions to specify
    which field names to compute statistics on, and/or which to
    group by. Full details are here.

    The min and max DSL functions, and the min/max/percentile
    aggregators for the stats1 and merge-fields verbs, now support
    numeric as well as string field values. (For mixed string/numeric
    fields, numbers compare before strings.) This means in particular
    that order statistics -- min, max, and non-interpolated percentiles
    -- as well as mode, antimode, and count are now possible on
    string-only (or mixed) fields. (Of course, any operations
    requiring arithmetic on values, such as computing sums, averages,
    or interpolated percentiles, yield an error on string-valued
    input.)

    There is a new DSL function mapexcept which returns a copy of
    the argument with specified key(s), if any, unset. The motivating
    use-case is to split records to multiple filenames depending
    on particular field value, which is omitted from the output:
    mlr --from f.dat put 'tee > "/tmp/data-".$a, mapexcept($*, \ 
"a")'
    Likewise, mapselect returns a copy of the argument with only
    specified key(s), if any, set. This resolves #137.

    A new -u option for count-distinct allows unlashed counts for
    multiple field names. For example, with -f a,b and without -u,
    count-distinct computes counts for distinct pairs of a and b
    field values. With -f a,b and with -u, it computes counts for
    distinct a field values and counts for distinct b field values
    separately.

    If you build from source, you can now do ./configure without
    first doing autoreconf -fiv. This resolves #131.

    The UTF-8 BOM sequence 0xef 0xbb 0xbf is now automatically
    ignored from the start of CSV files. (The same is already done
    for JSON files.) This resolves #138.

    For put and filter with -S, program literals such as the 6 in
    $x = 6 were being parsed as strings. This is not sensible, since
    the -S option for put and filter is intended to suppress numeric
    conversion of record data, not program literals. To get string
    6 one may use $x = "6".

Documentation:

    A new cookbook example shows how to compute differences between
    successive queries, e.g. to find out what changed in time-varying
    data when you run and rerun a SQL query.

    Another new cookbook example shows how to compute interquartile
    ranges.

    A third new cookbook example shows how to compute weighted
    means.

Bugfixes:

    CRLF line-endings were not being correctly autodetected when
    I/O formats were specified using --c2j et al.

    Integer division by zero was causing a fatal runtime exception,
    rather than computing inf or nan as in the floating-point case.

Log message:
Updated miller to 5.1.0.

This is a relatively minor release of Miller, containing feature
requests and bugfixes while I've been working on the Windows port
(which is nearly complete).

Features:

    JSON arrays: as described here, Miller being a tabular data
    processor isn't well-position to handle arbitrary JSON. (See
    jq for that.) But as of 5.1.0, arrays are converted to maps
    with integer keys, which are then at least processable using
    Miller. Details are here. The short of it is that you now have
    three options for the main mlr executable:

--json-map-arrays-on-input    Convert JSON array indices to Miller
map keys. (This is the default.) --json-skip-arrays-on-input
Disregard JSON arrays.  --json-fatal-arrays-on-input  Raise a fatal
error when JSON arrays are encountered in the input.

This resolves #133.

    The new mlr fraction verb makes possible in a few keystrokes
    what was only possible before using two-pass DSL logic: here
    you can turn numerical values down a column into their
    fractional/percentage contribution to column totals, optionally
    grouped by other key columns.

    The DSL functions strptime and strftime now handle fractional
    seconds. For parsing, use %S format as always; for formatting,
    there are now %1S through %9S which allow you to configure a
    specified number of decimal places. The return value from
    strptime is now floating-point, not integer, which is a minor
    backward incompatibility not worth labeling this release as
    6.0.0. (You can work around this using int(strptime(...)).) The
    DSL functions gmt2sec and sec2gmt, which are keystroke-savers
    for strptime and strftime, are similarly modified, as is the
    sec2gmt verb. This resolves #125.

    A few nearly-standalone programs -- which do not have anything
    to do with record streams -- are packaged within the Miller.
    (For example, hex-dump, unhex, and show-line-endings commands.)
    These are described here.

    The stats1 and merge-fields verbs now support an antimode
    aggregator, in addition to the existing mode aggregator.

    The join verb now by default does not require sorted input,
    which is the more common use case. (Memory-parsimonious joins
    which require sorted input, while no longer the default, are
    available using -s.) This another minor backward incompatibility
    not worth making a 6.0.0 over. This resolves #134.

    mlr nest has a keystroke-saving --evar option for a common use
    case, namely, exploding a field by value across records.

Documentation:

    The DSL reference now has per-function descriptions.

    There is a new feature-counting example in the cookbook.

Bugfixes:

    mlr join -j -l was not functioning correctly. This resolves
    #136.

    JSON escapes on output (\t and so on) were incorrect. This
    resolves #135.

Log message:
Updated miller to 5.0.1.

Two minor bugfixes

    As described in #132, mlr nest was incorrectly splitting fields
    with multi-character separators.

    The XTAB-format reader, when using multi-character IPS, was
    incorrectly splitting key-value pairs, but only when reading
    from standard input (e.g. on a pipe or less-than redirect).

Log message:
Updated miller to 5.0.0.

Autodetected line-endings, in-place mode, user-defined functions, and more

This major release significantly expands the expressiveness of the DSL for mlr \ 
put and mlr filter. (The upcoming 5.1.0 release will add the ability to \ 
aggregate across all columns for non-DSL verbs such as mlr stats1 and mlr \ 
stats2. As well, a Windows port is underway.)

Please also see the Miller main docs.

Simple but impactful features:

    Line endings (CRLF vs. LF, Windows-style vs. Unix-style) are now \ 
autodetected. For example, files (including CSV) with LF input will lead to LF \ 
output unless you specify otherwise.
    There is now an in-place mode using mlr -I.

Major DSL features:

    You can now define your own functions and subroutines: e.g. func f(x, y) { \ 
return x**2 + y**2 }.
    New local variables are completely analogous to out-of-stream variables: sum \ 
retains its value for the duration of the expression it's defined in; @sum \ 
retains its value across all records in the record stream.
    Local variables, function parameters, and function return types may be \ 
defined untyped or typed as in x = 1 or int x = 1, respectively. There are also \ 
expression-inline type-assertions available. Type-checking is up to you: omit it \ 
if you want flexibility with heterogeneous data; use it if you want to help \ 
catch misspellings in your DSL code or unexpected irregularities in your input \ 
data.
    There are now four kinds of maps. Out-of-stream variables have always been \ 
scalars, maps, or multi-level maps: @a=1, @b[1]=2, @c[1][2]=3. The same is now \ 
true for local variables, which are new to 5.0.0. Stream records have always \ 
been single-level maps; $* is a map. And as of 5.0.0 there are now map literals, \ 
e.g. {"a":1, "b":2}, which can be defined using JSON-like \ 
syntax (with either string or integer keys) and which can be nested arbitrarily \ 
deeply.
    You can loop over maps -- $*, out-of-stream variables, local variables, \ 
map-literals, and map-valued function return values -- using for (k, v in ...) \ 
or the new for (k in ...) (discussed next). All flavors of map may also be used \ 
in emit and dump statements.
    User-defined functions and subroutines may take map-valued arguments, and \ 
may return map values.
    Some built-in functions now accept map-valued input: typeof, length, depth, \ 
leafcount, haskey. There are built-in functions producing map-valued output: \ 
mapsum and mapdiff. There are now string-to-map and map-to-string functions: \ 
splitnv, splitkv, splitnvx, splitkvx, joink, joinv, and joinkv.

Minor DSL features:

    For iterating over maps (namely, local variables, out-of-stream variables, \ 
stream records, map literals, or return values from map-valued functions) there \ 
is now a key-only for-loop syntax: e.g. for (k in $*) { ... }. This is in \ 
addition to the already-existing for (k, v in ...) syntax.
    There are now triple-statement for-loops (familiar from many other \ 
languages), e.g. for (int i = 0; i < 10; i += 1) { ... }.
    mlr put and mlr filter now accept multiple -f for script files, freely \ 
intermixable with -e for expressions. The suggested use case is putting \ 
user-defined functions in script files and one-liners calling them using -e. \ 
Example: myfuncs.mlr defines the function f(...), then mlr put -f myfuncs.mlr -e \ 
'$o = f($i)' myfile.dat. More information is here.
    mlr filter is now almost identical to mlr put: it can have multiple \ 
statements, it can use begin and/or end blocks, it can define and invoke \ 
functions. Its final expression must evaluate to boolean which is used as the \ 
filter criterion. More details are here.
    The min and max functions are now variadic: $o = max($a, $b, $c).
    There is now a substr function.
    While ENV has long provided read-access to environment variables on the \ 
right-hand side of assignments (as a getenv), it now can be at the left-hand \ 
side of assignments (as a putenv). This is useful for subsidiary processes \ 
created by tee, emit, dump, or print when writing to a pipe.
    Handling for the # in comments is now handled in the lexer, so you can now \ 
(correctly) include # in strings.
    Separators are now available as read-only variables in the DSL: IPS, IFS, \ 
IRS, OPS, OFS, ORS. These are particularly useful with the split and join \ 
functions: e.g. with mlr --ifs tab ..., the IFS variable within a DSL expression \ 
will evaluate to a string containing a tab character.
    Syntax errors in DSL expressions now have a little more context.
    DSL parsing and execution are a bit more transparent. There have long been \ 
-v and -t options to mlr put and mlr filter, which print the expression's \ 
abstract syntax tree and do a low-level parser trace, respectively. There are \ 
now additionally -a which traces stack-variable allocation and -T which traces \ 
statements line by line as they execute. While -v, -t, and -a are most useful \ 
for development of Miller, the -T option gives you more visibility into what \ 
your Miller scripts are doing. See also here.

Verbs:

    most-frequent and least-frequent as requested in #110.
    seqgen makes it easy to generate data from within Miller: please also see \ 
here for a usage example.
    unsparsify makes it easy to rectangularize data where not all records have \ 
the same fields.
    cat -n now takes a group-by (-g) option, making it easy to number records \ 
within categories.
    count-distinct,
    uniq,
    most-frequent,
    least-frequent,
    top, and
    histogram
    now take a -o option for specifying their output field names, as requested \ 
in #122.
    Median is now a synonym for p50 in stats1.
    You can now start a then chain with an initial then, which is nice in \ 
backslashy/multiline-continuation contexts.
    This was requested in #130.

I/O options:

    The print statement may now be used with no arguments, which prints a \ 
newline, and a no-argument printn prints nothing but creates a zero-length file \ 
in redirected-output context.
    Pretty-print format now has a --pprint --barred option (for output only, not \ 
input). For an example, please see here.
    There are now keystroke-savers of the form --c2p which abbreviate --icsvlite \ 
--opprint, and so on.
    Miller's map literals are JSON-looking but allow integer keys which JSON \ 
doesn't. The
    --jknquoteint and --jvquoteall flags for mlr (when using JSON output) and \ 
mlr put (for dump) provide control over double-quoting behavior.

Documents new since the previous release:

    Miller in 10 minutes is a long-overdue addition: while Miller's detailed \ 
documentation is evident, there has been a lack of more succinct examples.
    The cookbook has likewise been expanded, and has been split out
    into three parts: part 1, part
    2, part 3.
    A bit more background on C performance compared to other languages I \ 
experimented with, early on in the development of Miller, is here.

On-line help:

    Help for DSL built-in functions, DSL keywords, and verbs is accessible using \ 
mlr -f, mlr -k, and mlr -l respectively; name-only lists are available with mlr \ 
-F, mlr -K, and mlr -L.

Bugfixes:

    A corner-case bug causing a segmentation violation on two sub/gsub \ 
statements within a single put, the first one matching its pattern and the \ 
second one not matching its pattern, has been fixed.

Backward incompatibilities: This is Miller 5.0.0, not 4.6.0, due to the \ 
following (all relatively minor):

    The v variables bound in for-loops such as for (k, v in \ 
some_multi_level_map) { ... } can now be map-valued if the v specifies a \ 
non-terminal in the map.
    There are new keywords such as var, int, float, num, str, bool, map, IPS, \ 
IFS, IRS, OPS, OFS, ORS which can no longer be used as variable names. See mlr \ 
-k for the complete list.
    Unset of the last key in an map-valued variable's map level no longer \ 
removes the level: e.g. with @v[1][2]=3 and unset @v[1][2] the @v variable would \ 
be empty. As of 5.0.0, @v has key 1 with an empty-map value.
    There is no longer type-inference on literals: "3"+4 no longer \ 
gives 7. (That was never a good idea.)
    The typeof function used to say things like MT_STRING; now it says things \ 
like string.