वीएस कोड में इंटेलिजेंस आदि के साथ इसके साथ खेलने का त्वरित तरीका चाहने वाले किसी भी व्यक्ति के लिए, यहां एक खेल का मैदान रेपो है ।

टाइप पी = टाइपोफ फू (0); // पी कोई है []
टाइप क्यू = टाइपोफ़ फू (सच); // क्यू स्ट्रिंग है

मुझे लगता है कि मानों के बजाय तर्क के रूप में प्रकारों का उपयोग करना एक अधिक मान्य वाक्यविन्यास है।

type P = typeof foo(number);    // P is any[]
type Q = typeof foo(boolean); // Q is string

यह अधिक स्पष्ट है कि फ़ंक्शन को नहीं कहा जा रहा है, क्योंकि आप प्रकार प्रदान करते हैं और मान तर्क के रूप में नहीं। दूसरी बात, यह कम अस्पष्ट है। कुछ लोग typeof foo(false) का उपयोग करेंगे, जबकि कुछ लोग typeof foo(true) का उपयोग करेंगे। यदि आपके पास तर्क के रूप में प्रकार हैं तो लोग केवल typeof foo(boolean) लिख सकते हैं।

@tinganho बिल्कुल!
हालांकि हम अभी भी #5185 . के साथ typeof foo("abc") लिख सकते हैं
यहाँ "abc" सिंगलटन स्ट्रिंग प्रकार है

@tinganho मैं आपके विचार को कुछ विचार दे रहा हूं और मुझे इस प्रस्ताव के बारे में कुछ चीजें पसंद हैं, और अन्य चीजें जिन्हें मैं आपके सुझाव के बारे में पसंद करता हूं। आपके द्वारा दिए गए कारणों के लिए आपका सुझाव अच्छा है (सरल स्पष्ट वाक्यविन्यास, कम अस्पष्ट, फ़ंक्शन कॉल की तरह कम दिखता है)। मैं अपने प्रस्ताव के बारे में जो चीज पसंद करता हूं वह यह है कि यह कोई उपन्यास वाक्यविन्यास पेश नहीं करता है, इसलिए पार्सर/चेकर में कोई जटिलता नहीं जोड़ता है, और यह अधिक जटिल परिदृश्यों का भी समर्थन करता है जहां आपके पास तर्कों के लिए सरल प्रकार के नाम नहीं हैं।

मैं सोच रहा था, क्या होगा यदि आपके foo(number) सिंटैक्स की तरह कुछ लिखने का एक बहुत ही संक्षिप्त तरीका था लेकिन मौजूदा अभिव्यक्ति पार्सिंग यांत्रिकी का उपयोग कर रहा था? तो एक प्रयोग के रूप में मैंने एक नई अभिव्यक्ति पेश की है: _unary as_. आप बस as T लिख सकते हैं और वह (null as T) के लिए शॉर्टहैंड है। आप मूल रूप से कह रहे हैं, _'मुझे मूल्य की परवाह नहीं है लेकिन मैं चाहता हूं कि अभिव्यक्ति का प्रकार X'_ हो।

इस परिवर्तन के साथ (जिसे मैंने खेल के मैदान रेपो में लागू किया है), आप अपने सुझाए गए वाक्यविन्यास के बहुत करीब कुछ लिख सकते हैं, लेकिन इसे अभी भी सामान्य अभिव्यक्ति के रूप में पार्स किया गया है:

type P = typeof foo(as number);    // P is any[]
type Q = typeof foo(as boolean); // Q is string

let prop2: typeof (as MyInterface).prop1.big.complex; // prop2 type is {anonymous: {type: {}}}

यह सिर्फ एक त्वरित प्रयोग था। एक समकक्ष वाक्यविन्यास हो सकता है (लेकिन मैंने इसे लागू नहीं किया है):

type P = typeof foo(<number>);    // P is any[]
type Q = typeof foo(<boolean>); // Q is string

let prop2: typeof (<MyInterface>).prop1.big.complex; // prop2 type is {anonymous: {type: {}}}

दूसरे सिंटैक्स को _nullary प्रकार का दावा_ कहा जा सकता है, जिसमें अभिव्यक्ति <T> (<T> null) के लिए शॉर्टहैंड है।

@yortus , हमने पिछले हफ्ते इस प्रस्ताव के बारे में बात करने में कुछ समय बिताया। पहले पोस्ट न करने के लिए खेद है। सर्वसम्मति 1 थी। हमें कुछ प्रकारों को संदर्भित करने में सक्षम नहीं होने की समस्या है, उदाहरण के लिए किसी फ़ंक्शन की वापसी या वर्ग अभिव्यक्ति का उदाहरण प्रकार। और 2. टाइप पोजीशन में एक्सप्रेशन जोड़ना कोई ऐसी चीज नहीं है, जिसमें हम सहज हों।

@tinganho का प्रस्ताव वह था जिसके बारे में हमने भी बात की थी। मुझे लगता है कि यह अधिक स्वादिष्ट है, हालांकि शायद इसे लागू करने के लिए और अधिक जटिल होगा। एक नया यूनरी ऑपरेटर जोड़ना या कास्ट सिंटैक्स का उपयोग करना वास्तव में केवल प्रकार के नामों का उपयोग करने के रूप में सुरुचिपूर्ण नहीं है।

आज स्लॉग में काफी देर तक चर्चा हुई। "पीआर स्वीकार करना" यहाँ है "पीआर को स्वीकार करना यह मानते हुए कि कार्यान्वयन बहुत पागल नहीं है"

@tinganho का प्रस्ताव बहुत अच्छा लग रहा है (कम से कम अन्य विकल्पों के सापेक्ष) और हम एक अस्थायी पीआर देखना चाहते हैं जो इसे लागू करता है।

मुश्किल बात यह है कि हम f(number) बनाम f(0) के रिटर्न प्रकार को हल करने के लिए पूरी तरह से अलग कोडपथ नहीं चाहते हैं, लेकिन ओवरलोड रिज़ॉल्यूशन एल्गोरिदम पूरी तरह से बेक-इन है इस धारणा के साथ कि यह _types_ के सेट के बजाय _expressions_ के सेट के साथ काम कर रहा है। लेकिन हमें लगता है कि थोड़ी सी चालबाजी के साथ यह सीधा होना चाहिए।

हमले की मूल योजना होगी:

• typeof को पार्स करते समय व्याकरण का विस्तार करें ताकि फ़ंक्शन कॉल, प्रॉपर्टी एक्सेस और इंडेक्सेड प्रॉपर्टी एक्सेस जैसी चीज़ों को अनुमति दी जा सके।
• किसी प्रकार की क्वेरी में फ़ंक्शन कॉल के लिए तर्कों को पार्स करते समय (चलिए उन्हें _psuedocalls_ / _psuedoarguments_ कहते हैं), parseType फ़ंक्शन का उपयोग करें। यह एक TypeNode बनाने जा रहा है, लेकिन नोड पर एक ध्वज सेट करें जो इंगित करता है कि यह एक प्रकार की क्वेरी के संदर्भ में पार्स किया गया एक प्रकार था
• चेकर में, checkExpression इस ध्वज के लिए जाँच करता है और सामान्य अभिव्यक्ति प्रसंस्करण के बजाय getTypeFromTypeNode पर कॉल करता है

@mhegazy , @RyanCavanaugh सुनिश्चित नहीं है कि टीम ने कितने कोने के मामलों पर चर्चा की, तो क्या मैं स्पष्टीकरण के लिए यहां कुछ ला सकता हूं? मैंने नीचे उदाहरणों का एक समूह सूचीबद्ध किया है और हर एक पर टिप्पणी की है जो मुझे लगता है कि typeof ऑपरेशन का परिणाम होना चाहिए, संदिग्ध मामलों पर प्रश्न चिह्नों के साथ।

अनुक्रमणिका संकेतन

var data = [1, 2, 3];
const LOBOUND = 0;
type Elem1 = typeof data[0];        // number
type Elem2 = typeof data[999999];   // number or ERROR?
type Elem3 = typeof data[1+2];      // ERROR or number?
type Elem4 = typeof data[LOBOUND];  // ERROR or number?

var tuple: [number, string] = [123, 'abc'];
type Elem4 = typeof tuple[0];       // number or number|string?
type Elem5 = typeof tuple[1];       // string or number|string?
type Elem6 = typeof tuple[999999];  // number|string or ERROR?

const ABC: 'a-b-c' = 'a-b-c';
let dict = { 'a-b-c': 123, 'd-e-f': true };
type Prop1 = typeof dict['a-b-c'];  // number
type Prop2 = typeof dict['d-e-f'];  // boolean
type Prop3 = typeof dict[ABC];      // ERROR or number or any?

फंक्शन रिटर्न टाइप नोटेशन

// A simple function
declare function f1(n: number): string[];
type Ret1 = typeof f1(number);      // string[]
type Ret2 = typeof f1(0);           // ERROR or string[]?

// An asynchronous function that either accepts a callback or returns a Promise
declare function f2(n: number): Promise<string[]>;
declare function f2(n: number, cb: (err?: any, result?: string[]) => void): void;
type Ret3 = typeof f2(number);                    // Promise<string[]>
type Ret4 = typeof f2(number, any);               // void
type Ret5 = typeof f2(number, Function);          // ERROR: Function not assignable to callback
type Ret6 = typeof f2(number, (err: any, result: string[]) => void); // void
type Ret7 = typeof f2(number, (...args) => any);  // void

// A special function-like object
interface Receiver {
    (data: string[]): void;
    transmogrify(): number[];
}
declare function f3(n: number, receiver: Receiver): Promise<void>;
declare function f3(n: number, callback: (err?: any, result?: string[]) => void): void;
type Ret8 = typeof f3(number, Receiver);           // Promise<void>
type Ret9 = typeof f3(number, any);                // ambiguous? or picks first overload?
type Ret10 = typeof f3(number, Function);          // ERROR
type Ret11 = typeof f3(number, (...args) => any);  // void since not assignable to Receiver

// A function with parameter destructuring
interface CartesianCoordinate {/***/}
interface PolarCoordinate {/***/}
declare function f4({ x: number, y: number }): CartesianCoordinate;
declare function f4({ r: number, t: number }): PolarCoordinate;
type Ret12 = typeof f4(any);        // ambiguous? or picks first overload?
type Ret13 = typeof f4({x;y});      // CartesianCoordinate
type Ret14 = typeof f4({r;t});      // PolarCoordinate
type Ret15 = typeof f4({x;r;t;y});  // ambiguous? or picks first overload?

// Type-ception: is there anything wrong with typeof-in-typeof?
declare function f5(n: number, receiver: Receiver): Promise<void>;
declare function f5(n: number, callback: (err?: any, result?: string[]) => void): void;
function myCallback(err, result) {/***/}
var myReceiver: Receiver;
type Ret16 = typeof f5(number, typeof myReceiver); // Promise<void>
type Ret17 = typeof f5(number, typeof myCallback); // void

एक वर्ग/इंटरफ़ेस प्रकार का हिस्सा निकालना

यानी, ऊपर दिए गए typeof (<MyInterface> null).prop1.big.complex; उदाहरण।

मैं इसे उपरोक्त टिप्पणियों से लेता हूं कि यह दायरे से बाहर है और इसका समर्थन नहीं किया जाएगा। क्या वो सही है?

अनुक्रमणिका संकेतन

var data = [1, 2, 3];
const LOBOUND = 0;
type Elem1 = typeof data[0];        // number
type Elem2 = typeof data[999999];   // number
type Elem3 = typeof data[1+2];      // ERROR, only literals allowed here
type Elem4 = typeof data[LOBOUND];  // number when const resolution is done, otherwise any

var tuple: [number, string] = [123, 'abc'];
type Elem4 = typeof tuple[0];       // number
type Elem5 = typeof tuple[1];       // string 
type Elem6 = typeof tuple[999999];  // number|string

const ABC: 'a-b-c' = 'a-b-c';
let dict = { 'a-b-c': 123, 'd-e-f': true };
type Prop1 = typeof dict['a-b-c'];  // number
type Prop2 = typeof dict['d-e-f'];  // boolean
type Prop3 = typeof dict[ABC];      // number when const resolution work is done, otherwise any

फंक्शन रिटर्न टाइप नोटेशन

// A simple function
declare function f1(n: number): string[];
type Ret1 = typeof f1(number);      // string[]
type Ret2 = typeof f1(0);           // error, 0 is not a type

// An asynchronous function that either accepts a callback or returns a Promise
declare function f2(n: number): Promise<string[]>;
declare function f2(n: number, cb: (err?: any, result?: string[]) => void): void;
type Ret3 = typeof f2(number);                    // Promise<string[]>
type Ret4 = typeof f2(number, any);               // void
type Ret5 = typeof f2(number, Function);          // ERROR: Function not assignable to callback
type Ret6 = typeof f2(number, (err: any, result: string[]) => void); // void
type Ret7 = typeof f2(number, (...args) => any);  // void

// A special function-like object
interface Receiver {
    (data: string[]): void;
    transmogrify(): number[];
}
declare function f3(n: number, receiver: Receiver): Promise<void>;
declare function f3(n: number, callback: (err?: any, result?: string[]) => void): void;
type Ret8 = typeof f3(number, Receiver);           // Promise<void>
type Ret9 = typeof f3(number, any);                // picks first overload
type Ret10 = typeof f3(number, Function);          // ERROR
type Ret11 = typeof f3(number, (...args) => any);  // void since not assignable to Receiver

// A function with parameter destructuring
interface CartesianCoordinate {/***/}
interface PolarCoordinate {/***/}
declare function f4({ x: number, y: number }): CartesianCoordinate;
declare function f4({ r: number, t: number }): PolarCoordinate;
type Ret12 = typeof f4(any);        // picks first overload
type Ret13 = typeof f4({x;y});      // CartesianCoordinate
type Ret14 = typeof f4({r;t});      // PolarCoordinate
type Ret15 = typeof f4({x;r;t;y});  // picks first overload

// Type-ception: is there anything wrong with typeof-in-typeof?
declare function f5(n: number, receiver: Receiver): Promise<void>;
declare function f5(n: number, callback: (err?: any, result?: string[]) => void): void;
function myCallback(err, result) {/***/}
var myReceiver: Receiver;
type Ret16 = typeof f5(number, typeof myReceiver); // Promise<void>
type Ret17 = typeof f5(number, typeof myCallback); // void

मैं उत्सुक हूँ कि यहाँ क्या होता है:

const number = "number";
type Ret3 = typeof f2(number); // What happens here?

@SaschaNaz अच्छा सवाल है। ऐसी ही स्थिति:

class MyClass { foo; bar; }
declare function f(inst: MyClass): number;
type Ret = typeof f(MyClass);     // number (presumably)

इस मामले में यह typeof f(MyClass) में MyClass _type_ के लिए MyClass _value_ (यानी कंस्ट्रक्टर फ़ंक्शन) से पहले विचार करने के लिए समझ में आता है। पूर्व Ret = number की ओर जाता है, बाद वाला error: MyClass is not a type जैसा कुछ ले जाएगा।

क्या वही तर्क उस नाम पर लागू होगा जो _type_ और _const value_ दोनों को संदर्भित करता है? आपके उदाहरण में इसका मतलब होगा कि प्रकार number हमेशा कॉन्स्ट वैल्यू number पर प्राथमिकता लेगा। कोई विचार @RyanCavanaugh?

ठीक है, हम इसे एक प्रकार की अभिव्यक्ति के सामान्य शब्दार्थ के तहत हल करेंगे (जैसे कि आपने var x: [whatever] लिखा था)। तो आपके पास उदाहरण पक्ष के साथ f का आह्वान करने के लिए $ typeof f(MyClass) हो सकता है, और typeof f(typeof MyClass) कन्स्ट्रक्टर फ़ंक्शन के साथ f का आह्वान करने का जिक्र कर सकता है।

तो फिर @SaschaNaz का उदाहरण स्पष्ट रूप से number को _type_ के रूप में संदर्भित करता है, _const value_ के रूप में नहीं, है ना?

const number = "number";
type Ret3 = typeof f2(number); // Promise<string[]>

@RyanCavanaugh क्या आप पुष्टि कर सकते हैं कि उपयोग के मामलों का तीसरा समूह दायरे से बाहर है? जैसे ओपी से:

// Declare an interface DRY-ly and without introducing extra type names
interface MyInterface {
    prop1: {
        big: {
            complex: {
                anonymous: { type: {} }
            }
        }
    },

    // prop2 shares some structure with prop1
    prop2: typeof (<MyInterface>null).prop1.big.complex; // OK: prop2 type is {anonymous: {type: {}}}
}

यह उपयोग-मामला (जो भी वाक्यविन्यास के साथ) इस समय समर्थित नहीं होगा, क्या यह सही है?

मुझे लगता है कि इसे this अभिव्यक्तियों की अनुमति देकर कवर किया जाना चाहिए।

   prop2: typeof this.prop1.big.complex;

मुझे लगता है कि const चीज़ को किसी अन्य typeof द्वारा हल किया जाना चाहिए।

type Ret3 = typeof f2(typeof number); // typeof number is string so error here

... जबकि यह typeof data[LOBOUND] को ब्लॉक कर देगा।

@mhegazy यह एक अच्छा विचार है typeof this । मुझे अभी एहसास हुआ कि यह पहले से ही इस प्रस्ताव के लिए किए गए फोर्क कार्यान्वयन में काम करता है। खैर, यह कक्षाओं के लिए काम करता है। इंटरफेस के लिए कोई त्रुटि नहीं है, लेकिन this प्रकार को हमेशा any के रूप में अनुमानित किया जाता है। फोर्कड इम्प्लांट से वर्तमान आउटपुट:

class MyClass {
    prop1: {
        big: {
            complex: {
                anonymous: { type: {} }
            }
        }
    };

    prop2: typeof this.prop1.big.complex; // prop2 type is {anonymous: {type: {}}}
}

interface MyInterface {
    prop1: {
        big: {
            complex: {
                anonymous: { type: {} }
            }
        }
    };

    prop2: typeof this.prop1.big.complex; // prop2 type is any
}

क्या इंटरफ़ेस घोषणाओं के अंदर this उल्लेख करना संभव है या यह सुविधा कक्षाओं तक ही सीमित रहेगी?

मैं #6179 और कोणीय के बारे में दो बिंदु बनाना चाहता हूं।

// A factory function that returns an instance of a local class
function myAPIFactory($http: HttpSvc, id: number) {
    class MyAPI {
        constructor(token: string) {...}
        foo() {...}
        bar() {...}
        static id = id;
    }
    return MyAPI;
}
type MyAPIConstructor = typeof myAPIFactory(null, 0); // OK: MyAPI is myAPIFactory's return type
function augmentAPI(api: MyAPIConstructor) {...} // OK

