Typescript: 提案：数値タイプとしての範囲

このアイデアは文字に拡張できます。たとえば、 "b".."d"は"b" | "c" | "d"ます。 文字セットを指定する方が簡単です。

これは拡張して、Haskellの範囲のような構文やセマンティクスを使用できると思います。

| 構文| 脱糖|
| -------------------------- | ---------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ------------------------------------------ |
| type U = (e1..e3) | type U = \| e1 \| e1+1 \| e1+2 \| ...e3 \|
e1 > e3場合、ユニオンはneverです|
| type U2 = (e1, e2..e3) | type U2 = \| e1 \| e1+i \| e1+2i \| ...e3 \| 、
ここで、増分iはe2-e1です。

増分が正またはゼロの場合、次の要素がe3より大きくなると、ユニオンは終了します。
e1 > e3場合、和集合はneverです。

増分が負の場合、次の要素がe3未満になると、ユニオンは終了します。
e1 < e3場合、ユニオンはneverです。 |

@panuhorsmalahti "bb".."dd"を指定するとどうなりますか？

@streamich

たぶん、整数には..を使用し、浮動小数点数には...を使用します。

このような整数型を生成するというアイデアは本当に好きですが、浮動小数点値がどのように機能するかわかりません。

@aluanhaddad確率を言う：

type TProbability = 0.0...1.0;

@streamichで、そのタイプには理論的に無限の数の可能な住民がいますか？

@aluanhaddadは、実際にはIEEE浮動小数点で無限にはほど遠いでしょう。 私の計算では、1,065,353,217人の住民がいるでしょう。

0.0...1.0 ？ JSはIEEEdoubleを使用します。これは、53ビットのダイナミックレンジです。 それがサポートされるとしたら、範囲はファーストクラスの型でなければならず、それを組合に脱糖することは非現実的ではありません。

@jcreadyは確かですが、 @ fatcerberusが指摘しているように、それを共用体型として実現することは非常に広大です。

私が得ていたのは、回りくどい方法で、これが言語に離散型と連続型の概念を導入するということでした。

共用体型としてそれを実現することは、法外に広大です。

@aluanhaddadはい。ただし、符号なし整数を和集合として指定することでさえ、非常にコストがかかります。

type TUInt = 0..4294967295;

今日のユニオンの実装は、これほど大きなユニオンを実現するにはまったく適していないため、これにはいくつかの説得力のあるユースケースが本当に必要です。 このようなことを書いたらどうなるか

type UInt = 0..4294967295;
var x: UInt = ......;
if (x !== 4) {
  x;
}

共用体型0 | 1 | 2 | 3 | 5 | 6 | 7 | ...のインスタンス化になります。

おそらく、それは数値リテラルに対してのみ機能する可能性があります。 リテラル以外の数値は、範囲内に存在すると見なされる前に、比較よりも大きい/小さい値で明示的に調整する必要があります。 整数範囲には、追加のNumber.isInteger()チェックも必要になります。 これにより、実際の共用体型を生成する必要がなくなります。

@RyanCavanaugh減算タイプ？ 🌞

否定型、型否定。

文字列以外のもの：

type NotAString = !string;

ゼロ以外の任意の数：

type NonZeroNumber = number & !0;

@streamich減算タイプは＃4183でカバーされています

私のユースケースは次のとおりです。パラメータを0または正の数（配列インデックス）として入力したいと思います。

@RoyTinkerこれは間違いなくクールだと思いますが、そのユースケースが議論に役立つかどうかはわかりません。
配列は単なるオブジェクトであり、昇順のインデックスは単なる慣例です。

let a = [];
for (let i = 0; i > -10; i -= 1) {
  a[i] = Math.random() * 10;
}

したがって、最終的には同じチェックを実行する必要があります

function withItem<T>(items: T[], index: number, f: (x: T) => void) {
  if (items[index]) {
    f(items[index]);
  }
}

秒、分、時、日、月などのタイプを定義するのに非常に役立ちます。

@Frikkiこれらのユニットは十分に制限された間隔にあるため、手で書くのは実用的で非常に困難です。

type Hour =
   | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12
   | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23;

@aluanhaddadしかし、unsigned intはありません：

type UInt = 0..4294967295;

ああ、このようなタイプはどうですか？

type Factorial<N extends number> = N > 2 ? Factorial<N - 1> * N : N;
type F1 = Factorial<1>; // 1
type F2 = Factorial<2>; // 1 | 2
type F3 = Factorial<3>; // 1 | 2 | 6
type FN = Factorial<number>; // 1 | 2 | 6 | ... 

@ aleksey-bykovコメントの*演算子の使用：

type char = 0..255;
type word = char ** 2;
type int = word ** 2;
type bigint = int ** 2;

@streamichビットカウントを2倍にすることは、2の乗算に対応しません。これは、指数として2を使用するべき乗に似ています。 ただし、上限を引き上げるべきではないため、まだ正しくありませんが、エンコード可能な数値は重要です。 全体として、それは良い定義戦略ではありません。

@streamich 、いくつかのコメント：

• char 、 wordなどの用語を使用すると、他の言語の人々が静的定義と実行時の動作の違いに気付かない可能性があるため、混乱する可能性があります。
• 提案された構文は下限を考慮していません-ゼロ以外の場合はどうなりますか？
• 指数演算子はすでにES2016に追加されているため、アンビエント/タイプのコンテキストで使用するためにべき乗演算子を採用することには注意が必要です。

型システムのチューリングを完了させて、 Ctrl + Shift + B達したときの停止問題を楽しんでみましょう。

@ aleksey-bykov確かにあなたはこの素晴らしい問題を覚えています😀

@aluanhaddad

それらの単位[時間単位]は十分に制限された間隔にあるため、手で書くことは実用的で非常に困難です。

https://github.com/Microsoft/TypeScript/issues/15480#issuecomment -349270853

さて、ミリ秒でそれを行います：wink：

この問題は死んでいますか？

@Palidそれは[Needs Proposal]タグ付けされているので、私

議論は楽しいものでしたが、私たちのほとんどは、説得力のある実際のユースケースを提供できていません。

https://github.com/Microsoft/TypeScript/issues/15480#issuecomment-324152700を参照して

__ユースケース：__

1. TypeScriptのサブセットをWebAssemblyまたはその他のターゲットにコンパイルできるように、正確なint型を定義できます。

2. 別の使用例は、 UInt8Array 、 Int8Array 、 Uint16Arrayなどです。これらのTypeScriptからデータを読み書きすると、エラーがチェックされる可能性があります。

const ab = new ArrayBuffer(1e3);
const uint8 = new UInt8Array(ab);

uint8[0] = 0xFFFFFFFF; // TSError: Number too big!

1. OPでいくつかのユースケースについて説明しました。

2. これを実装すると、TypeScriptコミュニティは何百万ものユースケースを思い付くでしょう。

私は本当に面白いユースケースを持っています、それは実際にここで提案された他のものに近いかもしれません。
APIはある範囲（私の場合は5-30）の間の整数を取り、そのためのSDKを実装する必要があります。
下に手動で書き込むことは、25個の値に対して（少し自動化することはできますが）面倒ですが、数百または数千はどうでしょうか？
type X = 5 | 6 | 7 | 8 | 9 | 10 ... | 30

@Palidこれは、この機能について私が見た中で最も簡単なケースです。

以下のような範囲ならば5..30ためのシンタックスシュガーとして定義された5 | 6 | 7 ... | 30 （同様に、それまでまたは機能）私は、これは簡単に勝つだろう賭けます。 ここでは、整数の離散範囲を表します。

おそらく、（離散ではなく）連続範囲は、ピリオド付きの数値（ 5.0..30.0 ）を使用して表記できます。

私は実際にTypescriptを見てタイピング保護を実装することを検討していました
https://www.npmjs.com/package/memory-efficient-object

