एफ # में x ++ (जहां x: int ref) को परिभाषित करने के लिए कैसे करें?

Question

मैं वर्तमान में इस सुविधा का उपयोग

let inc (i : int ref) = 
    let res = !i 
    i := res + 1 
    res 

++

let str = input.[inc index] 

कैसे वेतन वृद्धि ऑपरेटर को परिभाषित तरह बातें लिखने के लिए, ताकि मैं

let str = input.[index++] 

Answer 1

लिख सकता है आप में पोस्टफ़िक्स ऑपरेटरों को परिभाषित नहीं कर सकते एफ # - 4.4 Operators and Precedence देखें। आप बनाने के लिए सहमत अगर इसके बजाय यह उपसर्ग, तो आप उदाहरण के लिए, परिभाषित कर सकते हैं,

let (++) x = incr x; !x 

और नीचे के रूप में इसका इस्तेमाल करते हैं:

let y = ref 1 
(++) y;; 

val y : int ref = {contents = 2;} 

अद्यतन: के रूप में fpessoa ने बताया ++ नहीं हो सकता एक वास्तविक उपसर्ग ऑपरेटर के रूप में उपयोग किया जाता है, वास्तव में (here और there देखें, वैध F # उपसर्ग ऑपरेटरों वाले वर्णों और वर्ण अनुक्रमों के नियमों के लिए)।

दिलचस्प है, एकल + प्रयोजन के लिए अतिभारित किया जा सकता:

let (~+) x = incr x; !x 

let y = ref 1 
+y;; 

val y : int ref = {contents = 2;} 

फिर भी अनुमति देता है, यह समझ में आता है उल्लेख करने के लिए इस तरह एक सरणी पुनरावृत्ति के विचार

नीचे

let v = [| 1..5 |] 
let i = ref -1 
v |> Seq.iter (fun _ -> printfn "%d" v.[+i]) 

"पठनीयता" के लिए कम से कम सेंट दिखता है बेवकूफ कार्यात्मक तरीके से तुलना में रेंज

[|1..5|] |> Seq.iter (printfn "%d") 

जो कुछ आरंभिक रूप से मूल प्रश्नों पर टिप्पणियों में व्यक्त हुए थे।

Answer 2

मैं इसे एक उपसर्ग ऑपरेटर के रूप में लिखने की कोशिश कर रहा था, लेकिन आप उचित उपसर्ग ऑपरेटर के रूप में (++) को परिभाषित नहीं कर सकते हैं, यानी, उदाहरण के लिए ++ y जैसी चीजें चलाएं (उदाहरण के लिए) के लिए (! +):

let (!+) (i : int ref) = incr i; !i 

let v = [| 1..5 |] 
let i = ref -1 
[1..5] |> Seq.iter (fun _ -> printfn "%d" v.[!+i]) 

क्षमा करें, लेकिन मुझे लगता है कि जवाब यह है कि वास्तव में आप ऐसा भी नहीं कर सकते हैं।