Recursive Enums क्या हैं
एक recursive enum वह है जिसके अंदर इसकी खुद की एक और copy हो सकती है, nested boxes के एक set जैसा जिसमें हर एक एक छोटा box रखता है।
In this page:
Syntax
indirect enum EnumName {
case leaf(Type)
case node(EnumName, EnumName) // holds itself
}
func process(_ e: EnumName) -> Type {
switch e {
case .leaf(let v): return v
case .node(let l, let r): return process(l) /* combine */ process(r)
}
}Declaring a Recursive Enum
किसी case को indirect चिह्नित करना इसे उसी enum का एक और instance रखने देता है, recursive, tree-like structures enable करते हुए।
उदाहरण: Declaring a Recursive Enum
indirect enum ArithmeticExpression {
// Case `number`
case number(Int)
// Enum case(s): `addition(ArithmeticExpression, ArithmeticExpression)`
case addition(ArithmeticExpression, ArithmeticExpression)
}
// Declare a constant `expression`, set to `ArithmeticExpression.addition(.number(3), .number(4))`
let expression = ArithmeticExpression.addition(.number(3), .number(4))
// Print `expression` to the console
print(expression)Login to try C/C++/Java/PHP code in the editor
Evaluating a Recursive Enum
एक recursive function जो enum की structure को mirror करता है nested cases में से चल सकता है, उन्हें एक final result तक evaluate करते हुए।
उदाहरण: Evaluating a Recursive Enum
indirect enum ArithmeticExpression {
// Case `number`
case number(Int)
// Enum case(s): `addition(ArithmeticExpression, ArithmeticExpression)`
case addition(ArithmeticExpression, ArithmeticExpression)
}
// Define the function `evaluate` taking `expression` and returning an Int
func evaluate(_ expression: ArithmeticExpression) -> Int {
// Switch on `expression` and branch by case
switch expression {
// Case: `.number(let value)`
case .number(let value):
// Return `value` from this function
return value
// Case: `.addition(let left, let right)`
case .addition(let left, let right):
// Return `evaluate(left) + evaluate(right)` from this function
return evaluate(left) + evaluate(right)
}
}
// Declare a constant `expression`, set to `ArithmeticExpression.addition(.number(3), .addition(.number(4), .number(5)))`
let expression = ArithmeticExpression.addition(.number(3), .addition(.number(4), .number(5)))
// Print `evaluate(expression)` to the console
print(evaluate(expression))Login to try C/C++/Java/PHP code in the editor
Related Topics
{# common_mistakes/chapter_summary/browser_support: on Hindi pages the
view already swaps in the hi_ translation fields (or blanks these
out if untranslated), so this renders correctly for both languages
without a lang_code check here. #}
आम गलतियां
- किसी case (या पूरे enum) पर
indirectkeyword भूल जाना जो खुद को वापस refer करता है; इसके बिना, Swift type के लिए एक fixed size compute नहीं कर सकता। indirect case(एक case को indirection चाहिए चिह्नित करता है) कोindirect enum(पूरे enum को चिह्नित करता है) के साथ confuse करना, दोनों ज़रूरत के अनुसार valid हैं।- एक proper base case के बिना एक recursive enum पर एक recursive function लिखना, infinite recursion का कारण बनते हुए।
चैप्टर सारांश
- एक case जो enum के अपने type को एक associated value के रूप में रखता है उसे
indirectचिह्नित किया जाना चाहिए। indirectSwift को उस case का data inline के बजाय एक pointer के ज़रिए store करने को कहता है।- Recursive enums nested structures model करने के लिए perfect हैं जैसे arithmetic expressions या linked lists।
- किसी recursive enum को process करने वाले Functions आमतौर पर खुद recursion उपयोग करते हैं, हर case match करते हुए।
🔒
Chapter Quiz — Complete all 6 topics to unlock
0/6 topics done
Complete these topics first: