Streams এবং Lazy Collections (স্ট্রিমস এবং লেইজি কালেকশনস)

স্কালাতে স্ট্রিমস (Streams) এবং লেইজি কালেকশনস (Lazy Collections) অত্যন্ত শক্তিশালী এবং কার্যকরী ডেটা ম্যানিপুলেশন টুল যা আপনাকে বৃহত্তর ডেটা সেটের সাথে কাজ করার সময় কর্মক্ষমতা এবং স্মৃতি ব্যবস্থাপনাকে উন্নত করতে সহায়তা করে। এই দুটি ধারণা খুবই সম্পর্কিত এবং ফাংশনাল প্রোগ্রামিংয়ের অংশ হিসেবে কাজে লাগে।

১. স্ট্রিমস (Streams)

স্ট্রিমস একটি ডেটা স্ট্রাকচার যা একে একে ডেটা প্রক্রিয়া করার ধারণা প্রদান করে। এটি ফাংশনাল প্রোগ্রামিংয়ের একটি গুরুত্বপূর্ণ অংশ এবং একটি সিকোয়েন্স বা সিরিজের উপাদানগুলিকে একে একে প্রক্রিয়া করে, যেখানে আমরা প্রয়োজনীয় উপাদানগুলির উপর কাজ করতে পারি। স্কালাতে স্ট্রিমসকে Lazy Evaluation (লেইজি ইভ্যালুয়েশন) পদ্ধতির সাথে মিলিত করা হয়।

স্ট্রিমের ধারণা:

স্ট্রিমগুলির প্রধান সুবিধা হল Lazy Evaluation, যা শুধুমাত্র সেই উপাদানগুলিকে প্রক্রিয়া করে যেগুলি আসলেই প্রয়োজন। অর্থাৎ, যখন আপনি স্ট্রিমের উপর কোনো অপারেশন প্রয়োগ করেন, তা অবিলম্বে কার্যকর হয় না, বরং যখনই তার ফলাফলের প্রয়োজন হয়, তখনই এটি প্রক্রিয়া করা হয়।

স্ট্রিম তৈরি:

স্ট্রিম তৈরি করতে স্কালাতে Stream ব্যবহার করা হয়।

উদাহরণ:

val stream1 = Stream(1, 2, 3, 4, 5)

// স্ট্রিমের উপাদানগুলির উপর ম্যানিপুলেশন
val doubledStream = stream1.map(x => x * 2)
println(doubledStream)  // Stream(2, 4, 6, 8, 10)

এখানে, stream1 একটি স্ট্রিম যা 1 থেকে 5 পর্যন্ত মান ধারণ করছে এবং map অপারেশন প্রয়োগের মাধ্যমে প্রতিটি উপাদানের উপর একটি কাজ (বর্গফল) করা হয়েছে।

২. লেইজি কালেকশনস (Lazy Collections)

লেইজি কালেকশনস হল এমন কালেকশন যা Lazy Evaluation এর উপর ভিত্তি করে কাজ করে। এর মানে হলো, এই কালেকশনের উপাদানগুলিকে প্রয়োগ করা হয় না যতক্ষণ না সেগুলির প্রয়োজন হয়। এটি আপনাকে বৃহত্তর ডেটা সেটের সাথে কাজ করার সময় প্রভাবশালী কর্মক্ষমতা প্রদান করে।

স্কালাতে Lazy Collections এর মধ্যে সবচেয়ে পরিচিত উদাহরণ হলো Stream। Stream কে স্কালা "Lazy Collection" হিসেবে বিবেচনা করা হয়, কারণ এটি পুরো কালেকশনকে একসাথে লোড করে না, বরং যখনই আপনি একটি উপাদান অ্যাক্সেস করবেন, তখনই তার উপর কাজ করবে।

উদাহরণ:

val lazyStream = Stream.from(1)  // 1 থেকে শুরু হয়ে অনন্ত পর্যন্ত মান তৈরি হবে
println(lazyStream.take(5).toList)  // List(1, 2, 3, 4, 5)

এখানে, Stream.from(1) একটি লেইজি স্ট্রিম তৈরি করছে যা 1 থেকে শুরু হয়ে অনন্ত পর্যন্ত বৃদ্ধি পায়। তবে, যখন আপনি take(5) ব্যবহার করেন, তখন মাত্র 5টি উপাদান প্রক্রিয়া করা হয় এবং অন্যান্য উপাদানগুলি অকারণে প্রক্রিয়া করা হয় না।

৩. লেইজি কালেকশনস এবং স্ট্রিমের মধ্যে পার্থক্য

• স্ট্রিম: এটি এমন একটি লেইজি কালেকশন যা একে একে উপাদানগুলো ধারণ করে এবং এগুলির উপর কাজ করতে সক্ষম।
• লেইজি কালেকশনস: এই কালেকশনগুলিতে যখনই কোনো উপাদানের প্রয়োজন হয়, তখনই তা প্রক্রিয়া করা হয়, তবে অন্যথায় এগুলিকে লোড করা হয় না।

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

৪. লেইজি ইভ্যালুয়েশন (Lazy Evaluation)

