স্কালায় একটি ম্যানিফেস্ট কী এবং কখন আপনার এটির প্রয়োজন হবে?

Question

যেহেতু স্কেলা ২.7.২ রয়েছে এমন কিছু আছে Manifestযা জাভা ধরণের ক্ষয়ের জন্য একান্ত কার্যকর। তবে কীভাবে Manifestঠিক কাজ করে এবং কেন / কখন আপনার এটি ব্যবহার করা দরকার?

ব্লগ পোস্টটি প্রকাশ করে: জর্গে অর্টিজের দ্বারা রাইফাইড প্রকারগুলি এর কয়েকটি ব্যাখ্যা করে, তবে কীভাবে এটি প্রসঙ্গে সীমাবদ্ধতার সাথে ব্যবহার করতে হবে তা ব্যাখ্যা করে না ।

এছাড়াও, কী ClassManifest, এর সাথে পার্থক্য কী Manifest?

আমার কিছু কোড রয়েছে (বৃহত্তর প্রোগ্রামের অংশ, সহজেই এটি এখানে অন্তর্ভুক্ত করতে পারে না) যা মুছে ফেলার বিষয়ে কিছু সতর্কতা রয়েছে; আমি সন্দেহ প্রকাশ করে এগুলি সমাধান করতে পারি তবে আমি কীভাবে ঠিক তা নিশ্চিত নই।

Comments

সেখানে ম্যানিফেস্ট / ClassManifest পার্থক্য সম্পর্কে মেইলিং লিস্টে আলোচনা হয়েছে, দেখতে scala-programming-language.1934581.n4.nabble.com/...

— Arjan Blokzijl

আরও দেখুন: স্কেল: একটি টাইপট্যাগ কী এবং আমি কীভাবে এটি ব্যবহার করব?

— জেস্পার

Answer 1

সংকলক জেভিএম রানটাইম সহজে প্রতিনিধিত্ব করতে পারে তার চেয়ে প্রকারের সম্পর্কে আরও তথ্য জানে। ম্যানিফেস্ট হ'ল টাইপ তথ্য যা হারিয়েছিল সে সম্পর্কে রানটাইমের সময় কোডটিতে একটি আন্ত-মাত্রিক বার্তা পাঠানোর সংকলকটির একটি উপায়।

এটি কীভাবে ক্লেপটোনীয়রা জীবাশ্ম রেকর্ডে এবং "জঞ্জাল" মানুষের ডিএনএ-তে এনকোড করা বার্তা ফেলেছে তার অনুরূপ। লাইটস্পিড এবং মহাকর্ষীয় অনুরণন ক্ষেত্রগুলির সীমাবদ্ধতার কারণে তারা সরাসরি যোগাযোগ করতে পারছে না। তবে, যদি আপনি তাদের সংকেতটি টিউন করতে জানেন তবে, মধ্যাহ্নভোজনে কী খাবেন বা কোন লোটোর সংখ্যাটি খেলবেন তা স্থির করে আপনি কীভাবে কল্পনা করতে পারবেন না সেগুলি থেকে উপকৃত হতে পারেন।

ম্যানিফেস্টটি আরও বিশদ না জেনে আপনি যে ত্রুটিগুলি দেখছেন তাতে উপকৃত হবে কিনা তা পরিষ্কার নয়।

ম্যানিফেস্টের একটি সাধারণ ব্যবহার হ'ল কোনও সংগ্রহের স্থিতিশীল ধরণের ভিত্তিতে আপনার কোডটি ভিন্নভাবে আচরণ করা। উদাহরণস্বরূপ, আপনি যদি একটি তালিকা [স্ট্রিং] অন্য তালিকার অন্যান্য ধরণের চেয়ে আলাদাভাবে আচরণ করতে চান তবে কী হবে:

 def foo[T](x: List[T])(implicit m: Manifest[T]) = {
    if (m <:< manifest[String])
      println("Hey, this list is full of strings")
    else
      println("Non-stringy list")
  }

  foo(List("one", "two")) // Hey, this list is full of strings
  foo(List(1, 2)) // Non-stringy list
  foo(List("one", 2)) // Non-stringy list