範囲タイピングを使用すると、タイプチェック時に潜在的なメモリオーバーフローを簡単に見つけることができます。

ユニオン拡張は実際には必要ないようですが、範囲を比較するだけの包括的/排他的範囲定義のようです

type TTerminalColors = int & [0,15];
// int && v >= 0 && v <= 15

これは、速度が0〜255の範囲のモーターを制御する場合（たとえば、Johnny-Fiveを使用）に非常に役立ちます。

別の使用例：TypeScriptを使用してCanvasベースの描画プログラムを実装していて、不透明度（0.0〜1.0の数値である必要があります）の型チェックを行いたいと考えています。

考えているだけです...これを適切に実装するには、本当にすべてを尽くす必要があります。

• ランタイムタイプのガード機能をサポートする
• x <= 10ような条件の型の絞り込み
• サポートstring | number範囲（以降x == 5あるtrueのためにx === "5"数のみの範囲に加えて）
• おそらく、新しいintタイプ（ numberサブタイプ）のサポート、およびintのみとstring | int範囲のサポートです。 また、 x|0ような式の絞り込みも入力します

素晴らしいアイデアですが、それをカバーするのは大変です！

たぶん、ランタイムタイプガードは必要ありません。 代わりに、コンパイル時をずっとガードすることができます

これには、代わりに複雑な分岐予測が必要になります

仮定する

type TTerminalColors = int & [0,15];

function A(color: TTerminalColors):void
{

}

A(15); // OK
var x = 15;
A(x); // OK

function B(value: int) : void
{
    A(value); // ERROR!!!
    if(value >= 0 && value <= 15)
        A(value); // OK, because we check that it is in the range of TTerminalColors
}

function C(value: int) : void
{
    if(value < 0)
        value = 0;
    if(value > 15)
        value = 15;

    A(value); // OK, because is clamped. But maybe too hard to implemented
}

function ClampInt(value: int): TTerminalColors
{
    if(value >= 0 && value <= 15)
        return value; // Same as B(int)

    if(value > 15)
        return 15;

    return 0;
}

私のユースケース：

export const ajax: (config: AjaxOptions) => void;

type Callback = Success | Error;
type Success = (data: any, statusText: string, xhr: XMLHttpRequest) => void;
type Error = (xhr: XMLHttpRequest, statusText: string) => void;

interface AjaxOptions {
  // ...
  statusCode: { [code: number]: Callback | Callback[] },
  // ...
}

statusCodeオプションのキーを制限して、コンパイル時にステータスコードが成功コードまたはエラーコードに対応するかどうかを判断できるようにすると便利です。

interface AjaxOptions {
  // ...
  statusCode: {
    200..300: Success,
    400..600: Error
  },
  // ...
}

IMOこれは、浮動小数点数と整数に制限する必要があり、共用体として実装するのではなく、新しい範囲タイプとして実装する必要があります。 その場合、型チェックは次のように簡単になります。

if (val >= range.start && val < range.end) {
  return match;
} else {
  return no_match;
}

私たちは、おそらく、Rubyの本から葉を取り、使用することができます..包括範囲について（ [start, stop] ）と...非包括的範囲については（ [start, stop) ）。

もう1つの使用例は、データベースレコードをタイプチェックすることです。

• https://github.com/SweetIQ/schemats

もう1つの使用例は、Lat / Lon値の型チェックです。

これは、＃8665の一般的な検証メカニズムでカバーできます（重複として閉じられた理由はわかりません）。

type TTerminalColors (n: number) => Math.floor(n) == n && n >= 0 && n <= 15;
type TRgbColorComponent (n: number) => Math.floor(n) == n && n >= 0 && n <= 255;
type TUInt (n: number) => n >= 0 && n <= 0..4294967295;

または、＃4639で取得し、符号なし整数型がuintとして定義されていると仮定します。

type TTerminalColors (n: uint) => n <= 15;
type TRgbColorComponent (n: uint) => n <= 255;

私のユースケースはグローバル座標です。 緯度と経度を入力して、特定の範囲（-90から90および-180から180）にのみ収まるようにします。

編集：latとlongは負の範囲を持っています

私のユースケースは、サイズがパラメーターである固定サイズの配列の実装です。

たとえば、長さ2の文字列の配列の型を定義したいと思います。

let d: FixedSizeArray<2, string>;
d = [ 'a', 'b' ]; // ok
d = [ 'a' ]; // type error
d = [ 'a', 'b', 'c' ]; // type error
d[0] = 'a1'; // ok
d[1] = 'b1'; // ok
d[2] = 'c1' // type error

TSの現在のバージョンでは、上記の「仕様」に非常に近いものを定義することが可能です。 主な問題はメンバーアクセスです。たとえば、 d[1] = 'b1'は、正しい場合でもタイプエラーを返します。 エラーを回避するために、すべての正当なインデックスのリストをFixedSizeArrayの定義に手動でコンパイルする必要がありますが、これは退屈です。

range演算子に似たkeyof演算子がある場合、次の型定義で問題を解決できます。

type FixedSizeArray<U extends number, T> = {
    [k in range(U)]: T;
} & { length: U };

ここで、 range(N)はrange(0,N)ショートカットです。

与えられた数値リテラル（ナチュラル）M、N、M <N、

type r = range(M, N); 

と同等です

type r = M | M+1 | ... | N-1

より一般的なのは、述語ラムダを定義してそれらを型として使用できるかどうかです。 例：

predicate mypredicate = (x) => x > 1 && x < 10 
let x: mypredicate = 11 // not ok
let x: mypredicate = 5 // ok

ラムダはすでに利用可能であるため、プロは構文の複雑さが低くなります。必要なのは、ラムダを型として使用する機能だけです。型チェックは、とにかく型スクリプト固有です（「Javascriptへのスーパーセット」の哲学を念頭に置いてください）
短所は、述語の複雑さがフィードバックを提供するためのツールのパフォーマンスを決定するということです。

数値/文字が等差数列に属することを確認することは、一般的なユースケースとして適しています。

// a is the starting element d is the difference between two elements and L is the last element
const belongsToAP = (a, d, L) => {
  return (x) => {
    if(x < a || x > L) return false
    let n = ((x-a)/d) + 1
    if(Number.isInteger(n)) return true
    return false
  }
}

これにより、次のような型チェックを実行できます。
述語belongsToMyAP = BelongsToAP（1,1、10）

let x : belongsToMyAP = 5 // ok
let y : belongsToMyAP = 7.2 // not ok

これは文字にも拡張できます。

@Kasahsこれに似たものが＃8665ですでに提案されています。

「APIを反映する」ユースケースで私の多くを投入します。 私がラッパー関数を書いているRESTエンドポイントは、引数として1..1000の範囲の整数を取ります。 数値がその制約を満たさない場合、エラーが生成されます。

だから私は数値範囲の提案を書いています、そして私はどう対処するべきかわからないこの問題に出くわしたので、私はそれを検討のためにそこに投げ出します。

TypeScriptコンパイラはTypeScriptで記述されているため、数値演算子のプロパティを利用して範囲タイプを変更することができます。

// Syntax: x..y for an inclusive integer range.

let x: 0..10 = randomNumber(0, 10);
let y = x + 2; // Can deduce that y: 2..12.

これは、新しい変数に割り当てる場合は問題ありませんが、ミューテーションについてはどうでしょうか。

let x: 0..10 = randomNumber(0, 10);
x += 2; // Error: 2..12 is not assignable to type 0..10 (upper bound is out of range).

このエラーは技術的には正しいでしょうが、実際には、対処するのは非常に面倒です。 範囲戻り型を持つ関数によって返される変数を変更する場合は、常に型アサーションを追加する必要があります。

let x = randomNumber(0, 10) as number; // If randomNumber doesn't return a type assigable to number
// this will be an error, but it would still be annoying to have to sprinkle "as number"
// expressions everywhere.