লেইজি ইভ্যালুয়েশন এমন একটি কৌশল যা প্রতিটি উপাদানকে প্রয়োজনীয়তার ভিত্তিতে প্রক্রিয়া করে। এটি আপনার কোডের কর্মক্ষমতা এবং মেমরি ব্যবস্থাপনাকে উন্নত করে কারণ এটি যেসব উপাদানগুলো ব্যবহার করা হচ্ছে, শুধুমাত্র সেগুলোই প্রক্রিয়া করে।

উদাহরণ:

val lazyStream = Stream(1, 2, 3, 4, 5)
val result = lazyStream.takeWhile(_ < 4)  // 1, 2, 3
println(result.toList)  // List(1, 2, 3)

এখানে, takeWhile অপারেশনটি শুধুমাত্র প্রথম 3টি উপাদান নির্বাচন করবে যেগুলি 4 এর কম। লেইজি ইভ্যালুয়েশন নিশ্চিত করে যে শুধুমাত্র প্রক্রিয়া করা উপাদানগুলিই কার্যকর হবে, বাকি উপাদানগুলি এড়িয়ে যাবে।

৫. স্ট্রিম এবং লেইজি কালেকশনসের অপারেশন

স্ট্রিম এবং লেইজি কালেকশনসের উপর বিভিন্ন অপারেশন প্রয়োগ করা যায়, যেমন map, filter, flatMap, fold, reduce, ইত্যাদি। তবে, গুরুত্বপূর্ণ বিষয় হলো Lazy Evaluation এর কারণে এই অপারেশনগুলি ফলাফলটি তৈরি না হওয়া পর্যন্ত কার্যকর হয় না।

উদাহরণ:

val stream = Stream(1, 2, 3, 4, 5)

// filter এবং map অপারেশন
val processedStream = stream.filter(_ % 2 == 0).map(_ * 2)

println(processedStream.toList)  // List(4, 8)

এখানে, stream এর মধ্যে filter এবং map অপারেশন প্রয়োগ করা হয়েছে, তবে এগুলি Lazy হওয়ায়, শুধুমাত্র শেষ ফলাফলটি তৈরি হওয়ার পর তা প্রক্রিয়া করা হয়েছে।

৬. স্ট্রিমের অ্যাডভান্সড অপারেশনস (Advanced Stream Operations)

স্কালাতে স্ট্রিমের উপর আরও কিছু অ্যাডভান্সড অপারেশন প্রয়োগ করা যায়, যেমন zip, zipWithIndex, flatMap, ইত্যাদি।

উদাহরণ:

val stream1 = Stream(1, 2, 3)
val stream2 = Stream("one", "two", "three")

// zip অপারেশন
val zipped = stream1.zip(stream2)
println(zipped)  // Stream((1,one), (2,two), (3,three))

এখানে, zip অপারেশনটি দুটি স্ট্রিমকে একত্রে যুক্ত করেছে।

সারাংশ:

• স্ট্রিমস হল একটি লেইজি কালেকশন যা একে একে উপাদানগুলো প্রক্রিয়া করতে সক্ষম এবং এটি Lazy Evaluation ধারণা অনুসরণ করে।
• লেইজি কালেকশনস স্কালার শক্তিশালী টুল যা আপনাকে ইনফিনিট বা বড় ডেটাসেটের সাথে কাজ করতে এবং কর্মক্ষমতা উন্নত করতে সহায়তা করে।
• স্ট্রিম এবং লেইজি কালেকশনসের সাহায্যে আপনি map, filter, reduce, flatMap এবং অন্যান্য ফাংশনাল অপারেশন প্রয়োগ করতে পারেন, যেগুলি কার্যকর হবে যখনই প্রয়োজনীয় উপাদানগুলো প্রক্রিয়া করা হবে।

স্কালাতে স্ট্রিমস হল একটি ডেটা স্ট্রাকচার যা একে একে, পর্যায়ক্রমে উপাদান সরবরাহ করে। স্ট্রিমগুলি একাধিক উপাদান ধারণ করতে সক্ষম, কিন্তু এগুলো পুরোপুরি লোড বা ইন মেমোরি থাকে না। এর পরিবর্তে, এটি "অপরিশোধিত" উপাদানগুলিকে প্রয়োজনে প্রক্রিয়া করে, অর্থাৎ যখনই একটি উপাদান প্রয়োজন হয়, তখনই তা তৈরি বা গণনা করা হয়।

এটি লেইজি ইভ্যালুয়েশন ধারণার সাথে সম্পর্কিত, যেখানে মূল্যায়ন বা গণনা কেবল তখনই ঘটে যখন তা প্রয়োজনীয় হয়। এটি কার্যকরীভাবে স্মৃতি এবং পারফরম্যান্সের ক্ষেত্রে একটি গুরুত্বপূর্ণ ধারণা।

১. স্ট্রিমস (Streams) এর ধারণা:

স্ট্রিম হল একটি সিকোয়েন্স বা ক্রম যা এমনভাবে গঠিত যে একে একে উপাদানগুলো উৎপন্ন করা হয় এবং একে একে এগুলোকে প্রক্রিয়া করা হয়। স্ট্রিমের উপাদানগুলি সাধারণত এক্সটেনশন বা লেইজি ইভ্যালুয়েশন এর মাধ্যমে পাওয়া যায়, অর্থাৎ স্ট্রিমের উপাদানগুলি তখনই তৈরি হয় যখন তাদের প্রয়োজন হয়।

