Typescript: 제안: 숫자 유형의 범위

이 아이디어는 문자로 확장할 수 있습니다. 예를 들어 "b".."d" 는 "b" | "c" | "d" 입니다. 문자 집합을 지정하는 것이 더 쉬울 것입니다.

나는 이것이 확장될 수 있고 Haskell 범위와 같은 구문과 의미를 사용할 수 있다고 생각합니다.

| 구문 | 디슈가드 |
|----------------------------|---------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ------------------------------------------|
| type U = (e1..e3) | type U = \| e1 \| e1+1 \| e1+2 \| ...e3 \|
노조는 never 의 경우 e1 > e3 |
| type U2 = (e1, e2..e3) | type U2 = \| e1 \| e1+i \| e1+2i \| ...e3 \| ,
여기서 증분 i 은 e2-e1 입니다.

증분이 양수이거나 0이면 다음 요소가 e3 보다 클 때 합집합이 종료됩니다.
합집합은 never 경우 e1 > e3 입니다.

증분이 음수이면 다음 요소가 e3 보다 작을 때 합집합이 종료됩니다.
합집합은 never 경우 e1 < e3 입니다. |

@panuhorsmalahti "bb".."dd" 를 지정하면 어떻게 될까요?

@streamich

정수에는 ..를 사용하고 부동 소수점에는 ...를 사용할 수 있습니다.

저는 이와 같은 정수 유형을 생성하는 아이디어를 정말 좋아하지만 부동 소수점 값이 어떻게 작동하는지 모르겠습니다.

@aluanhaddad 확률 말하기:

type TProbability = 0.0...1.0;

@streamich 그래서 그 유형에는 이론적으로 가능한 주민 수가 무한대입니까?

@aluanhaddad 실제로 IEEE 부동 소수점에서 무한과는 거리가 멀습니다. 내 계산에 따르면 1,065,353,217명의 주민이 있을 것입니다.

0.0...1.0 ? JS는 IEEE double, 즉 53비트의 동적 범위를 사용합니다. 그것이 지원된다면 범위는 일급 유형이어야 하며, 이를 합집합에 적용하는 것은 비현실적일 것입니다.

@jcready는 사실이지만 @fatcerberus가 지적했듯이 이를 통합 유형으로 인식하는 것은 엄청나게 확장될 것입니다.

원형 교차로 방식으로 내가 얻은 것은 이산 대 연속 유형의 개념을 언어에 도입한다는 것입니다.

그것을 노동 조합 유형으로 깨닫는 것은 엄청나게 확장 될 것입니다.

@aluanhaddad 예, 하지만 unsigned 정수 를 공용체로 지정하는 것조차 매우 비쌉니다.

type TUInt = 0..4294967295;

오늘날의 공용체 구현은 이렇게 큰 공용체를 구현하는 데 완전히 부적합하기 때문에 여기에는 몇 가지 강력한 사용 사례가 필요합니다. 이런 글을 쓰면 어떤 일이 벌어질까

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

Union 유형 0 | 1 | 2 | 3 | 5 | 6 | 7 | ... 의 인스턴스화입니다.

아마도 숫자 리터럴에 대해서만 작동할 수 있습니다. 리터럴이 아닌 숫자 값은 범위에 있는 것으로 간주되기 전에 크거나 작음 비교를 통해 명시적으로 구체화되어야 합니다. 정수 범위에는 추가 Number.isInteger() 검사도 필요합니다. 이렇게 하면 실제 공용체 유형을 생성할 필요가 없어집니다.

@RyanCavanaugh 빼기 유형? 🌞

부정 유형, 부정 유형.

문자열 이외의 모든 것:

type NotAString = !string;

0을 제외한 모든 숫자:

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 하지만 서명되지 않은 정수는 없습니다.

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를 지수로 하는 지수와 더 비슷합니다. 그러나 상한을 올리면 안 되지만 인코딩 가능한 숫자는 포함되므로 여전히 정확하지 않습니다. 대체로 이것은 좋은 정의 전략이 아닙니다.

@streamich , 일부 의견:

• char , word 등의 용어를 사용하는 것은 혼란스러울 수 있습니다. 다른 언어의 사람들은 정적 정의와 런타임 동작의 차이를 인식하지 못할 수 있기 때문입니다.
• 제안한 구문은 하한을 고려하지 않습니다. 0이 아니면 어떻게 될까요?
• 이미 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" true 이므로)
• 아마도 새로운 int 유형( number 의 하위 유형이 됨)에 대한 지원과 int -only 및 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;
}

우리는 아마 루비의 책에서 잎을 가지고 사용할 수있는 .. 포괄적 인 범위 (대한 [start, stop] )와 ... 가 아닌 포괄적 인 범위에 대해에게 ( [start, stop) ).

