Wie wird der Flow-Typ für Zahlen deklariert, die Unendlichkeiten und NaN ausschließen?

Question

The built-in type number in Flow ermöglicht die "exotischen" Werte wie Infinity, -Infinity und NaN.

Wie kann ich den Typ erzwingen, um nur reelle Zahlen zuzulassen?

BEARBEITEN. Dies ist nicht eine Frage, wie Sie überprüfen, ob eine Variable reelle Zahl ist. Es geht darum, mit Flow zu tippen.

Ich suche die Art und Weise meine Funktionen zu schreiben wie:

// @flow 
function sum (x: real, y: real) { ... } 

Meine Frage ist, wie die Art zu definieren real so dass es mit Flow Works (http://flowtype.org/).

Answer 1

Mit Flow können Sie das nicht tun. Sie benötigen Laufzeitprüfungen.

Siehe Diskussion der Themen, mit reellen Zahlen hier: https://github.com/facebook/flow/issues/1406

Unterm Strich ist, so ziemlich jede Operation auf reelle Zahlen in der Unendlichkeit führen könnte, so zwischen reellen Zahlen und NaN Unterscheidung/Unendlich wäre nicht sehr sinnvoll sein, da es einen Typ zurückgeben würde, der nicht wirklich echt ist.

Zum Beispiel

Number.MAX_VALUE + Number.MAX_VALUE === Infinity 
-Number.MAX_VALUE - Number.MAX_VALUE === -Infinity 
Number.MAX_VALUE * 2 === Infinity 
Number.MAX_VALUE/0.5 === Infinity 

Getrennt von dieser Diskussion, Fluss hat keine Einrichtungen zu schwarzen Liste bestimmte Werten, während andere Werte des gleichen Typs zu ermöglichen. Sie können nur Whitelist Werte, einschließlich der Verwendung von Gewerkschaften und Kreuzungen.

Answer 2

Es gibt ein bisschen mittleren Boden, den Sie damit mit Flow schlagen können. Ja, Sie müssen am Ende eine Laufzeitprüfung durchführen, aber Sie können einen undurchsichtigen Typ erstellen, mit dem Flow erzwingen kann, dass Sie diese Validierungsfunktionen nicht umgehen können. Zuerst wird in einer Datei, diese setzen:

// @flow 

// Define `Int` as an opaque type. Internally, it's just a number. 
// It's opaque because only this module can produce values of 
// this kind, so in order to obtain an "Int", one _must_ use one of 
// these functions, which (at runtime) will guarantee that these 
// will always be integers. 
export opaque type Int = number; 

// Here's a function that will convert any number to an Int by running 
// a typecheck at runtime and perhaps change the value (by rounding) 
// This is the ONLY way of obtaining a value of the type Int 
export function int(n: number): Int { 
    if (!Number.isFinite(n)) { 
     throw new Error('Not a (finite) number'); 
    } 

    // Round any real numbers to their nearest int 
    return Math.round(n); 
} 

// In your private functions, you can now require Int inputs 
export function isPrime(n: Int): boolean { 
    // In here, you can assume the value of `n` is guaranteed to be an Integer number 
    for (let i = 2; i < Math.sqrt(n); i++) { 
     if (n % i === 0) return false; 
    } 
    return true; 
} 

Dann verwenden Sie die wie so:

// @flow 

import { int, isPrime } from './lib'; 

isPrime(int(NaN)); // ok, but a runtime error, because NaN is not a number! 
isPrime(int(3.14)); // ok, will effectively become isPrime(3) 
isPrime(3.14);  // Flow error!