बगीचे का जमावड़ा

कभी-कभी किसी स्थिति को कई वर्ड के बीच साझा करने की ज़रूरत पड़ती है, बिना हर बार उसे उनके स्टैक इफेक्ट से गुज़ारे। Factor के डायनैमिक वेरिएबल, जो SYMBOL: से घोषित किए जाते हैं, हर वर्ड को नेमस्पेस में रखी एक वैल्यू तक पहुँच देते हैं।

SYMBOL: और SYMBOLS:

SYMBOL: name एक वेरिएबल घोषित करता है। SYMBOLS: a b c ; एक साथ कई वेरिएबल घोषित करता है:

USING: namespaces ;

SYMBOLS: counter total ;

सेट करना और पाना

set-global और get-global (namespaces में) ग्लोबल नेमस्पेस पर काम करते हैं:

set-global    ( value variable -- )
get-global    ( variable -- value )
change-global ( variable quot: ( old -- new ) -- )

0 counter set-global
counter get-global .         ! => 0
counter [ 10 + ] change-global
counter get-global .         ! => 10

मॉड्यूल-लेवल की स्थिति के लिए आपको -global वाले रूप चाहिए।

with-variable से स्कोप्ड बाइंडिंग

एक डायनैमिक वेरिएबल एक दूसरे, स्कोप्ड रूप का भी समर्थन करता है। set / get / change (-global प्रत्यय के बिना) मौजूदा डायनैमिक स्कोप को पढ़ते और लिखते हैं, और with-variable (namespaces में) एक कोटेशन के चलने की अवधि के लिए नया स्कोप बनाता है:

with-variable ( value variable quot -- )
set           ( value variable -- )
get           ( variable -- value )
change        ( variable quot: ( old -- new ) -- )

वेरिएबल तब तक value से बंधा रहता है जब तक quot चलता है; वह लौटते ही बाइंडिंग गायब हो जाती है। इससे कोई बाहरी कॉलर एक वैल्यू "इंजेक्ट" कर सकता है, जिसे अंदर का कोड हर स्टैक सिग्नेचर से गुज़ारे बिना पढ़ सकता है।

SYMBOL: greeting

"Hello" greeting [
    greeting get .                ! => "Hello"
    "Howdy" greeting set
    greeting get .                ! => "Howdy"
    greeting [ "!" append ] change
    greeting get .                ! => "Howdy!"
] with-variable

greeting get-global .    ! => f   (the scoped binding is gone)

इस अभ्यास में हर जगह ग्लोबल रूप इस्तेमाल होता है। फिर भी, जब आप दूसरों का कोड पढ़ते हैं, तो set/get/change के इस समानांतर परिवार को पहचानना काम आता है।

म्यूटेबल वेक्टर

चूँकि डायनैमिक वेरिएबल एक रेफरेंस रखते हैं, आप किसी वेरिएबल के अंदर एक म्यूटेबल कलेक्शन रख सकते हैं और उसे उसी जगह अपडेट कर सकते हैं:

SYMBOL: history

V{ } clone history set-global
"first event" history get-global push
"second event" history get-global push
history get-global .
! => V{ "first event" "second event" }

V{ … } एक लिटरल वेक्टर है। किसी V{ } लिटरल को रखने से पहले हमेशा clone कीजिए: लिटरल अलग-अलग कॉल के बीच साझा होते हैं।

find: पहला मिलान

find (sequences में) वह पहला एलिमेंट लौटाता है जिसके लिए कोई प्रेडिकेट सही होता है, साथ ही उसका इंडेक्स भी:

find ( seq quot -- index elt/f )

अगर कुछ भी मेल नहीं खाता, तो दोनों वैल्यू f होती हैं। nip से इंडेक्स हटाना और unless* इस्तेमाल करना, यह "अगर न मिले तो डिफॉल्ट" का आम तरीका है।

reject: मैच छोड़ना

reject (जो sequences में भी है) filter का उलटा है: यह वे एलिमेंट लौटाता है जो प्रेडिकेट को पूरा नहीं करते।