diff --git a/INSTALL b/INSTALL
index 9dd3974..6aafff9 100644
--- a/INSTALL
+++ b/INSTALL
@@ -1,4 +1,3 @@
-
 This is the Perl distribution CHI-Memoize.
 
 Installing CHI-Memoize is straightforward.
@@ -9,10 +8,10 @@ If you have cpanm, you only need one line:
 
     % cpanm CHI::Memoize
 
-If you are installing into a system-wide directory, you may need to pass the
-"-S" flag to cpanm, which uses sudo to install the module:
-
-    % cpanm -S CHI::Memoize
+If it does not have permission to install modules to the current perl, cpanm
+will automatically set up and install to a local::lib in your home directory.
+See the local::lib documentation (https://metacpan.org/pod/local::lib) for
+details on enabling it in your environment.
 
 ## Installing with the CPAN shell
 
@@ -22,8 +21,11 @@ Alternatively, if your CPAN shell is set up, you should just be able to do:
 
 ## Manual installation
 
-As a last resort, you can manually install it. Download the tarball, untar it,
-then build it:
+As a last resort, you can manually install it. If you have not already
+downloaded the release tarball, you can find the download link on the module's
+MetaCPAN page: https://metacpan.org/pod/CHI::Memoize
+
+Untar the tarball, install configure prerequisites (see below), then build it:
 
     % perl Makefile.PL
     % make && make test
@@ -32,13 +34,42 @@ Then install it:
 
     % make install
 
-If you are installing into a system-wide directory, you may need to run:
+On Windows platforms, you should use `dmake` or `nmake`, instead of `make`.
+
+If your perl is system-managed, you can create a local::lib in your home
+directory to install modules to. For details, see the local::lib documentation:
+https://metacpan.org/pod/local::lib
+
+The prerequisites of this distribution will also have to be installed manually. The
+prerequisites are listed in one of the files: `MYMETA.yml` or `MYMETA.json` generated
+by running the manual build process described above.
+
+## Configure Prerequisites
 
-    % sudo make install
+This distribution requires other modules to be installed before this
+distribution's installer can be run.  They can be found under the
+"configure_requires" key of META.yml or the
+"{prereqs}{configure}{requires}" key of META.json.
+
+## Other Prerequisites
+
+This distribution may require additional modules to be installed after running
+Makefile.PL.
+Look for prerequisites in the following phases:
+
+* to run make, PHASE = build
+* to use the module code itself, PHASE = runtime
+* to run tests, PHASE = test
+
+They can all be found in the "PHASE_requires" key of MYMETA.yml or the
+"{prereqs}{PHASE}{requires}" key of MYMETA.json.
 
 ## Documentation
 
 CHI-Memoize documentation is available as POD.
-You can run perldoc from a shell to read the documentation:
+You can run `perldoc` from a shell to read the documentation:
 
     % perldoc CHI::Memoize
+
+For more information on installing Perl modules via CPAN, please see:
+https://www.cpan.org/modules/INSTALL.html
diff --git a/LICENSE b/LICENSE
index 273584e..0e4e915 100644
--- a/LICENSE
+++ b/LICENSE
@@ -292,21 +292,21 @@ Definitions:
 
   - "Package" refers to the collection of files distributed by the Copyright
     Holder, and derivatives of that collection of files created through
-    textual modification. 
+    textual modification.
   - "Standard Version" refers to such a Package if it has not been modified,
     or has been modified in accordance with the wishes of the Copyright
-    Holder. 
+    Holder.
   - "Copyright Holder" is whoever is named in the copyright or copyrights for
-    the package. 
+    the package.
   - "You" is you, if you're thinking about copying or distributing this Package.
   - "Reasonable copying fee" is whatever you can justify on the basis of media
     cost, duplication charges, time of people involved, and so on. (You will
     not be required to justify it to the Copyright Holder, but only to the
-    computing community at large as a market that must bear the fee.) 
+    computing community at large as a market that must bear the fee.)
   - "Freely Available" means that no fee is charged for the item itself, though
     there may be fees involved in handling the item. It also means that
     recipients of the item may redistribute it under the same conditions they
-    received it. 
+    received it.
 
 1. You may make and give away verbatim copies of the source form of the
 Standard Version of this Package without restriction, provided that you
@@ -373,7 +373,7 @@ products derived from this software without specific prior written permission.
 
 9. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
 WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
-MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 
 The End
 