স্ট্রিমের কিছু মৌলিক বৈশিষ্ট্য:

1. ইমিউটেবল: স্ট্রিমের উপাদানগুলি পরিবর্তন করা যায় না। এটি এক ধরনের immutable ডেটা স্ট্রাকচার।
2. লেইজি: স্ট্রিমের উপাদানগুলি তখনই গণনা বা তৈরি হয় যখন তা প্রয়োজনীয় হয়।
3. কর্মক্ষমতা: স্ট্রিম গুলি সাধারণত বড় ডেটাসেট পরিচালনা করতে কার্যকরী, কারণ এগুলি প্রয়োজন অনুযায়ী উপাদান উৎপন্ন করে।

২. লেইজি ইভ্যালুয়েশন (Lazy Evaluation):

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

এটি ডেটা প্রক্রিয়াকরণের দক্ষতা বৃদ্ধি করে এবং মেমোরি ব্যবহারের ক্ষেত্রে সুবিধা প্রদান করে।

লেইজি ইভ্যালুয়েশনের সুবিধা:

1. পারফরম্যান্স: যদি স্ট্রিমে অনেক উপাদান থাকে, তবে সেগুলোর সবকিছুর জন্য গণনা না করে কেবলমাত্র প্রয়োজনীয় অংশই প্রক্রিয়া করা হয়।
2. মেমোরি দক্ষতা: স্ট্রিমগুলি infinite (অসীম) হতে পারে, এবং Lazy Evaluation এর মাধ্যমে আমরা মেমোরি ব্যবহার করে শুধু প্রয়োজনীয় উপাদানগুলিই গণনা করি, পুরো স্ট্রিমকে একসাথে মেমোরিতে লোড না করে।
3. জটিল প্রক্রিয়াগুলির সহজ সমাধান: স্ট্রিমের মাধ্যমে জটিল এবং ভারী ডেটা প্রক্রিয়াকরণ সহজতর হয়, কারণ একে একে উপাদান প্রক্রিয়া করা হয়।

৩. স্ট্রিম এর অপারেশন:

স্ট্রিমে কিছু সাধারণ অপারেশন রয়েছে যেগুলি লেইজি ইভ্যালুয়েশন ব্যবহার করে কাজ করে:

1. map: একটি ফাংশন প্রয়োগ করে স্ট্রিমের প্রতিটি উপাদান পরিবর্তন করা।
2. filter: শর্তের মাধ্যমে স্ট্রিমের উপাদান ফিল্টার করা।
3. flatMap: একটি স্ট্রিম থেকে অন্য স্ট্রিম তৈরি করা।
4. reduce: স্ট্রিমের উপাদানগুলোকে একটি একক মানে রিডিউস করা।
5. collect: স্ট্রিমের উপাদানগুলোকে একটি সংগ্রহে (যেমন লিস্ট) পরিণত করা।

উদাহরণ ১: স্ট্রিমের সাথে map এবং filter ব্যবহার

val numbers = Stream(1, 2, 3, 4, 5, 6)

val evenNumbers = numbers.filter(x => x % 2 == 0).map(x => x * 2)

println(evenNumbers.take(3).toList)  // Output: List(4, 8, 12)

এখানে, প্রথমে filter ফাংশনটি স্ট্রিমের মধ্যে থেকে ইভেন সংখ্যাগুলি ফিল্টার করেছে এবং তারপর map ফাংশনটি প্রতিটি ইভেন সংখ্যার দ্বিগুণ করেছে। take(3) ব্যবহার করে প্রথম তিনটি উপাদান প্রিন্ট করা হয়েছে।

৪. লেইজি স্ট্রিমের সাথে অ্যালগরিদমের উন্নতি:

লেইজি ইভ্যালুয়েশন দিয়ে অসীম স্ট্রিম তৈরি করা সম্ভব। অর্থাৎ, আপনি অনন্ত সংখ্যার একটি স্ট্রিম তৈরি করতে পারেন যা কেবল তখনই উপাদান উৎপন্ন করবে যখন তা প্রয়োজন হবে।

উদাহরণ ২: অসীম স্ট্রিমের সাথে কাজ

val naturalNumbers = Stream.from(1)  // 1, 2, 3, 4, 5, 6, ...

val firstTen = naturalNumbers.take(10).toList  // প্রথম ১০টি সংখ্যার একটি লিস্ট তৈরি

println(firstTen)  // Output: List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

এখানে, Stream.from(1) দিয়ে একটি অসীম স্ট্রিম তৈরি করা হয়েছে যা 1, 2, 3, ... ক্রমে চলতে থাকে। তবে take(10) এর মাধ্যমে শুধুমাত্র প্রথম ১০টি উপাদান নেয়া হয়েছে, এবং এটি কেবল তখনই গণনা করা হয়েছে যখন এটি প্রয়োজন হয়েছিল।

৫. স্ট্রিম এর ব্যবহার এবং প্রয়োগ:

