"उठा हुआ प्रतिनिधित्व" क्या है?

Question

बस इस शब्द को यहाँ चलाया गया:

http://www.codemesh.io/codemesh2014/viktor-klang

"हम फ्लो एपीआई - एक उठा हुआ प्रतिनिधित्व - और साथ ही निष्पादन प्रतिनिधित्व में प्रवाहित प्रतिनिधित्व को बदलने के एक प्लगेबल तरीके से प्रदर्शित करेंगे- फ्लो मटेरलाइजेशन।"

Googling ने बहुत मदद नहीं की।

Comments

अनुशंसित पढ़ने: इस $ {ब्लॉग} पर चर्चा करें

— gnat

@ ऐसा लगता है कि उन्होंने उस शब्द का आविष्कार नहीं किया है, यह एक राय की तरह नहीं दिखता है, यह एक चर्चा को भड़काने की संभावना नहीं है और मेरी आंत की भावना यह है कि यह बहुत व्यापक नहीं है (हालांकि गणित की तरह लगता है)।

— डेन

मैं C # के संदर्भ में "उठा हुआ" के अर्थ पर चर्चा करता हूं: blogs.msdn.com/b/ericlippert/archive/2007/06/27/… - - संभावना है कि स्काला डेवलपर्स इस शब्द का प्रयोग एक अनुरूप, लेकिन अधिक में कर रहे हैं सामान्य फैशन।

— एरिक लिपर्ट

Answer 1

मैं फ्लो एपीआई से परिचित नहीं हूं।

शब्द "उठाने" श्रेणी के सिद्धांत से आता है। हस्केल या स्काला जैसी प्रोग्रामिंग भाषाओं में, एक liftफ़ंक्शन एक फ़ंक्शन लेता है A => B, और किसी तरह जादू करता है ताकि उठा हुआ फ़ंक्शन F[A] => F[B]किसी फ़नकार या मोनाड पर लागू किया जा सके F[A]।

स्काला के Seqकंटेनर का उपयोग करके एक ठोस उदाहरण : मान लें कि हमारे पास एक फ़ंक्शन def double(x: Int): Int = 2 * xऔर एक अनुक्रम है val xs = Seq(1, 2, 3)। हम double(xs)असंगत प्रकारों के कारण नहीं हो सकते । लेकिन अगर हम एक प्राप्त करते हैं val doubleSeq = liftToSeq(double), तो हम कर सकते हैं doubleSeq(xs), जो मूल्यांकन करता है Seq(2, 4, 6)। यहाँ, के liftToSeqरूप में लागू किया जा सकता है

def liftToSeq[A, B](f: A => B): (Seq[A] => Seq[B]) =
  (seq: Seq[A]) => seq.map(f)

Seq(…)निर्माता भी एक उठाने ऑपरेशन है, जो मूल्यों लिफ्टों के रूप में देखा जा सकता है 1, 2, 3एक में Seqउदाहरण है, इस प्रकार हमें इन मूल्यों के लिए सूची कपोल-कल्पना का उपयोग करने की इजाजत दी।

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

Comments

यह गणितीय "उठाने" का एक अच्छा वर्णन है। हमें विकिपीडिया से उठाने के अधिक औपचारिक विवरण का संदर्भ भी शामिल करना चाहिए ।

— स्कॉट व्हिटलॉक

"उठाने" का शायद अधिक स्पष्ट उदाहरण अशक्त (या "वैकल्पिक" या "शायद") प्रकारों को उठा रहा है। उदाहरण के लिए, मान लीजिए कि आपके पास एक ऑपरेटर है +जो इस तरह परिभाषित है int + int --> int। लिफ्ट-टू-नुल्लेबल ऑपरेटर int? + int? --> int?का शब्दार्थ है "यदि या तो ऑपरेंड शून्य है, तो उत्तर शून्य है, अन्यथा मानों पर गैर-लिफ्ट किए गए ऑपरेटर का उपयोग करें"।

— एरिक लिपर्ट

@ScottWhitlock क्या आप भी उठाती हैं?

— हेलिकॉप्टर

@ मुझे अपना उत्तर लिखने से पहले विकिपीडिया लेख पढ़ा, और यह भी समझ में नहीं आया। इसके बजाय, मैंने पाया हास्केल विकी पर भारोत्तोलन और अधिक सुलभ हो। ध्यान दें कि हमारे पास वास्तव में चार प्रकार नहीं हैं। हमारे पास चार ठोस प्रकार हैं, लेकिन केवल तीन प्रकार के चर हैं: दो प्रकार और , और एक फ़नकार जो एक प्रकार का कंस्ट्रक्टर है। ABF

— अमन

मैं इस सब में बहुत गहरा नहीं हूँ, लेकिन अगर Fएक प्रकार का निर्माता है, तो F[A]इसके निर्माण प्रकारों में से एक है। तो इन चार प्रकारों की बात करना क्यों गलत है? (दो प्रकार और एक प्रकार का कंस्ट्रक्टर निश्चित रूप से समान रूप से ठीक होगा)

— फ्रैंक

Answer 2

संदर्भ के आधार पर लिफ्ट के लिए शब्द का अलग-अलग अर्थ हो सकता है।

में सामान्य प्रोग्रामिंग यह अगले उच्च स्तर के लिए सार संक्षेप की प्रक्रिया का वर्णन। उदाहरण के लिए, आपके पास कोड के दो टुकड़े हो सकते हैं, एक प्रकार के साथ int, और दूसरे के साथ float। इस कोड को उठाने का मतलब होगा कि एक सामान्य प्रकार के साथ विधि को गति देना T, जो दोनों के लिए काम करता है, intऔर float।

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

विशेष रूप से, विक्टर कार्यात्मक प्रोग्रामिंग के संदर्भ में जाना जाता है, और इस संदर्भ में, आप वहां उठाने की दृष्टि से भिन्न व्याख्याएं पा सकते हैं । एक उदाहरण, एक फ़नकार में मूल्यों को उठाना है, या मौद्रिक मूल्यों (यानी हास्केल liftM2) पर काम करने के लिए कार्यों को उठाना है ।

"उठा हुआ प्रतिनिधित्व" का एक बहुत ही ठोस उदाहरण तब एफ.एक्स। ए List(1), या ए Some(1)।

Answer 3

इस तरह की अवधारणाओं को आमतौर पर एक ठोस उदाहरण के साथ समझना आसान है। इस प्रवाह एपीआई उदाहरण से निम्नलिखित अंश पर विचार करें :

Flow(text.split("\\s").toVector).
      // transform
      map(line => line.toUpperCase).
      // print to console (can also use ``foreach(println)``)
      foreach(transformedLine => println(transformedLine)).
      onComplete(FlowMaterializer(MaterializerSettings())) {
        case Success(_) => system.shutdown()
        case Failure(e) =>
          println("Failure: " + e.getMessage)
          system.shutdown()
      }

यह निम्नलिखित कोड लेता है:

text.split("\\s").toVector.
      map(line => line.toUpperCase).
      foreach(println)

और एक Flowसंदर्भ में "लिफ्ट" करता है। यह आपको उसी सिंटैक्स का उपयोग करने की अनुमति देता है जिससे आप अपने एल्गोरिथ्म को निर्दिष्ट करने के लिए परिचित हैं, लेकिन पर्दे के पीछे mapकई प्रोसेसर या यहां तक ​​कि मशीनों में समानांतर में किया जाता है, फिर foreach(println)मूल रूप से मुद्रण के लिए उस आउटपुट को एक प्रोसेसर में वापस इकट्ठा करता है।

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