Typescript: फेसबुक फ्लो टाइप सिस्टम के साथ तुलना

यह दिलचस्प और अधिक चर्चा के लिए एक अच्छा प्रारंभिक बिंदु है। क्या आपको बुरा लगता है अगर मैं स्पष्टता के लिए मूल पोस्ट में कुछ प्रतिलिपि किए गए परिवर्तन करूँ?

फ्लो में अनपेक्षित चीजें (इस टिप्पणी को अपडेट कर रहा हूं क्योंकि मैं इसकी अधिक जांच करता हूं)

विषम फ़ंक्शन तर्क प्रकार निष्कर्ष:

/** Inference of argument typing doesn't seem
    to continue structurally? **/
function fn1(x) { return x * 4; }
fn1('hi'); // Error, expected
fn1(42); // OK

function fn2(x) { return x.length * 4; }
fn2('hi'); // OK
fn2({length: 3}); // OK
fn2({length: 'foo'}); // No error (??)
fn2(42); // Causes error to be reported at function definition, not call (??)

वस्तु शाब्दिकों से कोई प्रकार का अनुमान नहीं:

var a = { x: 4, y: 2 };
// No error (??)
if(a.z.w) { }

यह दिलचस्प और अधिक चर्चा के लिए एक अच्छा प्रारंभिक बिंदु है। क्या आपको बुरा लगता है अगर मैं स्पष्टता के लिए मूल पोस्ट में कुछ प्रतिलिपि किए गए परिवर्तन करूँ?

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

@RyanCavanaugh मुझे लगता है कि अंतिम उदाहरण:

var a = { x: 4, y: 2 };
// No error (??)
if(a.z.w) { }

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

है

type A = () => void & (t: string) => void
var func : A;

के बराबर

Declare A : () => void | (t: string) => void
var func : A;

या हो सकता है?

@ डेविडसनसन 90 वास्तव में नहीं:

declare var func: ((t: number) => void) | ((t: string) => void)

func(3); //error
func('hello'); //error

इस उदाहरण में प्रवाह यह जानने में असमर्थ है कि संघ में कौन सा प्रकार func है इसलिए यह दोनों ही मामलों में त्रुटि की रिपोर्ट करता है

declare var func: ((t: number) => void) & ((t: string) => void)

func(3); //no error
func('hello'); //no error

func में दोनों प्रकार होते हैं इसलिए दोनों कॉल मान्य हैं।

टाइपस्क्रिप्ट में {} और mixed बीच कोई भी अवलोकन अंतर है?

@RyanCavanaugh मुझे वास्तव में नहीं पता है कि मुझे लगता है कि मुझे लगता है कि यह अभी भी इसके बारे में सोच रहा है।