স্ট্রিম ব্যবহার করে আপনি অনেক বড় ডেটাসেট নিয়ে কাজ করতে পারেন, যেখানে সাধারণভাবে লিস্ট বা অন্যান্য ডেটা স্ট্রাকচারে পুরো ডেটাসেট মেমোরিতে রাখা সম্ভব নয়।

উদাহরণ ৩: স্ট্রিমের মধ্যে বড় ডেটাসেট প্রক্রিয়া

val bigDataStream = Stream.continually(scala.util.Random.nextInt(100)) // অসীম র্যান্ডম সংখ্যা

val result = bigDataStream.filter(x => x > 50).take(5).toList  // ৫০ এর বেশি ৫টি সংখ্যা নেওয়া হচ্ছে

println(result)

এখানে, স্ট্রিমে অসীম র্যান্ডম সংখ্যা তৈরি হচ্ছে এবং filter অপারেশন দিয়ে ৫০ এর বেশি সংখ্যাগুলি ফিল্টার করা হচ্ছে। এরপর take(5) এর মাধ্যমে প্রথম ৫টি ফলাফল সংগ্রহ করা হচ্ছে।

সারাংশ:

স্ট্রিমস হল একটি কার্যকরী ডেটা স্ট্রাকচার যা লেইজি ইভ্যালুয়েশন ব্যবহার করে উপাদান একে একে তৈরি এবং প্রক্রিয়া করে। স্ট্রিমগুলি খুব বড় বা অসীম ডেটাসেটগুলির জন্য খুবই উপকারী, কারণ এগুলি মেমোরি এবং পারফরম্যান্সের ক্ষেত্রে দক্ষতা প্রদান করে। লেইজি ইভ্যালুয়েশন স্ট্রিমের মাধ্যমে শুধুমাত্র প্রয়োজনীয় উপাদানই প্রক্রিয়া হয়, যা সম্পদ ব্যবহারে সাহায্য করে।

লেজি কালেকশন (Lazy Collections) স্কালাতে এমন ধরনের কালেকশন, যা প্রয়োজন অনুযায়ী ডেটা প্রক্রিয়া করে, অর্থাৎ এগুলি ডেটা কেবল তখনই প্রক্রিয়া করে যখন তা প্রয়োজন হয়, অন্যথায় তা প্রক্রিয়া করা হয় না। এই বৈশিষ্ট্যটি লেজিনেস (laziness) নামে পরিচিত, এবং এটি মেমোরি ব্যবস্থাপনা এবং পারফরম্যান্সের জন্য খুবই উপকারী।

লেজি কালেকশনের সুবিধাসমূহ:

1. পার্থিব মেমোরি ব্যবহার (Efficient Memory Usage):
   লেজি কালেকশন যখন উপাদানগুলি প্রক্রিয়া করে তখন তা মেমোরিতে পুরোপুরি লোড না করেও কাজ করতে পারে। এতে করে নিউজ ডেটা কেবল তখনই লোড হয় যখন তা দরকার হয়। এই পদ্ধতি মেমোরি ব্যবহারকে সীমিত করে এবং বড় ডেটাসেটগুলোর জন্য এটি একটি শক্তিশালী টুল।

   উদাহরণ:

   val largeRange = (1 to 1000000).toStream  // একটি স্ট্রিম তৈরি হচ্ছে, তবে মেমোরি পূর্ণভাবে পূর্ণ হবে না

2. পুনঃব্যবহৃত হিসাব (Deferred Computation):
   লেজি কালেকশনের মাধ্যমে, আপনি একাধিক অপারেশন একসাথে চেইন করতে পারেন এবং প্রতিটি অপারেশন তখনই কার্যকর হবে যখন প্রয়োজন হবে। এতে করে অতিরিক্ত হিসাব থেকে বাঁচা যায় এবং প্রোগ্রামটির পারফরম্যান্স বৃদ্ধি পায়।

   উদাহরণ:

   val numbers = (1 to 100).toStream
   val doubled = numbers.map(_ * 2).filter(_ > 50)  // এটি লেজি প্রক্রিয়া

3. ডেটা প্রসেসিংয়ের গতি বৃদ্ধি (Lazy Evaluation Improves Speed):
   যখন ডেটা প্রক্রিয়ার মধ্যে কিছু উপাদান আপনার প্রয়োজন হয়, তখন লেজি কালেকশন শুধুমাত্র সেই অংশটিই প্রক্রিয়া করবে। এটি সম্পূর্ণ ডেটা সেটের উপর কাজ করার পরিবর্তে শুধুমাত্র প্রয়োজনীয় অংশের জন্য প্রসেসিং করবে, যা গতি বাড়ায়।

4. এনড-টু-এনড প্রসেসিং (End-to-End Processing):
   লেজি কালেকশনগুলো ব্যবহার করে আপনি একাধিক ফাংশন বা অপারেশন একে একে প্রয়োগ করতে পারেন। প্রতিটি ফাংশন ডেটার উপর কাজ করে যখনই সেটা প্রয়োজন হয়, এবং অতিরিক্ত সময় বা মেমোরি খরচ এড়ানো যায়।

   উদাহরণ:

   val range = (1 to 1000000).toStream
   val result = range.map(x => x * 2).filter(x => x > 50).take(10)
   println(result)  // এখানে শুধুমাত্র প্রথম 10 উপাদান প্রক্রিয়া হবে