diff --git a/MANIFEST b/MANIFEST
index 9807bb3..5132cd8 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -1,4 +1,4 @@
-# This file was automatically generated by Dist::Zilla::Plugin::Manifest v5.020.
+# This file was automatically generated by Dist::Zilla::Plugin::Manifest v6.024.
 Changes
 INSTALL
 LICENSE
diff --git a/META.json b/META.json
index 56339d2..756c0de 100644
--- a/META.json
+++ b/META.json
@@ -4,19 +4,19 @@
       "Jonathan Swartz <swartz@pobox.com>"
    ],
    "dynamic_config" : 0,
-   "generated_by" : "Dist::Zilla version 5.020, CPAN::Meta::Converter version 2.120921",
+   "generated_by" : "Dist::Zilla version 6.024, CPAN::Meta::Converter version 2.150010",
    "license" : [
       "perl_5"
    ],
    "meta-spec" : {
       "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec",
-      "version" : "2"
+      "version" : 2
    },
    "name" : "CHI-Memoize",
    "no_index" : {
       "directory" : [
-         "lib/CHI/Memoize/t",
-         "lib/CHI/Memoize/Test"
+         "lib/CHI/Memoize/Test",
+         "lib/CHI/Memoize/t"
       ],
       "file" : [
          "lib/CHI/Memoize/Util.pm"
@@ -53,6 +53,9 @@
          "web" : "https://github.com/jonswar/perl-chi-memoize"
       }
    },
-   "version" : "0.07"
+   "version" : "0.07",
+   "x_generated_by_perl" : "v5.34.0",
+   "x_serialization_backend" : "Cpanel::JSON::XS version 4.27",
+   "x_spdx_expression" : "Artistic-1.0-Perl OR GPL-1.0-or-later"
 }
 
diff --git a/META.yml b/META.yml
index b1d9889..3a65ad2 100644
--- a/META.yml
+++ b/META.yml
@@ -7,7 +7,7 @@ build_requires:
 configure_requires:
   ExtUtils::MakeMaker: '0'
 dynamic_config: 0
-generated_by: 'Dist::Zilla version 5.020, CPAN::Meta::Converter version 2.120921'
+generated_by: 'Dist::Zilla version 6.024, CPAN::Meta::Converter version 2.150010'
 license: perl
 meta-spec:
   url: http://module-build.sourceforge.net/META-spec-v1.4.html
@@ -15,8 +15,8 @@ meta-spec:
 name: CHI-Memoize
 no_index:
   directory:
-    - lib/CHI/Memoize/t
     - lib/CHI/Memoize/Test
+    - lib/CHI/Memoize/t
   file:
     - lib/CHI/Memoize/Util.pm
 requires:
@@ -27,3 +27,6 @@ resources:
   bugtracker: http://rt.cpan.org/NoAuth/Bugs.html?Dist=CHI-Memoize
   repository: git://github.com/jonswar/perl-chi-memoize.git
 version: '0.07'
+x_generated_by_perl: v5.34.0
+x_serialization_backend: 'YAML::Tiny version 1.73'
+x_spdx_expression: 'Artistic-1.0-Perl OR GPL-1.0-or-later'
diff --git a/Makefile.PL b/Makefile.PL
index 1141f5d..ca6243b 100644
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -1,13 +1,10 @@
-
-# This file was automatically generated by Dist::Zilla::Plugin::MakeMaker v5.020.
+# This file was automatically generated by Dist::Zilla::Plugin::MakeMaker v6.024.
 use strict;
 use warnings;
 
 
 
