मुझे पता है कि इसे लागू करने का एक तरीका यह है कि राज्य में हर बार एक बदलाव आने पर इसे फिर से स्थापित किया जाए, हालांकि यह अव्यावहारिक लगता है।
यदि किसी घटना के होने पर लागू होने वाले परिवर्तन एक या दूसरे तरीके से वितरण योग्य नहीं होते हैं, तो आपको हर बार किसी घटना के होने पर राज्य को फिर से स्थापित करना होगा, क्योंकि अंतिम स्थिति प्रारंभिक राज्य के अलावा और कुछ नहीं है, साथ ही क्रमिक परिवर्तन भी हैं। और यहां तक कि अगर परिवर्तन वितरित होते हैं, तो आप आमतौर पर एक राज्य को अगले एक में बदलना चाहते हैं, क्योंकि आप अपनी प्रक्रिया को एक दिए गए राज्य तक पहुंचाने के रूप में तेजी से रोकना चाहते हैं, और चूंकि आपको यह निर्धारित करने के लिए अगले राज्य की गणना करना है कि क्या नया एक वांछित राज्य है।
कार्यात्मक प्रोग्रामिंग में, राज्य परिवर्तन आमतौर पर फ़ंक्शन कॉल और / या फ़ंक्शन मापदंडों द्वारा दर्शाए जाते हैं।
जैसा कि आप अनुमान नहीं लगा सकते हैं कि अंतिम स्थिति की गणना कब की जाएगी, आपको गैर-पूंछ पुनरावर्ती फ़ंक्शन का उपयोग नहीं करना चाहिए। राज्यों की एक धारा, जिसमें प्रत्येक राज्य पिछले एक पर आधारित है, एक अच्छा विकल्प हो सकता है।
तो आपके मामले में, मैं निम्नलिखित कोड द्वारा, स्काला में प्रश्न का उत्तर दूंगा:
import scala.util.Random
val initState = 0.0
def nextState(state: Double, event: Boolean): Double = if(event) state + 0.3 else state - 0.1 // give a new state
def predicate(state: Double) = state >= 1
// random booleans as events
// nb: must be a function in order to force Random.nextBoolean to be called for each element of the stream
def events(): Stream[Boolean] = Random.nextBoolean #:: events()
val states: Stream[Double] = initState #:: states.zip(events).map({ case (s,e) => nextState(s,e)}) // a stream of all the successive states
// stop when the state is >= 1 ;
// display all the states computed before it stopped
states takeWhile(! predicate(_)) foreach println
उदाहरण के लिए, मैं (आउटपुट को सरल कर सकता हूं):
0.0
0.3
0.2
0.5
0.8
val states: Stream[Double] = ... वह रेखा है जहाँ क्रमिक अवस्थाओं की गणना की जाती है।
इस धारा का पहला तत्व प्रणाली की प्रारंभिक स्थिति है। zipतत्वों की जोड़ी की एक धारा में घटनाओं की धारा के साथ राज्यों की धारा को मिलाता है, प्रत्येक जोड़ी एक (राज्य, घटना) है। mapप्रत्येक जोड़ी को नए राज्य होने के एक एकल मान में बदल देता है, जिसे पुराने राज्य के एक समारोह और संबंधित घटना के रूप में गणना की जाती है। एक नया राज्य इसलिए पहले से गणना की गई स्थिति है, साथ ही संबद्ध घटना जो राज्य को "संशोधित" करती है।
इसलिए मूल रूप से, आप राज्यों की एक संभावित अनंत धारा को परिभाषित करते हैं, प्रत्येक नया राज्य अंतिम गणना राज्य का एक कार्य और एक नई घटना है। चूंकि स्काला (दूसरों के बीच) में धाराएं आलसी हैं, इसलिए केवल मांग पर गणना की जाती है, इसलिए आपको बेकार राज्यों की गणना करने की आवश्यकता नहीं है, और आप जितने चाहें उतने राज्यों की गणना कर सकते हैं।
यदि आप केवल पहले राज्य में रुचि रखते हैं जो विधेय का सम्मान करता है, तो कोड की अंतिम पंक्ति को प्रतिस्थापित करें:
states find predicate get
जो पुनर्प्राप्त करता है:
res7: Double = 1.1