5. বিশাল ডেটাসেট পরিচালনা (Handling Large Datasets):
   লেজি কালেকশন আপনাকে বৃহৎ ডেটাসেট সহজে পরিচালনা করার সুযোগ দেয় কারণ এটি ভলিউমের উপর কাজ করে না, বরং যখন ডেটা প্রক্রিয়া করা প্রয়োজন, তখনই তা করবে। উদাহরণস্বরূপ, বৃহৎ ফাইল বা ডেটাবেসের জন্য স্ক্রিপ্ট লেখার ক্ষেত্রে লেজি কালেকশন উপকারী।
6. সার্ভার পারফরম্যান্স উন্নতি (Improved Server Performance):
   লেজি কালেকশন সার্ভারে উন্নত পারফরম্যান্স প্রদান করতে সহায়ক। কারণ এতে করে সার্ভার সম্পদ খালি থাকে এবং প্রোগ্রামটি শুধুমাত্র প্রয়োজনীয় কাজের জন্য ডেটা প্রসেস করে।

লেজি কালেকশনের প্রয়োজনীয়তা:

1. বড় ডেটাসেটের সাথে কাজ করার জন্য:
   যখন ডেটাসেটটি খুব বড় এবং আপনি সম্পূর্ণ ডেটাসেট একবারে মেমোরিতে লোড করতে চান না, তখন লেজি কালেকশন কার্যকরী। লেজি কালেকশন ব্যবহারের মাধ্যমে আপনি ডেটা প্রসেসিংয়ের সময় এবং মেমোরি ব্যবস্থাপনা উন্নত করতে পারেন।

   উদাহরণ:
   বিশাল ফাইল পড়া, বা ডেটাবেস থেকে বড় ডেটা সংগ্রহের সময় লেজি কালেকশন ব্যবহারের মাধ্যমে কম সময়ে কার্যকর ফলাফল পাওয়া যায়।

2. অপটিমাইজড প্রোগ্রামিং:
   লেজি কালেকশনের মাধ্যমে আপনি শুধু প্রয়োজনীয় কাজ সম্পন্ন করতে পারেন। এতে করে কার্যক্রম কেবল তখনই সম্পন্ন হয় যখন তা প্রয়োজন হয়, ফলে দ্রুত ফলাফল পাওয়া যায় এবং অপ্রয়োজনীয় কাজ থেকে মুক্তি পাওয়া যায়।
3. ফাংশনাল প্রোগ্রামিংয়ের সুবিধা:
   ফাংশনাল প্রোগ্রামিংয়ের উপাদান হিসেবে, লেজি কালেকশন ফাংশনাল স্টাইল এ কোড লেখার সুবিধা দেয়। এতে একাধিক অপারেশনগুলি সংযুক্ত করা সহজ হয়, এবং প্রয়োজন হলে তাদের কার্যকর করা যায়।
4. ব্যক্তিগত প্রেক্ষিত (Personalization):
   লেজি কালেকশন প্রোগ্রামের অংশ হিসেবে ব্যক্তি-ভিত্তিক প্রক্রিয়াগুলি দ্রুত কাজ করে, যেখানে প্রতিটি ইন্টেনশন বা অপারেশন শুধু তখনই চালিত হয় যখন এটি ব্যবহারকারীর পক্ষে দরকারি।

লেজি কালেকশন ব্যবহার করার উদাহরণ:

1. স্ট্রিম (Stream) ব্যবহার:
   স্কালাতে স্ট্রিম একটি সাধারণ উদাহরণ যেখানে ডেটা লেজি লোডিং এবং প্রসেসিং করা হয়।

   val numbers = (1 to 1000).toStream  // এটা লেজি রেঞ্জ তৈরি করবে
   val result = numbers.map(_ * 2).filter(_ > 50).take(10)
   println(result)  // শুধুমাত্র প্রথম 10 উপাদান প্রক্রিয়া হবে

2. লেজি ফিল্টার (Lazy Filtering):
   এখানে, লেজি ফিল্টার ব্যবহার করা হয়েছে যেটি ডেটা শর্তসাপেক্ষে প্রসেস করে।

   val range = (1 to 1000).toStream
   val filtered = range.filter(_ % 2 == 0).take(10)
   println(filtered)  // প্রথম 10টি জোড় সংখ্যা

সারাংশ:

লেজি কালেকশন স্কালাতে খুবই শক্তিশালী একটি কৌশল, যা ডেটা প্রক্রিয়াকরণে প্রয়োজন অনুযায়ী (ডেটার উপর কাজ করার সময়) কার্যকরী অপারেশনগুলি চালায়, অর্থাৎ শুধুমাত্র প্রয়োজনীয় সময়েই প্রসেসিং সম্পন্ন হয়। এটি মেমোরি ব্যবহারকে অপটিমাইজ করে, ডেটা প্রক্রিয়াকরণ দ্রুত করে এবং বড় ডেটাসেট সঠিকভাবে পরিচালনা করার সুযোগ দেয়। ফাংশনাল প্রোগ্রামিং কৌশল ব্যবহার করতে স্কালায় লেজি কালেকশন গুরুত্বপূর্ণ ভূমিকা পালন করে।