そして、それを無視すると、次のような不健全さが生じます。

function logNumber0To10 (n: 0..10): void {
    console.log(n);
}

let x: 0..10 = randomNumber(0, 10);
x += 2; // Because we're ignoring mutations, x: 0..10, but the runtime value could be 11 or 12,
// which are outside the specified range...
logNumber0To10(x); // ...which means we lose type safety on this call.

これに対する修正は、宣言後に変数の型を変更する機能であるため、例2ではxの型を2..12に変更するだけです。 しかし、私の最初の本能は、コンパイラでは、あまりにも多くのオーバーヘッドを導入すると、ユーザーに混乱することです。

そして、ユーザー定義の関数とジェネリックはどうですか？

// How to define this return type, seeing as we can't do math in types?
function increment<L extends number, H extends number> (x: L..H): (L + 1)..(H + 1);

上記に対処する方法について何か考えはありますか？

@JakeTunaley

突然変異はどうですか？

突然変異が他の割り当てと異なる必要があるのはなぜですか？

これが私の謙虚な提案の試みです。 この提案では、他のタイプの追加も要求されています。

• Infinityタイプ
  
  
  
  • 値はInfinity
  
  
• -Infinityタイプ
  
  
  
  • 値は-Infinity
  
  
• NaNタイプ
  
  
  
  • 値はNaN
  
  
• doubleタイプ
  
  
  
  • [-Number.MAX_VALUE, Number.MAX_VALUE]または[-1.7976931348623157e+308, 1.7976931348623157e+308]の範囲内のすべてのnumber値
  
  
• numberはInfinity|-Infinity|NaN|double
• intタイプ
  
  
  
  • doubleサブタイプ
  
  
  • [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]または[-9007199254740991, 9007199254740991]とMath.floor(x) === xの範囲のすべてのnumber値x Math.floor(x) === x
  
  
  • したがって、 3と3.0値はintタイプになります
  
  
• 「有限リテラル」タイプ
  
  
  
  • 例は1 、 3.141 、 45
  
  
  • doubleまたはintサブタイプである可能性があります
  
  
• (>= x)表される「GtEq」タイプ
  
  
  
  • ここで、 xは有限リテラル、 Infinity 、または-Infinity
  
  
• (<= x)表される「LtEq」タイプ
  
  
  
  • ここで、 xは有限リテラル、 Infinity 、または-Infinity
  
  
• (> x)表される「Gt」タイプ
  
  
  
  • ここで、 xは有限リテラル、 Infinity 、または-Infinity
  
  
• (< x)表される「Lt」タイプ
  
  
  
  • ここで、 xは有限リテラル、 Infinity 、または-Infinity
  
  

GtEqタイプ; (>= x)

• (>= Infinity) = Infinity
• (>= -Infinity) = -Infinity|double|Infinity
• Infinityは(>= [finite-literal])サブタイプです
• (>= [finite-literal])はdouble|Infinityサブタイプです
• (>= NaN) = never
• (>= int) = (>= -9007199254740991)
• (>= double) = (>= -1.7976931348623157e+308)
• (>= number) = number

Gtタイプ; (> x)

• (> Infinity) = never
• (> -Infinity) = double|Infinity
• Infinityは(> [finite-literal])サブタイプです
• (> [finite-literal])はdouble|Infinityサブタイプです
• (> NaN) = never
• (> int) = (> -9007199254740991)
• (> double) = (> -1.7976931348623157e+308)
• (> number) = number

LtEqタイプ; (<= x)

• (<= Infinity) = -Infinity|double|Infinity
• (<= -Infinity) = -Infinity
• -Infinityは(<= [finite-literal])サブタイプです
• (<= [finite-literal])は-Infinity|doubleサブタイプです
• (<= NaN) = never
• (<= int) = (<= 9007199254740991)
• (<= double) = (<= 1.7976931348623157e+308)
• (<= number) = number

Ltタイプ; (< x)

• (< Infinity) = -Infinity|double
• (< -Infinity) = never
• -Infinityは(< [finite-literal])サブタイプです
• (< [finite-literal])は-Infinity|doubleサブタイプです
• (< NaN) = never
• (< int) = (< 9007199254740991)
• (< double) = (< 1.7976931348623157e+308)
• (< number) = number

レンジタイプ

(>= Infinity) 、 (> number)などを書くことはできますが、
結果のタイプは範囲タイプではありません。 それらは他のタイプの単なるエイリアスです。

範囲タイプは、

• (>= [finite-literal])
• (> [finite-literal])
• (<= [finite-literal])
• (< [finite-literal])

(> number)などの構文をジェネリックで使用できるようにします。

ユニオンGtEq / Gtタイプ

2つのGtEq / Gtタイプの和集合を取ると、「more」値を持つタイプが結果になります。

• (>= [finite-literal-A]) | (>= [finite-literal-B]) = ...
  
  
  
  • [finite-literal-A] >= [finite-literal-B]場合、結果は(>= [finite-literal-B])
  
  
  • それ以外の場合、結果は(>= [finite-literal-A])
  
  
  • 例： (>= 3) | (>= 5.5) = (>= 3) (>= 3)は(>= 5.5)スーパータイプであるため、
  
  
• (>= [finite-literal-A]) | (> [finite-literal-B]) = ...
  
  
  
  • [finite-literal-A] == [finite-literal-B]場合、結果は(>= [finite-literal-A])
  
  
  • [finite-literal-A] > [finite-literal-B]場合、結果は(> [finite-literal-B])
  
  
  • それ以外の場合、結果は(>= [finite-literal-A])
  
  
• (> [finite-literal-A]) | (> [finite-literal-B]) = ...
  
  
  
  • [finite-literal-A] >= [finite-literal-B]場合、結果は(> [finite-literal-B])
  
  
  • それ以外の場合、結果は(> [finite-literal-A])
  
  
  • 例： (> 3) | (> 5.5) = (> 3) (> 3)は(> 5.5)スーパータイプであるため、
  
  

また、

• (>= A|B) = (>= A) | (>= B)
• (> A|B) = (> A) | (> B)
  
  
  
  • 例： (> 4|3) = (> 4) | (> 3) = (> 3)
  
  
  • 例： (> number|3) = (> number) | (> 3) = number | (> 3) = number
  
  

ユニオンLtEq / Ltタイプ

2つのLtEq / Lt型の和集合を取ると、「more」値を持つ型が結果になります。

• (<= [finite-literal-A]) | (<= [finite-literal-B]) = ...
  
  
  
  • [finite-literal-A] <= [finite-literal-B]場合、結果は(<= [finite-literal-B])
  
  
  • それ以外の場合、結果は(<= [finite-literal-A])
  
  
  • 例： (<= 3) | (<= 5.5) = (<= 5.5) (<= 5.5)は(<= 3)スーパータイプであるため、
  
  
• (<= [finite-literal-A]) | (< [finite-literal-B]) = ...
  
  
  
  • [finite-literal-A] == [finite-literal-B]場合、結果は(<= [finite-literal-A])
  
  
  • [finite-literal-A] < [finite-literal-B]場合、結果は(< [finite-literal-B])
  
  
  • それ以外の場合、結果は(<= [finite-literal-A])
  
  
• (< [finite-literal-A]) | (< [finite-literal-B]) = ...
  
  
  
  • [finite-literal-A] <= [finite-literal-B]場合、結果は(< [finite-literal-B])
  
  
  • それ以外の場合、結果は(< [finite-literal-A])
  
  
  • 例： (< 3) | (< 5.5) = (< 5.5) (< 5.5)は(< 3)スーパータイプであるため、 (< 3) | (< 5.5) = (< 5.5) (< 3)
  
  

また、

• (<= A|B) = (<= A) | (<= B)
• (< A|B) = (< A) | (< B)
  
  
  
  • 例： (< 4|3) = (< 4) | (< 3) = (< 4)
  
  
  • 例： (< number|3) = (< number) | (< 3) = number | (< 3) = number
  
  