또 다른 사용 사례는 다음을 입력하여 데이터베이스 레코드를 확인하는 것입니다.

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

또 다른 사용 사례는 위도/경도 값을 유형 확인하는 것입니다.

이것은 #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)에만 속하도록 위도와 경도를 입력하고 싶습니다.

편집: 위도와 경도에는 음수 범위가 있습니다.

내 사용 사례는 크기가 매개변수인 고정 크기의 배열을 구현하는 것입니다.

예를 들어 길이가 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

Lambda가 이미 사용 가능하므로 전문가는 구문 복잡성이 낮을 것입니다. 우리가 필요한 것은 유형으로 사용하는 기능뿐입니다. 유형 검사는 어쨌든 유형 스크립트에 따라 다릅니다("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
  }
}

이렇게 하면 다음과 같은 유형 검사를 수행할 수 있습니다.
술어 includedToMyAP = includedToAP(1,1, 10)

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

이것은 캐릭터로도 확장될 수 있습니다.

@Kasah 이와 유사한 것이 #

"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] 범위의 모든 number 값 또는 [-1.7976931348623157e+308, 1.7976931348623157e+308]
  
  
• 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 유형

두 GtEq/Gt 유형의 합집합을 취할 때 "더 많은" 값을 가진 유형이 결과입니다.