স্কালাতে ইনফিনিট ডেটা স্ট্রাকচারস এবং স্ট্রিমস ব্যবহার করে আপনি সীমাহীন (infinite) ডেটার উপর অপারেশন করতে পারেন। এটি অনেক ক্ষেত্রেই অত্যন্ত কার্যকর, যেমন গণনা বা সিকোয়েন্স তৈরি করা যেখানে ডেটার পরিমাণ পূর্বানুমান করা সম্ভব নয় বা সীমাবদ্ধ নয়। স্কালার স্ট্রিমস একটি সিকোয়েন্স যা ডেমান্ড অনুযায়ী ডেটা উৎপন্ন করতে পারে, অর্থাৎ, এটি লেনজি (lazy) হতে পারে।

১. স্ট্রিমস (Streams) - ইনফিনিট ডেটা স্ট্রাকচার

স্ট্রিম হলো একটি ডেটা স্ট্রাকচার যা অসীম বা সীমাবদ্ধ ডেটার সিকোয়েন্স ধারণ করতে পারে, তবে এটি lazy evaluation ব্যবহার করে। অর্থাৎ, স্ট্রিমের উপাদানগুলো তখনই তৈরি হয় যখন সেগুলো অ্যাক্সেস করা হয়। এতে স্ট্রিমের উপাদানগুলো নির্দিষ্ট পরিমাণে মেমোরিতে সংরক্ষিত না হয়ে, প্রয়োজন অনুযায়ী স্ট্রিমের মধ্যে উৎপন্ন হতে থাকে।

স্ট্রিমের সুবিধা:

• Lazy evaluation: শুধুমাত্র যখন ডেটা প্রয়োজন হয় তখনই স্ট্রিমের উপাদানগুলো তৈরি হয়, যা মেমোরি দক্ষতা বাড়ায়।
• Infinite sequences: স্ট্রিমের মাধ্যমে অসীম সিকোয়েন্স তৈরি করা সম্ভব।
• Composability: স্ট্রিমগুলিকে বিভিন্ন ফাংশনাল অপারেশন দিয়ে একত্রিত করা যায় যেমন map, filter, fold, ইত্যাদি।

স্ট্রিম তৈরির পদ্ধতি:

স্কালাতে স্ট্রিম তৈরি করার জন্য Stream অবজেক্ট ব্যবহার করা হয়। এটি cons (head) এবং tail (rest) নামে দুটি প্রধান উপাদান ধারণ করে।

২. স্ট্রিম তৈরির উদাহরণ

1. ইনফিনিট ন্যাচারাল নাম্বার স্ট্রিম:
   স্ট্রিম ব্যবহার করে আপনি সহজেই অসীম সিকোয়েন্স তৈরি করতে পারেন। উদাহরণস্বরূপ, একটি স্ট্রিম তৈরি করতে যা প্রাকৃতিক সংখ্যা ধারণ করে।

   উদাহরণ:

   val naturals: Stream[Int] = Stream.from(1)
   println(naturals.take(10).toList)  // List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

   এখানে, Stream.from(1) একটি স্ট্রিম তৈরি করছে যা প্রাকৃতিক সংখ্যাগুলি একে একে উৎপন্ন করবে। take(10) ব্যবহার করে প্রথম 10টি উপাদান গ্রহণ করা হয়েছে।

2. স্ট্রিমের মধ্যে অপারেশন:
   স্ট্রিমের উপরে আপনি সাধারণভাবে map, filter, reduce ইত্যাদি অপারেশন চালাতে পারেন।

   উদাহরণ:

   val numbers = Stream.from(1)
   val evenNumbers = numbers.filter(_ % 2 == 0).take(5).toList
   println(evenNumbers)  // List(2, 4, 6, 8, 10)

   এখানে, filter অপারেশনটি স্ট্রিমের মধ্যে শুধুমাত্র সেগুলি বেছে নিচ্ছে যেগুলি সঠিক শর্ত পূর্ণ করে।

৩. স্ট্রিমের লজিক্যাল ফিচার (Lazy Evaluation)

স্ট্রিমের একটি গুরুত্বপূর্ণ বৈশিষ্ট্য হলো lazy evaluation। এটি মানে হল যে স্ট্রিমের উপাদানগুলো তখনই তৈরি হয় যখন সেগুলি প্রয়োজন হয়। উদাহরণস্বরূপ, আপনি যদি স্ট্রিমের প্রথম 100টি উপাদান চান, তবে স্কালা শুধুমাত্র প্রথম 100টি উপাদানই তৈরি করবে, এবং পরবর্তী উপাদানগুলো তখনই তৈরি হবে যখন সেগুলি প্রয়োজন হবে।

উদাহরণ:

val stream = Stream.from(1)
val first100Numbers = stream.take(100).toList
println(first100Numbers)

এখানে, স্কালা শুধু প্রথম 100টি সংখ্যা তৈরি করবে এবং সম্পূর্ণ স্ট্রিম তৈরির জন্য কোন অতিরিক্ত গণনা বা মেমোরি বরাদ্দ করবে না।