এটির প্রতিবিম্ব-ভিত্তিক সমাধান সম্ভবত তালিকার প্রতিটি উপাদানকে পর্যবেক্ষণের সাথে জড়িত।

একটি প্রেক্ষাপটে আবদ্ধ Scala টাইপ-শ্রেণীর ব্যবহার সবচেয়ে উপযুক্ত বলে মনে হয়, এবং ভাল দেবাশিস ঘোষ এখানে ব্যাখ্যা করা হয়: http://debasishg.blogspot.com/2010/06/scala-implicits-type-classes-here-i.html

প্রসঙ্গের সীমাগুলি কেবল পদ্ধতি স্বাক্ষরগুলিকে আরও পঠনযোগ্য করে তুলতে পারে। উদাহরণস্বরূপ, উপরের ফাংশনটি প্রসঙ্গের সীমানা ব্যবহার করে পুনরায় লিখিত হতে পারে:

  def foo[T: Manifest](x: List[T]) = {
    if (manifest[T] <:< manifest[String])
      println("Hey, this list is full of strings")
    else
      println("Non-stringy list")
  }

Answer 2

সম্পূর্ণ উত্তর নয়, তবে Manifestএবং এর মধ্যে পার্থক্য সম্পর্কে ClassManifestআপনি স্কেলা ২.৮ Arrayকাগজে একটি উদাহরণ খুঁজে পেতে পারেন :

কেবলমাত্র বাকি প্রশ্নটি কীভাবে জেনেরিক অ্যারে তৈরিটি প্রয়োগ করা যায়। জাভা থেকে ভিন্ন, স্কালা নতুন একটি উদাহরণ তৈরি করতে দেয় Array[T]যেখানে Tটাইপ প্যারামিটার থাকে। জাভাতে অভিন্ন বিন্যাসের উপস্থাপনের অস্তিত্ব নেই এই বিষয়টি বিবেচনা করে কীভাবে এটি বাস্তবায়ন করা যায়?

এটি করার একমাত্র উপায় হ'ল টাইপটি বর্ণনা করে এমন অতিরিক্ত রানটাইম তথ্য প্রয়োজন T। স্কালা ২.৮ এর জন্য একটি নতুন প্রক্রিয়া রয়েছে, যাকে ম্যানিফেস্ট বলা হয় । টাইপের একটি অবজেক্ট টাইপ Manifest[T]সম্পর্কে সম্পূর্ণ তথ্য সরবরাহ করে T।
Manifestমানগুলি অন্তর্ভুক্ত পরামিতিগুলিতে সাধারণত পাস করা হয়; এবং সংকলক স্থিতভাবে পরিচিত ধরণের জন্য কীভাবে এটি নির্মাণ করতে জানে T।

নামে একটি দুর্বল ফর্মও রয়েছে ClassManifestযা প্রয়োজনীয়তার সাথে যুক্তিযুক্ত সমস্ত ধরণের অজানা ছাড়া কোনও প্রকারের শীর্ষ স্তরের শ্রেণিটি জানা থেকে তৈরি করা যেতে পারে ।
এই ধরণের রানটাইম তথ্য যা অ্যারে তৈরির জন্য প্রয়োজনীয়।

উদাহরণ:

ClassManifest[T]অন্তর্নিহিত পরামিতি হিসাবে পদ্ধতিতে পাস করে একজনকে এই তথ্য সরবরাহ করতে হবে :

def  tabulate[T](len:Int,  f:Int=>T)(implicit m:ClassManifest[T]) =  { 
  val  xs  =  new  Array[T](len) 
  for   (i  <- 0  until   len)  xs(i)   = f(i) 
  xs 
} 

