कारें, इकट्ठी हों!

इस अभ्यास में आप कंडीशनल के बारे में सीखेंगे, यानी किसी वैल्यू के आधार पर दो या अधिक रास्तों में से एक चुनना। यह उन बूलियन पर आगे चलता है जो आपने Annalyn's Infiltration में सीखे थे, और उस पूर्णांक गणित पर जो Currency Conversion में था।

तुलना के शब्द

ये सभी math में रहते हैं (= के लिए kernel में):

=  ( x y -- ? )    ! equal
<  ( x y -- ? )    ! less than
<= ( x y -- ? )    ! less than or equal
>  ( x y -- ? )    ! greater than
>= ( x y -- ? )    ! greater than or equal

3 3 = .     ! => t
2 3 < .     ! => t
3 3 <= .    ! => t
3 4 = not . ! => t    (inequality: combine = with not)

zero? (math में) आम 0 = जाँच का छोटा रूप है। यह संख्या को हटा देता है और स्टैक पर यह डालता है कि वह शून्य थी या नहीं:

zero? ( n -- ? )    ! t when n is 0

रेंज की जाँच

between? (math.order में) जाँचता है कि कोई वैल्यू ऐसी रेंज में आती है या नहीं जिसमें दोनों सिरे शामिल हों। यह तब काम आता है जब कोई काम इस पर निर्भर हो कि संख्या किस दायरे में पड़ती है:

between? ( x lo hi -- ? )    ! lo <= x <= hi (inclusive)

5 1 10 between? .    ! => t
0 1 10 between? .    ! => f
10 1 10 between? .   ! => t   (inclusive at both ends)

आप इसे अक्सर cond का प्रेडिकेट के रूप में देखेंगे, जैसे dup 1 4 between?, ताकि किसी एक वैल्यू के बजाय रेंज के हिसाब से शाखा चुनी जा सके।

कोटेशन

ऊपर दिए तुलना वाले शब्द बूलियन बनाते हैं। किसी बूलियन पर काम करने के लिए आप कंडीशनल को एक या अधिक कोटेशन देते हैं। कोटेशन कोड का एक छोटा टुकड़ा होता है जो चौकोर ब्रैकेट में लपेटा रहता है, [ ... ]। इसे लिखने पर कोड चलता नहीं, बल्कि एक वैल्यू की तरह स्टैक पर चला जाता है। फिर if जैसा शब्द तय करता है कि कौन सा कोटेशन चलाना है।

[ neg ]   ! a quotation that negates the top of the stack
[ ]       ! the empty quotation — does nothing

कोटेशन के बारे में पूरी जानकारी आगे के किसी अभ्यास में मिलेगी। फिलहाल [ ... ] को "इस शाखा के लिए चलने वाला कोड" पढ़िए।

if, when, unless

if (kernel में) एक बूलियन और दो कोटेशन लेता है। जब बूलियन सही होता है तो यह पहला कोटेशन चलाता है, और जब गलत होता है तो दूसरा:

if ( ? then-quot else-quot -- )

: abs ( x -- y ) dup 0 < [ neg ] [ ] if ;

when अपना कोटेशन तभी चलाता है जब बूलियन सही हो; unless तभी जब वह गलत हो:

when   ( ? quot -- )
unless ( ? quot -- )

if*, when*, और unless*

kernel के तीन रूप बूलियन को ऐसी वैल्यू की तरह लेते हैं जिसे सही होने पर संभालकर रखना चाहिए। यह तब काम आता है जब कोई शब्द "वह चीज़, या f" लौटाता है:

if*     ( ? true false -- )    ! truthy: true is called WITH ? on stack
when*   ( ? true       -- )    ! truthy: true is called WITH ? on stack
unless* ( ? false      -- )    ! falsy: false runs and pushes a default

if* दो शाखाओं वाला रूप है। सही वाली शाखा को वैल्यू स्टैक पर रखे-रखे कॉल किया जाता है, और गलत वाली शाखा को बिना वैल्यू के कॉल किया जाता है:

42 [ ] [ "nothing" ] if* .   ! prints 42
f  [ ] [ "nothing" ] if* .   ! prints "nothing"

unless* "वैल्यू या डिफॉल्ट" का सबसे आम तरीका है। अगर वैल्यू सही है तो उसे वैसे ही छोड़ दिया जाता है; अगर वह f है तो वैल्यू हटा दी जाती है और कोटेशन चलकर उसकी जगह कोई और वैल्यू स्टैक पर डाल देता है:

"hello" [ "anonymous" ] unless* .   ! => "hello"
f       [ "anonymous" ] unless* .   ! => "anonymous"

when* if* का एक-शाखा वाला रूप है। यह अपना कोटेशन, वैल्यू को स्टैक पर रखे-रखे, तभी चलाता है जब वैल्यू सही हो; और जब वह f हो तो वैल्यू को बस हटा देता है। जब आपको "वह चीज़, या f" वाला नतीजा किसी चल रही वैल्यू में जोड़ना हो और f के मामले से निपटने की ज़रूरत न हो, तब इसका इस्तेमाल कीजिए:

0 41 [ + ] when* .   ! => 41   (truthy: 41 added to the running total)
0 f  [ + ] when* .   ! => 0    (falsy: f dropped, total left untouched)

cond

जब आपके पास चुनने के लिए कई विकल्प हों, तो cond (combinators में) सबसे स्वाभाविक चुनाव है। यह { predicate body } जोड़ों का एक ऐरे लेता है और पहले ऐसे प्रेडिकेट का बॉडी चलाता है जो सही वैल्यू देता है:

USING: combinators ;

: classify ( n -- label )
    {
        { [ dup 0 <  ] [ drop "negative" ] }
        { [ dup 0 =  ] [ drop "zero"     ] }
        [ drop "positive" ]
    } cond ;

कुछ बातें ध्यान देने लायक हैं:

• जोड़ों को क्रम से आज़माया जाता है। जो पहले मेल खाता है, वही जीतता है।
• अगर अंत में प्रेडिकेट के बिना कोई प्रविष्टि हो (सिर्फ एक कोटेशन), तो वह डिफॉल्ट का काम करती है।
• हर प्रेडिकेट इनपुट को देखता है, लेकिन डेटा स्टैक को वैसे ही छोड़ देना चाहिए जैसा उसे मिला था। इसके लिए आम तरीका dup ... <test> है।
• चुने गए जोड़े का बॉडी वही स्टैक पाता है जो प्रेडिकेट ने देखा था, इसलिए वह आमतौर पर पहले इनपुट को drop करके नतीजा स्टैक पर डालता है।