यह हास्केल कैसे कार्य समझ कार्य का उपयोग कर क्रमपरिवर्तन की गणना करने के लिए काम करता है?

Question

मैं पढ़ रहा हूँ साइमन थॉम्पसन के हास्केल: कार्यात्मक प्रोग्रामिंग की क्राफ्ट, और मैं यह कैसे काम करता है सोच रहा हूँ:

perms [] = [[]] 
perms xs = [ x:ps | x <- xs , ps <- perms (xs\\[x]) ] 

मैं समझ कैसे कि perms(xs\\[x]) कार्य करने के लिए माना जाता है नहीं कर पा रहे। एक दो तत्व सूची का पता लगाने पता चलता है:

perms [2,3] 
    [ x:ps | x <- [2,3] , ps <- perms ([2,3] \\ [x]) ]  exe.1 
    [ 2:ps | ps <- perms [3] ] ++ [ 3:ps | ps <- perms [2] ] exe.2 
    ... 

कैसे आप exe.2 करने के लिए exe.1 से जाते हैं?

Answer 1

यह मूल रूप से कहते हैं:

1. सूची xs (x <- xs) से किसी भी x लो
2. ps ले लो (नष्ट x साथ अर्थात xs) है कि सूची xs\\[x] के क्रमचय - perms (xs\\[x])
3. वापसी परिणाम।

perms(xs\\[x]) पुनरावर्ती कॉल कि xs से x हटाता है।

Answer 2

ठीक है, यह और 3 क्रमशः [2,3] \\ [x] में सम्मिलित करता है। तो तुम

[ 2:ps | ps <- perms ([2,3] \\ [2]) ] ++ [ 3:ps | ps <- perms ([2,3] \\ [3]) ] 

है और चूंकि \\ अंतर ऑपरेटर है, अर्थात यह जो दूसरी सूची में नहीं हैं पहली सूची के तत्वों देता है, परिणाम [3] और [2] क्रमशः है।