Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:128238
Feedback-ID: id5114917:Fastmail
Content-Type: multipart/alternative;
 boundary="------------k8qhrx0aYbEWhHD11v0EWLVP"
Message-ID: <d9112e11-d06f-42c5-abf9-82d41b5e6d6f@rwec.co.uk>
Date: Sat, 26 Jul 2025 14:45:24 +0100
Precedence: bulk
MIME-Version: 1.0
User-Agent: Mozilla Thunderbird
Subject: Re: [PHP-DEV] [DISCUSSION] Adding the "is_integer_safe()" function
To: internals@lists.php.net
References: <CAMU7irKKsXxe4j07tsiW45=EWt=fE56Wcz0tdXjdbhYkW3AhJw@mail.gmail.com>
 <BCD461E2-825D-472B-88D9-83435FFBC86A@rwec.co.uk>
 <CAMU7ir+CQuNZ--=bVZiuOu7QNv4M++pk1HXSgMkVNyekBSYaDA@mail.gmail.com>
Content-Language: en-GB
In-Reply-To: <CAMU7ir+CQuNZ--=bVZiuOu7QNv4M++pk1HXSgMkVNyekBSYaDA@mail.gmail.com>
From: imsop.php@rwec.co.uk ("Rowan Tommins [IMSoP]")

This is a multi-part message in MIME format.
--------------k8qhrx0aYbEWhHD11v0EWLVP
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit

On 26/07/2025 07:13, Alexandre Daubois wrote:

> The idea is to have a function that receives an integer or a float and
> returns bool if the provided argument is inside the safe Javascript
> integer interval, namely [-(2^53)+1 ; (2^53)-1].

That suggests maybe the name should communicate "safe for JavaScript"; 
or more generally "safe for 64-bit IEEE floating point".

is_safe_for_js()
is_safe_for_float()


> It's signature would
> be `is_integer_safe(int|float $num): bool`.


I'm not sure if accepting floats in the same function makes sense. If 
the question is "can this value safely be stored in a float?" and you 
give it a float, then the answer is surely "yes". You have no way of 
knowing if it _already_ lost precision during a previous operation.

Possibly there could be a separate function which asks "can this float 
value be safely converted to an integer?", but that implies a different 
definition - it wouldn't make much sense to answer "yes" for 3.5, or NaN.


That then makes me wonder if this is really part of a family of 
functions relating to casts - something I've been thinking about off an 
on for some time. Namely, "can this value be losslessly converted to 
this type?"

My thinking is that this needs new syntax, to avoid dozens of specific 
functions. For instance, a generic (or generic-like) form:

function can_lossless_cast<T>(mixed $value): bool

can_lossless_cast<float>(2 ** 50) === true
can_lossless_cast<float>(2 ** 54) === false

can_lossless_cast<int>(2 .0** 54) === true
can_lossless_cast<int>(2.0 ** 65) === false
can_lossless_cast<int>(3.5) === false
can_lossless_cast<int>(NaN) === false

can_lossless_cast<int>('9007199254740991000') == true // less than 2**64
can_lossless_cast<float>('9007199254740991000') == false // more than 2**53

can_lossless_cast<int|float>('9007199254740991000') == true
can_lossless_cast<int|float>('3.5') == true


Regards,

-- 
Rowan Tommins
[IMSoP]

--------------k8qhrx0aYbEWhHD11v0EWLVP
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: 8bit

<!DOCTYPE html>
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  </head>
  <body>
    <div class="moz-cite-prefix">On 26/07/2025 07:13, Alexandre Daubois
      wrote:</div>
    <div class="moz-cite-prefix"><br>
    </div>
    <div class="moz-cite-prefix">
      <blockquote type="cite">
        <pre wrap="" class="moz-quote-pre">The idea is to have a function that receives an integer or a float and
returns bool if the provided argument is inside the safe Javascript
integer interval, namely [-(2<sup class="moz-txt-sup"><span
        style="display:inline-block;width:0;height:0;overflow:hidden">^</span>53</sup>)+1 ; (2<sup
        class="moz-txt-sup"><span
        style="display:inline-block;width:0;height:0;overflow:hidden">^</span>53</sup>)-1].</pre>
      </blockquote>
    </div>
    <div class="moz-cite-prefix"><br>
    </div>
    <div class="moz-cite-prefix">That suggests maybe the name should
      communicate "safe for JavaScript"; or more generally "safe for
      64-bit IEEE floating point".</div>
    <div class="moz-cite-prefix"><br>
    </div>
    <div class="moz-cite-prefix">is_safe_for_js()<br>
      is_safe_for_float()</div>
    <div class="moz-cite-prefix"><br>
    </div>
    <div class="moz-cite-prefix"><br>
    </div>
    <blockquote type="cite"
cite="mid:CAMU7ir+CQuNZ--=bVZiuOu7QNv4M++pk1HXSgMkVNyekBSYaDA@mail.gmail.com">
      <pre class="moz-quote-pre" wrap="">It's signature would
be `is_integer_safe(int|float $num): bool`.</pre>
    </blockquote>
    <p><br>
    </p>
    <p>I'm not sure if accepting floats in the same function makes
      sense. If the question is "can this value safely be stored in a
      float?" and you give it a float, then the answer is surely "yes".
      You have no way of knowing if it _already_ lost precision during a
      previous operation.</p>
    <p>Possibly there could be a separate function which asks "can this
      float value be safely converted to an integer?", but that implies
      a different definition - it wouldn't make much sense to answer
      "yes" for 3.5, or NaN.</p>
    <p><br>
    </p>
    <p>That then makes me wonder if this is really part of a family of
      functions relating to casts - something I've been thinking about
      off an on for some time. Namely, "can this value be losslessly
      converted to this type?"</p>
    <p>My thinking is that this needs new syntax, to avoid dozens of
      specific functions. For instance, a generic (or generic-like)
      form:</p>
    <p>function can_lossless_cast&lt;T&gt;(mixed $value): bool</p>
    <p>can_lossless_cast&lt;float&gt;(2 ** 50) === true<br>
      can_lossless_cast&lt;float&gt;(2 ** 54) === false<br>
      <br>
      can_lossless_cast&lt;int&gt;(2 .0** 54) === true<br>
      can_lossless_cast&lt;int&gt;(2.0 ** 65) === false<br>
      can_lossless_cast&lt;int&gt;(3.5) === false<br>
      can_lossless_cast&lt;int&gt;(NaN) === false</p>
    <p>can_lossless_cast&lt;int&gt;('9007199254740991000') == true //
      less than 2**64<br>
      can_lossless_cast&lt;float&gt;('9007199254740991000') == false //
      more than 2**53</p>
    <p>can_lossless_cast&lt;int|float&gt;('9007199254740991000') == true<br>
      can_lossless_cast&lt;int|float&gt;('3.5') == true</p>
    <p><br>
    </p>
    <p>Regards,</p>
    <pre class="moz-signature" cols="72">-- 
Rowan Tommins
[IMSoP]</pre>
  </body>
</html>

--------------k8qhrx0aYbEWhHD11v0EWLVP--