শর্টহ্যান্ড ফর্ম হিসাবে, প্রসঙ্গের বাউন্ড 1 প্রকারের প্যারামিটারের Tপরিবর্তে ব্যবহার করা যেতে পারে ,

( উদাহরণের জন্য এই একই প্রশ্ন দেখুন )

, প্রদান:

def  tabulate[T:    ClassManifest](len:Int,  f:Int=>T)  =  { 
  val  xs  =  new  Array[T](len) 
  for   (i  <- 0  until   len)  xs(i)   = f(i) 
  xs 
} 

যখন কোনও ধরণের টেবিলেটে কল করা হয় যেমন Int, বা String, বা List[T], স্কালা সংকলক ট্যাবুলেটে অন্তর্নিহিত যুক্তি হিসাবে পাস করার জন্য একটি শ্রেণীর ম্যানিফেস্ট তৈরি করতে পারে।

Answer 3

ম্যানিফেস্টের উদ্দেশ্য ছিল জেনেরিক প্রকারগুলি যা জেভিএম (যা জেনেরিক সমর্থন করে না) চালানোর জন্য টাইপ-মোছা যায় তা পুনরায় সংস্কার করা। তবে তাদের কিছু গুরুতর সমস্যা ছিল: এগুলি খুব সরল ছিল এবং স্কালার টাইপ সিস্টেমকে পুরোপুরি সমর্থন করতে অক্ষম ছিল। এগুলি এহেতু স্কেলা ২.১০ এ অবমুক্ত করা হয়েছিল এবং তাদের দ্বারা প্রতিস্থাপন করা হয় TypeTag(যা মূলত স্কালার সংকলক প্রকারগুলি উপস্থাপন করার জন্য যা ব্যবহার করে, এবং তাই স্কালার প্রকারগুলি সম্পূর্ণ সমর্থন করে)। পার্থক্য সম্পর্কে আরও তথ্যের জন্য, দেখুন:

• স্কেল: একটি টাইপট্যাগ কী এবং আমি কীভাবে এটি ব্যবহার করব?
• নতুন স্কালা টাইপট্যাগগুলি কীভাবে (অবহেলিত) ম্যানিফেস্টগুলিকে উন্নত করবে?

অন্য কথায়

তোমার কখন দরকার?

2013-01-04 এর আগে, যখন স্কালা 2.10 প্রকাশিত হয়েছিল ।

Comments

এটি এখনও অবচয় করা হয়নি (তবে হবে), স্কালার প্রতিবিম্বটি এখনও 2.10-এ পরীক্ষামূলক।

— কেরোস

2013-01-04 এর আগে বা আপনি যদি এমন কোনও API ব্যবহার করেন যা এর উপর নির্ভর করে।

— ডেভিড মোলস

Answer 4

আসুন বের chck manifestমধ্যে scalaউৎস ( Manifest.scala), আমরা দেখুন:

Manifest.scala:
def manifest[T](implicit m: Manifest[T])           = m

নীচের উদাহরণের কোডের সাথে তাই:

def foo[A](somelist: List[A])(implicit m: Manifest[A]): String = {
  if (m <:< manifest[String]) {
    "its a string"
  } else {
    "its not a string"
  }
}

আমরা দেখতে পাচ্ছি যে manifest functionএকটি অন্তর্নিহিতের জন্য অনুসন্ধানগুলি m: Manifest[T]যা type parameterআমাদের উদাহরণ কোডটিতে আপনি সরবরাহ করেছিলেন তা সন্তুষ্ট করে manifest[String]। সুতরাং আপনি যখন কিছু কল:

if (m <:< manifest[String]) {

আপনি যেটি দেখছেন যদি বর্তমান implicit mযা আপনি আপনার ফাংশন সংজ্ঞায়িত ধরনের হয় manifest[String]এবং manifestধরনের একটি ফাংশন manifest[T]এটি একটি নির্দিষ্ট অনুসন্ধান করবে manifest[String]এবং যদি সেখানে যেমন একটি অন্তর্নিহিত এটি খুঁজে যাবে।