1. मापदंडों की संख्या बड़ी हो सकती है। मान लीजिए कि 15 पैरामीटर हैं। साथ ही कोई अधिभार नहीं है, और यह केवल अधिभार है जिसके लिए typeof में पैरामीटर आवश्यक हैं। तो इस मामले के लिए, क्या हम शायद निम्नलिखित जैसे सिंटैक्स के बारे में सोच सकते हैं?

   type MyAPI = typeof myAPIFactory(...);
   

2. फ़ैक्टरी फ़ंक्शन को आमतौर पर अपने वैश्विक चर को नहीं सौंपा जाता है। एक फ़ंक्शन अभिव्यक्ति का उपयोग किया जाता है:

   angular.module('app').factory('MyAPI', function($http: HttpSvc, id: number) { /*...*/ });
   

   आमतौर पर ऐसा ही दिखता है। जैसा कि देखा जा सकता है, यहां typeof का उपयोग बिल्कुल नहीं किया जा सकता है।

@ thron0 मेरा अंतर्ज्ञान यह है कि एक ऐसी चीज जिसमें कुछ से अधिक पैरामीटर हैं लेकिन _also_ एक अज्ञात प्रकार देता है वह बहुत दुर्लभ होगा। तुम क्या सोचते हो?

यह दुर्लभ हो जाएगा जब कोणीय 1 दुर्लभ हो जाएगा, पहले नहीं।

मूल रूप से, आपने जो वर्णन किया है वह एक विशिष्ट कोणीय _factory_ है:

एक ऐसी चीज जिसमें कुछ से अधिक पैरामीटर हैं, लेकिन एक अनाम प्रकार भी देता है

यह एक ऐसा फ़ंक्शन है जो निर्भरता को अपने पैरामीटर के रूप में लेता है और एक _service_ का उदाहरण बनाता है। आप सोच सकते हैं कि बड़ी संख्या में पैरामीटर परेशानी हो सकती है, लेकिन बात यह है कि उन कारखानों को कभी भी सीधे नहीं कहा जाता है। DI कंटेनर उन्हें कॉल करता है। कारखाने को तब कहा जाता है जब किसी चीज को निर्भरता के रूप में इसके वापसी मूल्य (सेवा) की आवश्यकता होती है। और इसे केवल एक बार बुलाया जाता है क्योंकि सेवाएं हमेशा कोणीय में सिंगलेट होती हैं। हालाँकि, एक सेवा कुछ भी हो सकती है, इसलिए यदि हमें एक गैर-सिंगलटन व्यवहार की आवश्यकता है, तो फ़ैक्टरी एक कंस्ट्रक्टर (या फ़ैक्टरी फ़ंक्शन) वापस कर सकता है। जैसे इस कोड उदाहरण में:

angular.module('app').factory('MyAPI', function($http: HttpSvc, id: number) {
    class MyAPI {
        constructor(token: string) {...}
        foo() {...}
        bar() {...}
        static id = id;
    }
    return MyAPI;
});

इस स्थिति के लिए मेरा वर्तमान समाधान इस तरह दिखता है:

class MyAPI {
    // dependencies (1)
    protected $http: HttpSvc;
    protected id: number;

    constructor(token: string) {...}
    foo() {...}
    bar() {...}
    // Static properties cannot be used with this approach because:
    // 1) this class is a global variable so it can be shared by different 
    // instances of the DI container,
    // 2) the id property isn't available here as it's initialized in the subclass
    //// static id0 = id;
}

angular.module('app').factory('MyAPI', function($http: HttpSvc, id: number) { // (2)
    return class extends MyAPI {
        $http = $http; // (3)
        id = id;
    };
});

// this type is needed for type annotations in the services that require MyAPI as a dependency
type MyAPIConstructor = typeof MyAPI;

angular.module('app').factory('someOtherService', function(MyAPI: MyAPIConstructor) {
    var api = new MyAPI('qwerty');
    /* ... */
});

जैसा कि आप देख सकते हैं, यह पूरी तरह से बदसूरत और दर्दनाक है। मुझे निर्भरताओं को तीन बार सूचीबद्ध करना होगा। यदि मेरे पास अधिक निर्भरताएं हैं, तो कभी-कभी कक्षा को सामान्य तरीके से (फ़ैक्टरी फ़ंक्शन के अंदर) लिखना और अपने उपभोक्ताओं के लिए एक इंटरफ़ेस घोषित करना आसान होता है।

नमस्ते, मैं टाइपऑफ़ सिंटैक्स/सिमेंटिक्स को बरकरार रखने का प्रस्ताव देना चाहता हूं और इसके बजाय एक साधारण प्रकार के एक्सेस बीजगणित को लागू करना चाहता हूं:

आइए टाइप सिंटैक्स एक्सटेंशन की कल्पना करें:

type          ::=  ... |  literalType | type typeAccess | guarded
guarded    ::= "type" id
literalType   ::= stringLiteral | numberLiteral | symLiteral | booleanLiteral 
typeAccess    ::= typeField | typeSubscript | typeCall
typeField     ::= "." id
typeSubscript ::= "[" type "]"
typeCall      ::= "(" [type {"," type}] ")"

दायरे में प्रत्येक पहचानकर्ता एक साथ दो संस्थाओं के लिए बाध्य हो सकता है:

• संकलन समय प्रकार
• रन टाइम वैल्यू

टाइप गार्ड केवल पूर्व को निकालता है। इस प्रकार

class A {}
var a: A;

के बराबर है

class A {}
var a: type A;

इस मामले में अगर हमारे पास एक वर्ग होगा

class ABC {
    a: number;
    b(x: number): string;
    c:string[];
    d:[number, string];
}

तब हम लिख सकते थे

var a: (type ABC).a; // number
var b: (type ABC).b(number); // string
var c: (type ABC).c[number]; // string
var d: (type ABC).c[0]; // number

इसमें लेक्सिकल स्कोप में समान पहचानकर्ता के तहत _type_ संस्थाओं और _value_ संस्थाओं को मर्ज करना भी शामिल है।

interface SAME {
    x: number;
}
namespace SAME: {
    export type x = boolean;
    export var x: string;
}

var a: SAME.x   // boolean
var b: (type SAME).x  // number
var b: (typeof SAME).x  // string

@RyanCavanaugh , @sandersn क्या आप इस विचार की जांच कर सकते हैं?

आप अपने प्रस्ताव के साथ अभिव्यक्ति के प्रकार को कैसे पकड़ते हैं?

गुरु, 19 मई 2016 12:26 को अनातोली रेसिन, नोटिफिकेशन @github.com ने लिखा:

नमस्ते, मैं टाइपऑफ़ सिंटैक्स/सिमेंटिक्स को बरकरार रखने का प्रस्ताव देना चाहता हूं और
इसके बजाय एक साधारण प्रकार का एक्सेस बीजगणित लागू करें:

आइए टाइप सिंटैक्स एक्सटेंशन की कल्पना करें:

टाइप करें ::= ... | शाब्दिक प्रकार | टाइप टाइप एक्सेस | संरक्षित
संरक्षित ::= "टाइप" आईडी
लिटरल टाइप ::= स्ट्रिंग लिटरल | संख्या शाब्दिक | सिमलिटरल | बूलियनशाब्दिक
टाइप एक्सेस ::= टाइपफिल्ड | टाइपसबस्क्रिप्ट | टाइप कॉल
टाइपफिल्ड ::= "।" पहचान
टाइपसबस्क्रिप्ट ::= "[" टाइप करें "]"
टाइपकॉल ::= "(" [टाइप {",," टाइप}] ")"

दायरे में प्रत्येक पहचानकर्ता एक साथ दो से बंधा हो सकता है
संस्थाएं:

• संकलन समय प्रकार
• रन टाइम वैल्यू

_type_ गार्ड केवल पूर्व को निकालता है। इस प्रकार

एक कक्षा {}
ए: ए

के बराबर है

एक कक्षा {}
ए: टाइप ए

इस मामले में अगर हमारे पास एक वर्ग होगा

कक्षा एबीसी {
एक संख्या;
बी (एक्स: संख्या): स्ट्रिंग;
सी स्ट्रिंग[];
डी: [संख्या, स्ट्रिंग];
}

तब हम लिख सकते थे

वर ए: (एबीसी टाइप करें)। ए; // नंबरवार बी: (एबीसी टाइप करें)। बी (संख्या); // स्ट्रिंगवर सी: (एबीसी टाइप करें)। सी [संख्या]; // स्ट्रिंगवर डी: (एबीसी टाइप करें)। सी [0]; // संख्या

इसमें _type_ संस्थाओं और _value_ संस्थाओं को विलय करना भी शामिल है
शाब्दिक दायरे में एक ही पहचानकर्ता।

इंटरफ़ेस समान {
एक्स: संख्या;
}नामस्थान समान: {
निर्यात प्रकार x = बूलियन;
निर्यात संस्करण एक्स: स्ट्रिंग;
}
var a: SAME.x // booleanvar b: (टाइप SAME).x // numbervar b: (टाइपऑफ SAME).x // string

@RyanCavanaugh https://github.com/RyanCavanaugh , @sandersn
https://github.com/sandersn क्या आप इस विचार की जांच कर सकते हैं?

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपने इस थ्रेड की सदस्यता ली है।
इस ईमेल का सीधे उत्तर दें या इसे GitHub पर देखें
https://github.com/Microsoft/TypeScript/issues/6606#issuecomment -220378019

आपका उदाहरण मुझे याद दिलाता है कि एक टाइपऑफ़ डॉटेड एक्सप्रेशन और टाइप प्रॉपर्टी टाइप #1295 काफी समान प्रस्ताव है। एक को छोड़कर दूसरा अधिक गतिशील है।

मुझे टाइपऑफ़ कीवर्ड को स्किप करने का विचार भी पसंद है।

   prop2: this.prop1.big.complex;

@mhegazy आपके उदाहरण में आप typeof this-expression कर रहे हैं:

prop2: typeof this.prop1.big.complex;

चूंकि हम आज ऐसा कर सकते हैं:

someProp: this;

मेरे विचार में, अधिक बिंदीदार गुणों के लिए उपरोक्त सिंटैक्स का एक एक्सट्रपलेशन है:

someProp: this.prop1.prop2.prop3;

और नहीं:

someProp: typeof this.prop1.prop2.prop3;

और सिर्फ एक्सट्रपलेशन के साथ जारी रखने के लिए - टाइपऑफ़ को एक साथ क्यों न छोड़ें?

someProps: foo(number)

टाइपऑफ़ को एक साथ क्यों न छोड़ें?

एक कारण मैं सोच सकता हूं कि यह अस्पष्ट हो जाएगा कि क्या आप किसी वर्ग या स्थिर पक्ष के उदाहरण पक्ष का संदर्भ दे रहे हैं:

class C {}

// Does 'x' have the instance type of 'C',
// or does it have the shape of its constructor?
let x: C;

मैं किसी अन्य इंटरफ़ेस के भीतर किसी इंटरफ़ेस में किसी संपत्ति के प्रकार को भी संदर्भित करना चाहता हूं। मेरा उदाहरण # 10588 के रूप में पोस्ट किया गया जो अब इस टिकट के पक्ष में बंद है।

ऐसा कुछ लिखना अच्छा होगा:

interface Foo {
  bar: string;
}

interface Box<T> {
  container: T;
}

interface FooWithBoxedProps {
  bar: Box<Foo.bar>; // OR: bar: Box<typeof Foo.bar>;
}

जो बस इसका अनुवाद करेगा:

interface Foo {
  bar: string;
}

interface Box<T> {
  container: T;
}

interface FooWithBoxedProps {
  bar: Box<string>;
}

खैर पहले बताए गए कुछ परिदृश्यों को अब _indexed एक्सेस टाइप_ (#11929) के साथ व्यक्त किया जा सकता है। बस इस सुविधा को मानक typeof अभिव्यक्ति के साथ संयोजित करें और आप कुछ इस तरह प्राप्त कर सकते हैं:

interface MyInterface {
    prop1: {
        big: {
            complex: {
                anonymous: { type: {} }
            }
        }
    },

    // prop2 shares some structure with prop1
    prop2: MyInterface["prop1"]["big"]["complex"];
}

और यह काम करता है! (वर्तमान में टाइपप्रति@अगले में)

मुझे लगता है कि अगली प्राकृतिक चीज कुछ समान होगी लेकिन कार्यों के लिए, कुछ "फ़ंक्शन कॉल प्रकार" इस ​​तरह होंगे:

interface FunctionLike{
    (arg1 : number, arg2 : string) : {a : number; b : string;}
}

type ReturnType = FunctionLike(number, string); // {a : number; b : string;} 

इसलिए हम इसे स्वाभाविक रूप से typeof ऑपरेटर के साथ जोड़ सकते हैं

interface BigThing {
    testString: string;
    testNumber: number;
    testBoolean: boolean;
}

function getSmallThing(thing:BigThing){
    return {
        testString : thing.testString,
        testBoolean : thing.testBoolean
    }
}

type SmallThing = typeof getSmallThing(BigThing) // {testString: string; testBoolean : boolean}

और ऐसा लगता है कि यह वाक्य रचना है जो पहले से ही इस धागे (@tinganho) की शुरुआत में प्रस्तावित की गई थी। :)
लेकिन यह अधिक सामान्य विशेषता होगी कि वर्तमान typeof ऑपरेटर के साथ अच्छी तरह से रचना करें, जैसे _indexed एक्सेस प्रकार_ अभी करें।

हालाँकि कुछ प्रश्न / संदेह अभी भी बने हुए हैं:

• क्या यह सुविधा कुछ अन्य परिदृश्यों जैसे _indexed access type_ को हैंडल करेगी? यदि नहीं, तो क्या इसे लागू करना इसके लायक है?
• मुझे लगता है कि ज्यादातर मामलों में तर्क प्रकारों को निर्दिष्ट करने की आवश्यकता नहीं है, क्योंकि सबसे आम परिदृश्य है "मैं सिर्फ इस एक फ़ंक्शन का प्रकार प्राप्त करना चाहता हूं जिसमें अन्य अधिभार नहीं हैं। तो शायद कुछ परिचय इसके लिए नया विशिष्ट ऑपरेटर ठीक रहेगा (उदाहरण के लिए typeofreturn या returnof )

ऐसा लगता है कि यह तकनीकी रूप से संभव है। इसे ओवरलोड रिज़ॉल्यूशन/प्रकार तर्क अनुमान को दोबारा करने की आवश्यकता हो सकती है ताकि आपको तर्कों को हल करने की आवश्यकता न हो। मुझे नहीं लगता कि जेनरिक एक अतिरिक्त समस्या का बहुत अधिक है। पूछने के लिए एक प्रश्न यह है कि क्या होता है यदि कोई अधिभार कॉल से मेल नहीं खाता है।

मुझे लगता है कि यह स्पष्ट नहीं है कि क्या यह सुविधा वांछनीय है। यदि कोई फ़ंक्शन एक बहुत विस्तृत अनाम प्रकार देता है, तो क्या लेखक के रूप में प्रकार का नाम देना अधिक सहायक नहीं होगा, ताकि इसे इस तरह से संदर्भित करने की आवश्यकता न हो? मैं मानता हूं कि यह सिर्फ एक शैलीगत वरीयता पर आधारित है। मुझे लगता है कि मुझे यकीन नहीं है कि व्यवहार में इसका उपयोग करना कितना सुविधाजनक होगा। मुझे लगता है कि हालांकि तत्व पहुंच के लिए यह ठीक है।

टाइप पी = टाइपोफ फू (0); // पी कोई है []
टाइप क्यू = टाइपोफ़ फू (सच); // क्यू स्ट्रिंग है

मापदंडों को उनके प्रकारों द्वारा संदर्भित करने की अनुमति देने पर इस चर्चा को लिखें, मैं सुझाव दूंगा कि इसे वास्तविक कार्यों के लिए भी अनुमति दी जाए।
संदर्भ: मैं वस्तुओं पर map पर एक फ़ंक्शन टाइप करना चाहता हूं:
function map<T, F extends Function>(fn: F, obj: T): { [P in keyof T]: typeof F(T[P]) }
जिस कारण से मैं फ़ंक्शन को इसके प्रकार F (केवल इसके नाम fn से अलग) द्वारा संदर्भित करने में सक्षम होना चाहता हूं, उन मामलों के लिए होगा जहां इसका नाम अनुपलब्ध हो सकता है, उदाहरण के लिए I' d type MapFn<T, F extends Function> = { [P in keyof T]: typeof F(T[P]) } कहने में सक्षम होना चाहता हूं।

कुछ ऐसा जो शायद लागू करना बहुत आसान होगा (और अभी भी बहुत उपयोगी) होगा:

const myFunc = () => ({ x: 10 });
type myType = returnof myFunc;    // { x: number; }

सिद्धांत रूप में, यदि आप प्रकार को कुछ स्तरों तक गहरा करना चाहते हैं, तो उन्हें भी जंजीर में बांधा जा सकता है। कोई विचार?

संपादित करें: बस एहसास हुआ कि इसका उल्लेख ऊपर @mpawelski . द्वारा किया गया था

@dehli हालांकि अतिभारित कार्यों के लिए काम नहीं करेगा। या सामान्य कार्य जहां एक प्रकार का पैरामीटर रिटर्न प्रकार में उपयोग किया जाता है।

@JsonFreeman विभिन्न रिटर्न प्रकारों को केवल OR ओवरलोड नहीं कर सका? और सामान्य कार्यों के लिए आपको प्रकार निर्दिष्ट करने की आवश्यकता हो सकती है?

यह संभव होगा, लेकिन मुझे यकीन नहीं है कि यह कितना उपयोगी होगा। ऐसा लगता है कि लोग कुछ अधिक परिष्कृत चाहते हैं।

मुझे वास्तव में उम्मीद है कि इसे जल्द ही लागू किया जाएगा क्योंकि यह एक वास्तविक दर्द है।

वैकल्पिक हल

चूंकि अंतिम समाधान अब काम नहीं करता है, इसलिए मैं वर्तमान में इसका उपयोग करता हूं:

// 0 argument function
export default function returnof<T>(fn: () => T): T;

// 1 argument function
// If no ambiguity simply infer the return type
export default function returnof<A, T>(fn: (a: A) => T): T;

// 1 argument function, with possible overload for the argument type.
// Explicitly set the type and use the correct overload
export default function returnof<A, T>(fn: (a: A) => T, a: A): T;

// ...

यदि आपके फ़ंक्शन का कोई अधिभार नहीं है, तो आपको तर्क निर्दिष्ट करने की आवश्यकता नहीं है।