• (>= [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) 의 상위 유형이기 때문에 (>= 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 유형

두 LtEq/Lt 유형의 합집합을 취할 때 "더 많은" 값을 가진 유형이 결과입니다.

• (<= [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) 의 상위 유형이기 때문에 (<= 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) 의 상위 유형이기 때문에 (< 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 유형

두 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) 의 하위 유형이기 때문에 (>= 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 유형

두 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) 의 하위 유형이기 때문에 (<= 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) 의 하위 유형이기 때문에
  
  

사용 사례

• 정수가 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
}

한 가지 더 사용 사례: 백분율을 나타내는 함수에 숫자 입력이 있습니다. 값을 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 플랫폼, 특히 행렬 지향 플랫폼에서 숫자 범위를 정의하는 방법입니다.

균일한 범위가 일반적으로 최상의 모델링 접근 방식 중 하나이기 때문에 이러한 방식으로 수행합니다.

따라서 순차 범위는 다음과 같습니다.

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 플랫폼, 특히 행렬 지향 플랫폼에서 숫자 범위를 정의하는 방법입니다.

균일한 범위가 일반적으로 최상의 모델링 접근 방식 중 하나이기 때문에 이러한 방식으로 수행합니다.

따라서 순차 범위는 다음과 같습니다.

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개의 인덱스 단계(길이)가 있습니다. 따라서 여기서 범위는 두 표현식을 결합하여 더 쉽게 추론할 수 있는 유형 시스템의 경우 편리하게 integer & 0:9 수 있습니다.

4GL은 실제로 일반적인 레이블입니다. 저에게는 대부분 MatLab이었습니다.

내 요점은 포괄적인 범위만 있으면 제네릭에서 사용하기가 더 어려워진다는 것입니다(hack-y 유형 수준 수학 연산을 구현하지 않는 한).

유형 매개변수로 "길이"만 사용하는 대신 이제 길이와 최대 색인이 필요하기 때문입니다. 그리고 최대 인덱스는 길이-1과 같아야 합니다.

그리고 다시 말하지만, hack-y 유형 수준의 수학 연산을 구현하지 않는 한 실제로 그런 경우인지 확인할 수 없습니다.

@AnyhowStep 귀하의 우려 사항을 설명하는 가장 좋은 방법을 생각하고 있었지만 먼저 다음을 명확히 하는 것이 도움이 될 수 있습니다.

(이 인덱스/개수 시나리오와 같은) n-1 문제에 특별히 적용할 수 있는 포괄 여부를 제쳐두고, 그것이 어떻게든 독립적으로 해결되었다고 가정하면(그냥 유머러스하게 생각함), 숫자 범위가 적용되는 다른 시나리오가 있습니까? 적절하게 설명하기 위해 여전히 덜 선언적이거나 비관습적인 구문이 필요합니까?

나는 두 가지 별개의 측면이 있다는 것을 알고 있습니다. 일반적으로 해당 도메인의 기대치와 일치하는 숫자 범위가 필요하고 인덱스/카운트 유형에 대한 술어도 필요합니다.

양수만.

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;

또한 현재 논의와 관련이 없지만 여기에 숫자 범위 유형이 필요한 또 다른 이유가 있습니다.

내 하루 일과의 대부분은 서로 다른 소프트웨어 시스템을 함께 엮는 것입니다. 그리고 이러한 많은 시스템은 동일한 의미를 가진 데이터에 대해 서로 다른 요구 사항을 가지고 있습니다.

예: (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 "Range as Number type"이라는 것이 더 일반적인 사용자(즉, 범위가 간격보다 포괄성을 강조하는 이유를 궁금해하는 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
}

유형 가드만으로는 만족스러운 솔루션 이

또한 귀하의 예제는 유형 가드도 사용하지 않습니다.

위의 어리석은 해키 장난감 예제를 사용하면 범위 유형이 다른 범위 안에 있는 경우 범위 유형을 다른 범위 유형에 할당할 수 있습니다(함수 매개변수를 통해).

또한 프리미티브에서 사용되는 태그 유형, 명목 유형 및 값 개체는 일반적으로 유형 시스템이 충분히 표현되지 않는다는 신호입니다.

태그 유형을 사용하는 어리석은 장난감 예제는 매우 인체공학적이지 않기 때문에 싫어합니다. 범위가 기본이 되는 것이 더 나은 방법에 대해서는 이 긴 주석을 참조할 수 있습니다.

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)까지만 처리할 수 있는 것 같습니다.

@시니가미92
이 접근 방식을 사용하면 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가 놀라거나 느려질 수 있습니다. . 그러나 이러한 솔루션은 "더 작은" 범위에서 확실히 작동합니다.

@아무튼스텝
재귀 횟수가 한계라는 것을 알기 때문에 이러한 범위를 달성하려면 유형 정의 내에서 단일 비재귀 연산으로 숫자 나누기/곱셈을 수행하는 방법을 찾아야 합니다.

성능은 여전히 ​​문제입니다. 이러한 이유로 이전에 대형 앱에서 유용한 공용체 유형을 선별해야 했습니다. 흥미로운 작업일 수 있지만 확실히 솔루션은 아닙니다.

아직 완벽한 솔루션이 없는 것 같은데요?

나는 이것이 일반적으로 다음과 같이 수행될 수 있기를 바랍니다(그러나 어렵긴 하지만).

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

(즉, 변수가 유형으로 대체된다는 점을 제외하고 여기에서 일반 자바스크립트 문/함수를 사용할 수 있음)

내 이해에서 현대 언어 = 일반 논리 + 메타 논리, 여기서 메타 논리 = 코드 검사 + 코드 생성. 많은 작업이 메타 논리 구문을 우아한 방식으로 병합하려고 합니다.

어쩌면 우리는 범위 유형을 일종의 설탕이 아니라 핵심 개념으로 가정할 수 있습니까?

// 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> 두 번째 유형 매개변수로 낮은 숫자의 가능성은 범위를 더 짧게 제한합니다.
6. 1.5 extends Range<1, 2> 는 정의상 true여야 합니다.
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에 이어집니다.

Ranges 안의 Ranges에 대해 조금:

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 기능을 사용하기 위한 제안이 있습니까?

그 자체로는 제안이 없지만 이전에 빠른 프로토타입 을

@yudinns 문제는 Range가 최소한 이 이름에 존재하므로 혼란스러울 수 있습니다. https://developer.mozilla.org/en-US/docs/Web/API/range 참조 또한 정의할 수 있는 기능이 그리워요 <1, n+2> 와 같은 수열 - 하나 이상의 복잡한 방정식에서 시작하는 2단계.

이 TC39 제안 은 구현되기 전에 아마도 4단계에 도달할 것입니다.
티켓은 3세입니다.

제안: 정규식 검증 문자열 유형: https://github.com/Microsoft/TypeScript/issues/6579

(관련 SO 질문: https://stackoverflow.com/questions/3895478/does-javascript-have-a-method-like-range-to-generate-a-range-within-the-supp)

number in range eg if 1 in 1..2 또는 인클루시브 if 1 in 1..=2 과 같은 작업을 할 수 있다면 또한 멋질 것입니다. https://doc.rust-lang.org/reference/ 표현/범위-expr.html . 그것은 많은 공간을 절약 할 것입니다

python과 rust에는 이미 유형이 지정된 범위 기능이 없나요?
주요 목적과 가장 큰 사용 사례가 숫자 범위인 동안 바퀴를 재발명하거나 문자열, 부동 소수점 등을 사용하여 추가 일반화하는 대신 다른 언어로 기존 솔루션을 다시 구현할 수 있습니까? 나중에 필요할 때 더 추가할 수 있습니다.

나는 이것을 두 번 이상 만났고 여기에 0...1 사이의 분수인 유형을 정의하는 방법을 검색했습니다. 이것은 https://news.ycombinator.com/item?id= 에서 논의되고

@andrewphillipo 나는 그것이 논의되는 것을 보았고 스택 교환에 대한 답변 중 하나 에서 Unit Interval 이라는 용어에 대해 배웠습니다. 이는 일반적인 컨텍스트에서 해당 특정 범위를 참조하는 올바른 방법인 것 같습니다.

유형으로서의 범위가 유형 스크립트에서 구현된 경우 아마도 UnitInterval 전역 유형으로 정의하여 프로그래밍에서 자주 사용하는 것에 대한 몇 가지 공통 명명법을 장려할 수 있습니다.

예 UnitInterval은 0...1 범위의 올바른 이름이므로 유형에 맞습니다! 여전히 숫자의 이름이 정확하지 않으므로 이러한 유형을 사용하여 코드를 더 정확하게 설명하는 데 이것이 가능하다면 훌륭할 것입니다. 이것은 Rust의 유형 시스템에서 후드 아래에서 어떻게 작동합니까?

CantorSpace 가 너무 과장되지 않으면 컴퓨터가 이해하는 [0, 1] 사이의 "모든" 실수의 "범위"에 대한 공정한 정의가 될 것입니다. 컴파일시에 값이 할당하는 것은 유추 할 수없는 하부 및 상부 자바 스크립트의의 경계 Math.floor 또는 Math.ceil 부터 Math.ceil(0) === 0 , 그리고 Math.floor(1) === 1 하는이 불행한 사람.

모든 숫자 집합 (0, 1) 가 대신 사용되면 위의 예를 사용하여 작동하지만 일상 언어에서 백분율로 참조되는 값을 제외하는 것은 좋지 않습니다. 가능하다면 컴파일러가 경계를 포함하도록 하는 것이 좋을 것입니다. 아마도 에지 케이스 0과 1에 대한 엄격한 === 검사를 통해서일 것입니다.

또는 정수에는 1~~3 를 사용하고 float 에는 0.1~0.5 를 사용하시겠습니까?

~ 는 이미 단항 비트 NOT 연산자에 의해 사용됩니다.

그 빌어먹을 수레에 대해 이야기해야 하는 이유는 정수에 대한 문제입니다. 99.99%는 정수 문제 0.001%는 부동 소수점 문제입니다.
일반적인 솔루션은 쉽게 불가능하므로 수년 전에 이미 구현된 것처럼 대부분의 프로그래밍 언어에서 볼 수 있는 0..10의 숫자 범위로 가보겠습니다.

플로트 얘기 그만해

청구서를 분할하고 int 경우에 대해 이 제안을 확장할 수 있습니다.
https://gist.github.com/rbuckton/5fd81582fdf86a34b45bae82d842304c

그리고 float의 경우 현재 이 문제의 몇 가지 아이디어(주로 @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
그리고 그것을 하루라고 부릅니다.

✅바퀴를 재발명할 필요가 없습니다
✅수레를 고려할 필요가 없습니다.
✅언어 간 일관성
✅기존 소스에서 테스트 및 복사 가능한 안정적인 코드

"int" 기반 유형 검사는 모든 고정 정수 0..1000의 합집합으로 유형 값을 하드 코딩하여 숫자 < 1000에 대해 사소하므로 "다시 할 필요가 없습니다"라고 말합니다. - 바퀴를 발명하라"는 것은 약간 아이러니하다. 간단한 사용 사례에서 이미 작동하는 것을 사용하지 않는 이유는 무엇입니까?

오히려 무리수와 같은 것을 이해하는 유형 정의를 허용할 여지가 있는지 확인하고 싶습니다. 라디안으로 작업할 때 컴파일 타임에 불변량을 감지하는 기능은 흥미로운 사용 사례가 될 것입니다. 범위 값 경계에 대한 인수로 τ를 지원하는 것은 이 기능이 의도한 대로 작동한다고 주장하기에 좋은 대상입니다.

자바스크립트에는 명시적인 integer 가 없음을 명심하십시오. 모든 것은 float로 저장되는 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#에서 배열을 인덱싱하는 데 사용할 수 없습니다.

기타 사용 사례: 언어 간 변환 용이성, 성능 최적화 등

이것이 유용할 또 하나의 경우는 매우 명시적인 별도의 숫자 유형이 있는 WebAssembly와의 상호 작용입니다(C# 사용 사례로 간략하게 언급되었지만 그보다 훨씬 더 광범위하게 적용된다는 점을 분명히 하고 싶었습니다).

UPD: Nvm, Github이 "숨겨진 항목"으로 "유용하게" 숨긴 https://github.com/microsoft/TypeScript/issues/15480#issuecomment -365420315에서 언급된 것으로 보입니다.

+1