লাসাগনা বিশারদ

ছোট ওয়ার্ডের জন্য স্ট্যাক জাগলিং ঠিক আছে। কোনো ওয়ার্ডে যখন একাধিক ইনপুট থাকে আর সেগুলোকে নাম ধরে ডাকতে হয়, তখন Factor দেয় লোকাল, অর্থাৎ নামযুক্ত বাইন্ডিং, যেগুলো চালু করা হয় :: (ওয়ার্ড ডিফিনিশনের জন্য) বা [| | ] (ইনলাইন ল্যাম্বডার জন্য) দিয়ে।

:: ( inputs -- outputs )

: এর জায়গায় :: বসালে ইনপুটের নামগুলোই বডির ভেতরে লোকাল ভ্যারিয়েবল হয়ে যায়:

USING: locals ;

:: hypotenuse ( a b -- c )
    a a *
    b b *
    + sqrt ;

এবার স্ট্যাক এলোমেলো করে করা সংস্করণটির সঙ্গে তুলনা করুন:

! DOCTEST: SKIP   (shown for comparison — would re-define hypotenuse)
: hypotenuse ( a b -- c )
    [ sq ] bi@ + sqrt ;

দুটোই বৈধ। কোনো ইনপুট একাধিকবার ব্যবহার হলে, বা কাজের ক্রম স্বাভাবিকভাবে স্ট্যাকের ক্রমের সঙ্গে না মিললে, লোকাল সবচেয়ে ভালো কাজ করে।

:> দিয়ে মধ্যবর্তী মান বাইন্ড করা

:: বডির ভেতরে (বা ইনলাইন [| ... |] ল্যাম্বডায়) :> ডেটা স্ট্যাক থেকে একটি মান তুলে নিয়ে নতুন একটি লোকালে বাইন্ড করে:

value :> name      ! immutable binding
value :> name!     ! mutable binding (name! is its setter)

অপরিবর্তনীয় রূপটিই বেশি ব্যবহৃত হয়। এটি দিয়ে কোনো মধ্যবর্তী মানের নাম দিন, যাতে বডিটা উপর থেকে নিচে পড়া যায়:

USING: locals math ;

:: average-3 ( x y z -- avg )
    x y + z + :> sum
    sum 3 / ;

! যুক্ত রূপটি লোকালটিকে পরিবর্তনযোগ্য ঘোষণা করে; পরে বডির ভেতরে value name! (কোলন নেই, :> নেই) দিয়ে সেটির মান আবার বসানো হয়:

USING: kernel locals math math.order ;

:: clamped ( x lo hi -- y )
    x :> v!
    v lo < [ lo v! ] when
    v hi > [ hi v! ] when
    v ;

পরের অনুশীলনীগুলোতে যেসব ইটারেশন ওয়ার্ডের সঙ্গে পরিচয় হবে (যেমন while), সেখানে পরিবর্তনযোগ্য লোকাল সবচেয়ে ভালো কাজ করে।

[let দিয়ে যেকোনো জায়গা থেকেই স্কোপ তৈরি

:> কেবল একটি লেক্সিকাল স্কোপের ভেতরেই কাজ করে, আর :: ও [| ... |] নিজে থেকেই সেই স্কোপ তৈরি করে দেয়। সাধারণ : ওয়ার্ড থেকে বা লিসেনার থেকে লোকাল চালু করতে হলে কোডটি [let ... ] দিয়ে মুড়ে দিন:

[let code :> name code :> name ... body ]

প্রতিটি :> name আগের এক্সপ্রেশনের স্ট্যাকের একদম উপরের মানটি বাইন্ড করে; ফর্মের বাকি অংশ সেই বাইন্ডিংগুলো দেখতে পায়।

USING: locals math ;

[let 3 :> x 4 :> y x x * y y * + ] .   ! => 25

স্ট্যাক-ধাঁচের : ডিফিনিশন আর নামযুক্ত বাইন্ডিংয়ের মধ্যে সেতু হলো [let। কোনো ওয়ার্ডের কেবল একটি অংশে যদি লোকাল থেকে সুবিধা হয়, তখন এটি বেশ কাজে লাগে।

ল্যাম্বডা: [| inputs | body ]

একটি কোয়োটেশনের ভেতরে [| inputs | body ] এমন লোকাল চালু করে, যেগুলোকে বডি নাম ধরে ব্যবহার করতে পারে। assoc-map-এর মতো হায়ার-অর্ডার ওয়ার্ডের সঙ্গে এটি বিশেষভাবে কাজে লাগে, যার কোয়োটেশন key এবং value পায়:

USING: assocs locals ;

H{ { "a" 1 } { "b" 2 } }
[| key value | key value neg ] assoc-map .
! => H{ { "a" -1 } { "b" -2 } }

একই ধরনটি কাজ করে map-index-এর ক্ষেত্রেও ([sequences][sequences] ভোকাবুলারিতে), যার কোয়োটেশন এলিমেন্ট এবং তার ইনডেক্স পায়। নামগুলো স্পষ্ট করে দেয় কোন অপারেন্ড কোন ভূমিকা নেয়:

USING: locals sequences ;

! Divide each element by its 1-based position:
{ 10 80 270 } [| elt i | elt i 1 + / ] map-index .
! => { 10 40 90 }

ল্যাম্বডার স্ট্যাক ইফেক্ট নির্ধারিত হয় ইনপুট তালিকা এবং তার বডি কী তৈরি করে তা দিয়ে।

কখন লোকাল ব্যবহার করবেন

লোকাল ব্যবহার করবেন যখন:

• একই ইনপুট একাধিক জায়গায় ব্যবহার হয়।
• কাজের স্বাভাবিক ক্রম স্ট্যাকের ক্রমের সঙ্গে মেলে না, আর তা ঠিক করার dup/swap/rot পড়তে কষ্ট হয়।
• আপনি এমন একটি ইনলাইন ল্যাম্বডার ভেতরে আছেন, যা কোনো হায়ার-অর্ডার ওয়ার্ডকে দেওয়া হয়েছে, আর সেই ওয়ার্ড একসঙ্গে বেশ কয়েকটি মান দেয় (যেমন assoc-map-এ)।

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

assoc-map: একবারে একটি এন্ট্রি

assoc-map (assocs ভোকাবুলারিতে) একটি অ্যাসোসিয়েটিভ কালেকশনের প্রতিটি এন্ট্রির উপর একটি কোয়োটেশন ম্যাপ করে:

assoc-map ( assoc quot: ( key value -- newkey newvalue ) -- newassoc )

কোয়োটেশন লেখার সবচেয়ে পরিচ্ছন্ন উপায় হলো লোকাল ল্যাম্বডা।

cond আবার দেখা

f অথবা কোনো সংখ্যামান অনুযায়ী কাজ ভাগ করতে হলে cond-ই একেবারে ঠিক। এখানে case লাগে না, কারণ তুলনা করার মতো একটিমাত্র মান নেই।