const hello = (arg: number) => 'World'

const helloReturnValue = returnof(hello)
type helloReturnType = typeof helloReturnValue // string

अतिभारित कार्य

declare function hello(): void;
declare function hello(a: number): number;

const helloReturnValue = returnof(hello)
type helloReturnType = typeof helloReturnValue // void

const helloReturnValue = returnof(hello, 42)
type helloReturnType = typeof helloReturnValue // number

सभी परिभाषाएँ यहाँ हैं:
https://github.com/kube/returnof/blob/master/lib/returnof.d.ts

मैंने आपके प्रोजेक्ट को प्रदूषित किए बिना इसे आसानी से बंडल करने के लिए एक छोटा NPM पैकेज बनाया है।

यदि वैकल्पिक जेनरिक को https://github.com/Microsoft/TypeScript/issues/2175 में प्रस्तावित की तरह जोड़ा जाता है, तो यह एक साधारण घोषणात्मक-केवल समाधान की अनुमति देगा:

type Return<T extends () => S, S> = S

और इसे इस तरह इस्तेमाल करें:

type helloReturnType = Return<typeof hello>

@mhegazy @JsonFreeman इस सुविधा पर कोई योजना?

हेलो सब लोग,
मेरे पास इस समस्या का एक वैकल्पिक संभावित समाधान है (क्षमा करें यदि यह पहले से ही सुझाया गया है और मैंने इसे याद किया है) - मैंने इसे # 13949 अंक में प्रस्तावित किया है। मैं उस स्तर पर टाइपोफ़ ऑपरेटर के बारे में नहीं जानता था, लेकिन मुझे लगता है कि मेरा समाधान अधिक सामान्य है। मूल रूप से, =MyType जैसा कुछ नया वाक्यविन्यास पेश करें, जिसका उपयोग आप कहीं भी MyType का उपयोग कर सकते हैं, लेकिन ऑब्जेक्ट को MyType प्रकार का घोषित करने के बजाय, यह एक बनाता है वस्तु के अनुमानित प्रकार से MyType नाम टाइप करें। उदाहरण के लिए, मैं इसका उपयोग Vue घटक बनाने में कैसे करूंगा।

function createData(){
  return <=MyData>{
    dataProp1: <string>null
  }
}

function method1(){
  let self: MyComponent = this;
  console.log(self.dataProp1);
  self.method2();
}

function method2(){
  let self: MyComponent = this;
  //dostuff
}

type MyComponent = MyData & MyMethods;

let componentOptions = {
  data: createData,
  methods: <=MyMethods>{method1, method2}
}
//todo: register component...

नोट createData फ़ंक्शन लिखित द्वारा भी किया जा सकता है

function createData(): =MyData {
  return {
    dataProp1: <string>null
  }
}

मुझे वास्तव में एक मजेदार काम मिला जो किसी भी अभिव्यक्ति को सामान्यीकृत करता है:

const varWithRightType = (false as true) && some.deep.access()
type MyType = typeof varWithRightType;

संपादित करें: मुझ पर हंसना बंद करो यह गंभीर प्रकार है

@johnfn यह साधारण मामलों के लिए मजेदार लग रहा है :), लेकिन अगर आपके फ़ंक्शन को कुछ पैरा की आवश्यकता है तो आपको इस तरह अतिरिक्त काम करना होगा:

const stateProps = (false as true) && mapStateToProps({} as any);

मैं एक अलग काम का उपयोग कर रहा हूं, जो विशेष रूप से रिएक्ट और रेडक्स के लिए उपयोगी है, जब mapStateToProps फ़ंक्शन से प्रोप प्रकार प्राप्त करने के लिए प्रकार अनुमान का उपयोग करने का प्रयास किया जाता है। फिर Redux connect द्वारा इंजेक्ट किए गए प्रॉप्स के इंटरफ़ेस को मैन्युअल रूप से घोषित करने और बनाए रखने की कोई आवश्यकता नहीं है, जो बनाए रखने और त्रुटि प्रवण के लिए थकाऊ है।
यह काम अन्य उपयोग के मामलों के लिए किसी दिए गए फ़ंक्शन हस्ताक्षर को भी अच्छी तरह से संभाल लेगा।

typeof ऑपरेटर "React & Redux" उपयोग-मामले का उदाहरण:

उदाहरण के नीचे typeof ऑपरेटर के उपयोग के लिए एक सामान्य रीयल-प्रोजेक्ट उपयोग-मामला दिखाने का प्रयास करें ताकि फ़ंक्शन घोषणा से एक प्रकार प्राप्त किया जा सके जो टाइपस्क्रिप्ट में जोड़े जाने पर बेहद उपयोगी होगा।

import { returntypeof } from 'react-redux-typescript';
import { RootState } from '../../store';
...

const mapStateToProps = (state: RootState) => ({
  currencies: CurrencyRatesSelectors.getCurrencies(state),
  currencyConverter: storeState.currencyConverter,
});

const stateProps = returntypeof(mapStateToProps); 
type Props = typeof stateProps & typeof dispatchToProps;
type State = {};

class CurrencyConverterContainer extends React.Component<Props, State> {
...

स्रोत: https://github.com/piotrwitek/react-redux-typescript-patterns#react -connected-components

@kube का समाधान और उनका पैकेज https://github.com/kube/returnof अपेक्षा के अनुरूप काम करता प्रतीत होता है! मैं

हम्म। काश returnof .d.ts फ़ाइल से टपल-आधारित map() टाइप करने में मदद करता, लेकिन अभिव्यक्ति भाषा पर इसकी निर्भरता को देखते हुए ( const परिवेशी संदर्भों में प्रयोग करने योग्य नहीं है ), मुझे डर है कि मेरा उपयोग-मामला कम से कम अधिक जटिल होगा।

संपादित करें: ऐसा लगता है कि वैकल्पिक जेनरिक अब तक विलय कर दिए गए हैं, जिसका अर्थ है @kube की घोषणात्मक प्रकार की भाषा केवल संस्करण ( type Return<T extends () => S, S> = S -> type helloReturnType = Return<typeof hello> ) व्यवहार्य हो जाएगी। :डी

सुधार: नहीं, डिफ़ॉल्ट जेनेरिक मानों के लिए मर्ज किए गए समर्थन से जेनरिक के हिस्से को निर्दिष्ट करने की अनुमति नहीं मिलती है, जबकि अन्य अपने अनुमानित मूल्यों पर वापस आते हैं; Return<typeof hello> बस त्रुटि उत्पन्न करता है Generic type 'Return' requires 2 type argument(s). ।

@ tycho01 हाँ, मैं निराश था कि इसने समस्या का समाधान नहीं किया।

मैंने पहले से ही वैकल्पिक सामान्य प्रकार के अनुमान के बारे में एक संबंधित मुद्दा खोला है:

14400

आप आम तौर पर एक डमी परिवेश फ़ंक्शन के संयोजन के माध्यम से फ़ंक्शन का रिटर्न प्रकार प्राप्त कर सकते हैं और अनुमान टाइप कर सकते हैं:

परिवेश function returnTypeOf<RT>(fn:(...rest:any[])=>RT):RT {return void 0};
स्थानीय रूप से var r = returnTypeOf(someFunction); मूल्य undefined . हो जाता है

लेकिन अगर आप उस रिटर्न प्रकार का पुन: उपयोग करना चाहते हैं, तो आपको इसे कैप्चर करना होगा ... इसलिए हम वापस वहीं हैं जहां हमने शुरुआत की थी:

type RT = typeof r;

यह इतना आसान होगा यदि हम शुरुआत में typeof की अवधारणा को typeof returntypeof अनुमति देने के लिए विस्तारित करते हैं या इससे भी बेहतर इस उपयोग का अनुमान typeof fn(a,b,c,...) से लगाते हैं, जो तब विभिन्न हस्ताक्षर रिटर्न प्रकारों को कैप्चर कर सकता है . यह वापसी-प्रकार की समझ पहले से ही TS द्वारा आंतरिक रूप से की जाती है।

typeofexpression () एक प्रकार का रिटर्न-टाइप रिकर्सन होगा जो टाइप ऑपरेशंस के साथ मिश्रित होगा: उदाहरण के लिए

type E = typeofexpression (f(1) + g("x"))

है

type E = typecomprehensionof (typeof f(1) + typeof g("x"))

जिसे एक की तरह समझा जा सकता है

type E = typecomprehensionof (string + string) यानी string
type E = typecomprehensionof (string + number) यानी string
type E = typecomprehensionof (number + number) यानी number

यह आंतरिक रूप से कितना मुश्किल है और प्रदर्शन लागत मेरे लिए अज्ञात है।

संपादित करें ------------------------------------------------- ------------

मेरा मतलब जोड़ना था ... यह विशेष रूप से किसी के लिए भी महत्वपूर्ण है जिसे Function.bind, Function.apply, Function.call का उपयोग करना है क्योंकि ये वर्तमान में any टाइप करते हैं और इसका मतलब है कि उन्हें लगातार टाइप करना होगा- यह सुनिश्चित करने के लिए एनोटेट किया गया है कि वे टाइप-चेकिंग प्रक्रिया से बाहर न हों।

फ़ंक्शन तर्क के रिटर्न प्रकार को संदर्भित करने में सक्षम होने के नाते ... आनंद ...

@poseidonCore

फ़ंक्शन तर्क के रिटर्न प्रकार को संदर्भित करने में सक्षम होने के नाते ... आनंद ...

मुझे वर्तमान typeof <expression> बेहतर लगता है, और वापसी प्रकार का मुद्दा पहले से ही #12342 में शामिल है।

मैं स्पष्टीकरण में उन उपयोगों को अलग करने के साधन के रूप में केवल typeofexpression और typecomprehensionof का उपयोग कर रहा था। मैं वास्तविक सिंटैक्स के रूप में typeof (expression) पसंद करूंगा।

मेरा कहना था कि अभिव्यक्ति के प्रकार को समझने के लिए फ़ंक्शन के रिटर्न प्रकार को समझना होगा ... f(1) भी एक अभिव्यक्ति है। #12342 इस तरह से संबंधित है। वे पारस्परिक रूप से विशिष्ट नहीं हैं।

हम पहले से ही चर के लिए typeof कर सकते हैं और इसलिए चूंकि एक अभिव्यक्ति चर और कार्यों पर एक ऑपरेशन है, अगली आवश्यकता फ़ंक्शन के प्रकार को वापस करने में सक्षम हो रही है ... और फिर प्रकार नियमों के आधार पर परिणाम को समझें .

दरअसल, अच्छा बिंदु। मुद्दा # 12342 चाहता है कि सामान्य प्रकार के लिए संपत्ति जैसी चीज के रूप में रिटर्न प्रकार तक पहुंचने का एक तरीका है, इसलिए मैंने संबंध को गलत समझा।

प्रस्ताव में typeof फ़ंक्शन कॉल के लिए अभिव्यक्तियों का उपयोग करने के बारे में, लेकिन पैरामीटर के स्थान पर सीधे प्रकारों का उपयोग करने के बारे में कैसे?

उदाहरण के लिए

function myFunction<T>(param1: T, param2: string, param3: number): T & {test: string} {
  // ...
}

type ResultType = typeof myFunction({hello: string}, string, number)
// ResultType is: {hello: string} & {test: string}

ध्यान दें कि यह किसी को भी कॉल के भीतर टाइपोफ़ का उपयोग करके, स्थानीय रूप से स्कोप किए गए चर के प्रकारों का उपयोग करने से नहीं रोकता है, अर्थात:

type ResultType = typeof myFunction(typeof obj, string, number)
// ResultType is: typeof obj & {test: string} 

यह मूल प्रस्ताव से थोड़ा बेहतर लगता है, क्योंकि यह परिवेश के संदर्भ में काम करता है और सामान्य रूप से अधिक लचीला लगता है। मेरे लिए, यह यह भी स्पष्ट करता है कि हम वास्तव में फ़ंक्शन को कॉल नहीं कर रहे हैं, बस इसके रिटर्न वैल्यू के प्रकार को वापस करने का प्रयास कर रहे हैं।

मैंने इसे अपने साधारण मामले के लिए कैसे किया:

interface IAlertMessage {
  addedAt: number;
  text: string;
  type: "error" | "warning" | "info" | "success";
}

declare let alertMessageInterface: IAlertMessage;

const messages: IAlertMessage[] = [];

function addMessage(text: string, type: typeof alertMessageInterface.type): void {
  messages.push({addedAt: new Date().getTime(), text, type});
}

addMessage("something", "info"); // <- OK - and also has intellisense for the second parameter (after typing first " of the second parameter, press Ctrl+Space in VSCode)
addMessage("something", "fatal"); // <- Compilation error : error TS2345: Argument of type '"fatal"' is not assignable to parameter of type '"error" | "warning" | "info" | "success"'.

उपरोक्त इंटरफ़ेस के सदस्यों के साथ भी काम करता है:

declare let myIface: MyInterface;

interface MyInterface {
    prop1: {
        big: {
            complex: {
                anonymous: { type: {} }
            }
        }
    },
    prop2: typeof myIface.prop1.big.complex.anonymous;
}

मेरे लिए type ... $ के बजाय declare let ... का उपयोग करने का लाभ यह है कि यह आउटपुट .js फ़ाइल में कुछ भी उत्पन्न नहीं करता है।

@varadero यह समस्या को हल नहीं करता है, जो फ़ंक्शन कॉल के रिटर्न प्रकार को पुनर्प्राप्त कर रहा है। आप जो कुछ कर रहे हैं वह एक प्रकार की संपत्ति के प्रकार को पुनर्प्राप्त कर रहा है, जो कि टाइपस्क्रिप्ट 2.2 के बाद से एक समर्थित सुविधा है, मेरा मानना ​​​​है।

यह वास्तव में एक (नकली) मूल्य की संपत्ति का प्रकार है। कंपाइलर आपको "शुद्ध" प्रकार या इंटरफ़ेस के साथ टाइपऑफ़ का उपयोग करने नहीं देता है, यह केवल मूल्यों पर काम करता है।

यह होना बहुत अच्छा होगा!

चूंकि type KEYOF<T extends any[]> = keyof T[0] पहले से मौजूद है, typeof T[0]('something') इस कार्यान्वयन के साथ भी काम करेगा, यह मानते हुए कि function myFunc<T, K extends KEYOF<T>>(type: K)>{ } और myFunc([(r: string) => r]) ( typeof T[0]('something') के लिए स्ट्रिंग लौटाएगा) ?

यह बहुरूपी this के साथ शक्तिशाली होगा।

ऐसा होने का समय!

इस सूत्र को फिर से पढ़कर, मैंने यह समझने की कोशिश की कि हम typeof सिंटैक्स-वार के साथ क्या कर रहे हैं और क्यों।

जाहिर है, पहले से लागू मामूली typeof foo मामले में, यह foo का प्रकार देता है। (मुझे लगता है कि pet is Fish विशेष सिंटैक्स का उपयोग करने के लिए प्रतिरक्षा है।)

वर्तमान प्रस्ताव में इस खोजशब्द को क्या करना चाहिए, मेरे वर्तमान पढ़ने में, खोजशब्द स्वयं अब जो करता है उससे अधिक नहीं करता है, और वर्तमान प्रस्ताव वास्तव में typeof कीवर्ड से असंबंधित है।

मैं इसे ऊपर लाता हूं क्योंकि यह उस मामले में मायने रखता है जिसका मैंने ऊपर उल्लेख किया है, जहां हम एक प्रकार के रूप में संग्रहीत फ़ंक्शन को लागू कर रहे हैं (चाहे वह type के माध्यम से या एक सामान्य के रूप में हो), बजाय एक मूल्य के रूप में।

यह देखते हुए, मुझे लगता है कि, जबकि typeof fn<A>(string) को typeof $ की आवश्यकता है, जबकि अभिव्यक्ति-स्तर चर fn को टाइप स्तर पर उपयोग के लिए उठाने के लिए, दूसरी ओर Fn<A>(string) , Fn के साथ एक फ़ंक्शन वाले जेनेरिक के रूप में, इसकी आवश्यकता नहीं होगी, और इसलिए इसे 'लागू' किया जा सकता है ताकि typeof की आवश्यकता के बिना यहां उचित रिटर्न प्रकार प्राप्त किया जा सके।

इस व्याख्या में, हम संभावित फ़ंक्शन प्रकारों के बाद किसी भी बाद फ़ंक्शन कॉल की जांच करेंगे: typeof fn(...) / typeof fn<...>(...) के अलावा Fn(...) / Fn<...>(...) के अलावा, यदि कार्य भी नहीं है शाब्दिक ((foo: Foo) => Bar)(Baz) / + जेनरिक। अन्यथा, हमले की योजना बरकरार रहनी चाहिए।

हो सकता है कि मैं गलत व्याख्या कर रहा हूं कि आप इसे कैसे देखते हैं, हो सकता है कि प्रकारों में संग्रहीत कार्यों पर भी विचार नहीं किया गया हो (जैसा कि मुझे उनका कोई उल्लेख नहीं मिला)। किसी भी तरह से, मुझे लगा कि यह पुष्टि करने लायक होगा।

यदि फ़ंक्शन एप्लिकेशन की घोषणा करना typeof के लिए अभी तक एक और अर्थपूर्ण अधिभार बन जाता है, हालांकि, क्लास कंस्ट्रक्टर्स को असंबद्ध करने और एक्सप्रेशन-लेवल वेरिएबल्स को टाइप लेवल तक उठाने के अलावा ( एक्सप्रेशन-लेवल typeof से अलग), चीजें धीरे-धीरे अधिक जटिल लगते हैं, जैसा कि इस सूत्र में पहले के कुछ प्रश्नों से संकेत मिलता है।

संपादित करें: एक सामान्य प्रकार पहले से ही एक फ़ंक्शन प्रकार लौटा सकता है, जिसमें जेनेरिक भी हो सकते हैं। इसका मतलब है कि एक और क्रमपरिवर्तन GetFn<A><B>() होगा, जिसमें पहला जेनेरिक सेट सामान्य प्रकार के आमंत्रण से संबंधित होगा, बाद वाला फ़ंक्शन आमंत्रण से संबंधित होगा। हालांकि GetFn<A><B><C>() नहीं, हालांकि GetFn<A><B>()<C>() वैध भी होगा। हालांकि पहले का निष्कर्ष अपरिवर्तित रहता है: किसी भी प्रकार में एक फ़ंक्शन हो सकता है और इसलिए (संभावित रूप से) एक फ़ंक्शन के रूप में लागू किया जा सकता है।

संपादित करें 2: मुझे अभी एहसास हुआ कि X<Y>() में एक दुर्भाग्यपूर्ण अस्पष्टता होगी। अब, X एक प्रकार का फ़ंक्शन प्रकार लौटाएगा।

• यदि X सामान्य नहीं है, तो यह स्पष्ट है - <Y> फ़ंक्शन कॉल से संबंधित है।
• यदि X सामान्य है और पैरामीटर की आवश्यकता है, तो यह भी स्पष्ट है - यह प्रकार से संबंधित है, और फ़ंक्शन किसी भी प्रकार के पैरामीटर को पारित नहीं करता है।
• यदि X में वैकल्पिक जेनेरिक है, तो यह अस्पष्ट हो जाता है।
  
  
  