交差点GtEq / Gtタイプ

2つのGtEq / Gtタイプの共通部分をとると、「少ない」値のタイプが結果になります。

• (>= [finite-literal-A]) & (>= [finite-literal-B]) = ...
  
  
  
  • [finite-literal-A] >= [finite-literal-B]場合、結果は(>= [finite-literal-A])
  
  
  • それ以外の場合、結果は(>= [finite-literal-B])
  
  
  • 例： (>= 3) & (>= 5.5) = (>= 5.5) (>= 5.5)は(>= 3)サブタイプであるため、
  
  
• (>= [finite-literal-A]) & (> [finite-literal-B]) = ...
  
  
  
  • [finite-literal-A] == [finite-literal-B]場合、結果は(> [finite-literal-B])
  
  
  • [finite-literal-A] > [finite-literal-B]場合、結果は(>= [finite-literal-A])
  
  
  • それ以外の場合、結果は(> [finite-literal-B])
  
  
• (> [finite-literal-A]) & (> [finite-literal-B]) = ...
  
  
  
  • [finite-literal-A] >= [finite-literal-B]場合、結果は(> [finite-literal-A])
  
  
  • それ以外の場合、結果は(> [finite-literal-B])
  
  
  • 例： (> 3) & (> 5.5) = (> 5.5) (> 5.5)は(> 3)サブタイプであるため、
  
  

交差点LtEq / Ltタイプ

2つのLtEq / Ltタイプの共通部分をとると、「少ない」値のタイプが結果になります。

• (<= [finite-literal-A]) & (<= [finite-literal-B]) = ...
  
  
  
  • [finite-literal-A] <= [finite-literal-B]場合、結果は(<= [finite-literal-A])
  
  
  • それ以外の場合、結果は(<= [finite-literal-B])
  
  
  • 例： (<= 3) & (<= 5.5) = (<= 3) (<= 3)は(<= 5.5)サブタイプであるため、
  
  
• (<= [finite-literal-A]) & (< [finite-literal-B]) = ...
  
  
  
  • [finite-literal-A] == [finite-literal-B]場合、結果は(< [finite-literal-B])
  
  
  • [finite-literal-A] < [finite-literal-B]場合、結果は(<= [finite-literal-A])
  
  
  • それ以外の場合、結果は(< [finite-literal-B])
  
  
• (< [finite-literal-A]) & (< [finite-literal-B]) = ...
  
  
  
  • [finite-literal-A] <= [finite-literal-B]場合、結果は(< [finite-literal-A])
  
  
  • それ以外の場合、結果は(< [finite-literal-B])
  
  
  • 例： (< 3) & (< 5.5) = (< 3) (< 3)は(< 5.5)サブタイプであるため、 (< 3) (< 5.5)
  
  

ユースケース

• 整数がMySQL UNSIGNED INTデータ型に収まるように静的に保証するには、

  //TODO Propose numeric and range sum/subtraction/multiplication/division/mod/exponentiation types?
  function insertToDb (x : int & (>= 0) & (<= 4294967295)) {
    //Insert to database
  }
  

• 文字列が指定された長さであることを静的に確認するには、

  function foo (s : string & { length : int & (>= 1) & (<= 255) }) {
    //Do something with this non-empty string that has up to 255 characters
  }
  

• 配列のようなオブジェクトに適切なlength値があることを静的に確認するには、

  function foo (arr : { length : int & (>= 0) }) {
    //Do something with the array-like object
  }
  

• 有限数のみが与えられることを静的に保証するために、

  function foo (x : double) {
    //`x` is NOT NaN|Infinity|-Infinity
  }
  

• 配列インデックスが存在することを静的に確認するには？

  function foo (arr : { [index : int & (>= 0) & (< 10)] : string }) {
    console.log(arr[0]); //OK
    console.log(arr[1]); //OK
    console.log(arr[2]); //OK
    console.log(arr[9]); //OK
    console.log(arr[10]); //Error
  }
  

数値と範囲の加算/減算/乗算/除算/ mod /べき乗のタイプを提案したいのですが、それはこの問題では範囲外のようです。

[編集]
あなたは、名前の変更ができdoubleし、それを呼び出すfloat 、私はちょうどと思っdoubleより正確に、これは倍精度浮動小数点数であることを表します。

[編集]

一部のタイプをnever 。

コンパイラにフロー分析を行わせることは可能でしょうか？

この関数があるとしましょう

function DoSomething(x : int & (>= 0) & (< 10)){
   // DoSomething
}

function WillError(x : int){
    DoSomething(x); // error; x is not >= 0 & < 10
}

function WillNotError(x : int){
    if(x >= 0 && x < 10)
        DoSomething(x); // not error by flow analysis
}

もう1つのユースケース：パーセンテージを表す関数への数値入力があります。 値を0から1の間に制限したい。

[...Array(256)].map((_,i) => i).join("|")を実行して、これまでで最も醜い型定義を作成しました

非負の整数と小さい数が可能です：

type ArrayT<T> = T extends (infer P)[] ? P : never;
type A = ArrayT<Range<5, 10>>;//5|6|7|8|9|10

範囲：https ：//github.com/kgtkr/typepark/blob/master/src/list.ts

「小さい数」とは、ステージ3を使用しないことを意味しますBigInt ？

@Mouvediaコンパイラの再帰制限内に収まる数値

たぶん、整数には..を使用し、浮動小数点数には...を使用します。

..は包括的範囲を意味し、 ...排他的であるべきだと思います。 たとえばRubyのように。 http://rubylearning.com/satishtalim/ruby_ranges.htmlを参照してください

私は、包括的範囲と排他的範囲を区別するために単一の期間を使用するのが好きではありません

飛び込むことはできますか？ 型指定の単一の拡張として見られるこの機能は、ここに行くための最良の方法ではない可能性が高いと思います。

type range = 1:2:Infinity // 1, 3, 5… Infinity

これは、多くの4glプラットフォーム、特にマトリックス指向のプラットフォームで数値範囲を定義する方法です。

均一な範囲は従来、最良のモデリング手法の1つであるため、この方法で行います。

したがって、順次範囲は次のとおりです。

type decmials = 1:10 // like 1 .. 10 with all decimals in between

そして整数だけの場合：

type integers = 1:1:10 // 1, 2, 3, 4, 5, 6, 7, 8, 10

// OR

type integers = number.integers<1:10>

構文をいじりたい場合：

type something = 1::10 // whatever use cases need today

それがトークナイザーに適していない場合、これは私の意見ではここに焦点を当てる正しいブロッキング優先順位ではありません。 私は、ある解決策が次の解決策にたどり着くのを制限しないことを望んでいることを指摘します。

編集：私が説明できないのは包括性の側面です—そしてここで、すべての数値を暗黙的に含む均一な範囲に依存する多くの問題を人々が解決したときに、なぜそれが問題ではなかったのかを理解するのに十分なデューデリジェンスを行っているかどうか疑問に思う必要があります増分が範囲の終わりと正確に一致しなかった場合を除きます。

範囲タイプで「ステップ」サイズを定義できるようになるのは興味深いことです。

「浮動小数点」（固定ステップサイズなし）と「整数」（ステップサイズ1、整数から開始）の範囲を超えて、他のステップサイズの範囲の実際のユースケースに遭遇したことはありません。

それで、それが他の場所のものであると聞くのは興味深いです。 今まで聞いたことがないので、4glについて学ぶ必要があります。

ハーフオープン間隔を定義できると、配列のようなオブジェクトに役立ちます。 何かのようなもの、

interface SaferArray<T, LengthT extends integer & (>= 0)> {
    length : LengthT;
    [index in integer & (>= 0) & (< LengthT)] : T
}

