--- JSON-XS/XS.pm	2013/10/25 19:53:08	1.141
+++ JSON-XS/XS.pm	2013/10/28 23:19:54	1.144
@@ -111,6 +111,8 @@
 use Exporter;
 use XSLoader;
 
+use Types::Serialiser ();
+
 =head1 FUNCTIONAL INTERFACE
 
 The following convenience methods are provided by this module. They are
@@ -141,15 +143,6 @@
 
 Except being faster.
 
-=item $is_boolean = JSON::XS::is_bool $scalar
-
-Returns true if the passed scalar represents either JSON::XS::true or
-JSON::XS::false, two constants that act like C<1> and C<0>, respectively
-and are used to represent JSON C<true> and C<false> values in Perl.
-
-See MAPPING, below, for more information on how JSON values are mapped to
-Perl.
-
 =back
 
 
@@ -675,8 +668,7 @@
 so far.
 
 This is useful if your JSON texts are not delimited by an outer protocol
-(which is not the brightest thing to do in the first place) and you need
-to know where the JSON text ends.
+and you need to know where the JSON text ends.
 
    JSON::XS->new->decode_prefix ("[1] the tail")
    => ([], 3)
@@ -780,10 +772,10 @@
 =head2 LIMITATIONS
 
 All options that affect decoding are supported, except
-C<allow_nonref>. The reason for this is that it cannot be made to
-work sensibly: JSON objects and arrays are self-delimited, i.e. you can concatenate
-them back to back and still decode them perfectly. This does not hold true
-for JSON numbers, however.
+C<allow_nonref>. The reason for this is that it cannot be made to work
+sensibly: JSON objects and arrays are self-delimited, i.e. you can
+concatenate them back to back and still decode them perfectly. This does
+not hold true for JSON numbers, however.
 
 For example, is the string C<1> a single JSON number, or is it simply the
 start of C<12>? Or is C<12> a single JSON number, or the concatenation
@@ -986,10 +978,11 @@
 
 =item true, false
 
-These JSON atoms become C<JSON::XS::true> and C<JSON::XS::false>,
-respectively. They are overloaded to act almost exactly like the numbers
-C<1> and C<0>. You can check whether a scalar is a JSON boolean by using
-the C<JSON::XS::is_bool> function.
+These JSON atoms become C<Types::Serialiser::true> and
+C<Types::Serialiser::false>, respectively. They are overloaded to act
+almost exactly like the numbers C<1> and C<0>. You can check whether
+a scalar is a JSON boolean by using the C<Types::Serialiser::is_bool>
+function (after C<use Types::Serialier>, of course).
 
 =item null
 
@@ -1008,15 +1001,13 @@
 
 =item hash references
 
-Perl hash references become JSON objects. As there is no inherent ordering
-in hash keys (or JSON objects), they will usually be encoded in a
-pseudo-random order that can change between runs of the same program but
-stays generally the same within a single run of a program. JSON::XS can
-optionally sort the hash keys (determined by the I<canonical> flag), so
-the same datastructure will serialise to the same JSON text (given same
-settings and version of JSON::XS), but this incurs a runtime overhead
-and is only rarely useful, e.g. when you want to compare some JSON text
-against another for equality.
+Perl hash references become JSON objects. As there is no inherent
+ordering in hash keys (or JSON objects), they will usually be encoded
+in a pseudo-random order. JSON::XS can optionally sort the hash keys
+(determined by the I<canonical> flag), so the same datastructure will
+serialise to the same JSON text (given same settings and version of
+JSON::XS), but this incurs a runtime overhead and is only rarely useful,
+e.g. when you want to compare some JSON text against another for equality.
 
 =item array references
 
@@ -1026,15 +1017,20 @@
 
 Other unblessed references are generally not allowed and will cause an
 exception to be thrown, except for references to the integers C<0> and
-C<1>, which get turned into C<false> and C<true> atoms in JSON. You can
-also use C<JSON::XS::false> and C<JSON::XS::true> to improve readability.
+C<1>, which get turned into C<false> and C<true> atoms in JSON.
 
-   encode_json [\0, JSON::XS::true]      # yields [false,true]
+Since C<JSON::XS> uses the boolean model from L<Types::Serialiser>, you
+can also C<use Types::Serialiser> and then use C<Types::Serialiser::false>
+and C<Types::Serialiser::true> to improve readability.
 
-=item JSON::XS::true, JSON::XS::false
+   use Types::Serialiser;
+   encode_json [\0, Types::Serialiser::true]      # yields [false,true]
 
-These special values become JSON true and JSON false values,
-respectively. You can also use C<\1> and C<\0> directly if you want.
+=item Types::Serialiser::true, Types::Serialiser::false
+
+These special values from the L<Types::Serialiser> module become JSON true
+and JSON false values, respectively. You can also use C<\1> and C<\0>
+directly if you want.
 
 =item blessed objects
 
@@ -1420,6 +1416,14 @@
 security right).
 
 
+=head1 INTEROPERABILITY WITH OTHER MODULES
+
+C<JSON::XS> uses the L<Types::Serialiser> module to provide boolean
+constants. That means that the JSON true and false values will be
+comaptible to true and false values of iother modules that do the same,
+such as L<JSON::PP> and L<CBOR::XS>.
+
+
 =head1 THREADS
 
 This module is I<not> guaranteed to be thread safe and there are no
@@ -1459,29 +1463,18 @@
 
 =cut
 
-our $true  = do { bless \(my $dummy = 1), "JSON::XS::Boolean" };
-our $false = do { bless \(my $dummy = 0), "JSON::XS::Boolean" };
-
-sub true()  { $true  }
-sub false() { $false }
+BEGIN {
+   *true    = \$Types::Serialiser::true;
+   *true    = \&Types::Serialiser::true;
+   *false   = \$Types::Serialiser::false;
+   *false   = \&Types::Serialiser::false;
+   *is_bool = \&Types::Serialiser::is_bool;
 
-sub is_bool($) {
-   UNIVERSAL::isa $_[0], "JSON::XS::Boolean"
-#      or UNIVERSAL::isa $_[0], "JSON::Literal"
+   *JSON::XS::Boolean:: = *Types::Serialiser::Boolean::;
 }
 
 XSLoader::load "JSON::XS", $VERSION;
 
-package JSON::XS::Boolean;
-
-use overload
-   "0+"     => sub { ${$_[0]} },
-   "++"     => sub { $_[0] = ${$_[0]} + 1 },
-   "--"     => sub { $_[0] = ${$_[0]} - 1 },
-   fallback => 1;
-
-1;
-
 =head1 SEE ALSO
 
 The F<json_xs> command line utility for quick experiments.
@@ -1493,3 +1486,5 @@
 
 =cut
 
+1
+