mixed पास कोई गुण नहीं है, यहां तक ​​कि ऑब्जेक्ट भी नहीं हैं। जो ऑब्जेक्ट Object.prototyp से विरासत में मिला है कि {} में (# 1108) यह गलत है।

एक और अंतर यह है कि फ्लो प्रकार की धारणा को पीछे की ओर टाइप करता है ताकि इनफर्ड टाइप को एक प्रकार के संघ में विस्तृत किया जा सके। यह उदाहरण https://github.com/facebook/flow/issues/67#issuecomment -64221511 से है

class A { x: string; }
class B extends A { y: number; }
class C extends A { z: number; }

function foo() {
    var a = new B();
    if (true) a = new C(); // TypeScript reports an error, because a's type is already too narrow
    a.x; // Flow reports no error, because a's type is correctly inferred to be B | C
}

("सही ढंग से" मूल पोस्ट से है।)

इसका मतलब है कि निम्नलिखित भी संकलन करेंगे।

var x = "5"; // x is inferred as string
if ( true) { x = 5; } // Inferred type is updated to string | number
x.toString(); // Compiles
x += 5; // Compiles. Addition is defined for both string and number after all, although the result is very different

संपादित करें: दूसरे स्निपेट का परीक्षण किया और यह वास्तव में संकलन करता है।
संपादित करें 2: जैसा कि नीचे @fdecampredon द्वारा बताया गया है, दूसरे असाइनमेंट के आसपास if (true) { } के लिए string | number रूप में फ़्लो का अनुमान लगाना आवश्यक है। if (true) number बजाय यह

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

उसी तर्क से मैं इस व्यवहार की उम्मीद करूंगा:

declare function foo<T>(x:T, y: T): T;
var r = foo(1, "a"); // no problem, T is just string|number

लेकिन मैं वास्तव में वह व्यवहार नहीं चाहता हूं।

@danquirk मैं इनफ़ॉर्म करना ऐसा व्यवहार नहीं है जो मुझे पसंद है।
लेकिन मुझे लगता है कि यह प्रवाह दर्शन से आता है, एक वास्तविक भाषा से अधिक, प्रवाह टीम बस एक प्रकार की चेकर बनाने की कोशिश करती है, उनका अंतिम लक्ष्य किसी भी प्रकार के एनोटेशन के बिना 'सुरक्षित' कोड बनाने में सक्षम होना है। यह कम सख्त होता है।

इस तरह के व्यवहार के प्रभावों को देखते हुए सटीक सख्ती पर भी बहस होती है। अक्सर यह सिर्फ एक त्रुटि को स्थगित कर रहा है (या एक पूरी तरह से छिपा रहा है)। प्रकार के तर्कों के लिए हमारे पुराने प्रकार के अनुमान नियमों ने एक समान दर्शन को प्रतिबिंबित किया। जब संदेह होता है, तो हम एक त्रुटि के बजाय एक प्रकार के पैरामीटर के लिए {} का अनुमान लगाते हैं। इसका मतलब है कि आप कुछ नासमझ चीजें कर सकते हैं और फिर भी परिणाम पर सुरक्षित रूप से कुछ न्यूनतम सेट व्यवहार करते हैं (अर्थात toString जैसी चीजें)। कुछ लोगों का तर्क जेएस में नासमझ बातें करता है और हमें यह प्रयास करने की कोशिश करनी चाहिए कि हम क्या कर सकते हैं। लेकिन व्यवहार में बहुमत के संदर्भ में {} वास्तव में सिर्फ त्रुटियां थीं, और जब तक आप यह महसूस करने के लिए T का एक चर चुका था, तब तक आपको इंतजार करना होगा (या इसी तरह एक अप्रत्याशित संघ प्रकार) और फिर पीछे की ओर ट्रेस करना सबसे अच्छा कष्टप्रद था। यदि आपने इसे कभी भी बंद नहीं किया है (या टाइप टी के कुछ भी नहीं लौटाया है) तो आपने रनटाइम तक त्रुटि को नोटिस नहीं किया था जब कुछ उड़ा (या बुरा, दूषित डेटा)। इसी प्रकार:

declare function foo(arg: number);
var x = "5";
x = 5;
foo(x); // error

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

null और undefined किसी भी प्रकार की त्रुटियों को छिपाने के लिए उसी तरह से असाइन करने योग्य है, जब अधिकांश बार किसी प्रकार के साथ टाइप किया गया चर और null मान छिपाने से लीड हो जाएगा रनटाइम में त्रुटि।

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

यह नीचे आता है कि क्या किसी को यह उम्मीद है कि var x = new B(); x = new C(); (जहां B और C दोनों A से प्राप्त होते हैं) को संकलन करना चाहिए या नहीं, और यदि ऐसा होता है, तो इसका क्या अर्थ है?

1. संकलन नहीं करना चाहिए।
2. संकलित किया जाना चाहिए और बी और सी के प्रकार पदानुक्रमों के लिए सबसे व्युत्पन्न आधार प्रकार के रूप में अनुमान लगाया जाना चाहिए - संख्या और स्ट्रिंग उदाहरण के लिए यह {} होगा।
3. संकलन करना चाहिए और B | C रूप में अनुमान लगाया जाना चाहिए।

टीएस वर्तमान में (1) और फ्लो करता है (3)। मैं (1) और (2) को अधिक पसंद करता हूं (3)।

मैं मूल मुद्दे पर @Arnavion उदाहरण जोड़ना चाहता था, लेकिन थोड़ा खेलने के बाद मुझे एहसास हुआ कि जिन चीजों को हमने समझा था, उससे कहीं ज्यादा अजनबी थे।
इस उदाहरण में:

var x = "5"; // x is inferred as string
x = 5; // x is infered as number now
x.toString(); // Compiles, since number has a toString method
x += 5; // Compiles since x is a number
console.log(x.length) // error x is a number

अब क :

var x = '';
if (true) {
  x = 5;
}

इस उदाहरण के बाद x string | number
और अगर मैं:

1. var x = ''; 
2. if (true) {
3.  x = 5;
4. }
5. x*=5;

मुझे लाइन 1 में यह कहते हुए त्रुटि हुई: myFile.js line 1 string this type is incompatible with myFile.js line 5 number

मुझे अभी भी यहाँ तर्क को समझने की जरूरत है ...।

प्रवाह के बारे में एक दिलचस्प बात यह भी है कि मैं भूल गया:

function test(t: Object) { }

test('string'); //error

मूल रूप से type ऑब्जेक्ट ’अन्य आदिम प्रकार के साथ संगत नहीं है, मुझे लगता है कि एक समझ में आता है।

'जेनेरिक रिज़ॉल्यूशन कैप्चर' निश्चित रूप से टीएस के लिए विशेषता होनी चाहिए!

@fdecampredon हाँ आप सही हैं। var x = "5"; x = 5; x का अनुमानित प्रकार number में अपडेट किया जाता है। दूसरे असाइनमेंट के चारों ओर if (true) { } जोड़कर, टाइपराइकर को यह मानने में धोखा दिया जाता है कि या तो असाइनमेंट मान्य है, यही वजह है कि इसके बजाय number | string का अनुमान लगाया गया है।

आपको myFile.js line 1 string this type is incompatible with myFile.js line 5 number मिलने वाली त्रुटि सही है, क्योंकि number | string * ऑपरेटर का समर्थन नहीं करता है (केवल यूनियन प्रकार पर अनुमत कार्य सभी प्रकार के सभी ऑपरेशनों का प्रतिच्छेदन हैं संगठन)। इसे सत्यापित करने के लिए, आप इसे x += 5 बदल सकते हैं और आप इसे संकलन देखेंगे।

मैंने if (true) होने के लिए अपनी टिप्पणी में उदाहरण को अपडेट किया है

'जेनेरिक रिज़ॉल्यूशन कैप्चर' निश्चित रूप से टीएस के लिए विशेषता होनी चाहिए!

+1

@ अर्णवियन , यह सुनिश्चित नहीं है कि आप {} B | C से अधिक क्यों पसंद करेंगे। B | C का उपयोग उन कार्यक्रमों के सेट को चौड़ा करता है जो शुद्धता से समझौता किए बिना टाइपकास्ट करते हैं जो afaik आमतौर पर टाइप सिस्टम की वांछनीय संपत्ति है।

उदाहरण

declare function foo<T>(x:T, y: T): T;
var r = foo(1, "a"); // no problem, T is just string|number

पहले से ही, वर्तमान संकलक के तहत typechecks को छोड़कर टी होने के लिए मान लिया जाता है {} बजाय string | number । यह शुद्धता से समझौता नहीं करता है लेकिन मोटे तौर पर इसके कम उपयोगी होने की बात करता है।

number | string बजाय {} करना मुझे समस्याग्रस्त नहीं लगता। उस विशेष मामले में यह वैध कार्यक्रमों के सेट को चौड़ा नहीं करता है, हालांकि यदि प्रकार संरचना साझा करते हैं, तो टाइप सिस्टम को यह एहसास होता है और कुछ अतिरिक्त तरीकों और / या गुणों को वैध बनाने से केवल एक सुधार की तरह लगता है।

B | C संदर्भ उन कार्यक्रमों के सेट को चौड़ा करता है जो शुद्धता से समझौता किए बिना टाइपकास्ट करते हैं

मुझे लगता है कि किसी ऐसी चीज पर + ऑपरेशन की अनुमति देना जो या तो एक स्ट्रिंग हो सकती है या एक संख्या सहीता से समझौता कर रही है, क्योंकि ऑपरेशन एक-दूसरे के समान नहीं हैं। यह उस स्थिति की तरह नहीं है जहां ऑपरेशन एक सामान्य आधार वर्ग (मेरा विकल्प 2) पर होता है - उस स्थिति में आप कुछ समानता की उम्मीद कर सकते हैं।

+ ऑपरेटर कॉल करने योग्य नहीं होगा, क्योंकि इसमें दो असंगत अधिभार होंगे - एक जहां दोनों तर्क संख्याएं हैं, और एक जहां दोनों तार हैं। चूंकि बी | C स्ट्रिंग और संख्या दोनों की तुलना में संकरा है, इसे ओवरलोड में एक तर्क के रूप में अनुमति नहीं दी जाएगी।

सिवाय कार्यों के द्विभाजित उनके तर्क हैं कि एक समस्या हो सकती है?

मैंने सोचा था कि चूंकि var foo: string; console.log(foo + 5); console.log(foo + document); संकलित करता है कि स्ट्रिंग + ऑपरेटर ने दाईं ओर कुछ भी करने की अनुमति दी है, इसलिए string | number में + <number> एक मान्य संचालन के रूप में होगा। लेकिन आप सही हैं:

error TS2365: Operator '+' cannot be applied to types 'string | number' and 'number'.

बहुत सारी टिप्पणियों ने फ्लो में प्रकारों के स्वत: चौड़ीकरण पर ध्यान केंद्रित किया है। दोनों ही मामलों में आप एक एनोटेशन जोड़कर जो व्यवहार चाहते हैं, कर सकते हैं। TS में आप घोषणा में व्यापक रूप से कहेंगे: var x: number|string = 5; और प्रवाह में आप घोषणा पर रोक लगा देंगे: var x: number = 5; । मुझे लगता है कि जिस मामले में एक प्रकार की घोषणा की आवश्यकता नहीं होती है, वह यह होनी चाहिए कि लोग अक्सर उपयोग करते हैं। अपनी परियोजनाओं में मैं यूनियन प्रकार की तुलना में var x = 5; x = 'five'; अधिक बार त्रुटि होने की उम्मीद करूंगा। तो मैं कहूंगा कि टीएस को इस पर अधिकार मिल गया।

फ्लो सुविधाओं के लिए जैसा कि मुझे लगता है कि सबसे मूल्यवान हैं?

1. गैर-अशक्त प्रकार
   मुझे लगता है कि इस कीड़े को कम करने की बहुत अधिक क्षमता है। मौजूदा टी एस परिभाषा के साथ संगतता के लिए, मैं इसे के रूप में अधिक एक गैर-शून्य संशोधक कल्पना string! बजाय प्रवाह के नल संशोधक ?string । मैं इसके साथ तीन मुद्दे देखता हूं:
   कक्षा के सदस्यों को कैसे संभाला जाए? _ (शायद उन्हें ctor में सौंपा जाना है और यदि वे असाइन करने से पहले ctor से बच सकते हैं तो उन्हें अशक्त माना जाता है) _
   undefined को कैसे संभालें? _ (फ्लो साइड-स्टेप्स इस इश्यू) _
   क्या यह स्पष्ट प्रकार की बहुत सारी घोषणाओं के बिना काम कर सकता है?
2. mixed और Object बीच अंतर।
   क्योंकि C # आदिम प्रकारों के विपरीत हर जगह एक वस्तु का उपयोग नहीं किया जा सकता है। अपने ब्राउज़र में Object.keys(3) का प्रयास करें और आपको एक त्रुटि मिलेगी। लेकिन यह महत्वपूर्ण नहीं है क्योंकि मुझे लगता है कि बढ़त के मामले कम हैं।
3. सामान्य संकल्प पर कब्जा
   उदाहरण सिर्फ समझ में आता है। लेकिन मैं यह नहीं कह सकता कि मैं बहुत से कोड लिख रहा हूं जो इससे लाभान्वित होंगे। शायद यह अंडरस्कोर जैसे कार्यात्मक पुस्तकालयों के साथ मदद करेगा?

स्वचालित संघ प्रकार के निष्कर्ष पर: मेरा मानना ​​है कि "प्रकार का निष्कर्ष" प्रकार की घोषणा के लिए प्रतिबंधित है। एक तंत्र जो निहित रूप से एक लोप प्रकार की घोषणा को प्रभावित करता है। जैसे := गो में। मैं कोई टाइप थ्योरीवादी नहीं हूँ, लेकिन जहाँ तक मैं समझता हूँ, टाइप इन्वेंशन एक कंपाइलर पास है जो एक स्पष्ट प्रकार के एनोटेशन को प्रत्येक निहित चर घोषणा (या फ़ंक्शन तर्क) में जोड़ता है, जिस प्रकार से इसे असाइन किया जा रहा है, उससे अनुमान लगाया गया है। जहां तक ​​मुझे पता है, यह है कि यह किस तरह से काम करता है .. अच्छी तरह से .. हर दूसरे प्रकार के निष्कर्ष तंत्र वहाँ से बाहर निकलते हैं। सी #, हास्केल, गो, वे सभी इस तरह से काम करते हैं। या नहीं?

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

मुझे बहुत सारे फ्लक्स विचार पसंद हैं, लेकिन यह एक, ठीक है, अगर यह वास्तव में इस तरह से किया जाता है ... तो यह अजीब है।

आधुनिक प्रकार की प्रणाली के लिए गैर-अशक्त प्रकार एक अनिवार्य विशेषता की तरह प्रतीत होते हैं। क्या ts में जोड़ना आसान होगा?

यदि आप TS में गैर-अशक्त प्रकार जोड़ने की जटिलताओं पर कुछ प्रकाश पढ़ना चाहते हैं तो https://github.com/Microsoft/TypeScript/issues/185 देखें

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

वास्तव में जितना मैं गैर-अशक्त प्रकार को याद करता हूं, प्रवाह से वास्तविक विशेषता मुझे याद आती है जेनेरिक कैप्चर, तथ्य यह है कि हर जेनेरिक {} को हल करता है यह वास्तव में कुछ कार्यात्मक निर्माण, विशेष रूप से करी के साथ उपयोग करना कठिन बनाता है।

व्यक्तिगत रूप से, सामान्य कब्जा और गैर-अशक्तता प्रवाह से _high_ मूल्य लक्ष्य हैं। मैं दूसरे सूत्र को पढ़ूंगा, लेकिन मैं अपना 2 सी भी यहीं फेंकना चाहता था।

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

मैं हर उस चर का एनोटेट करूंगा जो मुझे दिल की धड़कन में गैर-अशक्त के रूप में मिल सकता है।

प्रवाह में काफी छिपी हुई विशेषताएं हैं, प्रवाह की साइट में प्रलेखित नहीं। जिसमें सुपर टाइप बाउंड और अस्तित्वगत प्रकार शामिल हैं

http://sitr.us/2015/05/31/advanced-features-in-flow.html