包括的範囲しかない場合は、 (<= LengthT - 1)が必要になりますが、それはあまりエレガントではありません。

飛び込むことはできますか？ 型指定の単一の拡張として見られるこの機能は、ここに行くための最良の方法ではない可能性が高いと思います。

type range = 1:2:Infinity // 1, 3, 5… Infinity

これは、多くの4glプラットフォーム、特にマトリックス指向のプラットフォームで数値範囲を定義する方法です。

均一な範囲は従来、最良のモデリング手法の1つであるため、この方法で行います。

したがって、順次範囲は次のとおりです。

type decmials = 1:10 // like 1 .. 10 with all decimals in between

そして整数だけの場合：

type integers = 1:1:10 // 1, 2, 3, 4, 5, 6, 7, 8, 10

// OR

type integers = number.integers<1:10>

構文をいじりたい場合：

type something = 1::10 // whatever use cases need today

それがトークナイザーに適していない場合、これは私の意見ではここに焦点を当てる正しいブロッキング優先順位ではありません。 私は、ある解決策が次の解決策にたどり着くのを制限しないことを望んでいることを指摘します。

編集：私が説明できないのは包括性の側面です—そしてここで、すべての数値を暗黙的に含む均一な範囲に依存する多くの問題を人々が解決したときに、なぜそれが問題ではなかったのかを理解するのに十分なデューデリジェンスを行っているかどうか疑問に思う必要があります増分が範囲の終わりと正確に一致しなかった場合を除きます。

うーん、Haskellでの処理方法のように見えます。 これはいいと思います。 ジェネレーターは遅延評価も可能にします。

他の構文= xで遅延評価を行うことができないわけではありません

範囲タイプで「ステップ」サイズを定義できるようになるのは興味深いことです。

範囲は、開始、終了、および増分と考えています。 したがって、増分が正確に最後まで四捨五入される場合は、それが含まれます。 範囲関数としての配列のインデックスと長さは、配列にすることができます0：1：9には10個のインデックスステップ（長さ）があります。 したがって、ここでの範囲は、これら2つの式の組み合わせからより簡単に推測できる型システムの場合、便利なことにinteger & 0:9になります。

4GLは本当に一般的なラベルであり、私にとってはほとんどがMatLabでした。

私のポイントは、包括的範囲しかない場合、ジェネリックスでの使用が難しくなるということでした（ハックのような型レベルの数学演算を実装しない限り）。

なぜなら、タイプパラメータとして「長さ」だけを使用するのではなく、長さと最大インデックスが必要になるからです。 また、最大インデックスは長さ-1に等しくなければなりません。

そして、繰り返しますが、これらのハックのようなタイプレベルの数学演算を実装しない限り、実際にそれが当てはまるかどうかを確認することはできません。

@AnyhowStep私はあなたの懸念を

包括的またはそうでないものをn-1問題（このインデックス/カウントシナリオなど）に特に適用できるものとは別にして、それが何らかの方法で独立して解決されたと仮定すると（考えをユーモアを交えて）、数値範囲がそれでも、適切に説明するために、宣言型および/または型破りな構文が必要ですか？

私はそれらが2つの別々の側面であることに気づいています、あなたはそのドメインの期待に従来通り整列されている数値範囲を必要とし、そしてあなたはまたインデックス/カウントタイプの述語を必要とします...など。

正の数のみ。

declare let x : (> 0);
x = 0.1; //OK
x = 0.0001; //OK
x = 0.00000001; //OK
x = 0; //Error
x = 1; //OK
x = -1; //Error

包括的のみの範囲で、

declare let x : epsilon:epsilon:Infinity; //Where epsilon is some super-small non-zero, positive number

Infinityを除く正の数、

declare let x : (> 0) & (< Infinity);

包括的のみの範囲で、

const MAX_FLOAT : 1.7976931348623157e+308 = 1.7976931348623157e+308;
declare let x : epsilon:epsilon:MAX_FLOAT;

また、現在の議論とは関係ありませんが、数値範囲タイプが本当に必要なもう1つの理由があります。

私の日常の仕事の多くは、さまざまなソフトウェアシステムを組み合わせることです。 そして、これらのシステムの多くは、同じ意味を持つデータに対して異なる要件を持っています。

例：（systemA、1〜255の値）、（systemB、3〜73の値）など。
例：（systemC。文字列の長さ7-88）、（systemD、文字列の長さ9-99）、（systemE、文字列の長さ2-101）など。

今のところ、これらすべての個別の要件を注意深く文書化し、あるシステムのデータが別のシステムに正しくマッピングできることを確認する必要があります。 マップされない場合は、回避策を見つける必要があります。

私は人間だけです。 私は失敗する。 データがマッピングできないことがあることに気づいていません。 範囲チェックは失敗します。

数値範囲タイプを使用すると、最終的に、各システムが期待する範囲を宣言し、コンパイラーにチェックを任せることができます。

たとえば、使用しているAPIで、すべての文字列値に対して10kの文字列長制限があるという状況が発生しました。 ええと、APIに送られるすべての文字列が10k未満の文字列長であることを確認するようにTypeScriptに指示する方法がありませんでした。

TSが行く可能性のある素晴らしいコンパイルエラーではなく、実行時エラーが発生しました。

`string` is not assignable to `string & { length : (<= 10000) }`

@AnyhowStep私の意図は、「数値タイプとしての範囲」と呼ばれるものが、より一般的なユーザー（つまり、範囲が間隔よりも包括性を強調する理由を疑問に思っているTSに移動する人）に対する一般的な期待と単純に一致することを確認することだけであることを理解していただければ幸いです。

正直なところ、ユースケースは常に機能を推進する必要があると思います。インデックスと長さに関する問題は、私たちの多くが時々本当に見逃している問題だと思います。 だから私は単に正しいラベルの下でその問題に対処したいのです—それは数字タイプのものですか、それともインデックスタイプのものですか？ 正確な答えはわかりませんが、数型として解いても、同じように理解していない数型ユーザーにとっては、うっかりして問題が増えることはないと思います。

それで、そのような問題を修正することが誰にとっても意味がある他の場所は、この時点で私が疑問に思っているすべてです、考え？

バイト配列を渡すAPIを扱っているので、バイトタイプを定義したいと思います。

type byte = 0x00..0xFF
type bytes = byte[]

これは、 Uint8Arrayするときにも役立ちます。

あなたが私のようで、現時点で実際に使用できる範囲タイプを取得することに実際の範囲タイプのコードスニペットがあります。

TL; DR、
範囲タイプが機能するようになりました

interface CompileError<_ErrorMessageT> {
    readonly __compileError : never;
}
///////////////////////////////////////////////
type PopFront<TupleT extends any[]> = (
    ((...tuple : TupleT) => void) extends ((head : any, ...tail : infer TailT) => void) ?
    TailT :
    never
);
type PushFront<TailT extends any[], FrontT> = (
    ((front : FrontT, ...tail : TailT) => void) extends ((...tuple : infer TupleT) => void) ?
    TupleT :
    never
);
type LeftPadImpl<TupleT extends any[], ElementT extends any, LengthT extends number> = {
    0 : TupleT,
    1 : LeftPad<PushFront<TupleT, ElementT>, ElementT, LengthT>
}[
    TupleT["length"] extends LengthT ?
    0 :
    1
];
type LeftPad<TupleT extends any[], ElementT extends any, LengthT extends number> = (
    LeftPadImpl<TupleT, ElementT, LengthT> extends infer X ?
    (
        X extends any[] ?
        X :
        never
    ) :
    never
);
type LongerTuple<A extends any[], B extends any[]> = (
    keyof A extends keyof B ?
    B :
    A
);

///////////////////////////////////////////////////////
type Digit = 0|1|2|3|4|5|6|7|8|9;
/**
 * A non-empty tuple of digits
 */
type NaturalNumber = Digit[];

/**
 * 6 - 1 = 5
 */