  • एक व्याख्या में, X को एक प्रकार का पैरामीटर पारित किया जाता है, जबकि फ़ंक्शन नहीं होता है।
  
  
  • एक अन्य व्याख्या में, X को इसके डिफ़ॉल्ट प्रकार के परम का उपयोग करने के लिए छोड़ दिया गया है, जबकि <Y> इसके बजाय फ़ंक्शन कॉल को पैरामीटर करेगा।
  
  

मुझे अभी तक यकीन नहीं है कि यहां सबसे अच्छा समाधान क्या होगा।

• एक विकल्प यह होगा कि टाइप इनवोकेशन को पूरी तरह से डिफ़ॉल्ट प्रकार के मापदंडों पर निर्भर करते हुए स्पष्ट रूप से खाली <> का उपयोग करने के बजाय इसे छोड़ने की अनुमति दी जाए। हालाँकि, यह एक तोड़ने वाला बदलाव होगा।
• एक विकल्प यह होगा कि इसके बजाय टाइप-लेवल फंक्शन इनवोकेशन पर इस तरह का प्रतिबंध लगाया जाए - क्योंकि यह नया होगा, कोई ब्रेकिंग चेंज पेश नहीं किया जाएगा। हालाँकि, यह दृष्टिकोण इस मायने में सुरुचिपूर्ण होगा कि यह अभिव्यक्ति और प्रकार की भाषाओं के बीच फ़ंक्शन आमंत्रण के लिए सिंटैक्स के बीच एक विषमता का परिचय देगा, जो इसे कम सहज बना सकता है।

@icholy : हाँ, ये संपादन आपके बिंदु को और जोड़ रहे हैं, मुझे पता है।

संपादित करें 3: ठीक है, यह सुविधा अब मेरी इच्छा सूची में सबसे ऊपर है। अनुमान के प्रभाव के संदर्भ में कोई अन्य अपग्रेड दूर से भी नहीं आता है।

@icholy : संक्षेप में, यदि 'फ़ंक्शन' सामान्य/प्रकार में है, तो क्या हम अभी भी typeof लिखेंगे?

यदि ऐसा किया जाता है तो यह ओवरलोड के साथ सही ढंग से इंटरैक्ट करता है, यह वास्तव में आपको मुफ्त में "वैरिएडिक" फ़ंक्शन देता है (वे> 1 एरिटी होने के बजाय सिर्फ करीबी हैं), क्योंकि आप फ़ंक्शन के रिटर्न प्रकार को पुनरावर्ती रूप से परिभाषित कर सकते हैं। कुछ बेस-केस अधिभार के साथ, इसके अधिभारों में से एक का अनुप्रयोग। हास्केल में चीजें इस तरह से की जाती हैं, और टाइपस्क्रिप्ट में होना एक अद्भुत विशेषता होगी।

@masaeedu : यह दिलचस्प लगता है। और हाँ, अधिभार निश्चित रूप से हैं जो इस प्रस्ताव को इतना दिलचस्प बनाते हैं - उनका उपयोग विभिन्न विकल्पों पर पैटर्न-मिलान के लिए किया जा सकता है, जिसमें any फ़ॉलबैक शामिल हैं। इस तरह के प्रकार की जाँच अभी तक प्रकार के स्तर पर संभव नहीं थी।

मैं मानता हूँ कि मैंने हास्केल की तुलना में रामदा का अधिक उपयोग किया है। लेकिन उस पृष्ठभूमि से, मैंने सोचा कि करी सामान्य रूप से विविध कार्यों के साथ अच्छी तरह से गठबंधन नहीं करती है, क्योंकि करी को अतिरिक्त तर्कों से निपटने के लिए परिणाम या किसी अन्य फ़ंक्शन को वापस करना है या नहीं।

क्या आप शायद कुछ छद्म कोड दिखा सकते हैं कि आप इस विचार को Object.assign जैसे विविध कार्यों के लिए कैसे काम करेंगे ( & बनाम Overwrite जैसे विवरणों को छोड़कर मैंने उपयोग किया मेरे पीओसी में R.mergeAll के लिए)?

@ tycho01 मैं इस तरह के कोड के साथ खेल रहा हूं:

interface Pop<TVarStack extends VarStack> {
    (a: TVarStack["head"]): Pop<TVarStack["tail"]>
}

interface VarStack<THead = any, TTail extends (void | VarStack) = any> {
    head: THead
    tail: TTail
    <TNew>(a: TNew): VarStack<TNew, this>
    (): (a: Pop<this>) => any
}

// Figure out implementation later :)
let stack: VarStack<void, void>;
const pop = stack(new Date())(10)("Bob's")("your")("uncle")()

// a, b, c, d, and e are well-typed
pop(a => b => c => d => e => {
    // Need this because can't figure out how to encode base-case in Pop recursion
    return stack
})

VarStack एक अर्थ में एक "वैरिएडिक" फ़ंक्शन प्रकार है, जिसमें आप इसे विषम तर्कों की एक मनमानी संख्या दे सकते हैं और यह प्रकार के स्तर पर रिकर्सन का उपयोग करके संबंधित प्रकार की जानकारी को ईमानदारी से रिकॉर्ड करेगा। दुर्भाग्य से टाइपस्क्रिप्ट के पास प्रकार के स्तर पर परिवर्तन और पैटर्न मिलान के लिए अच्छा समर्थन नहीं है, उसी तरह जैसे हास्केल करता है।

अगर हमारे पास typeof तक पहुंच होती, तो मैं Pop के लिए बेस-केस समस्या को हल करने में सक्षम होता, क्योंकि returnof(overloadedFunction(T)) अनिवार्य रूप से मुझे पैटर्न करने का एक तरीका देगा- प्रकार के स्तर पर मिलान।

@ tycho01 मैं इसे Object.assign के लिए ठीक से नहीं कर सकता, क्योंकि जैसा कि मैंने कहा, यह केवल करीबी कार्यों के लिए काम करता है, लेकिन मैं आपके लिए एक करीबी assign फ़ंक्शन बनाने की कोशिश करूंगा जो मोटे तौर पर काम करता है उसी तरह।

मेरी इच्छा है कि वे बीजगणित प्रकार को थोड़ा सामान्य कर दें, ताकि उदाहरण के लिए (a: string) => (b: number) => void केवल Func<string, Func<number, void>> के लिए चीनी थी, और (a: string, b: number) => void केवल Arity<number, Arity<string, void>> के लिए चीनी थी, या ऐसा कुछ। फिर हमें आकस्मिक रूप से बहुत सारी रोचक सुविधाएं प्राप्त करने के लिए प्रकारों को बदलने के लिए सामान्य प्रयोजन उपकरण की आवश्यकता होगी।

ट्रिपल पोस्ट के लिए सभी को खेद है। @ tycho01 यहाँ करी है, "वैरिएडिक" assign :

interface Assign<TCurr extends {} = {}> {
    <TAdd extends {}>(a: TAdd): Assign<TCurr & TAdd>
    (): TCurr
}

let assign: Assign = undefined // implement somehow
const result = assign({ foo: "bar" })({ baz: 42 })()

@masaeedu : हाँ, तो मुझे लगता है कि यह एक रेड्यूसर फ़ंक्शन होने जैसा है :), हालांकि गैर-वैरिएडिक (?) तर्क भी होने पर वह हिस्सा कठिन हो सकता है।

मुझे यह विचार पसंद आया; मैं निश्चित रूप से इंटरफेस की दिशा में ज्यादा नहीं सोच रहा हूं।
अगर हम टाइपिंग के लिए जेएस बदल सकते हैं, तो शायद मैं टीसी39 को Object.assign को गैर-वैरिएडिक mergeAll में बदलने के लिए कहूंगा। :डी