-use ExtUtils::MakeMaker ;
-
-
+use ExtUtils::MakeMaker;
 
 my %WriteMakefileArgs = (
   "ABSTRACT" => "Make functions faster with memoization via CHI",
@@ -16,7 +13,6 @@ my %WriteMakefileArgs = (
     "ExtUtils::MakeMaker" => 0
   },
   "DISTNAME" => "CHI-Memoize",
-  "EXE_FILES" => [],
   "LICENSE" => "perl",
   "NAME" => "CHI::Memoize",
   "PREREQ_PM" => {
@@ -52,6 +48,3 @@ delete $WriteMakefileArgs{CONFIGURE_REQUIRES}
   unless eval { ExtUtils::MakeMaker->VERSION(6.52) };
 
 WriteMakefile(%WriteMakefileArgs);
-
-
-
diff --git a/README b/README
deleted file mode 100644
index 61880c1..0000000
--- a/README
+++ /dev/null
@@ -1,265 +0,0 @@
-NAME
-    CHI::Memoize - Make functions faster with memoization, via CHI
-
-VERSION
-    version 0.07
-
-SYNOPSIS
-        use CHI::Memoize qw(:all);
-    
-        # Straight memoization in memory
-        memoize('func');
-        memoize('Some::Package::func');
-
-        # Memoize to a file or to memcached
-        memoize( 'func', driver => 'File', root_dir => '/path/to/cache' );
-        memoize( 'func', driver => 'Memcached', servers => ["127.0.0.1:11211"] );
-
-        # Expire after one hour
-        memoize('func', expires_in => '1h');
-    
-        # Memoize based on the second and third argument to func
-        memoize('func', key => sub { $_[1], $_[2] });
-
-DESCRIPTION
-    "`Memoizing' a function makes it faster by trading space for time. It
-    does this by caching the return values of the function in a table. If
-    you call the function again with the same arguments, `memoize' jumps in
-    and gives you the value out of the table, instead of letting the
-    function compute the value all over again." -- quoted from the original
-    Memoize
-
-    For a bit of history and motivation, see
-
-        http://www.openswartz.com/2012/05/06/memoize-revisiting-a-twelve-year-old-api/
-
-    `CHI::Memoize' provides the same facility as Memoize, but backed by CHI.
-    This means, among other things, that you can
-
-    *   specify expiration times (expires_in) and conditions (expire_if)
-
-    *   memoize to different backends, e.g. File, Memcached, DBI, or to
-        multilevel caches
-
-    *   handle arbitrarily complex function arguments (via CHI key
-        serialization)
-
-  FUNCTIONS
-    All of these are importable; only `memoize' is imported by default. `use
-    Memoize qw(:all)' will import them all as well as the `NO_MEMOIZE'
-    constant.
-
-    memoize ($func, %options)
-        Creates a new function wrapped around *$func* that caches results
-        based on passed arguments.
-
-        *$func* can be a function name (with or without a package prefix) or
-        an anonymous function. In the former case, the name is rebound to
-        the new function. In either case a code ref to the new wrapper
-        function is returned.
-
-            # Memoize a named function
-            memoize('func');
-            memoize('Some::Package::func');
-
-            # Memoize an anonymous function
-            $anon = memoize($anon);
-
-        By default, the cache key is formed from combining the full function
-        name, the calling context ("L" or "S"), and all the function
-        arguments with canonical JSON (sorted hash keys). e.g. these calls
-        will be memoized together:
-
-            memoized_function({a => 5, b => 6, c => { d => 7, e => 8 }});
-            memoized_function({b => 6, c => { e => 8, d => 7 }, a => 5});
-
-        because the two hashes being passed are canonically the same. But
-        these will be memoized separately because of context:
-
-             my $scalar = memoized_function(5);
-             my @list = memoized_function(5);
-
-        By default, the cache namespace is formed from the full function
-        name or the stringified code reference. This allows you to
-        introspect and clear the memoized results for a particular function.
-
-        `memoize' throws an error if *$func* is already memoized.
-
-        See OPTIONS below for what can go in the options hash.
-
-    memoized ($func)
-        Returns a CHI::Memoize::Info object if *$func* has been memoized, or
-        undef if it has not been memoized.
-
-            # The CHI cache where memoize results are stored
-            #
-            my $cache = memoized($func)->cache;
-            $cache->clear;
-
-            # Code references to the original function and to the new wrapped function
-            #
-            my $orig = memoized($func)->orig;
-            my $wrapped = memoized($func)->wrapped;
-
-    unmemoize ($func)
-        Removes the wrapper around *$func*, restoring it to its original
-        unmemoized state. Also clears the memoize cache if possible (not
-        supported by all drivers, particularly memcached). Throws an error
-        if *$func* has not been memoized.
-
-            memoize('Some::Package::func');
-            ...
-            unmemoize('Some::Package::func');
-
-  OPTIONS
-    The following options can be passed to memoize.
-
-    key Specifies a code reference that takes arguments passed to the
-        function and returns a cache key. The key may be returned as a list,
-        list reference or hash reference; it will automatically be
-        serialized to JSON in canonical mode (sorted hash keys).
-
-        For example, this uses the second and third argument to the function
-        as a key:
-
-            memoize('func', key => sub { @_[1..2] });
-
-        and this is useful for functions that accept a list of key/value
-        pairs:
-
-            # Ignore order of key/value pairs
-            memoize('func', key => sub { %@_ });
-
-        Regardless of what key you specify, it will automatically be
-        prefixed with the full function name and the calling context ("L" or
-        "S").
-
-        If the coderef returns `CHI::Memoize::NO_MEMOIZE' (or `NO_MEMOIZE'
-        if you import it), this call won't be memoized. This is useful if
-        you have a cache of limited size or if you know certain arguments
-        will yield nondeterministic results. e.g.
-
-            memoize('func', key => sub { $is_worth_caching ? @_ : NO_MEMOIZE });
-
-    set and get options
-        You can pass any of CHI's set options (e.g. expires_in,
-        expires_variance) or get options (e.g. expire_if, busy_lock). e.g.
-
-            # Expire after one hour
-            memoize('func', expires_in => '1h');
-    
-            # Expire when a particular condition occurs
-            memoize('func', expire_if => sub { ... });
-
-    cache options
-        Any remaining options will be passed to the CHI constructor to
-        generate the cache:
-
-            # Store in file instead of memory
-            memoize( 'func', driver => 'File', root_dir => '/path/to/cache' );
-
-            # Store in memcached instead of memory
-            memoize('func', driver => 'Memcached', servers => ["127.0.0.1:11211"]);
-
-        Unless specified, the namespace is generated from the full name of
-        the function being memoized.
-
-        You can also specify an existing cache object:
-
-            # Store in memcached instead of memory
-            my $cache = CHI->new(driver => 'Memcached', servers => ["127.0.0.1:11211"]);
-            memoize('func', cache => $cache);
-
-CLONED VS RAW REFERENCES
-    By default `CHI', and thus `CHI::Memoize', returns a deep clone of the
-    stored value *even* when caching in memory. e.g. in this code
-
-        # func returns a list reference
-        memoize('func');
-        my $ref1 = func();
-        my $ref2 = func();
-
-    `$ref1' and `$ref2' will be references to two completely different lists
-    which have the same contained values. More specifically, the value is
-    serialized by Storable on `set' and deserialized (hence cloned) on
-    `get'.
-
-    The advantage here is that it is safe to modify a reference returned
-    from a memoized function; your modifications won't affect the cached
-    value.
-
-        my $ref1 = func();
-        push(@$ref1, 3, 4, 5);
-        my $ref2 = func();
-        # $ref2 does not have 3, 4, 5
-
-    The disadvantage is that it takes extra time to serialize and
-    deserialize the value, and that some values like code references may be
-    more difficult to store. And cloning may not be what you want at all,
-    e.g. if you are returning objects.
-
-    Alternatively you can use CHI::Driver::RawMemory, which will store raw
-    references the way `Memoize' does. Now, however, any modifications to
-    the contents of a returned reference will affect the cached value.
-
-        memoize('func', driver => 'RawMemory');
-        my $ref1 = func();
-        push(@$ref1, 3, 4, 5);
-        my $ref2 = func();
-        # $ref1 eq $ref2
-        # $ref2 has 3, 4, 5
-
-CAVEATS
-    The caveats of Memoize apply here as well. To summarize:
-
-    *   Do not memoize a function whose behavior depends on program state
-        other than its own arguments, unless you explicitly capture that
-        state in your computed key.
-
-    *   Do not memoize a function with side effects, as the side effects
-        won't happen on a cache hit.
-
-    *   Do not memoize a very simple function, as the costs of caching will
-        outweigh the costs of the function itself.
-
-KNOWN BUGS
-    *   Memoizing a function will affect its call stack and its prototype.
-
-RELATED MODULES
-    A number of modules address a subset of the problems addressed by this
-    module, including:
-
-    *   Memoize::Expire - pluggable expiration of memoized values
-
-    *   Memoize::ExpireLRU - provides LRU expiration for Memoize
-
-    *   Memoize::Memcached - use a memcached cache to memoize functions
-
-SUPPORT
-    Questions and feedback are welcome, and should be directed to the
-    perl-cache mailing list:
-
-        http://groups.google.com/group/perl-cache-discuss
-
-    Bugs and feature requests will be tracked at RT:
-
-        http://rt.cpan.org/NoAuth/Bugs.html?Dist=CHI-Memoize
-        bug-chi-memoize@rt.cpan.org
-
-    The latest source code can be browsed and fetched at:
-
-        http://github.com/jonswar/perl-chi-memoize
-        git clone git://github.com/jonswar/perl-chi-memoize.git
-
-SEE ALSO
-    CHI, Memoize
-
-AUTHOR
-    Jonathan Swartz <swartz@pobox.com>
-
-COPYRIGHT AND LICENSE
-    This software is copyright (c) 2011 by Jonathan Swartz.
-
-    This is free software; you can redistribute it and/or modify it under
-    the same terms as the Perl 5 programming language system itself.
-