type SubOne<D extends Digit> = {
    0 : never,
    1 : 0,
    2 : 1,
    3 : 2,
    4 : 3,
    5 : 4,
    6 : 5,
    7 : 6,
    8 : 7,
    9 : 8,
}[D];

type LtDigit<A extends Digit, B extends Digit> = {
    0 : (
        B extends 0 ?
        false :
        true
    ),
    1 : false,
    2 : LtDigit<SubOne<A>, SubOne<B>>
}[
    A extends 0 ?
    0 :
    B extends 0 ?
    1 :
    2
];


//false
type ltDigit_0 = LtDigit<3, 3>;
//true
type ltDigit_1 = LtDigit<3, 4>;
//false
type ltDigit_2 = LtDigit<5, 2>;


/**
 * + Assumes `A` and `B` have the same length.
 * + Assumes `A` and `B` **ARE NOT** reversed.
 *   So, `A[0]` is actually the **FIRST** digit of the number.
 */
type LtEqNaturalNumberImpl<
    A extends NaturalNumber,
    B extends NaturalNumber
> = {
    0 : true,
    1 : (
        LtDigit<A[0], B[0]> extends true ?
        true :
        A[0] extends B[0] ?
        LtEqNaturalNumberImpl<
            PopFront<A>,
            PopFront<B>
        > :
        false
    ),
    2 : never
}[
    A["length"] extends 0 ?
    0 :
    number extends A["length"] ?
    2 :
    1
];
type LtEqNaturalNumber<
    A extends NaturalNumber,
    B extends NaturalNumber
> = (
    LtEqNaturalNumberImpl<
        LeftPad<A, 0, LongerTuple<A, B>["length"]>,
        LeftPad<B, 0, LongerTuple<A, B>["length"]>
    > extends infer X ?
    (
        X extends boolean ?
        X :
        never
    ) :
    never
);

//false
type ltEqNaturalNumber_0 = LtEqNaturalNumber<
    [1],
    [0]
>;
//true
type ltEqNaturalNumber_1 = LtEqNaturalNumber<
    [5,2,3],
    [4,8,9,2,3]
>;
//false
type ltEqNaturalNumber_2 = LtEqNaturalNumber<
    [4,8,9,2,3],
    [5,2,3]
>;
//true
type ltEqNaturalNumber_3 = LtEqNaturalNumber<
    [5,2,3],
    [5,2,3]
>;
//true
type ltEqNaturalNumber_4 = LtEqNaturalNumber<
    [5,2,2],
    [5,2,3]
>;
//false
type ltEqNaturalNumber_5 = LtEqNaturalNumber<
    [5,1],
    [2,5]
>;
//false
type ltEqNaturalNumber_6 = LtEqNaturalNumber<
    [2,5,7],
    [2,5,6]
>;

type RangeLt<N extends NaturalNumber> = (
    number &
    {
        readonly __rangeLt : N|undefined;
    }
);
type StringLengthLt<N extends NaturalNumber> = (
    string & { length : RangeLt<N> }
);

type AssertStringLengthLt<S extends StringLengthLt<NaturalNumber>, N extends NaturalNumber> = (
    LtEqNaturalNumber<
        Exclude<S["length"]["__rangeLt"], undefined>,
        N
    > extends true ?
    S :
    CompileError<[
        "Expected string of length less than",
        N,
        "received",
        Exclude<S["length"]["__rangeLt"], undefined>
    ]>
);
/**
 * String of length less than 256
 */
type StringLt256 = string & { length : RangeLt<[2,5,6]> };
/**
 * String of length less than 512
 */
type StringLt512 = string & { length : RangeLt<[5,1,2]> };

declare function foo<S extends StringLengthLt<NaturalNumber>> (
    s : AssertStringLengthLt<S, [2,5,6]>
) : void;

declare const str256 : StringLt256;
declare const str512 : StringLt512;

foo(str256); //OK!
foo(str512); //Error

declare function makeLengthRangeLtGuard<N extends NaturalNumber> (...n : N) : (
    (x : string) => x is StringLengthLt<N>
);

if (makeLengthRangeLtGuard(2,5,6)(str512)) {
    foo(str512); //OK!
}

declare const blah : string;
foo(blah); //Error

if (makeLengthRangeLtGuard(2,5,5)(blah)) {
    foo(blah); //OK!
}

if (makeLengthRangeLtGuard(2,5,6)(blah)) {
    foo(blah); //OK!
}

if (makeLengthRangeLtGuard(2,5,7)(blah)) {
    foo(blah); //Error
}

遊び場

ここからCompileError<>タイプを使用します。
https://github.com/microsoft/TypeScript/issues/23689#issuecomment -512114782

AssertStringLengthLt<>タイプは魔法が起こる場所です

タイプレベルの追加を使用すると、 str512 + str512を取得して、 str1024を取得できます。

https://github.com/microsoft/TypeScript/issues/14833#issuecomment -513106939

@AnyhowStepソリューションを見ると、より良い一時的なソリューションがあると思います。 タイプガードを覚えていますか？：

/**
 * Just some interfaces
 */
interface Foo {
    foo: number;
    common: string;
}

interface Bar {
    bar: number;
    common: string;
}

/**
 * User Defined Type Guard!
 */
function isFoo(arg: any): arg is Foo {
    return arg.foo !== undefined;
}

/**
 * Sample usage of the User Defined Type Guard
 */
function doStuff(arg: Foo | Bar) {
    if (isFoo(arg)) {
        console.log(arg.foo); // OK
        console.log(arg.bar); // Error!
    }
    else {
        console.log(arg.foo); // Error!
        console.log(arg.bar); // OK
    }
}

doStuff({ foo: 123, common: '123' });
doStuff({ bar: 123, common: '123' });

したがって、次のコードを見てください。

class NumberRange {
    readonly min: number;
    readonly max: number;
    constructor(min:number, max:number, ) {
        if (min > max) { 
            throw new RangeError(`min value (${min}) is greater than max value (${max})`);
        } else {
            this.min = min;
            this.max = max;
        }
    }
    public isInRange = (num: number, explicit = false): boolean => {
        let inRange: boolean = false;
        if (explicit === false) {
            inRange = num <= this.max && num >= this.min;
        } else {
            inRange = num < this.max && num > this.min;
        }
        return inRange;
    };
}
const testRange = new NumberRange(0, 12);
if(testRange.isInRange(13)){
    console.log('yay')
}else {
  console.log('nope')
}

これは単なるアイデアですが、タイプガードを使用すると、範囲を使用できます。

ここでの問題は、これができないことです。

declare const a : number;
declare let b : (>= 5);
const testRange = new NumberRange(12, 20);
if (testRange.isInRange(a)) {
  b = a; //ok
} else {
  b = a; //compile error
}

タイプガードだけでは満足のいく解決策ではあり

また、あなたの例ではタイプガードさえ使用していません。

上記の私のばかげたハッキーなおもちゃの例では、境界が他の範囲内にある場合、範囲タイプを別の範囲タイプに（関数paramsを介して）割り当てることができます。

また、プリミティブで使用されているタグタイプ、ノミナルタイプ、および値オブジェクトは、通常、型システムが十分に表現力に欠けていることを示しています。

タグタイプを使用する愚かなおもちゃの例は、非常に非人間的であるため、嫌いです。 範囲がプリミティブであることがどのように優れているかについては、この長いコメントを参照できます。

https://github.com/microsoft/TypeScript/issues/6579#issuecomment -548249683

これは、現在のTypescriptバージョンで実現できます。

// internal helper types
type IncrementLength<A extends Array<any>> = ((x: any, ...xs: A) => void) extends ((...a: infer X) => void) ? X : never;
type EnumerateRecursive<A extends Array<any>, N extends number> = A['length'] extends infer X ? (X | { 0: never, 1: EnumerateRecursive<IncrementLength<A>, N> }[X extends N ? 0 : 1]) : never;

