গোলকধাঁধা নির্মাতা

র‍্যান্ডম

Elm-এর মতো পিউর ফাংশনাল ভাষায়, একই আর্গুমেন্ট দিয়ে কল করা একটি ফাংশনকে সর্বদা একই মান রিটার্ন করতে হয়। তাই rand : Int টাইপ সিগনেচারযুক্ত একটি ফাংশন কেবল rand = 4 হিসেবেই ইমপ্লিমেন্ট করা যায়, যা র‍্যান্ডম ইন্টিজার জেনারেট করার জন্য ভালো কোনো ইঙ্গিত নয়।

তাহলে Elm-এ আমরা কীভাবে র‍্যান্ডম মান জেনারেট করি? আমরা সমস্যাটিকে দুই ভাগে ভাগ করি: প্রথমে আমরা Random.Generator a দিয়ে যে মানটি জেনারেট করতে চাই তা বর্ণনা করি, তারপর একটি মান জেনারেট করি।

মান জেনারেট করার প্রথম উপায় হলো initialSeed : Int -> Seed দিয়ে একটি Random.Seed তৈরি করা, তারপর step : Generator a -> Seed -> ( a, Seed ) ব্যবহার করা, যা একটি মান আর একটি নতুন সিড রিটার্ন করে। মনে রাখবেন, এই দুটি ফাংশনই পিউর, তাই একই আর্গুমেন্ট দিয়ে দুইবার কল করলে একই মানই পাওয়া যাবে।

মান জেনারেট করার দ্বিতীয় উপায় হলো generate : (a -> msg) -> Generator a -> Cmd msg ব্যবহার করা, তবে এটি কেবল একটি Elm অ্যাপ্লিকেশনের ভেতরেই করা যায়। সেক্ষেত্রে Elm রানটাইম সিড জেনারেট করতে step-এর পাশাপাশি বাইরের, পিউর নয় এমন রিসোর্সও ব্যবহার করতে পারে।

এখন থেকে আমরা জেনারেটর নিয়েই আলোচনা করব।

উদাহরণ দেখানোর সুবিধার্থে ধরে নিই, initialSeed আর step দিয়ে আমরা একটি ফাংশন generate : Int -> Generator a -> List a ডিফাইন করেছি, যা একটি জেনারেটর থেকে কয়েকটি মান জেনারেট করে।

Random মডিউল নির্দিষ্ট রেঞ্জের মধ্যে ইন্টিজার আর ফ্লোট জেনারেট করার জন্য দুটি মৌলিক জেনারেটর দেয়:

generate 5 (Random.int -5 5)
    --> [0, 3, -5, 5, 0]

generate 3 (Random.float 0 5)
    --> [1.61803, 3.14159, 2.71828]

এই মানগুলো টাপলে বা মানের তালিকায় মেলানো যায়:

generate 2 (Random.list 3 (Random.int 0 3))
    --> [[0, 3, 3], [1, 3, 2]]

generate 2 (Random.pair (Random.int 0 3) (Random.float 10 10.3))
    --> [(0, 10.23412), (2, 10.17094)]

elm-community/random-extra প্যাকেজ নানা ডেটা স্ট্রাকচারের জন্য আরও অনেক জেনারেটর দেয়: স্ট্রিং, তারিখ, ডিকশনারি, অ্যারে, সেট ইত্যাদি।

Random.constant ব্যবহার করে আমরা এমন জেনারেটর বানাতে পারি যেগুলো কেবল একটি মানই রিটার্ন করে:

generate 4 (Random.constant "hello")
    --> ["hello", "hello", "hello", "hello"]

Random.uniform ব্যবহার করে আমরা দেওয়া এলিমেন্টগুলো থেকে সমান সম্ভাবনায় র‍্যান্ডমভাবে বেছে নিতে পারি:

generate 5 (Random.uniform Red [Green, Blue])
    --> [Red, Blue, Blue, Green, Red]

Random.uniform দুটি আর্গুমেন্ট নেয় (Red আর [Green, Blue]), যাতে বেছে নেওয়ার জন্য অন্তত একটি মান থাকা নিশ্চিত হয়, কারণ একটি তালিকা তো খালিও থাকতে পারে।

Random.weighted দিয়ে আমরা সম্ভাবনাগুলো একটু বদলাতেও পারি:

generate 5 (Random.weighted (80, Red) [(15, Green), (5, Blue)])
    --> [Red, Red, Green, Red, Red]

মানগুলোর যোগফল ১০০ হতে হবে না, যাই হোক সেগুলো রিনরমালাইজ হয়ে যাবে।

Random.map দিয়ে আমরা একটি জেনারেটরের ভেতরে পৌঁছাতে পারি:

generate 3 (Random.int 1 6 |> Random.map (\n -> n * 10))
    --> [30, 60, 10]

আরও জেনারেটর মেলাতে আমরা Random.map2 থেকে শুরু করে Random.map5 পর্যন্ত ব্যবহার করতে পারি:

position =
    Random.map3
      (\x y z -> Position x y z)
      (Random.float -100 100)
      (Random.float -100 100)
      (Random.float -100 100)

generate 1 position
    --> [Position 33.788 -98.321 10.0845]

আরও জটিল ব্যবহারের জন্য আছে Random.andThen : (a -> Generator b) -> Generator a -> Generator b, যা একটি জেনারেটরের জেনারেট করা মান ব্যবহার করে আরেকটি জেনারেটর বানাতে পারে:

bool = Random.uniform True [False]

failHalfOfTheTime : Generator a -> Generator (Maybe a)
failHalfOfTheTime generator =
    bool
        |> Random.andThen
            (\boolResult ->
                if boolResult then
                    Random.map Just generator

                else
                    Random.constant Nothing
            )

generate 6 (Random.int 0 1 |> failHalfOfTheTime)
    --> [Nothing, Just 1, Just 0, Nothing, Just 1, Nothing]

মাঝে মাঝে একটি জেনারেটরকে নিজের ভেতরেই রিকার্সিভভাবে ডিফাইন করা দরকার হয়। সেসব ক্ষেত্রে কম্পাইলার যাতে জেনারেটরটিকে অসীমভাবে আনরোল না করে, সেজন্য আপনাকে Random.lazy ব্যবহার করতে হতে পারে।

type Peano
    = Zero
    | Next Peano


peano : Generator Peano
peano =
    Random.uniform (Random.constant Zero)
        [ Random.map Next (Random.lazy (\_ -> peano))
        ]
        |> Random.andThen identity

generate 12 peano
    --> [Zero, Next(Next(Zero)), Zero, Next(Zero), Zero, Zero, Next(Zero), Zero, Zero, Next(Zero), Next(Next(Next(Zero)))]

উদাহরণটি একটু ভারী, তাই চলুন এটা ভেঙে দেখি।

Peano এমন একটি টাইপ যা ধনাত্মক ইন্টিজার বোঝায়: Zero হলো ০, Next(Zero) হলো ১, Next(Next(Zero)) হলো ২, ইত্যাদি। আমরা peano ডিফাইন করেছি যাতে এটি আমাদের একটি র‍্যান্ডম Peano সংখ্যা দেয়।

প্রথমেই মনে রাখবেন, Random.lazy লজিকে নতুন কিছু যোগ করে না, এটি কেবল কম্পাইলারকে অনন্তকাল ধরে peano-র ভেতরে peano লিখতে থাকা থেকে আটকায়।

আমরা Random.uniform দিয়ে বেছে নিই শূন্য (৫০% সম্ভাবনায়) আর আরেকটি Peano সংখ্যার সঙ্গে এক যোগ করা মানের (৫০% সম্ভাবনায়) মধ্যে। তবে আগের উদাহরণের মতো নয়, এখানে Random.uniform মান (যেমন Zero) থেকে বেছে নিচ্ছে না, বরং জেনারেটর (যেমন Random.constant Zero) থেকে বেছে নিচ্ছে, কারণ আমরা peano-কে নিজেই ব্যবহার করতে চাই। এর মানে Random.uniform যে মান রিটার্ন করবে তার টাইপ হবে Generator (Generator Peano), যা আমাদের দরকার নয়।

জেনারেটরটিকে "ফ্ল্যাট" করতে আমরা এটিকে Random.andThen : (a -> Generator b) -> Generator a -> Generator b-এ পাইপ করি, যেখানে আমরা চাই b হবে Peano। যেহেতু Generator a হলো Generator (Generator Peano), তাই a-কে হতে হবে Generator Peano, আর (a -> Generator b) ফাংশনের টাইপ হতে হবে (Generator Peano -> Generator Peano)। আমরা কিছুই বদলাতে চাই না, তাই identity-ই সঠিক পছন্দ।

সবশেষে, peano আসলে কেমন সংখ্যা তৈরি করবে? আমরা জানি, এটি ৫০% সময়ে ০ তৈরি করবে, আর ৫০% সময়ে নিজের আরেকটি ইটারেশনের সঙ্গে এক যোগ করা মান তৈরি করবে। অর্থাৎ সংখ্যাগুলো হবে ০ (৫০% সময়ে), ১ (২৫% সময়ে), ২ (১২% সময়ে), ৩ (৬% সময়ে) ইত্যাদি। peano ইচ্ছেমতো বড় সংখ্যাও তৈরি করতে পারে, তবে সম্ভাবনা সূচকীয়ভাবে কমতে থাকে।