৪. স্ট্রিমের সাথে কাজ করার অন্যান্য পদ্ধতি

1. unfold ফাংশন:
   unfold ফাংশনটি স্ট্রিম তৈরি করার একটি শক্তিশালী পদ্ধতি। এটি একটি ফাংশন ব্যবহার করে স্ট্রিমের উপাদানগুলো উৎপন্ন করে।

   উদাহরণ:

   val ones = Stream.continually(1)
   println(ones.take(5).toList)  // List(1, 1, 1, 1, 1)

2. স্ট্রিমের সাথে zip:
   দুটি স্ট্রিমকে একত্রিত করতে zip ব্যবহার করা যায়। এটি দুটি স্ট্রিমের উপাদানগুলো জোড়া করে দেয়।

   উদাহরণ:

   val stream1 = Stream(1, 2, 3)
   val stream2 = Stream("a", "b", "c")
   val zipped = stream1.zip(stream2)
   println(zipped.toList)  // List((1, "a"), (2, "b"), (3, "c"))

৫. ইনফিনিট ডেটা স্ট্রাকচারস (Infinite Data Structures)

স্ট্রিমের সাহায্যে ইনফিনিট ডেটা স্ট্রাকচার তৈরি করা সম্ভব, যেখানে ডেটা অসীম হতে পারে এবং মেমোরিতে একত্রিত না হয়ে প্রয়োজন অনুযায়ী উৎপন্ন হতে থাকে। স্কালাতে স্ট্রিমের মাধ্যমে আপনি ইনফিনিট সিকোয়েন্স তৈরি করতে পারেন, যেমন ফিবোনাচ্চি সিরিজ, প্রাইম নাম্বারস ইত্যাদি।

উদাহরণ:

ফিবোনাচ্চি সিরিজ স্ট্রিম:

val fibs: Stream[Int] = 0 #:: 1 #:: fibs.zip(fibs.tail).map{ case (a, b) => a + b }
println(fibs.take(10).toList)  // List(0, 1, 1, 2, 3, 5, 8, 13, 21, 34)

এখানে, fibs একটি স্ট্রিম যা ফিবোনাচ্চি সিরিজের মান উৎপন্ন করছে। #:: এর মাধ্যমে এটি একটি স্ট্রিমের মধ্যে নতুন উপাদান যুক্ত করছে।

সারাংশ:

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

স্কালাতে স্ট্রিম এবং লেজি কালেকশনস দুটি গুরুত্বপূর্ণ ফিচার যা ডেটা প্রক্রিয়াকরণের জন্য অত্যন্ত কার্যকরী। এগুলি লেজি (Lazy) বা অন-ডিমান্ড (on-demand) অপারেশন প্রক্রিয়া গ্রহণ করে, অর্থাৎ আপনার ডেটার সবগুলো উপাদান একসাথে লোড না করে শুধুমাত্র প্রয়োজনীয় উপাদানগুলি প্রক্রিয়া করা হয়।

১. স্ট্রিম (Streams)

স্ট্রিম হল একটি ধারাবাহিক ডেটা প্রবাহ, যা একটি ডেটা কালেকশন থেকে উপাদানগুলি একে একে পড়তে এবং প্রক্রিয়া করতে ব্যবহৃত হয়। স্কালাতে, স্ট্রিমগুলি মূলত লেজি কালেকশনস বা lazy evaluation এর সাথে সম্পর্কিত, যেখানে সমস্ত উপাদান একই সময়ে লোড বা প্রক্রিয়া করা হয় না। স্ট্রিমগুলির মধ্যে অপারেশনগুলি লেজি (Lazy) হয়, যা শুধু তখনই কার্যকরী হয় যখন এগুলিকে কোনো অপারেশন বা ফাংশন প্রয়োগ করা হয়।

২. লেজি কালেকশনস (Lazy Collections)

লেজি কালেকশনস এমন কালেকশন যা কোনো অপারেশন সম্পাদন করার সময় তাদের উপাদানগুলোকে একসাথে লোড না করে, বরং প্রয়োজনে পরবর্তী উপাদানগুলি প্রক্রিয়া করে। অর্থাৎ, লেজি কালেকশনগুলো কেবল তখনই উপাদান তৈরি বা প্রক্রিয়া করে যখন তা প্রয়োজন হয়।

স্কালাতে লেজি কালেকশনস সাধারণত Stream হিসেবে পরিচিত এবং এটি lazy val অথবা Stream ডেটা টাইপের মাধ্যমে তৈরি করা হয়।

স্ট্রিম এবং লেজি কালেকশনস এর উদাহরণ:

উদাহরণ ১: স্ট্রিম ব্যবহার

স্কালাতে Stream ডেটা টাইপটি লেজি অপারেশন করে। এখানে, স্ট্রিমের উপর যে কোনো অপারেশন প্রযোজ্য হলে, কেবলমাত্র প্রয়োজনীয় উপাদানগুলিই তৈরি করা হয়।

// Lazy evaluation using Stream
val numbers: Stream[Int] = Stream.from(1)  // Infinite Stream starting from 1
val firstTenNumbers = numbers.take(10).toList  // Only takes the first 10 numbers