// actual utility types
export type Enumerate<N extends number> = Exclude<EnumerateRecursive<[], N>, N>;
export type Range<FROM extends number, TO extends number> = Exclude<Enumerate<TO>, Enumerate<FROM>>;

// usage examples:
type E1 = Enumerate<3>; // hover E1: type E1 = 0 | 1 | 2
type E2 = Enumerate<10>;  // hover E2: type E2 = 0 | 1 | 3 | 2 | 4 | 5 | 6 | 7 | 8 | 9

type R1 = Range<0, 5>; // hover R1: type R1 = 0 | 1 | 3 | 2 | 4
type R2 = Range<5, 11>; // hover R2: type R2 = 10 | 5 | 6 | 7 | 8 | 9

包括的開始インデックスと排他的終了インデックスを使用するという規則に従いましたが、必要に応じて調整できます。

vsコードのホバーヒントはコメントにあります。

ホバーヒントの数字がランダムに並べ替えられていることに注意してください。

悲しいことに、それは約10要素までしか機能しません:(

編集： Enumerateは最大15再帰（0〜14）しか処理できないようです

@ Shinigami92
このアプローチでは、Enumerateは最大40を処理します。
これはまだ制限ですが、実際にはそれほど厳しくないかもしれません。

type PrependNextNum<A extends Array<unknown>> = A['length'] extends infer T ? ((t: T, ...a: A) => void) extends ((...x: infer X) => void) ? X : never : never;
type EnumerateInternal<A extends Array<unknown>, N extends number> = { 0: A, 1: EnumerateInternal<PrependNextNum<A>, N> }[N extends A['length'] ? 0 : 1];
export type Enumerate<N extends number> = EnumerateInternal<[], N> extends (infer E)[] ? E : never;
export type Range<FROM extends number, TO extends number> = Exclude<Enumerate<TO>, Enumerate<FROM>>;

type E1 = Enumerate<40>;
type E2 = Enumerate<10>;
type R1 = Range<0, 5>;
type R2 = Range<5, 34>;

そして今、それはたまたま魔法のように分類されました;）。

私の典型的なユースケースは、 [1, 255] 、 [1, 2048] 、 [1, 4096] 、 [20, 80]などの範囲を使用します。大きな共用体タイプを作成すると、TSが異常終了/減速する可能性があります。 。 しかし、これらのソリューションは間違いなく「より小さな」範囲で機能します

@AnyhowStep
再帰カウントが制限であることを知っているので、これらの範囲を達成するために、型定義内の単一の非再帰操作で2による数の除算/乗算を実行する方法を見つける必要があります。

パフォーマンスは依然として問題です。 このため、以前は大きなアプリから有用な共用体型を選別する必要がありました。これは興味深い演習かもしれませんが、解決策ではありません。

私が推測する完璧な解決策はまだありませんか？

私はこれが一般的な方法で次のようにできることを願っています（しかし難しいですが）。

type X => (number >= 50 && number > 60 || number = 70) || (string.startsWith("+"))

（つまり、変数が型に置き換えられていることを除いて、通常のjavascriptステートメント/関数をここで使用できます）

私の理解では、現代語=通常の論理+メタ論理、ここでメタ論理=コードチェック+コード生成。 多くの作品は、メタ論理構文をエレガントな方法でマージしようとしているだけです。

どういうわけか、範囲タイプをある種の砂糖ではなく、コアコンセプトであると想定することができますか？

// number literal extend `number` despite the fact 
// that `number` is not union of all number literals
type NumberLiteralIsNumber = 5 extends number ? true : false // true

// so if we will define Range (with some non-existing syntax which is clearly should be done in lib internals)
type Range<MIN extends number, MAX extends number> = MAX > MIN ? 5 and 2NaN : MAX === MIN ? MAX : MIN..MAX

// and assume that `number` is Range<-Infinity, +Infinity>
type NumberIsInfinitRange = number extends Range<-Infinity, +Infinity> ?
    Range<-Infinity, +Infinity> extends number ? true : false :
    false // true

// following things will be true
type AnyRangeIsNumber<T extends number, K extends Number> = 
    Range<T, K> extends number ? true : false // true
type NestedRangeIsNumber<T extends number, K extends number, S extends number> =
    Range<T, Range<K, S>> extends number ? true : false // true

これを完了するには、場合によっては動作を宣言する必要があります

1. 定義上Range<T, T> === T
2. 定義上Range<5, 1> === NaN
3. Range<NaN, T> === Range<T, NaN> === NaNそのような値は存在できません
4. Range<1 | 2, 5> === Range<2, 5>最初のタイプのパラメーターが範囲を短く制限するため、数値が大きくなる可能性があります
5. Range<1, 4 | 5> === Range<1, 4> 2番目のタイプのパラメーターが範囲を短くするように制限するため、数値が小さくなる可能性
6. 1.5 extends Range<1, 2>は定義上真である必要があります
7. Range<Range<A, B>, C> === NaN extends Range<A, B> ? NaN : Range<B, C>は5と3から続きます
8. Range<A, Range<B, C>> === NaN extends Range<B, C> ? NaN : Range<A, B>は6と3から続きます

そして、範囲内の範囲について少し：

type RangeIsInsideRange<T extends Range<any, any>, K extends Range<any, any>> = 
    T extends Range<infer A, infer B> 
        ? K extends Range<infer C, infer D> 
            ? NaN extends Range<A, C> 
                ? false 
                : NaN extends Range<B, D> 
                    ? false 
                    : true 
            : never
        : never

範囲サブタイプは、タイプレベルの比較関数(a: T, b: T) => '<' | '=' | '>'として、一般的な方法で定義することもできます。

...タイプレベルで通常のJS関数を使用するための提案はありますか？

提案はありませんが、以前に簡単なプロトタイプを作成しました。 残念ながら、IDEのパフォーマンスと入力のサニタイズには大きな懸念があります。

@yudinnsの問題は、範囲が少なくともこの名前で存在するため、混乱する可能性があることです。https ： //developer.mozilla.org/en-US/docs/Web/API/rangeも参照してください。定義できる機能がありません。 <1, n+2>ような数列-1つ以上の複雑な方程式から始まるステップ2-1。

このTC39提案は、これが実装される前に、おそらくステージ4に到達します。
チケットは3歳です。

提案：正規表現で検証された文字列タイプ： https ：

（関連するSOの質問：https：//stackoverflow.com/questions/3895478/does-javascript-have-a-method-like-range-to-generate-a-range-within-the-supp）

number in rangeようなことをすることができればそれもクールでしょう。例えばif 1 in 1..2または包括的if 1 in 1..=2 rustはそれをうまく処理しますhttps://doc.rust-lang.org/reference/ expression /range-expr.html 。 それは多くのスペースを節約するでしょう

Pythonとrustにはすでに型付き範囲機能がありませんか？
主な目的と最大のユースケースは数値範囲ですが、車輪の再発明や文字列、浮動小数点数などで特別に汎用化するのではなく、既存のソリューションを他の言語で再実装することはできますか？ 後で必要に応じて追加できます

私はこれに何度も遭遇し、0 ... 1の間の分数である型を定義する方法を探しにここに来ました-これはhttps://news.ycombinator.com/item?id=で議論されてい24362658＃24372935 。 typescriptがここで役立つのであれば、それは素晴らしいことですが、タイプレベルで実施するのは非常に難しいかもしれません。

@andrewphillipoそれも議論されているのを見て、スタック交換に関する回答の1つからユニット間隔という用語について学びました。これは、一般的なコンテキストでその特定の範囲を参照する正しい方法のようです。

型としての範囲がtypescriptで実装されたことがあれば、おそらくUnitIntervalグローバル型として定義して、プログラミングで頻繁に使用するものに共通する命名法を奨励することができます。

はいUnitIntervalは範囲0 ... 1の正しい名前なので、タイプに適しています！ まだ番号の名前が正しくないので、このような型を使用してコードをより正確に記述するためにこれが利用可能であれば、これは優れています-これはRustの型システムの内部でどのように機能しますか-それは単なる警備員ですか？

CantorSpaceがそれほど大きくない場合、コンピューターで理解されるように、 [0, 1]間の「すべての」実数の「範囲」の公正な定義になると思います。 コンパイル時にこれらを値に割り当てることは、 Math.ceil(0) === 0以降のjavascriptのMath.floorまたはMath.ceil下限と上限、およびMath.floor(1) === 1によって推測することはできません。残念ながら。

すべての数値のセット(0, 1)が代わりに使用された場合、上記の例を使用して機能しますが、日常の言語でパーセンテージとして参照される値を除外するのはちょっと悪いことです。 可能であれば、コンパイラに境界を含めると、エッジケース0と1に対して厳密な===チェックを行うことができます。

または、整数には1~~3を使用し、浮動小数点数には0.1~0.5を使用しますか？

~は、単項ビット単位のNOT演算子によってすでに使用されています。

なぜ私たちがそれらのいまいましい山車について話す必要があるのか​​、私たちが抱えている問題は整数にあります。 99.99％は整数の問題です。0.001％は浮動小数点の問題です。
一般的な解決策は簡単にはあり得ないので、何年も前にすでに実装されているように、ほとんどのプログラミング言語で見られるように、0から10の数の範囲に行きましょう。

フロートの話をやめなさい

たぶん、私たちは法案を分割し、intの場合にこの提案を拡張することができます：
https://gist.github.com/rbuckton/5fd81582fdf86a34b45bae82d842304c

そして、フロートについては、現在、この号のいくつかのアイデアに基づいて別の設計提案に取り組んでいます（主に@AnyhowStep、基本的にはOpen-Interval-Typeを持つ機能）。

シンプルに保つ
x..yは整数のみです。
0.1..2はエラーになります
1..2.1もエラーになります
そして、検出可能な非整数。
から実装ロジックをコピーします
https://en.m.wikibooks.org/wiki/Ada_Programming/Types/range
または
https://kotlinlang.org/docs/reference/ranges.html
または
https://doc.rust-lang.org/reference/expressions/range-expr.html
そしてそれを1日と呼びます。

✅車輪の再発明の必要はありません
✅フロートを考慮する必要はありません
✅言語間の一貫性
✅既存のソースからテスト済みでコピー可能な安定したコード

型の値をすべての固定整数0..1000の和集合としてハードコーディングすることにより、1000未満の数値の場合、「int」ベースの型チェックは簡単であるため、floatを解決するために努力する価値があります。 -車輪の再発明」は少し皮肉なことです。 単純なユースケースですでに機能しているものを使用してみませんか？

私はむしろ、無理数のようなものを理解する型定義を可能にするために、いくらかの余地があることを望んでいます。 ラジアンを使用する場合、コンパイル時に不変条件を検出する機能は、興味深いユースケースになります。 範囲値の境界への引数としてτをサポートすることは、この機能が意図したimoとして機能すると主張するための良いターゲットです。

javascriptには明示的なintegerがないことに注意してください。 すべてがnumberであり、浮動小数点数として格納されます。 範囲型演算子が実装されている場合、 numberが処理できるすべての値を処理する必要があります。

explicitの定義に応じた@aMoniker ： BigInt

bigintの場合でも、bigintがMySQLの符号付き/符号なしbigint内に収まるようにするなど、ユニオンが解決できないユースケースがあります。

この機能のintrinsic範囲タイプを作成するのはどうですか？

lib.es5.d.ts （またはbigintsのサポートを含める場合はlib.es2020.bigint.d.ts ）

type GreaterThan<N extends number | bigint> = intrinsic
type GreaterThanOrEqualTo<N extends number | bigint> = GreaterThan<N> | N
type LessThan<N extends number | bigint> = intrinsic
type LessThanOrEqualTo<N extends number | bigint> = LessThan<N> | N

/**
 * prevent `GreaterThan` and `LessThan` from desugaring
 * (in the same way that `number` does _not_ desugar to `-Infinity | ... | Infinity`)
 */

ユーザーランド

type GreaterThanOrEqualTo2 = GreaterThanOrEqualTo<2>
type LessThan8 = LessThan<8>

type GreaterThanOrEqualTo2_And_LessThan8 = GreaterThanOrEqualTo2 & LessThan8
type LessThan2_Or_GreaterThanOrEqualTo8 = LessThan<2> | GreaterThanOrEqualTo<8> // inverse of `GreaterThanOrEqualTo2_And_LessThan8` (would be nice to be able to just do `Exclude<number | bigint, GreaterThanOrEqualTo2_And_LessThan8>` but that might be wishful thinking)
type LessThan2_And_GreaterThanOrEqualTo8 = LessThan<2> & GreaterThanOrEqualTo<8> // `never`
type GreaterThanOrEqualTo2_Or_LessThan8 = GreaterThanOrEqualTo2 | LessThan8 // `number | bigint`

type RangesAreNumbersOrBigIntsByDefault = LessThan8 extends number | bigint ? true : false // `true` (the user could always narrow this on a per-range basis, e.g. `LessThan8 & number`)
type RangesAcceptUnions = LessThan<7n | 7.5 | 8> // `LessThan<8>`
type RangesAcceptOtherRanges1 = LessThan<LessThan8> // `LessThan8`
type RangesAcceptOtherRanges2 = LessThan<GreaterThanOrEqualTo2> // `number | bigint`
type RangesSupportBeingInAUnion = (-6 | 0.42 | 2n | 2 | 3) | LessThan<2> // `LessThan<2> | 2n | 2 | 3`
type RangesSupportBeingInAnIntersection = (-6 | 0.42 | 2n | 2 | 3) & LessThan<2> // `-6 | 0.42`
type RangesSupportBeingInAUnionWithOtherRanges = LessThan<2> | LessThan8 // `LessThan8`
type RangesSupportBeingInAnIntersectionWithOtherRanges = LessThan<2> & LessThan8 // `LessThan<2>`

@RyanCavanaugh

今日のユニオンの実装は、これほど大きなユニオンを実現するにはまったく適していないため、これにはいくつかの説得力のあるユースケースが本当に必要です。 あなたがこのような何かを書いた場合に起こるであろう何か...

以下は、int型がないと不健全になります。

const arr: string[] = ['a', 'b', 'c']
const item = arr[1.01]  // Typescript inferred this as string but actually it is undefined
console.log(item)  // Will print undefined, we miss inferred the type

次のタイプを使用すると、この問題を防ぐことができます。

type TUInt = 0..4294967295;

Int32とInt64タイプを使用する別の使用例は、特に人々がコードに注釈を付け始めるときです...他の言語とのより良い相互運用性への扉を開きます...ほとんどすべて静的にタイプされます言語には整数型があります：Java、C＃、C、Rust、F＃、Go ...など。

たとえば、C＃からTypeScriptで記述されたnpmライブラリを呼び出したい場合、TypeScript定義を取得し、C＃でインターフェイスを作成するライブラリがありますが、問題はnumberタイプがfloat大文字と小文字を区別せずにC＃で配列にインデックスを付けるために使用することはできません...など。

その他のユースケース：言語間のトランスパイルの容易さ、パフォーマンスの最適化...など

これが役立つもう1つのケースは、非常に明示的な個別の数値タイプを持つWebAssemblyとの対話であることに注意してください（C＃のユースケースとして簡単に言及されたと思いますが、それよりもはるかに広く適用されることを明確にしたかったのです）。

UPD：Nvm、 https： //github.com/microsoft/TypeScript/issues/15480#issuecomment -365420315で言及されていたようですが、Githubは「隠しアイテム」として「便利に」隠しています。

+1