मेरे वेतन वृद्धि-आधारित पुनरावृत्ति की तरह नहीं, वास्तव में अब तक (# 17086) व्यवहार में कार्यों के साथ काम किया है ...

@ tycho01 मुझे लगता है कि यदि आप विविध कार्यों को निश्चित धर्मार्थ कार्यों में बदलने के लिए कहते हैं, तो आपको अधिक कर्षण प्राप्त करने की संभावना नहीं है, क्योंकि करीबी कार्यों या बार-बार आवेदन के लिए रनटाइम लागत है जो जेएस (या कम से कम मौजूदा जेएस इंजन और कोड) शायद के लिए अत्यधिक अनुकूलित नहीं है। मुझे लगता है कि इसके बजाय हमें जो चाहिए वह टाइपस्क्रिप्ट के लिए समान रूप से आसान बनाने के लिए है और एरिटी के लिए प्रकारों को डीकंस्ट्रक्ट करना> 1 पुनरावर्ती रूप से कार्य करता है। मुझे लगता है कि यह सब #5453 पर वापस आता है।

दूसरों को यह जानना दिलचस्प हो सकता है कि सी ++ में एक समान विशेषता है: decltype(expression)

क्या यह सुविधा कभी टाइपस्क्रिप्ट में आने वाली है?
मैं मूल प्रस्तावित फॉर्म को अत्यधिक पसंद करता हूं जहां तर्क एक अभिव्यक्ति है, लेकिन टीएस टीम की अभिव्यक्ति की स्थिति में प्रकारों के साथ विशेष वाक्यविन्यास रखने का इरादा सब कुछ जटिल करता है और इसे भाषा में उतरने में देरी करता है।
हमें इस विषय को ऊपर रखना होगा।

मुझे वास्तव में खुशी होगी अगर हम इस प्रस्ताव का एक सबसेट भी लागू कर सकें। अर्थात्, यह एकल:
type A = typeof anotherVariable । मैं बस इसी एक लाइन से सब कुछ कर सकता था। interface B extends A , <B & A> : B & A , आदि।

मैं प्रतिक्रिया के साथ इस तरह की चीजों के लिए बहुत सारे उपयोग-मामले देख रहा हूं। जब आप उच्च ऑर्डर घटक बनाते हैं, तो घटक वर्ग घोषणा को इंगित करना बहुत कठिन होता है कि यह वर्तमान में एक एचओसी है।

मैंने जो किया वह दो वर्ग बना रहा है। एक वर्ग React.Component विस्तार करता है और सभी अतिरिक्त विधियों को जोड़ता है, जबकि HOC फ़ंक्शन के अंदर की कक्षा render() में हेरफेर करती है।

@blindbox type A = typeof anotherVariable पहले से ही काम करता है:

var data = [1, 2, 3].map(v => ({ raw: v, square: v * v }));

function checkItem(item: typeof data) {
    // item is Array<{ raw: number; square: number; }>
}

@Igorbek वाह, तुम सही हो।

ठीक है, मुझे पता चला कि यह मेरी ओर से काम क्यों नहीं कर रहा था।
यह काम नहीं करेगा

interface B {
  thisIsB: boolean
}

const typeTest = (type: any) => {
  return 1 as any as App & B
}
type A = typeof typeTest(1)
declare const aVal: A; // aVal's type isn't of type App & B, but something else.

हालांकि यह काम करेगा।

interface B {
  thisIsB: boolean
}

const typeTest = (type: any) => {
  return 1 as any as App & B
}
const typeTestVal = typeTest(1)
type A = typeof typeTestVal
declare const aVal: A; // aVal's type is of type App & B!

हाँ, तो समस्या यह है कि इसका उपयोग कुछ उपयोग के मामलों में नहीं किया जा सकता है, जैसे कि जब आपको सामान्य प्रकार के तर्कों का उपयोग करने की आवश्यकता होती है।

function someFunctionWithComplexReturnTypeThatUsesGenerics<T>(item: T) { ... }

// it is impossible to work this around because there's no chance to create a fake variable that would be parameterized by T
function use<T>(item: typeof someFunctionWithComplexReturnTypeThatUsesGenerics<T>(item)) { ... }

@ इगोरबेक :

मैं मूल प्रस्तावित फॉर्म को अत्यधिक पसंद करता हूं जहां तर्क एक अभिव्यक्ति है, लेकिन टीएस टीम की अभिव्यक्ति की स्थिति में प्रकारों के साथ विशेष वाक्यविन्यास रखने का इरादा सब कुछ जटिल करता है और इसे भाषा में उतरने में देरी करता है।

इसलिए जब से उन्होंने लिखा है, हमें स्ट्रिंग्स और संख्याओं के लिए अक्षर मिल गए हैं, जिसका अर्थ है कि चीजें थोड़ी अस्पष्ट हो रही हैं - वे किसी भी तरह से काम करेंगे। शाब्दिक सरणी और वस्तुएं समान रूप से उनके प्रकार के नोटेशन के समान दिखती हैं, अब तक इतनी अच्छी।

तो फिर हमारे पास संग्रहीत मूल्य/प्रकार भी हैं, जैसे चर, जेनरिक, अन्य प्रकार। चीजों के उपयोगी होने के लिए, हमें यहां केवल इनके हिस्से के लिए समझौता नहीं करना चाहिए।
यहां उनके प्रकार-आधारित दृष्टिकोण के लिए एक अच्छा तर्क यह है कि इस मिश्रण को प्रकार के स्तर पर मुफ्त में आने की अनुमति है। कहने का तात्पर्य यह है कि, प्रकार के स्तर पर हम पहले से ही typeof myVar कह सकते हैं, जिसका अर्थ है कि यदि यह फ़ंक्शन 'एप्लिकेशन' टाइप स्तर में जोड़ा जाता है, तो हम स्वचालित रूप से संग्रहीत प्रकारों और नियमित चर दोनों में प्लग इन करने में सक्षम होंगे .

मुझे मूल रूप से सुझाए गए दृष्टिकोण पर आपके और विचार देखने में दिलचस्पी होगी। बेशक, यह टाइप स्तर पर थोड़ा और खुलासा करने के लिए काम कर सकता है: जेएस-आधारित ऑपरेटर (सोचें ! && || + - * / instanceof ) और साथ ही टाइपस्क्रिप्ट विशिष्ट ऑपरेटर (अभिकथन ऑपरेटर ! )।
उन जेएस ऑपरेटरों के बारे में बात इस तरह है ... वे टाइप स्तर पर बहुत बेकार हैं क्योंकि यह खड़ा है, क्योंकि उन्हें संबंधित शाब्दिक परिणाम प्राप्त करने के लिए शाब्दिक पर काम करने की इजाजत है, वर्तमान में दायरे से बाहर माना जाता है ( रेफरी ) - अभिव्यक्ति -स्तर 1 + 1 केवल number टाइप करता है, और दूसरों के लिए समान है।
इस बात को ध्यान में रखते हुए मैं स्वयं उनके टाइप-आधारित प्रस्ताव के साथ थोडा नीचे आ गया हूँ।

क्या यह सुविधा कभी टाइपस्क्रिप्ट में आने वाली है? [...] हमें इस विषय को बनाए रखने की जरूरत है।

मैंने इस प्रस्ताव को यहां एक छोटे से लक्षण के लिए एक अधिक सामान्य समाधान के रूप में सुझाया, हालांकि सीमित सफलता के लिए।

@ tycho01 typeof की अभिव्यक्ति-आधारित भिन्नता के लिए मेरे तर्क लगभग वही हैं जो मूल रूप से @yortus द्वारा बताए गए हैं:

• संगति : मौजूदा typeof (प्रकार की स्थिति में) पहले से ही भावों के साथ काम कर रहा है, हालांकि एक प्रतीक को स्वीकार करने के लिए विवश है। ताकि स्वीकार करने वाले प्रकार या छद्म कॉल अधिक बोझिल वाक्यविन्यास पेश करेंगे जो कि एक और वाक्यविन्यास शाखा है (अभिव्यक्तियों और प्रकारों के अतिरिक्त)।
  
  
  
  • उपयोगकर्ताओं को नया सिंटैक्स सीखने की ज़रूरत नहीं है
  
  
• सादगी : टाइपस्क्रिप्ट में पहले से ही इस सुविधा को विनीत तरीके से लागू करने के लिए आवश्यक सभी सुविधाएं हैं (यह पीआर द्वारा सिद्ध किया गया है)
• पूर्णता : अभिव्यक्तियों में कम से कम प्रकार के समान अभिव्यक्ति होती है, क्योंकि हम हमेशा प्रकार के दावे ( (undefined as any as <any arbitrary type can be here>) ) का उपयोग कर सकते हैं, लेकिन कभी-कभी टाइप सिस्टम में ऐसे प्रकार नहीं होते हैं जिन्हें अभिव्यक्तियों में व्यक्त किया जा सकता है (प्रसार और बाकी प्रकार बाद में पेश किए गए थे संबंधित भाव उतरा गया था)।

धन्यवाद @ tycho01 कि आपने उस बिंदु को promised PR (मैं वास्तव में आपकी टिप्पणियों के बाद यहां आया था) पर लाया, जो वास्तव में दिखाता है कि इस तरह की एक सरल और सामान्य विशेषता बहुत अधिक जटिल परिदृश्यों को बिना पकाए बहुत ही सुरुचिपूर्ण तरीके से कवर कर सकती है। भाषा में बहुत विशिष्ट व्यवहार में।

मैं विस्तारित typeof को टाइप सिस्टम अभिव्यक्ति के लिए वास्तविक गेम चेंजर के रूप में देखता हूं, मैप किए गए प्रकारों की तरह/ keyof ने ऐसा किया।

@ इगोरबेक : विस्तृत करने के लिए धन्यवाद, मैं देखता हूं कि आप कहां से आ रहे हैं। शायद ये दो दृष्टिकोण अलग-अलग उपयोग-मामलों की सेवा करते हैं।

मुझे लगता है कि आप आज के मूल प्रस्ताव की तुलना में मूल प्रस्ताव के आज के मूल्य का बेहतर प्रदर्शन कर रहे हैं, क्योंकि वर्तमान टीएस (या, ठीक है, खेल का मैदान का 2.3.3 ) पहले से ही कई मूल परिदृश्यों को काम कर सकता है:

// I have a strongly-typed collection but the element type is anonymous/unknown, how can I reference the element type? (#3749)

// Mapping to a complex anonymous type. How to reference the element type?
var data = [1, 2, 3].map(v => ({ raw: v, square: v * v }));
declare function checkItem(item: typeof data[0]): any
// ^ no longer errors, needs no further change

// A statically-typed dictionary. How to reference a property type?
var things = { 'thing-1': 'baz', 'thing-2': 42 };
type Thing2Type = typeof things['thing-2'];
// ^ no longer errors, needs no further change

// A strongly-typed collection with special indexer syntax. How to reference the element type?
var nodes = document.getElementsByTagName('li');
type ItemType = typeof nodes.item(0);
// ^ the `.item` access works, but function applications still errors, would be fixed by either version of the proposal.

// A function returns a local/anonymous/inaccessible type, how can I reference this return type? (#4233, #6179, #6239)

// A factory function that returns an instance of a local class
function myAPIFactory($http: HttpSvc, id: number) {
  class MyAPI {
    constructor(http) {}
    foo() {}
    bar() {}
    static id = id;
  }
  return new MyAPI($http);
}
declare function augmentAPI(api: typeof myAPIFactory(HttpSvc, number) /* ERROR */): any
// ^ function applications errors, would be fixed by either version of the proposal, if using slightly different syntax.

// I have an interface with a complex anonymous shape, how can I refer to the types of its properties and sub- properties ? (#4555, #4640)

// Declare an interface DRY-ly and without introducing extra type names
type MyInterface = {
  prop1: {
    big: {
      complex: {
        anonymous: { type: {} }
      }
    }
  },
  // prop2 shares some structure with prop1
  prop2: MyInterface['prop1']['big']['complex'];
}
// ^ no longer errors after swapping `.k` access to `['k']`. `typeof` was unnecessary and counter-productive -- MyInterface isn't exposed on the expression level.

मुझे लगता है कि ये उदाहरण अब अभिव्यक्ति या प्रकार के दृष्टिकोण के लिए ज्यादा मामला नहीं बना रहे हैं - अधिकांश अप्रचलित हैं, और तुच्छ कार्य अनुप्रयोग या तो सक्षम होंगे।

माना जाता है कि टाइप-लेवल आधारित फ़ंक्शन एप्लिकेशन, जैसा कि टिंगनहो द्वारा केंद्रित है, टीएस टीम और मैं अभिव्यक्ति चर को typeof के माध्यम से उजागर कर सकते हैं, हालांकि जैसा कि आपने नोट किया है, प्रकार स्तर अभिव्यक्ति पर उजागर कार्यक्षमता के पीछे स्वीकार्य रूप से पिछड़ जाता है स्तर। यह फ़ंक्शन एप्लिकेशन के साथ-साथ आपके द्वारा उल्लिखित स्प्रेड सिंटैक्स स्पष्ट रूप से प्राथमिक उदाहरण हैं, और मैं निश्चित रूप से उन्हें संबोधित करते हुए देखना पसंद करूंगा। शायद मौजूदा अंतर के बहुत से यहां भी निपटा जा सकता है।

इसी तरह, एक अभिव्यक्ति-प्रथम दृष्टिकोण भी <MyType> whatever या whatever as MyType का उपयोग करके इंजेक्शन प्रकारों की अनुमति देगा, हालांकि प्रकार दृष्टिकोण में typeof के रूप में, यह समान रूप से बाद के विचार की तरह प्रतीत होगा: प्रश्न प्रकार/जेनेरिक में संग्रहीत कार्यों को लागू करने के बारे में, जो संभावित रूप से उस प्रकार-आधारित दृष्टिकोण के वास्तविक अतिरिक्त मूल्य के लिए बनाते हैं (हालांकि वहां उल्लेख नहीं किया गया है) - उच्च-आदेश कार्यों के लिए सटीक अनुमान, साथ ही टाइप-आधारित सशर्त कहते हैं उस promised धागे की तरह। * इससे भी बदतर, ओपी के उपयोग-मामले के विपरीत, इनका कोई कामकाज नहीं है।

मुझे लगता है कि विचार कहां टकराते हैं - वर्तमान प्रस्तावों में विरोधाभासी विचार हैं कि typeof कीवर्ड अपनी अभिव्यक्ति को मूल्य स्तर पर बदल देगा, बनाम (मेरी व्याख्या में) typeof को छोड़कर , लेकिन प्रकार के स्तर पर फ़ंक्शन एप्लिकेशन सिंटैक्स को उजागर करना।

मेरे विचार में, विरोधाभास कुछ हद तक आकस्मिक है। मैं किसी भी उपयोग-मामले की वैधता की अवहेलना नहीं करूंगा; अगर दोनों को लागू किया जाना था तो मैं अर्थशास्त्र संघर्ष से बचने के लिए एक अतिरिक्त कीवर्ड देख सकता था। मैं ईमानदारी से उदासीन हूं कि क्या कीवर्ड एक तरह से समाप्त होंगे या कोई अन्य - मैं सिर्फ बकवास टाइप करना चाहता हूं।

*: मुझे अभी-अभी एहसास हुआ है कि आप जेनरिक में उनके प्रकारों को कैप्चर करने के बजाय, उनके पैरामीटर नामों द्वारा पैरामीटर में फ़ंक्शंस को संदर्भित करके उच्च-क्रम के कार्यों के बारे में जानेंगे।
ऐसा लगता है कि चीजों को वास्तव में दोनों दिशाओं में परिवर्तित किया जा सकता है: typeof मूल्य स्तर से प्रकार स्तर तक उठाने में मदद करता है, जबकि declare let y: x; चीजों को मूल्य स्तर से प्रकार स्तर तक उठाने में मदद करता है। ओपी के कामकाज की तरह सुरुचिपूर्ण, लेकिन हाँ।
यदि फ़ंक्शन प्रकारों को उदाहरण के लिए स्पष्ट जेनरिक के माध्यम से लाया गया था, तो मुझे लगता है कि यह मदद नहीं करेगा - वे उन्हें स्थानांतरित करने के तरीके के बिना प्रकार के स्तर पर होंगे।
अगर ऐसा लगता है कि मैं कार्यक्षमता के आधार पर पूर्व-खाली रूप से कवर करने की उम्मीद कर रहा हूं, तो शायद यह इसलिए है क्योंकि अनसुलझी टाइपिंग चुनौतियों पर मेरी अधिकांश प्रगति इस एक ऐड-ऑन (उल्लेखनीय उल्लेख के साथ 5453) पर अवरुद्ध हो गई है। लेकिन अगर हम इन चीजों का पता लगा सकते हैं, तो यह इसके लायक होगा।

संपादित करें: मैंने कुछ सैद्धांतिक मामलों के बारे में सोचा है जिन्हें अब अभिव्यक्ति-आधारित दृष्टिकोण में बाहर रखा जा सकता है, हालांकि अभी तक कोई व्यावहारिक घटना दिमाग में नहीं आई है:

• कार्यों को स्पष्ट रूप से प्रदान किए गए सामान्य के माध्यम से पारित किया गया।
• पैरामीटर फ़ंक्शंस द्वारा लौटाए गए फ़ंक्शन, जेनेरिक में कैप्चर किए जाने के लिए, यानी (अभिव्यक्ति-आधारित प्रस्ताव के सिंटैक्स का उपयोग करके) declare function f<G extends (...args: any[]) => R, R extends <T>(foo: T) => Bar<T>>(g: G): typeof R(baz); // error following the expression-based proposal: R is not exposed at the expression level । ये निश्चित रूप से गणना की जा सकती हैं यदि आप जानते हैं और पैरामीटर प्रकार प्रदान कर सकते हैं G , लेकिन afaik इस जानकारी को अब तक प्राप्त करने का कोई तरीका नहीं है (जब तक कि शायद # 14400?) मुझे लगता है कि इस श्रेणी में उपरोक्त वर्णित एंगुलरजेएस में उपयोग किए जाने वाले कारखाने के कार्यों पर काम करने वाले कार्य शामिल होंगे।

@Igorbek मुझे समझ में नहीं आता कि आप इस स्निपेट से क्या उम्मीद करते हैं:

function use<T>(item: typeof someFunctionWithComplexReturnTypeThatUsesGenerics<T>(item)) { ... }

यह एक गोलाकार परिभाषा की तरह लगता है।

@masaeedu क्षमा करें, मेरा मतलब था:

($#$ someFunctionWithComplexReturnTypeThatUsesGenerics $#$ के बजाय f पर स्विच करें)

function use<T>(item: typeof f<T>(undefined as any as T)) { ... }

बस विस्तृत करने के लिए, नकली चर पेश करके वर्तमान में काम नहीं किया जा सकता है:

const _typeofItem = f<T>(undefined as any as T); // no T here
function use<T>(item: typeof _typeofItem) { ... }

BTW, बस एहसास हुआ कि वर्तमान प्रस्ताव सदस्य प्रकार क्वेरी प्रकार ऑपरेटर T[K] के साथ संघर्ष करता है क्योंकि typeof की उच्च प्राथमिकता है:

• typeof x[K] का अर्थ है (typeof x)[K] जहां K _is_ एक प्रकार है
• यदि अभिव्यक्ति-आधारित भिन्नता ली जाती है, तो एक अस्पष्टता पेश की जाएगी:
  
  
  
  • typeof x[k] का अर्थ है (typeof x)[k] जहां k एक प्रकार है; या
  
  
  • typeof x[k] का अर्थ है typeof (x[k]) जहां k एक अभिव्यक्ति है
  
  

मैं वास्तव में typeof (x[k]) पसंद करूंगा क्योंकि वे शब्दार्थ समकक्ष हैं, लेकिन निश्चित रूप से एक ब्रेकिंग बदलाव है।

जब मैंने क्रोम के डेवलपर टूल्स का इस्तेमाल किया, तो मुझे पता चला कि सदस्य ऑपरेटर की उच्च प्राथमिकता है। वह आपको कहां मिला?

@Igorbek : हाँ, ऐसा प्रतीत होता है कि मूल पोस्ट से type Thing2Type = typeof things['thing-2']; पहले से ही क्यों काम करता है।

@dehli : आप JS अभिव्यक्ति स्तर की तुलना TS प्रकार के स्तर से कर रहे हैं - वे समान नहीं हैं। एक ब्राउज़र/नोड में चलता है, दूसरा टीएस कंपाइलर में।

मुझे व्यक्तिगत रूप से यह अजीब लगता है कि टाइपस्क्रिप्ट टाइप-लेवल typeof को इंडेक्सेड टाइप एक्सेस की तुलना में उच्च प्राथमिकता के साथ हल करता है। यह लगभग मेरे लिए एक बग की तरह दिखता है, ईमानदारी से। (मुझे आश्चर्य है कि क्या उस मामले का वास्तव में परीक्षण किया गया है।)

@ tycho01 गोचा । मैंने मान लिया था कि TS JS के समान वरीयता के क्रम का उपयोग करेगा।

@dehli अभिव्यक्ति का स्तर समान है, हाँ। प्रकार के स्तर पर यह समान वाक्यविन्यास के साथ एक और चीज है, लेकिन एक स्ट्रिंग के बजाय एक प्रकार लौटा रहा है।

मैं अनुमान लगा रहा हूं कि प्राथमिकता उन सीमाओं का परिणाम हो सकती है जिनकी उन्होंने कल्पना की थी। मैं मानता हूँ कि यदि इसके कार्य का विस्तार करना है तो वे विचार अब उतने समझदार नहीं लग सकते।

एक अन्य नोट पर, यदि प्रस्ताव के दोनों संस्करणों को लागू किया जाना था, तो कोष्ठक यह स्पष्ट करने के लिए एक प्रभावी तरीके के रूप में काम करेंगे कि हम इसके लिए किस स्तर पर होंगे। मुझे उन चीजों के साथ आने में परेशानी हो रही है जो समझौता की तरह नहीं लगती हैं, लेकिन हाँ।

@Igorbek क्या यह मनमानी अभिव्यक्तियों पर typeof के लिए प्राथमिक शेष उपयोग केस है? अगर हमें #14400 मिलता है, तो अगर मैं गलत नहीं हूं तो यह हमें सादे उपयोगकर्ता-परिभाषित प्रकारों का उपयोग करके returnof देगा।

14400 हमें अपने सामान्य रूप में returnof नहीं देगा:

type Return<T extends () => R, R = any> = R;

// overloaded function
declare function f(item: number): number;
declare function f(item: string): boolean;

type fType1 = Return<typeof f>; // ??
type fType2 = typeof f(1); // number
type fType3 = typeof f('a'); // boolean

// generic function
declare function g<T>(item: T): T;

type gType1 = Return<typeof g>; // ??
type gType2 = Return<typeof g<number>>; // not supported syntax
type gType3 = typeof g(1); // number
type gType4 = typeof g<number>(1); // number
type gType5 = typeof g('a' as 'a'); // 'a'

मुझे शेष सभी उपयोग-मामलों के बारे में पता नहीं है, वे अभी तक खोजे नहीं गए हैं, लेकिन मेरे लिए सबसे अपराजेय और आकर्षक हैं:

• _कंडीशनल मैप किए गए प्रकार_ जो बहुत अधिक शक्तिशाली हैं जो हमें #12424 के साथ मिल सकते हैं, क्योंकि typeof मानक अधिभार रिज़ॉल्यूशन का उपयोग करेगा; @ tycho01 ने promised प्रकार PR #17077 . में एक सुंदर उदाहरण दिखाया है
• सामान्य प्रकारों के संदर्भ में फ़ंक्शन/विधि रिटर्न प्राप्त करना (जैसा कि मैंने पहले दिखाया था)

@masaeedu : अच्छा सवाल है। संक्षिप्त संस्करण काफी हद तक @Igorbek ने कहा है; हल की गई ठोस चुनौतियों के बारे में थोड़ा और विस्तार के लिए, आपको #16392 में मेरी 'शीर्ष आवश्यक सुविधाओं' की सूची में एक छोटी सूची मिलेगी, जहां मैंने अनसुलझी चुनौतियों को उन प्रस्तावों से जोड़ने का प्रयास किया है जो उन्हें सक्षम कर सकते हैं।

यह भी शामिल है:

• फ़ैक्टरी फ़ंक्शंस जैसे कि एंगुलरजेएस द्वारा उपयोग किया जाता है, यहां मूल पोस्ट में जुड़े तीन धागे देखें। - वास्तव में यह नव निर्मित ReturnType को देखते हुए ठीक होना चाहिए।
• ज्ञात इनपुट को देखते हुए आप अचानक reduce / map / filter / find जैसी चीजों के लिए सटीक रिटर्न प्रकारों की गणना कर सकते हैं - कुछ भी जिसमें पुनरावृत्ति और जांच शामिल है। stdlib.d.ts से वहां लाभ होगा, और इसी तरह एफपी रामदा/लोदश की तरह काम करेगा। व्यवहार में सभी इनपुट ज्ञात नहीं हो सकते हैं (ट्यूपल्स की तुलना में अधिक सूची-जैसे सरणियाँ), लेकिन map और filter ऑब्जेक्ट्स पर संचालन केवल Partial से भी बेहतर टाइप किया जा सकता है। राज्य प्रबंधन पुस्तकालयों जैसे कि रेडक्स (https://github.com/piotrwitek/react-redux-typescript/issues/1 देखें) और एंगुलर के एनजीआरएक्स को बेहतर तरीके से टाइप करने के लिए यह आवश्यक है, जो तब तक अपने उपयोगकर्ता एपीआई को निम्न स्तर पर रखने के लिए मजबूर हैं। क्योंकि एक अच्छी तरह से टाइप किए गए map ऑपरेशन के बिना उनके लिए DRY'er इनपुट डेटा से टाइप स्तर पर वांछित परिणाम की गणना करने का कोई तरीका नहीं है।
• वर्तमान में फंक्शन कंपोजिशन टाइपिंग इनपुट-निर्भर रिटर्न प्रकारों को भी ध्यान में नहीं रख पा रही है।
• यह अचानक लेंस जैसी चीजों को टाइप करना शुरू करने के लिए भी व्यवहार्य बना देगा। - मुझे लगता है कि तकनीकी रूप से यह अभी भी इनपुट-निर्भर रिटर्न प्रकारों के साथ संपादन संचालन पर अवरुद्ध है। जो वास्तव में एक विलासिता है। टुपल्स को बदलने के लिए अभी भी (हिस्सा) # 5453 की जरूरत है।
  यह भी सक्षम बनाता है:
• प्रकार के स्तर पर बूलियन अक्षर पर काम करना, जो अब तक असंभव रहा है
• flatMap के लिए अलिखित प्रकार - जैसे कि promised प्रस्ताव जैसे संचालन
• टाइप/फ़ंक्शन इनपुट के लिए बाधाओं को जोड़ना, # 15347 का विषय और एक विचार जो मुझे 'इदरीस के साथ टाइप-संचालित विकास' पुस्तक से निर्भर प्रकारों पर मिला। यह कहने में मदद कर सकता है कि 0 भाजक को अस्वीकार करें - अनिवार्य रूप से प्रकार से घटाने के लिए एक हैक, #4183 का विषय। मुझे यकीन है कि मैंने अभी तक अधिकांश उपयोग-मामलों की कल्पना नहीं की है, लेकिन यह इसके साथ किया जा सकता है, उदाहरण के लिए function div<B extends number, NotZero = { (v: '1') => 'whatever'; }({ (v: 0) => '0'; (v: number) => '1'; }(B))>(a: number, b: B) । आम तौर पर इदरीस भाषा लंबाई-सुरक्षित वेक्टर/मैट्रिक्स संचालन के साथ विज्ञापन करती है, लेकिन इसकी आवश्यकता केवल उच्च-आदेश कार्यों के लिए होती है।
• उपरोक्त बाधाओं का उपयोग करके इनपुट प्रकारों पर Union<T> / NonUnion<T> बाधाओं को व्यक्त करने का एक तरीका + IsUnion । - उस प्रकार का क्रम टूट गया और मुझे यकीन नहीं है कि इस बारे में अब कैसे जाना है।
• #5453 भी दिया गया है, यह curry , Function.prototype.bind , Promise.all जैसे प्रकार के कार्यों में भी मदद करता है (एक विस्तृत सूची नहीं, केवल कुछ कार्यों को अन्य लोगों ने चुनौतीपूर्ण के रूप में उठाया)।
• switch तर्क #13500 में प्रस्तावित है, यहाँ फ़ंक्शन अधिभार पैटर्न मिलान के माध्यम से हल किया गया है
• वे मैप किए गए सशर्त प्रकार जो #12424 और #17077 ( promised ), उर्फ ​​टाइप-लेवल टाइप चेक का विषय हैं। हालाँकि, यह इसे हल नहीं करेगा - भले ही वह आज कहीं भी बूलियन शाब्दिक उत्पादन के लिए उपयोग करने योग्य हो, जब तक कि इस # 6606 भूमि के पास अभी भी प्रकार के स्तर पर इस तरह के बूलियन शाब्दिक के आधार पर काम करने / करने का कोई तरीका नहीं था। वैसे भी।
• ऑब्जेक्ट प्रकारों पर स्ट्रिंग इंडेक्स उपस्थिति की जांच करना जैसे कि इसे पूरे संचालन में संरक्षित करना (जैसे Omit , Overwrite #12215 से), #12424 में मेरी टिप्पणी देखें
• उपरोक्त स्ट्रिंग इंडेक्स चेक के आधार पर, ऑब्जेक्ट टाइप प्रॉपर्टी एक्सेस को ठीक करने का एक तरीका जैसे कि ऑब्जेक्ट प्रोटोटाइप विधियों (जैसे toString , toLocaleString ) के नामों से मेल खाने वाले स्ट्रिंग्स के लिए जाँच करता है, बल्कि स्ट्रिंग इंडेक्स को हल करेगा प्रोटोटाइप विधियों की तुलना में, संभावित रूप से अन्य सभी प्रकार के संचालन में toString ऑब्जेक्ट एक्सेस से संबंधित गड़बड़ियों को ठीक करना जो पहले ग्लिच्ड बिल्ट-इन ऑब्जेक्ट प्रॉपर्टी एक्सेस पर निर्भर थे।

संपादित करें: लेखन के समय से सशर्त प्रकारों (# 21496) से भरे हुए उपयोग-मामलों को पार कर गया।

@Igorbek का अभिव्यक्ति-प्रथम दृष्टिकोण का प्रस्ताव (उपरोक्त सूची के हिस्से के कुछ अज्ञात अनुप्रयोगों को तोड़ने की कीमत पर - मुझे अभी तक कुछ भी ठोस नहीं सोचना है, हालांकि मुझे एक कोने में चित्रित होने का डर है ) अतिरिक्त रूप से मूल्य और प्रकार स्तरों के बीच के अंतर को बंद करने का वादा करता है, जिसमें वर्तमान में इस फ़ंक्शन एप्लिकेशन (यह #6606), स्प्रेड/रेस्ट (#5453), अभिकथन ऑपरेटर ! (#17370), यूनियन प्रकार जैसी चीजें शामिल हैं। टाइप गार्ड के माध्यम से घटाव (#4183, अन्यथा ऊपर उल्लिखित बाधाओं के माध्यम से प्राप्त किया जा सकता है), और संभवतः अधिक मैं अपने सिर के ऊपर से नहीं सोच सकता।

मुझे लगता है कि यह संपूर्ण व्यापार-बंद कुछ प्रश्न उठा सकता है जैसे सभी समान कार्यक्षमता को दो तरीकों से सुलभ क्यों बनाते हैं (वास्तविक प्रकार स्तर, अभिव्यक्ति स्तर प्रकार स्तर में एम्बेडेड)।

संपादित करें: एक अतिरिक्त संभावित चुनौती के साथ ऊपर मेरी तुलना टिप्पणी को अपडेट किया।

2 संपादित करें:

यहां यह दुर्भाग्यपूर्ण है कि मूल पोस्ट में आपको विश्वास होगा कि यह केवल कुछ किनारे के मामलों को कुछ null & वर्कअराउंड के बिना लिखने की अनुमति देगा, जबकि वास्तव में यह टीएस को अभी वापस रखने वाली महत्वपूर्ण विशेषता है, जिसमें परिवेश के संदर्भों के लिए कोई ज्ञात समाधान नहीं है। .

इसका मतलब है कि यह अलग .d.ts फाइलों में लिखे गए TS को प्रभावित करता है, जो कि न केवल stdlib.d.ts के लिए आदर्श है, बल्कि उनके मूल JS प्रोजेक्ट्स से अलग से लिखे गए सभी DT टाइपिंग के लिए भी है, जो शायद ही कभी बदलने की संभावना है जबकि JS libs फ़्लो जैसे विकल्पों के लिए भी खुला रहना चाहते हैं।

(यह .ts टाइपिंग के लिए बहुत बेहतर नहीं है, उस प्रकार में ओपी के 'वर्कअराउंड' का उपयोग पैरामीटरयुक्त नहीं किया जा सकता है जैसे अभिव्यक्ति स्तर को प्रभावित किए बिना उच्च-स्तरीय पुन: प्रयोज्य प्रकारों में लिखना।)

@ tycho01 सूची के लिए धन्यवाद; वहाँ बहुत सारे लिंक हैं जिन्हें मुझे पचाने की आवश्यकता है। मैं वास्तव में प्रकार पर भी पैटर्न मिलान करना चाहता हूं, और #6606 समस्या का एक अच्छा, व्यावहारिक समाधान है। हालाँकि मुझे ऐसा लगता है कि मूल्य और प्रकार के स्तर पर चीजों के बीच भ्रम बढ़ रहा है, और #6606 इस क्षेत्र में चीजों में सुधार नहीं करेगा।

इस सुविधा की आवश्यकता का कारण यह है कि हमारे पास ऐसे प्रकार के भाव बनाने का कोई तरीका नहीं है जो इसके अनुरूप हों:

• फ़ंक्शन प्रकार का रिटर्न प्रकार, जब कुछ प्रकार के तर्कों के साथ लागू किया जाता है
• ( typeof K[L] से पहले) किसी ऑब्जेक्ट प्रकार पर एक संपत्ति का प्रकार जो एक स्ट्रिंग अक्षर प्रकार की कुंजी से मेल खाता है
• (संभवतः अन्य, मुझे आपकी सूची पर अधिक बारीकी से जाने की आवश्यकता है)

मुझे ऐसा लगता है कि मूल्य-स्तर की संरचनाओं और प्रकार-स्तर के भावों को एक साथ मिलाने का सहारा लिए बिना, इनके लिए विशुद्ध रूप से टाइप स्तर के भाव बनाना संभव होना चाहिए । यह अच्छा होगा यदि (a: A) => B या A | B जैसे प्रकार Func<A, B> , Union<A, B> जैसे साधारण पैरामीट्रिज्ड प्रकारों पर चीनी थे, और हमारे पास पैरामीट्रिज्ड प्रकारों में हेरफेर करने के लिए सामान्य उपकरण थे (HKTs, fundeps या टाइप परिवार, आदि)।

मुझे पता है कि सुदृढ़ता पर अत्यधिक ध्यान टाइपस्क्रिप्ट के लक्ष्यों में से एक नहीं है, लेकिन अब बहुत सी प्रकार-स्तरीय अवधारणाएं हैं जो अपारदर्शी तरीकों से एक साथ बातचीत करती हैं। किसी प्रकार की औपचारिकता, और यांत्रिक नियमों को निर्धारित करने का एक तरीका कि कैसे एक प्रकार अन्य प्रकारों (सबटाइपिंग, डिस्ट्रक्टिंग आदि) के साथ इंटरैक्ट करता है, एक लंबा रास्ता तय करेगा।

मुझे ऐसा लगता है कि मूल्य-स्तर की संरचनाओं और प्रकार-स्तर के भावों को एक साथ मिलाने का सहारा लिए बिना, इनके लिए विशुद्ध रूप से टाइप स्तर के भाव बनाना संभव होना चाहिए ।

ओह, हाँ, मैं व्यक्तिगत रूप से वास्तव में मूल्य-स्तर की संरचनाओं का उपयोग करने का सहारा नहीं लेना चाहता था - यह सब मैं कोशिश कर रहा हूं। यदि मूल्य स्तर अपरिहार्य होता, तो मैं स्वयं यहाँ अभिव्यक्ति-आधारित शिविर में होता। :पी

मुझे लगता है कि मूल्य और प्रकार के स्तर के बीच का अंतर ज्यादातर संकीर्ण होने की उम्मीद है (क्या टीसी39 टीएस की तुलना में तेजी से आगे बढ़ता है?), और अंतराल में पहले से ही उत्कृष्ट प्रकार-स्तर का प्रस्ताव है (मेरी पिछली पोस्ट के नीचे देखें)।

हेक, मुझे एहसास है कि कुछ कार्यों के लिए टाइपिंग का निर्माण अधिकांश उपयोगकर्ताओं के अनुभव से बाहर होगा।
जिस तरह से मैं इसे देखता हूं, मैं चाहता हूं कि मानक पुस्तकालय और एफपी libs इतनी अच्छी तरह से टाइप किए जाएं कि टीएस उपयोगकर्ता उन्हें लिख सकें और उनके लिए अनुमान स्वचालित रूप से ख्याल रखा जा सके।
TS के पास केवल कुछ प्रकार के स्तर के ऑपरेटर हैं, लेकिन उनके साथ वास्तविक समस्याओं को हल करना (प्रमुख उदाहरण #12215 का Overwrite / Omit है) आकस्मिक वेब देवों के लिए रॉकेट साइंस से थोड़ा कम लग सकता है। बिल्ली, यह हमें हाल ही में भी ले गया है, और वे अभी तक प्रोटोटाइप/इंडेक्स/प्रतीक -प्रूफ भी नहीं हैं।

यह अच्छा होगा यदि प्रकार (ए: ए) => बी या ए | फंक , यूनियन जैसे साधारण पैरामीट्रिज्ड प्रकारों पर बी चीनी थे

हम इसे चारों ओर फ़्लिप कर सकते हैं और पैरामीटरयुक्त प्रकार को उपनाम/प्रकार कन्स्ट्रक्टर के रूप में बना सकते हैं। Foo<Bar> लेने वाले एक प्रकार के ऑपरेशन के लिए, इससे कोई फर्क नहीं पड़ता कि आपकी चीज़ एक को सरल बनाती है या नहीं - यह सिर्फ यह जांचता है कि यह विवरण में फिट बैठता है या नहीं।
यह वही है जो stdlib.d.ts करता है -- आपके पास foo[] है, लेकिन यह Array<Foo> विवरण को संतुष्ट करता है और इसलिए इसके Array.prototype टाइपिंग के साथ काम करता है।
ऐसा नहीं है कि वास्तव में मदद करता है हालांकि:

type Union2<A, B> = A | B;
type TuplizeA<Tpl extends Union2<any, any>, A, B> = [Tpl[0], Tpl[1]];
// ^ sorry, no way to access union members through e.g. [0]
// type a = TuplizeA<1 | 2>;
type TuplizeB<Tpl extends any | any> = [Tpl[0], Tpl[1]];
// ^ sorry, no way to access union members through e.g. [0]
// type b = TuplizeB<1 | 2>;
type TuplizeC<Tpl extends Union2<A, B>, A, B> = [A, B];
type c = TuplizeC<1 | 2>;
// ^ need 3 arguments, maybe fixable with #14400
type TuplizeD<Tpl extends A | B, A, B> = [A, B];
// ^ need 3 arguments, maybe fixable with #14400
type d = TuplizeD<1 | 2>;

तो उम हाँ, इसे हल नहीं किया है, लेकिन अभी एहसास हुआ है कि क्यूब का # 14400 वास्तव में वहां मदद कर सकता है। और मैंने आपको आज भी पहले वहाँ देखा था!
वास्तव में कार्यों के लिए वही बात - जो एक अच्छा अनुस्मारक है कि # 14400 न केवल फ़ंक्शन रिटर्न प्रकार बल्कि परम प्रकार भी कर सकता है।

इस दृष्टिकोण को इस समय ओवरलोड का उपयोग करने की आवश्यकता होगी, जो दुर्भाग्यपूर्ण है क्योंकि यह स्केल नहीं करता है, लेकिन हाँ। इसे फिर से सामान्य बनाने के लिए, हम अनिवार्य रूप से इन #6606 पैटर्न-मिलान वाले ओवरलोड का उपयोग विभिन्न प्रकार के एरिटीज़ के लिए सही विकल्प को ट्रिगर करने के लिए करेंगे।
मुझे लगता है कि कोई इसका उपयोग सामान्य रूप से उन्हें टुपल प्रकारों में परिवर्तित करने के लिए कर सकता है, फिर किसी भी तरह से उन पर काम करने के लिए मेरे वेतन वृद्धि दृष्टिकोण का उपयोग करके उन पर पुनरावृति करें।
यूनियनों के लिए मैं टुपल प्रकारों में कनवर्ट करने के लिए एक सुंदर तरीके की उम्मीद कर रहा था। हालांकि यह एक मनमाना आदेश जोड़ देगा, और एक सुंदर वाक्यविन्यास/कीवर्ड के बारे में भी नहीं सोच सकता है।

संपादित करें: उन अभिव्यक्ति/प्रकार स्तर की कार्यक्षमता अंतराल पर फिर से जाने के लिए:

• समारोह आवेदन: यह #6606
• अभिकथन ऑपरेटर ! (#17370): इसके बाद #6606 इसे हल किया जाता है
• टाइप गार्ड के माध्यम से संघ प्रकार घटाव (#4183): ऊपर ! का एक सामान्य मामला, इस #6606 के साथ बाधाओं के माध्यम से भी प्राप्त किया जा सकता है (उदाहरण के लिए NotZero ऊपर)।
• स्प्रेड/रेस्ट (#5453) - भले ही टुपल्स को उस भूमि तक हेरफेर नहीं किया जा सकता है, समान ArrayLike s, मेरे सार में List संचालन देख सकते हैं। इस #6606 के साथ अब मुझे लगता है कि हम अनुपयुक्त कार्यों से पैरा निकाल सकते हैं, हालांकि उन्हें आवेदन के समय निकालने के लिए (यानी उनके सटीक इनपुट मान प्राप्त करने के लिए), अभी भी 5453 की आवश्यकता होगी।

संक्षेप में, अगर यह प्रस्ताव जमीन पर होता, तो मैं कहूंगा कि अभिव्यक्ति और प्रकार के स्तर के बीच एक कार्यक्षमता अंतर यहां अभिव्यक्ति-स्वाद वाले प्रस्ताव की ओर एक बड़ा बड़ा तर्क नहीं देगा। अगर 5453 भी अंदर होते, तो मैं अब वहां किसी के बारे में नहीं सोच सकता था। और ध्यान दें कि दुर्लभ अपवादों के लिए, यहां मूल पोस्ट में उल्लिखित समाधान अभी भी मान्य होगा।

अब, एक तर्क जो अभी भी इसके लिए आसानी से बनाया जा सकता है, वह यह होगा कि अभिव्यक्ति-स्वाद वाले संस्करण के साथ, मिररिंग ऑपरेटरों में टाइप स्तर पकड़ने से पहले, यह कार्यक्षमता जेएस (बिना वर्कअराउंड के) के समान सिंटैक्स के तहत उजागर होगी। सीखने की अवस्था को कम करना।

2 संपादित करें:

मुझे अभी-अभी एहसास हुआ कि अभिव्यक्ति स्तर पर प्रकार लाने की अभिव्यक्ति प्रस्ताव की चाल, 1 as any as MyType , तार्किक रूप से फ़ंक्शन के लिए भी काम करना चाहिए।

इसका शायद यह अर्थ है कि दोनों स्वादों द्वारा सक्षम वास्तविक कार्यक्षमता कुछ हद तक समान लगती है, बाहरी अंतर ज्यादातर typeof myVar (प्रकार स्वाद) बनाम myVar (अभिव्यक्ति स्वाद) से मिलकर कार्य अनुप्रयोग में चर का उपयोग करते हैं; उनमें प्रकारों का उपयोग करने के लिए MyType (प्रकार स्वाद) बनाम 1 as any as MyType (अभिव्यक्ति स्वाद, वैकल्पिक declare let a: any; फिर <MyType>a )।

या तो एएसटी परिवर्तन काफी प्रबंधनीय लगते हैं। अभिव्यक्ति स्वाद को इसके बजाय मूल्य अभिव्यक्ति को इंगित करने के लिए केवल typeof संयोजन की आवश्यकता होती है; टाइप फ्लेवर मौजूदा फंक्शन एप्लिकेशन सिंटैक्स ( fn<T>(arg) ) को एक्सप्रेशन से टाइप लेवल तक कॉपी करेगा, जैसा कि ऊपर रयान द्वारा प्रस्तावित किया गया है।

मुझे लगता है कि यह तब निम्न पर आता है:

अभिव्यक्ति स्वाद के लिए मामला:

• typeof expr TS प्रकार के स्तर के समर्थन के आगे बिना वर्कअराउंड के JS सिंटैक्स के साथ

प्रकार के स्वाद के लिए मामला:

• प्राथमिकता पर कोई ब्रेकिंग परिवर्तन नहीं
• मूल्य अभिव्यक्ति अभी भी वर्कअराउंड के माध्यम से कैप्चर करने योग्य है (या टीएस के माध्यम से यदि ऑपरेटरों को पकड़ने तक अलग-अलग वाक्यविन्यास के तहत)
• MyType के बजाय 1 as any as MyType : आपके अभिव्यक्ति स्तर में आपके प्रकार के स्तर में आपके अभिव्यक्ति स्तर में कोई प्रकार का स्तर नहीं है।

एक संबंधित विषय अब तक यहां अछूता रह गया है कि इस प्रकार-स्तरीय फ़ंक्शन 'एप्लिकेशन' में this बाइंडिंग कैसे प्रदान करें। अब, जेएस प्रतिनिधि इसे Function.prototype विधियों में अधिलेखित कर देते हैं, लेकिन जैसा कि यह खड़ा है, उनमें टाइप स्तर पर इसे संभालने का कोई तरीका नहीं है।

रैंडम उदाहरण सिंटैक्स, एक फ़ंक्शन प्रकार दिया गया F (this: Foo, a: number, b: string) => SomeReturnType जिसे अन्यथा F(MyA, MyB) : F(this: MyFoo, MyA, MyB) के रूप में लागू किया जा सकता है।

this बाइंडिंग को ओवरराइट किए बिना रिटर्न प्रकार की गणना करना अभी भी F(MyA, MyB) जैसा होगा, यह दर्शाता है कि टाइप-लेवल this तर्क को सामान्य रूप से अनदेखा किया जाता है यदि आप इस तरह के फ़ंक्शन का उपयोग करने का प्रयास करते हैं अभिव्यक्ति का स्तर।

इस उदाहरण वाक्य रचना के पेशेवरों:

• घोषणा वाक्य रचना दर्पण

इस उदाहरण वाक्य रचना के विपक्ष:

• घोषणा वाक्य रचना दर्पण

तो, पता चला, यह पहले से ही भाषा में है!

ज्यादा उत्तेजित न हों।

@DanielRosenwasser ने मुझे सिर्फ # 12146 की ओर इशारा किया, एक बग जो शाब्दिक पर फ़ंक्शन कॉल को प्रकारों के स्थान पर उपयोग करने की अनुमति देता है।

_5 मिनट के बाद_

ता दाह! एक भयानक बुरी चीज जिसे हमें कभी भी उत्पादन में उपयोग नहीं करना चाहिए। लेकिन यह लुभावना है ...

interface String {
    passthrough<T>(v: T): T;
}

// All work
type ANumber = "".passthrough(10 * 10);
type AString = "".passthrough("hello" + "world");
type AHelloWorld = "".passthrough("hello world");
type AnArbitraryThing = "".passthrough(Object.assign({hello: "world"}, {foo: "bar"}));
type ThisCraziness = "".passthrough((() => "cows are big dogs"));

~इससे इस मुद्दे पर Effort: Difficult थोड़ा संदिग्ध लग रहा है, ऐसा लगता है कि उन्होंने इसे वहां दुर्घटना से किया था। ~ मैं और पढ़ता हूं और मूर्खतापूर्ण महसूस करता हूं, यह _is_ अच्छी तरह से करना मुश्किल है।

मज़े करो @ tycho01।

@TheOtherSamP मैंने इसे टाइपस्क्रिप्ट 2.4.2 के साथ आजमाया और उन सभी प्रकारों का अनुमान लगाया गया है any ।

@pelotom हुह, यह यहाँ 2.4.2 और 2.5.0-dev.20170803 पर काम कर रहा है। लक्ष्य ES6 और सख्त मोड।

ऐसा लगता है कि उन्होंने अभी-अभी इसे ठीक किया है, मुझे डर है कि यह मेरी गलती हो सकती है। #17628

@TheOtherSamP नहीं, कोई पासा नहीं। ओह अच्छा।

@pelotom यह अजीब है, यह मेरे लिए पूरी तरह से नए प्रोजेक्ट में काम कर रहा है, मुझे नहीं पता कि हमारे सेटअप के बारे में क्या अलग होगा।

@TheOtherSampP : हाहा, यह बहुत मज़ेदार है।
समय-समय पर ऐसा लगता है कि उन्होंने आपकी टिप्पणी से थोड़ा पहले ही इसे ठीक करना शुरू कर दिया था। ओह अच्छा।

@पेलोटॉम :

मैंने टाइपस्क्रिप्ट 2.4.2 के साथ यह कोशिश की और उन सभी प्रकारों का अनुमान लगाया गया है।

उनका स्निपेट खेल के मैदान (2.3.2) में काम करता प्रतीत होता है। इसके बाहर हाल ही के संस्करण पर ( ^2.5.0-dev.20170626 ) मुझे पुन: पेश करने में भी परेशानी हो रही है।

इससे इस मुद्दे पर Effort: Difficult थोड़ा संदिग्ध दिखता है, ऐसा लगता है कि उन्होंने इसे वहां दुर्घटना से किया था।

वे एक प्रकार-आधारित कार्यान्वयन की बात कर रहे थे, जिसका अर्थ कुछ परिवर्तन होगा, जबकि यह अभिव्यक्ति भाषा (-> + , Object.assign , आगे फ़ंक्शन कॉल) का उपयोग करता प्रतीत होता है।

@ tycho01 I _think_ यह सब मेरे द्वारा #7618 में इस ओर ध्यान आकर्षित करने से शुरू हुआ। ओह ठीक है, यह मुझे उत्पादन में इसका उपयोग करने पर अर्ध-गंभीरता से विचार करना सिखाएगा।

वे एक प्रकार-आधारित कार्यान्वयन की बात कर रहे थे, जिसका अर्थ होगा कुछ परिवर्तन, जबकि ऐसा लगता है कि यह अभिव्यक्ति भाषा (-> +, ऑब्जेक्ट.असाइन, आगे फ़ंक्शन कॉल) का उपयोग करता है।

हाँ, मैं एक मूर्ख था और यह कहने के बाद तक इस पूरे मुद्दे को नहीं पढ़ा। यह शर्म की बात है, कि शायद यह सुविधा का एक बेहतर संस्करण है, लेकिन मेरी इच्छा है कि हम इसे अभी प्राप्त कर सकें। मैं टाइप सिस्टम की सीमाओं को बहुत आगे बढ़ाता हूं, और या तो यह या #12424 इतने सारे विकल्प खोलेगा।

#17961 पर एक जनसंपर्क खोला।

@yortus क्या यह 'टाइपोफ़ लिटरल' का कवर केस है?
टाइपस्क्रिप्ट आज "const x: typeof 1 = 1;" लिखने की अनुमति नहीं देता है।

@ एनएन --- मूल प्रस्ताव में सभी अभिव्यक्तियां शामिल हैं, लेकिन जैसा कि मैं इसे 'अनुमोदित' भाग में समझता हूं केवल संपत्ति पहुंच और फ़ंक्शन रिटर्न प्रकार शामिल करता है।

भले ही typeof 1 की अनुमति दी गई हो, मुझे यकीन नहीं है कि यह शाब्दिक प्रकार ( 1 ) या व्यापक प्रकार ( number ) देगा।

टाइपस्क्रिप्ट आज "const x: typeof 1 = 1;" लिखने की अनुमति नहीं देता है।

const x: 1 = 1; क्यों नहीं?

@SaschaNaz मैं कुछ ऐसा लिखना चाहता था

const a = {q:1};
const b = {q:1};
const x: ReadonlyArray<typeof a> = [a,b];

लेकिन समान अक्षर के साथ काम नहीं करता है:

const x: ReadonlyArray<typeof 1> = [1,2,3];

@yortus सटीक प्रकार के बारे में अच्छी बात है। शाब्दिक प्रकारों के बारे में नहीं सोचा ..

@ एनएन ---: मेरा मानना ​​​​है कि आपका उदाहरण पहले से ही काम करता है।

@ tycho01 फ्लो में अब $Call प्रकार है जो रिटर्न प्रकार का फ़ंक्शन प्राप्त करने के लिए है https://github.com/facebook/flow/commit/ac7d9ac68acc555973d495f0a3f1f97758eeedb4

केवल typeof fn(...) की अनुमति नहीं देना typeof की मनमानी अभिव्यक्ति की अनुमति देने जैसा ही होगा?

function fn() {
  return /** whatever expression you like */;
}
type a = typeof fn();

सिवाय इसके कि अब आप एक प्रकार का पता लगाने के अलावा किसी अन्य उद्देश्य के लिए रनटाइम फ़ंक्शन नहीं बना रहे हैं?

ज़रुरी नहीं। आप अभिव्यक्ति का एक प्रकार का मूल्यांकन कर रहे हैं, अभिव्यक्ति का निष्पादन नहीं।

@ dyst5422 typeof fn() वास्तव में अभिव्यक्ति का मूल्यांकन नहीं करेगा, यह आपको केवल रिटर्न प्रकार देगा।

संपादित करें: शायद यही आप कहने की कोशिश कर रहे थे, निश्चित नहीं। लेकिन मुझे लगता है कि @ sky87 बिना किसी उद्देश्य के _defining_ एक फ़ंक्शन के बारे में बात कर रहा था, इसे एक प्रकार की अभिव्यक्ति में उपयोग करने के अलावा, _evaluating_ नहीं।

@dyst5422 , जैसा कि @pelotom ने कहा, मेरा मतलब यह नहीं था कि आप फ़ंक्शन को निष्पादित करेंगे। अधिक विस्तृत करने के लिए: यदि आप typeof की मनमानी अभिव्यक्तियों की अनुमति नहीं देते हैं, लेकिन आप फ़ंक्शन के रिटर्न प्रकार के typeof की अनुमति देते हैं, तो मैं अधिक जटिल प्रकार का पता लगाने के लिए क्या करूंगा भाव उन्हें एक समारोह में लपेटना है ताकि मैं इसके रिटर्न प्रकार के लिए पूछ सकूं। यह रनटाइम पर एक फ़ंक्शन बनाता है, हालांकि इसे रिटर्न प्रकार प्राप्त करने के लिए, और यह लिखने के लिए अधिक बॉयलरप्लेट है।

संपादित करें: आप वास्तव में पहले से ही मनमानी अभिव्यक्तियों के प्रकार का पता लगा सकते हैं, यह बदसूरत है लेकिन काम करता है

const dummy = (false as true) && /* arbitrary exp */;
type TypeOfExp = typeof dummy;

मैं ईमानदारी से नहीं जानता कि मैं कौन सा हैक पसंद करूंगा। मुझे लगता है कि typeof का उपयोग करके सीधे प्रकार के लिए पूछने में सक्षम होना सबसे अच्छी बात होगी।

आह, मैं अब अनुसरण करता हूं। हाँ, मुझे लगता है कि जाने का बेहतर तरीका इसका उपयोग करने में सक्षम होना होगा

type TypeOfExp = typeof (
  false &
  "false" &
  0
)

मनमाने ढंग से अभिव्यक्ति प्रकार मूल्यांकन करने में सक्षम होने के लिए

क्या new आमंत्रण के रिटर्न प्रकार से पूछताछ करना संभव होगा? मेरा उपयोग मामला: मैं एक फ़ंक्शन के लिए टाइप एनोटेशन लिखना चाहता हूं जो किसी भी PromiseConstructorLike कार्यान्वयन (जैसे $q या ब्लूबर्ड) के संदर्भ को स्वीकार करता है और उस कार्यान्वयन द्वारा निर्मित एक वादा देता है।

declare function wait<P extends PromiseConstructorLike>(time: number, implementation: P): typeof new implementation<void>((res: any, rej: any) => void);

const bluebirdPromise = wait(1e3, Bluebird);
// typeof bluebirdPromise should be instance of Bluebird

क्या typeof के बिना रिटर्न प्रकारों के लिए पूछताछ करना संभव होगा, या हमें null as FnType करना होगा?

interface Fn {
    (a: string): string;
    (a: number): boolean;
}
type Ret = Fn(number); // Ret = boolean
type Ret = typeof (null as Fn)(number);

क्षमा करें यदि इन प्रश्नों का उत्तर पहले ही दिया जा चुका है; मैं उन्हें नहीं ढूंढ सका।

यहाँ new का क्या मतलब है, क्या आप केवल typeof implementation() नहीं चाहेंगे?

नहीं, क्योंकि implementation() एक वैध कॉल नहीं है। PromiseConstructorLike केवल new के माध्यम से, इसके प्रकार की घोषणाओं के अनुसार लागू किया जा सकता है। typeof implementation() एक प्रकार की त्रुटि है, ठीक उसी तरह जैसे (typeof implementation)['foobar'] एक प्रकार की त्रुटि होगी।

खेल का मैदान लिंक

क्या फ़्लोटाइप ने क्या किया जैसे अनुमानित सामान्य प्रकारों को पेश करना संभव है? कम से कम, यह फ़ंक्शन के रिटर्न वैल्यू के प्रकार को प्राप्त करने की समस्या को हल कर सकता है।

type _ExtractReturn<B, F: (...args: any[]) => B> = B;
type ExtractReturn<F> = _ExtractReturn<*, F>;

@Cryrivers : उस दृष्टिकोण के लिए #14400 देखें। यह वास्तव में उस समस्या को हल नहीं करता है जहां आउटपुट प्रकार इनपुट पर निर्भर करता है।

यह संकेत देने के लिए आज फिर से इसकी आवश्यकता समाप्त हो गई कि किसी फ़ंक्शन पर कॉल गतिशील रूप से वापस आ जाएगी, निश्चित रूप से इसे प्राथमिकता मिलेगी।

सशर्त प्रकारों द्वारा संचालित TS 2.8 में ReturnType<T> ऑपरेटर को lib.d.ts में जोड़ा जा रहा है।

चूंकि ReturnType<T> को अभी तक तर्क प्रकारों पर निर्भर रिटर्न प्रकारों को ध्यान में रखना है, संदर्भ के लिए, यहां फ़्लो का $Call प्रकार कार्यान्वयन है।

संपादित करें: क्षमा करें @goodmind , मुझे नहीं पता था कि आप पहले से ही उससे जुड़े हुए हैं।

मैंने हाल ही में टीएस परिवर्धन के आधार पर इस प्रस्ताव (या इसके प्रकार कॉल व्याख्या) के उपयोग-मामलों की अपनी पिछली पोस्ट को अपडेट किया।
पैटर्न मिलान उपयोग-मामलों को अब #21496 द्वारा कवर किया गया है,... वे मामले जहां हम उपयोगकर्ता द्वारा प्रदान किए गए लैम्ब्डा के आधार पर प्रकारों की गणना करना चाहते हैं, उदाहरण के लिए curry , फ़ंक्शन संरचना, map , reduce , लैम्ब्डा पर आधारित लेंस संपादन... मजेदार सामग्री। :)

पीएस @ कांटा0 : मुझे लगता है कि आपका कोणीय उपयोग-मामला अब ReturnType (#21496) से भरा जा सकता है!

मुझे लगता है कि इस अभिव्यक्ति को अनुमति देकर इसे कवर किया जाना चाहिए।
प्रोप2: टाइपऑफ़ this.prop1.big.complex;

@mhegazy क्या इसे ट्रैक करने के लिए कोई अलग समस्या है?
यह कष्टप्रद है कि टाइपोफ़ स्थानीय लोगों के लिए काम करता है, लेकिन गुणों के लिए नहीं, जबकि स्थैतिक गुणों के लिए काम करता है।

class A {
    x: number;
    static y: number;
    f() {
        const a: number = 1;
        const b: typeof a = 2; // OK
        const c: this.x = 3; // No :(
        const d: this['x'] = 3; // OK
        const e: typeof A.y = 4 // OK
    }
}

@ एनएन --- आप इसके लिए हमेशा अनुक्रमित प्रकारों का उपयोग कर सकते हैं:

this['x']

@ कैमरून-मार्टिन काम नहीं करता। खेल का मैदान

@ tycho01 नए प्रकार के अनुमान और सशर्त भयानक हैं, लेकिन यह भी बहुत कष्टप्रद है कि वे फ़ंक्शन ओवरलोडिंग के लिए काम नहीं करते हैं। कारण दिया गया था कि फ़ंक्शन प्रकार को संभावित लोगों में से हल करने के लिए इसे typeof की तरह कुछ चाहिए।

@NN बस const d: this['x'] = 3; . का उपयोग करें

ओह अच्छा :)

@ एनएन --- या उपयोग करें

class A {
    x: number;
    static y: number;
    f() {
        const self = this;
        const a: number = 1;
        const b: typeof a = 2; // OK
        const c: typeof self.x = 3; // OK
        const d: typeof self['x'] = 3; // OK
        const e: typeof A.y = 4 // OK
    }
}

@tsofist मुझे पता है कि स्थानीय काम करता है, लेकिन मुझे यह बदसूरत लगता है।
यह अंतर्निहित कैप्चर के साथ लैम्ब्डा का उपयोग करने के बजाय 'फ़ंक्शन() {}' कॉलबैक के लिए मैन्युअल बचत 'यह' जैसा ही है।

@एनएन

यह बदसूरत।

हाँ, यह सिर्फ एक विकल्प है :)

सशर्त प्रकार अब इसे काफी हद तक अप्रासंगिक बनाते हैं क्योंकि आप विशिष्ट अन्य उपनामों के साथ ReturnTypeOf<T> लिख सकते हैं यदि आप तर्कों के एक विशेष सेट को मान्य करना चाहते हैं। वे ओवरलोड रिज़ॉल्यूशन नहीं कर सकते हैं, लेकिन हमें नहीं लगता कि यह सुविधा केवल उस उपयोग के मामले में जटिलता के लायक है।

@RyanCavanaugh मेरा मानना ​​​​है कि आपका मतलब ReturnType<T> है?

@RyanCavanaugh जो दुर्भाग्यपूर्ण है - अधिभार संकल्प वह है जो मुझे वास्तव में चाहिए था। क्या सशर्त/अनुमान प्रकारों में ओवरलोड रिज़ॉल्यूशन जोड़ने को ट्रैक करने के लिए कोई और समस्या है?

आपको इसे लिखने में सक्षम होना चाहिए:

type Return1<A1, T extends (a: A1) => any> = T extends (a: A1) => infer R ? R : any;
type Return2<A1, A2, T extends (a: A1, a: A2) => any> = T extends (a: A1, a: A2) => infer R ? R : any;

declare function something(a: number): number;
declare function something(a: string): string;
declare function something(a: number, b: string): boolean;

type A = Return1<number, something>; // number
type B = Return1<string, something>; // string
type C = Return2<number, string, something>; // boolean

हालांकि मैंने इसका परीक्षण नहीं किया है, और आपको प्रत्येक संख्या के तर्कों के लिए एक अलग सहायक की आवश्यकता होगी।

@ForbesLindesay : something वर्तमान में एक अभिव्यक्ति-स्तर चर है - इसे संदर्भित करना उदाहरण के लिए typeof यहां (या इसे एक इंटरफ़ेस के रूप में घोषित करना) इसे ठीक करता है। मैं वास्तव में इसे उचित रिटर्न प्रकार प्राप्त करने के लिए प्रबंधन नहीं कर रहा हूं (हालांकि 2.8.0-dev.20180318 पर)।

@ForbesLindesay दुर्भाग्य से मुझे विश्वास नहीं है कि काम करता है; अनुमान तंत्र _last_ विधि अधिभार का चयन करेगा:

type Funcs = ((p1: string, p2: string) => void) & ((p1: number) => void);

type FuncPromise1<T> = T extends (p1: infer P1) => void ? (p1: P1) => Promise<[P1]> : never;
type FuncPromise2<T> = T extends (p1: infer P1, p2: infer P2) => void ? (p1: P1, p2: P2) => Promise<[P1, P2]> : never;

let foo: FuncPromise1<Funcs> & FuncPromise2<Funcs>;

हालांकि , अनुमान तंत्र _is_ टपल यूनियनों से निपटने में सक्षम है:

type Tuples = [string, string] | [number];

type TuplePromise1<T> = T extends [infer P1] ?  (p1: P1) => Promise<[P1]> : never;
type TuplePromise2<T> = T extends [infer P1, infer P2] ? (p1: P1, p2: P2) => Promise<[P1, P2]> : never;

let foo: TuplePromise1<Tuples> & TuplePromise2<Tuples>;

हो सकता है कि हमें ओवरलोड -> ऑब्जेक्ट, और फ़ंक्शन -> ऑब्जेक्ट, अलिखित करने की अनुमति देने के लिए कुछ चाहिए। वहां टाइप मैपिंग और इंट्रेंस करें, फिर एक फंक्शन और ओवरलोड में बैक अप लें।

@MeirionHughes :

हो सकता है कि हमें ओवरलोड -> ऑब्जेक्ट, और फ़ंक्शन -> ऑब्जेक्ट, अलिखित करने की अनुमति देने के लिए कुछ चाहिए। वहां टाइप मैपिंग और इंट्रेंस करें, फिर एक फंक्शन और ओवरलोड में बैक अप लें।

जैसे (a: number, b?: string) => boolean -> { a: number, b?: string } ? हम अभी तक उस तरह के परम नाम नहीं प्राप्त कर सकते हैं, लेकिन अवधारणात्मक रूप से यह बाकी पैराम ( (a: number, ...b: string[]) => boolean ) के लिए कठिन हो जाता है, क्योंकि हम ऑर्डर करने के लिए ऑब्जेक्ट प्रकारों का उपयोग नहीं कर सकते हैं।

ऑर्डर शायद नामों से ज्यादा मायने रखता है, और हम पैराम्स और टुपल्स के बीच कनवर्ट कर सकते हैं। स्प्रेड/वैकल्पिक अभी भी इसे थोड़ा जटिल कर सकते हैं।

इससे ओवरलोड निकालने की समस्या कम हो जाती है। ओवरलोड ((a: number) => 123) & ((s: string) => 'hi') जैसे फ़ंक्शन प्रकारों का एक प्रतिच्छेदन होना चाहिए, इसलिए समस्या यह है कि एक चौराहे प्रकार (उदाहरण के लिए एक टपल प्रकार) को कैसे 'खोलें' - अभी तक, हमारे पास वह नहीं है।

मुझे यह पथ असंतोषजनक लगता है क्योंकि यह अधिभार उपयोग-मामले को संबोधित करेगा, फिर भी जेनरिक नहीं कहेगा, लेकिन हाँ। चौराहा खोलना अभी भी किसी भी तरह से एक अंतर था।

चूंकि यह मुद्दा अब बंद हो गया है, क्या अब भी उन हिस्सों के लिए कोई नया प्रस्ताव है जो अभी भी गायब हैं? तर्कों के आधार पर वापसी प्रकार से निपटने के तरीके की तरह?

चूंकि यह मुद्दा अब बंद हो गया है, क्या अब भी उन हिस्सों के लिए कोई नया प्रस्ताव है जो अभी भी गायब हैं?

कोई नहीं जिससे मैं अवगत हूं।

तर्कों के आधार पर वापसी प्रकार से निपटने के तरीके की तरह?

ऐसा नहीं लगता कि हमारे पास कॉल प्रकारों को ट्रैक करने में कोई समस्या है।

क्या केवल टाइप लेवल फंक्शन एप्लिकेशन जोड़ने के विचार के लिए प्रारंभिक समर्थन है? मैं उसके लिए एक प्रस्ताव लिख सकता था। वाक्य रचनात्मक रूप से मुझे लगता है कि यह सबसे आसान रास्ता है।

type MyType<A> = {
    foo: A
}

type Wrap = {
    <T>(maybe: MyType<T>): MyType<T>;
    (maybe: any): MyType<any>;
}

type Naive = ReturnType<Wrap>; // Naive = { foo: any }
type Proposed1 = Wrap(maybe: number); // Proposed1 = { foo: number }
type Proposed2 = Wrap(maybe: MyType<number>); // Proposed2 = { foo: number }
type Proposed3 = (<T>(maybe: T) => MyType<T>)(maybe: number) // Proposed3 = { foo: number }

किनारे के मामले:

const foo = <T>(a: T) => T:

type Edge1 = (typeof foo)(a: number) // Probably trivial?

type Foo = {
    <T>(a: string): T
}

type Edge2 = Foo<number>(a: string) // Should this be allowed? Probably not, because:

type Bar<A> = {
    (a: string): A
}

type Edge3 = Bar<number>(a: string) // Things are getting strange

interface Baz<A> {
    <T>(a: T): T | A
}

type Edge4 = Baz<number>(a: string) // What is this?

क्या केवल टाइप लेवल फंक्शन एप्लिकेशन जोड़ने के विचार के लिए प्रारंभिक समर्थन है? मैं उसके लिए एक प्रस्ताव लिख सकता था। वाक्य रचनात्मक रूप से मुझे लगता है कि यह सबसे आसान रास्ता है।

फिलहाल नहीं। हम वास्तव में उच्च-क्रम-प्रकार के स्थान में अधिभार संकल्प नहीं रखना चाहते हैं; प्रक्रिया बल्कि शामिल है, और इसमें प्रकार के मापदंडों का अनुमान लगाने के लिए कई पास शामिल हैं, और प्रासंगिक रूप से तर्क, आदि। समय है।

# 24897 में हालिया काम को देखते हुए @mhegazy ने इस पर टीम का रुख बिल्कुल बदल दिया है ??

ऐसा लगता है कि ऐसे कुछ मुद्दे हैं जिनके समाधान को $Call प्रकार तक कम किया जा सकता है, और $Call प्रकार उच्च-प्रकार के प्रकारों का अनुकरण करने के अपेक्षाकृत सरल तरीके से द्वार खोल देगा; उदाहरण के लिए https://gist.github.com/hallettj/0fde5bd4c3ce5a5f6d50db6236aaa39e देखें ( $PropertyType और $ObjMap के उपयोग को $#$ $Call $#$ से बदलें)। संपादित करें: अतिरिक्त उदाहरण: https://github.com/facebook/flow/issues/30#issuecomment -346674472

इस तरह की सुविधा यकीनन कई समस्याओं के लिए एक उचित सामान्य समाधान खोजने के टाइपस्क्रिप्ट के ट्रैक रिकॉर्ड के अनुरूप होगी, नहीं?

सशर्त प्रकार अब इसे काफी हद तक अप्रासंगिक बनाते हैं क्योंकि आप विशिष्ट अन्य उपनामों के साथ ReturnTypeOf<T> लिख सकते हैं यदि आप तर्कों के एक विशेष सेट को मान्य करना चाहते हैं। वे ओवरलोड रिज़ॉल्यूशन नहीं कर सकते हैं, लेकिन हमें नहीं लगता कि यह सुविधा केवल उस उपयोग के मामले में जटिलता के लायक है।

@RyanCavanaugh @mhegazy

मैं सहमत हूं कि सशर्त प्रकारों का उपयोग करके चीजें करना संभव है। मुझे लगता है कि अगर हम User.avatar से User extends { avatar: infer T } ? T : never को फिर से लिखेंगे तो यह कंपाइलर में बहुत अधिक जटिलता नहीं लाएगा? तो उदाहरण के लिए हम लिख सकते हैं

export type Avatar = User extends { avatar: infer T } ? T : never;

जैसा

export type Avatar = User.avatar;

पठनीयता में सुधार करने के लिए।

पूरा उदाहरण

मान लीजिए कि हम कुछ डेटा लोड और रूपांतरित करते हैं, और एक फ़ंक्शन के साथ समाप्त करते हैं findUser इस तरह

export function findUser() {
  return {
    username: 'johndoe',
    avatar: {
      lg: '1.jpg',
      s: '2.jpg'
    },
    repos: [
      {
        name: 'ts-demo',
        stats: {
          stars: 42,
          forks: 4
        },
        pull_requests: [
          { date: '2019-08-19', tags: ['bug', 'agreed-to-cla'] },
          { date: '2019-08-10', tags: ['bug', 'includes-tests'] },
          { date: '2019-08-07', tags: ['feature'] }
        ]
      }
    ]
  };
}

मैप किए गए प्रकारों से अनुमान के लिए धन्यवाद, हम इस प्रकार के फ़ंक्शन से प्रकार निकाल सकते हैं:

export type User = ReturnType<typeof findUser>;
export type Avatar = User extends { avatar: infer T } ? T : never;

सुझाव: यह उसी चीज़ का मूल्यांकन करना चाहिए

export type Avatar = User.avatar;

इसके अतिरिक्त, हम यह भी कह सकते हैं कि User.avatar प्रकार का नहीं होना चाहिए never ।

और ज्यादा उदाहरण

export type Repositories = User extends { repos: infer T } ? T : never;
export type Repository = User extends { repos: (infer T)[] } ? T : never;
export type RepositoryStats = Repository extends { stats: infer T } ? T : never;
export type PullRequests = Repository extends { pull_requests: (infer T)[] } ? T : never;
export type PullRequest = Repository extends { pull_requests: (infer T)[] } ? T : never;
export type Tags = PullRequest extends { tags: infer T } ? T : never;
export type Tag = PullRequest extends { tags: (infer T)[] } ? T : never;

export type Repositories = User.repos;
export type Repository = User.repos[];
export type RepositoryStats = User.repos[].stats;
export type PullRequests = User.repos[].pull_requests;
export type PullRequest = User.repos[].pull_requests[];
export type Tags = User.repos[].pull_requests[].tags;
export type Tag = User.repos[].pull_requests[].tags[];

नेस्टेड संपत्ति को एक बार में मैप करते समय, यह बहुत स्पष्ट नहीं है कि क्या हो रहा है

export type Tag2 = User extends { repos: { pull_requests: { tags: (infer T)[] }[] }[] } ? T : never;

इससे बहुत कुछ साफ हो जाएगा

export type Tag = User.repos[].pull_requests[].tags[];

कोने का मामला

export class Hello {
  static world = 'world';
  world = 42;
}

export type ThisWillBeANumber = Hello extends { world: infer T } ? T : never;
export type ThisWillBeANumber = Hello.world;

export type ThisWillBeAString = (typeof Hello) extends { world: infer T } ? T : never;
export type ThisWillBeAString = (typeof Hello).world;

@lukaselmer ऐसा लगता है जैसे आप बस चाहते हैं

export type Avatar = User["avatar"];

जो आज काम करता है

@lukaselmer ऐसा लगता है जैसे आप बस चाहते हैं

export type Avatar = User["avatar"];

जो आज काम करता है

ठीक यही मैं ढूंढ रहा था। मैं इसे प्रलेखन में खोज रहा था, लेकिन यह नहीं मिला। शुक्रिया!

क्या यह पुस्तिका का हिस्सा है, या यह कैसे काम करता है इस पर कोई आधिकारिक दस्तावेज है? मैं इसका उपयोग करने के तरीके से काफी परिचित हूं, लेकिन जब मैं लोगों को दस्तावेज़ीकरण के लिए निर्देशित करने का प्रयास करता हूं, तो मुझे केवल टाइपऑफ गार्ड मिल सकते हैं, जो वास्तव में पूरी तरह से अलग है

इसलिए, मैंने देखा है कि यह प्रस्ताव 2015 के आसपास बाउंस हो गया था और मूल लक्ष्यों में से एक किसी भी तरह एक इंटरफ़ेस की एकल संपत्ति का प्रकार प्राप्त करना था।

interface a {
 foo: bar;
 /* more types */
}

const example = (fooNeeded: [magic] a.foo ) => {};

क्या मैं यह मानने के लिए सही हूं कि 5 साल बाद भी यह संभव नहीं है?

@MFry मुझे लगता है कि आप इस सिंटैक्स की तलाश कर रहे हैं: a['foo']

क्या हम जानते हैं कि क्या अभी तक इसका कोई समाधान है?

मैं कुछ इस तरह पाने की कोशिश कर रहा हूँ:

declare function something<A, B>(): void;

type Payload = string;

const hello = something<{}, Payload>();

declare function doThing<T extends ReturnType<typeof something>>(arg: T): { payload: unknown };

doThing(hello).payload === 123; // this should validate to a string aka type Payload

https://www.typescriptlang.org/play/index.html?ts=4.0.0-dev.20200512#code/CYUwxgNghgTiAEAzArgOzAFwJYHtXwGccBbEDACy1QHMAeAQQBp4AhAPgAoBKALngDccWYAG4AUGIwBPAA4IAClCkQcUYPAC8hDDCrVxYsHgIZ45EBBWbCJMpRq0A3gF9mi5auCcuB0JFgIKOjYePDAOAAq9nQR8CAAHhggqMAE8ABKZMgwqBGyILTScjiINqQUemycsNR8EbzwjvAySipqfGgA1qg4AO74zr6R0RzmljhcAHQtHmqaGloAjABMAMwi8AD0m -AVaQTkOMgQ6vxQEMJQSbs48FDaujR3nfdFCq2eYkA

हाय @maraisr मैं 100% निश्चित नहीं हूं कि आप क्या हासिल करने की कोशिश कर रहे हैं। आपके उदाहरण में something दो प्रकार लेता है लेकिन उनका उपयोग नहीं करता है, और hello किसी चीज का वापसी मूल्य है जो हमेशा void होगा; तो doThing कभी भी किसी भी बिंदु पर string प्रकार नहीं देखता है।

शायद नीचे जैसा कुछ आप चाहते हैं?

declare function something<ReturnType>(): ReturnType;

type Payload = string;

const hello = () => something<Payload>();

declare function doThing<F extends () => any>(f: F): { payload: ReturnType<F> };

doThing(hello).payload === 'a string';

आह हाँ - इसके लिए खेद है। तत्पर जवाब के लिए धन्यवाद!! :100: @ acutmore

void केवल यह इंगित करने के लिए था कि उस फ़ंक्शन का रिटर्न टाइप अप्रासंगिक है। वे 2 प्रकार अन्य सामान्य प्रकारों पर अग्रेषित हो जाते हैं, जो अंततः तर्कों में उपयोग किए जाते हैं।

कुछ इस तरह:

declare function something<A, B>(a: MyComplexGeneric<A>, b: B[]): { somethingA: number, somethingB: number };

// Those 2 generics influence the return object so they do get used as such. And the 2 arguments are roughly that. Its an object and an array, more-or-less. 

मेरा doThing फ़ंक्शन वास्तव में परवाह नहीं करता है कि पहला ( A ) जेनेरिक क्या है, लेकिन यह परवाह करता है कि दूसरा ( B ) क्या है।

देखें कि something मेरे अपने उपयोगकेस में एक साइड इफेक्ट करता है जो doThing द्वारा पढ़ा जाता है।

तो मैं बस किसी फ़ंक्शन का रिटर्न टाइप नहीं प्राप्त कर सकता - मुझे किसी भी तरह से बनाए गए फ़ंक्शन के जेनेरिक को चूसने की ज़रूरत है।

अगर आपको लगता है कि यह प्रश्न इस मुद्दे के दायरे से बाहर है, तो स्टैक ओवरफ्लो पर मेरी यात्रा जारी रखें!

@maraisr अतिरिक्त जानकारी के लिए धन्यवाद।

यदि आप doThing को $#$ something $#$ से मूल B प्रकार प्राप्त करने में सक्षम होना चाहते हैं तो इसे किसी भी तरह से hello में पारित करने की आवश्यकता है। टाइपस्क्रिप्ट केवल hello को देख रहा है और कुछ मदद के बिना यह नहीं जान पाएगा कि यह something का रिटर्न प्रकार है।

यह एक तरीका है जिससे यह किया जा सकता है:

/** Create a type that can store some extra type information **/
interface SomethingResult<T> {
    __$$__: T;
    somethingA: number;
    somethingB: number;
}

declare function something<A, B>(): SomethingResult<B>;

type Payload = string;

const hello = something<{}, Payload>();

declare function doThing<Result extends SomethingResult<any>>(arg: Result): { payload: Result['__$$__'] };

doThing(hello).payload === 1123; // error because `payload` is of type string

interface User {
  avatar: string;
}

interface UserData {
  someAvatar: User['avatar'];
}

@RyanCavanaugh यह बंद क्यों है? सशर्त प्रकार इसे और कई अन्य उपयोग के मामलों को हल नहीं करते हैं, और यदि यह विलय हो जाता है तो यह बहुत सी चीजें संभव बना देगा।

मैं ऐसे फ़ंक्शन पर काम कर रहा हूं जो किसी भी विधि कॉल को "पॉइंट-फ्री" संस्करण में बदल सकता है (उदाहरण: [].map(() => n > 5) map(() => n > 5)([]) में बदल जाता है और केवल एक चीज गायब है सशर्त प्रकार और infer जेनेरिक का पता नहीं लगा सकता है, इसलिए सामान्य कार्यों में कुछ प्रकार unknown के रूप में सामने आएंगे।

अगर मैं प्रकार ( typeof myFunc(() => Either<string,number>) ) प्राप्त करने के लिए कार्यों को "कॉल" कर सकता हूं, तो यह कार्यक्षमता (जो वर्तमान में असंभव है) होना संभव होगा, और कई अन्य चीजों को करना आसान हो जाएगा (एचकेटी, आदि .. ।)

क्या $Call एक फ़ंक्शन (जैसे प्रवाह में) में सक्षम होने के लिए जटिलता बहुत अधिक है? मुझे लगता है कि टाइपस्क्रिप्ट पहले से ही इसे स्वचालित रूप से करता है।

@nythrox हमें नहीं लगता कि वाक्यात्मक भ्रम जो इससे हो सकता है, उन मामलों से अधिक है जहां आपको किसी प्रकार के लिए इसकी आवश्यकता होती है। कॉल एक्सप्रेशन को हल करने का विशिष्ट मामला कहीं और ट्रैक किया जाता है; ओपी में "किसी भी अभिव्यक्ति की अनुमति दें" का प्रस्ताव ऐसा कुछ नहीं है जो हमें लगता है कि भाषा के लिए उपयुक्त होगा।

@RyanCavanaugh ओह ठीक है, मैं समझता हूँ। प्रतिक्रिया के लिए धन्यवाद, क्या आप जानते हैं कि फ़ंक्शन कॉल को हल करने में कौन सी समस्याएं ट्रैक कर रही हैं?

मैंने थोड़ी खोज की है और फ़ंक्शन कॉल उपयोगिता प्रकार के लिए कोई समस्या नहीं मिली है; मुझे जो मिला उसका एकमात्र संदर्भ # 20352 में था, जो अभी इस मुद्दे से जुड़ा हुआ है।

कॉल एक्सप्रेशन को हल करने का विशिष्ट मामला कहीं और ट्रैक किया जाता है

@RyanCavanaugh मन कहीं और से जुड़ रहा है? मैं

@tjjfvi #37181 किसी फ़ंक्शन को उसके इनपुट के आधार पर हल करने के बारे में अधिक विशिष्ट है। हो सकता है कि आप जो खोज रहे हैं।

@acutmore जो कुछ मैं ढूंढ रहा था उसके साथ कुछ हद तक है, हालांकि मैं विशेष रूप से प्रवाह-एस्क्यू $Call उपयोगिता, या अन्य वाक्यविन्यास के बारे में बात कर रहा था ताकि इसे लागू करने में सक्षम हो। सुझाव दिया गया दृष्टिकोण अजीब है, लेकिन लिंक के लिए धन्यवाद।