println(firstTenNumbers)  // List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

এখানে, Stream.from(1) একটি ইনফিনিট স্ট্রিম তৈরি করছে যা ১ থেকে শুরু হয়, এবং take(10) ব্যবহার করে প্রথম ১০টি উপাদান নেওয়া হচ্ছে। গুরুত্বপূর্ণ ব্যাপার হলো, স্ট্রিমে উপাদানগুলো লেজি (lazy)ভাবে তৈরি হয়, তাই কেবলমাত্র যখন take(10) প্রয়োগ করা হয়, তখনই পরবর্তী ১০টি উপাদান প্রক্রিয়া হয়।

উদাহরণ ২: স্ট্রিমের সাথে লেজি অপারেশন

স্ট্রিমের সাথে লেজি অপারেশন যেমন map, filter ইত্যাদি ব্যবহার করলে প্রক্রিয়া করা হয় না যতক্ষণ না তা দরকার হয়।

val numbers: Stream[Int] = Stream.from(1)

// Applying a lazy operation
val lazySquares = numbers.map(x => x * x).take(5).toList

println(lazySquares)  // List(1, 4, 9, 16, 25)

এখানে, map অপারেশন দিয়ে প্রতিটি সংখ্যাকে স্কোয়ার করা হয়েছে, তবে উপাদানগুলো প্রক্রিয়া করা হচ্ছে লেজি (lazy)ভাবে যখন take(5) প্রয়োগ করা হয় এবং কেবলমাত্র প্রথম ৫টি উপাদান স্কোয়ার করা হয়।

উদাহরণ ৩: লেজি কালেকশনস (Lazy Collections) - Stream এর সুবিধা

স্ট্রিম ব্যবহারের আরেকটি উদাহরণ যেখানে বড় ডেটা সেটের মধ্যে খোঁজা হয়, কিন্তু স্ট্রিমের মাধ্যমে শুধুমাত্র প্রয়োজনীয় উপাদানটি পাওয়া যায়।

val largeRange = Stream.range(1, 1000000)  // Lazy sequence of numbers from 1 to 999999

// Filtering to find the first number greater than 500
val firstMatch = largeRange.filter(_ > 500).head

println(firstMatch)  // 501

এখানে, আমরা Stream.range(1, 1000000) দিয়ে একটি বড় রেঞ্জ তৈরি করেছি, কিন্তু স্ট্রিমটি লেজি এবং সুতরাং শুধুমাত্র যখন filter(_ > 500) প্রয়োগ করা হয় তখনই সেই উপাদানগুলো প্রক্রিয়া করা হয়। অতএব, প্রথম মিল পাওয়া উপাদানটি (যেমন ৫০১) ফিরে আসবে, এবং স্ক্যান করা হবে না পুরো রেঞ্জ।

উদাহরণ ৪: ইনফিনিট রেঞ্জ এবং লেজি অপারেশন

একটি ইনফিনিট রেঞ্জ তৈরি করা এবং তার উপর লেজি অপারেশন প্রয়োগ করার একটি উদাহরণ:

val infiniteRange: Stream[Int] = Stream.from(1)

// Take the first 10 odd numbers from an infinite range
val firstTenOddNumbers = infiniteRange.filter(_ % 2 != 0).take(10).toList

println(firstTenOddNumbers)  // List(1, 3, 5, 7, 9, 11, 13, 15, 17, 19)

এখানে, Stream.from(1) দিয়ে একটি ইনফিনিট স্ট্রিম তৈরি করা হয়েছে, এবং তার উপরে filter ও take(10) অপারেশন ব্যবহার করা হয়েছে শুধুমাত্র প্রথম ১০টি বিজোড় সংখ্যা পাওয়ার জন্য। কারণ স্ট্রিম লেজি, তাই শুধুমাত্র যখন take(10) প্রয়োগ করা হয় তখনই এটির উপাদান প্রক্রিয়া করা হয়।

সারাংশ:

• স্ট্রিম এবং লেজি কালেকশনস ব্যবহারে ডেটা প্রক্রিয়া করার সময় লেজি (lazy) evaluation ব্যবহার করা হয়, যেখানে উপাদানগুলো একসাথে লোড বা প্রক্রিয়া না করে প্রয়োজনের সময় তৈরি এবং প্রক্রিয়া করা হয়।
• এটি মেমরি এবং পারফরম্যান্সের দিক থেকে উপকারী হতে পারে, কারণ বড় ডেটা সেট বা অন্তহীন ডেটা ডাইনামিকভাবে হ্যান্ডেল করা যায়।
• Stream ব্যবহার করে স্ট্রিম থেকে শুধু প্রয়োজনীয় উপাদানগুলি তোলা যায়, এবং বিভিন্ন লেজি অপারেশন যেমন map, filter, take, drop ইত্যাদি এর সাথে ব্যবহার করা যায়।

এই ফিচারটি বিশেষভাবে তখন কার্যকরী, যখন বড় ডেটা সেটের সাথে কাজ করা হয় অথবা আপনি যদি সীমিত বা নির্দিষ্ট সংখ্যক উপাদান প্রক্রিয়া করতে চান।