Corecursion
கணினி அறிவியலில், கோர்கர்ஷன் என்பது ஒரு வகை செயல்பாடாகும், இது மறுபயன்பாட்டிற்கு இரட்டை ஆகும். மறுநிகழ்வு பகுப்பாய்வு ரீதியாக செயல்படுகிறது, ஒரு அடிப்படை வழக்கில் இருந்து மேலும் தரவைத் தொடங்கி, அதை சிறிய தரவுகளாக உடைத்து, ஒரு அடிப்படை வழக்கை அடையும் வரை மீண்டும் மீண்டும் செய்கிறது, கோர்கர்ஷன் செயற்கை முறையில் செயல்படுகிறது, ஒரு அடிப்படை வழக்கில் தொடங்கி அதை உருவாக்குகிறது, மீண்டும் மீண்டும் ஒரு அடிப்படை வழக்கில் இருந்து மேலும் அகற்றப்பட்ட தரவை உருவாக்குகிறது. எளிமையாகச் சொன்னால், கோர்கர்ஸிவ் அல்காரிதம்கள் தாங்களாகவே உற்பத்தி செய்யும் தரவைப் பயன்படுத்துகின்றன, பிட் மூலம் பிட், அவை கிடைக்கும்போது, மேலும் தேவைப்படுவதால், மேலும் பிட் தரவுகளை உருவாக்குகின்றன. இதேபோன்ற ஆனால் தனித்துவமான கருத்து ஜெனரேட்டிவ் ரிகர்ஷன் ஆகும், இது கோர்கர்ஷன் மற்றும் ரிகர்ஷனில் உள்ளார்ந்த ஒரு திட்டவட்டமான "திசை" இல்லாமல் இருக்கலாம். மறுநிகழ்வு நிரல்களை தன்னிச்சையாக சிக்கலான தரவுகளில் செயல்பட அனுமதிக்கும் போது, அவை எளிய தரவுகளாக (அடிப்படை நிகழ்வுகள்) குறைக்கப்படும் வரை, கோர்கர்ஷன் நிரல்களை ஸ்ட்ரீம்கள் போன்ற தன்னிச்சையாக சிக்கலான மற்றும் எல்லையற்ற தரவு கட்டமைப்புகளை உருவாக்க அனுமதிக்கிறது, இது வரையறுக்கப்பட்ட படிகளின் வரிசையில் எளிய தரவுகளிலிருந்து (அடிப்படை நிகழ்வுகள்) தயாரிக்கப்படும் வரை. மறுநிகழ்வு முடிவடையாத இடங்களில், ஒரு அடிப்படை நிலையை ஒருபோதும் எட்டாத நிலையில், மைய சுழற்சி ஒரு அடிப்படை நிலையில் இருந்து தொடங்குகிறது, இதனால் அடுத்தடுத்த படிகளை தீர்மானகரமாக உருவாக்குகிறது, இருப்பினும் அது காலவரையின்றி தொடரக்கூடும் (இதனால் கடுமையான மதிப்பீட்டின் கீழ் முடிவடையாது), அல்லது அது உற்பத்தி செய்வதை விட அதிகமாக உட்கொள்ளலாம், இதனால் உற்பத்தி செய்யாததாக மாறும். பாரம்பரியமாக மறுநிகழ்வாக பகுப்பாய்வு செய்யப்படும் பல செயல்பாடுகள் மாற்றாக, மற்றும் விவாதிக்கக்கூடிய வகையில் மிகவும் இயற்கையாகவே, ஒரு குறிப்பிட்ட கட்டத்தில் நிறுத்தப்படும் கோர்கர்ஸிவ் செயல்பாடுகளாக விளக்கப்படலாம், எடுத்துக்காட்டாக காரணி போன்ற மறுநிகழ்வு உறவுகள். கோர்கர்ஷன் முடிவுகளாக வரையறுக்கப்பட்ட மற்றும் எல்லையற்ற தரவு கட்டமைப்புகள் இரண்டையும் உருவாக்க முடியும், மேலும் சுய-குறிப்பு தரவு கட்டமைப்புகளைப் பயன்படுத்தலாம். கோரகர்ஷன் பெரும்பாலும் சோம்பேறி மதிப்பீட்டுடன் இணைந்து பயன்படுத்தப்படுகிறது, இது எல்லையற்ற கட்டமைப்பின் ஒரு வரையறுக்கப்பட்ட துணைக்குழுவை மட்டுமே உருவாக்குகிறது (ஒரே நேரத்தில் ஒரு முழு எல்லையற்ற கட்டமைப்பை உருவாக்க முயற்சிப்பதை விட). கோர்கர்ஷன் என்பது செயல்பாட்டு நிரலாக்கத்தில் ஒரு முக்கியமான கருத்தாகும், இதில் கோர்கர்ஷன் மற்றும் கோடாட்டா ஆகியவை மொத்த மொழிகளை எல்லையற்ற தரவு கட்டமைப்புகளுடன் வேலை செய்ய அனுமதிக்கின்றன. எடுத்துக்காட்டுகள் கோரகர்ஷனை மறுநிகழ்வுக்கு மாறாக புரிந்து கொள்ள முடியும், இது மிகவும் பரிச்சயமானது. கோர்கர்ஷன் முதன்மையாக செயல்பாட்டு நிரலாக்கத்தில் ஆர்வமாக இருக்கும்போது, அதை கட்டாய நிரலாக்கத்தைப் பயன்படுத்தி விளக்கப்படலாம், இது பைத்தானில் உள்ள ஜெனரேட்டர் வசதியைப் பயன்படுத்தி கீழே செய்யப்படுகிறது. இந்த எடுத்துக்காட்டுகளில் உள்ளூர் மாறிகள் பயன்படுத்தப்படுகின்றன, மேலும் மதிப்புகள் கட்டாயமாக (அழிவுகரமாக) ஒதுக்கப்படுகின்றன, இருப்பினும் இவை தூய செயல்பாட்டு நிரலாக்கத்தில் கோர்கர்ஷனில் தேவையில்லை. தூய செயல்பாட்டு நிரலாக்கத்தில், உள்ளூர் மாறிகளுக்கு ஒதுக்குவதை விட, இந்த கணக்கிடப்பட்ட மதிப்புகள் ஒரு மாறாத வரிசையை உருவாக்குகின்றன, மேலும் முந்தைய மதிப்புகள் சுய-குறிப்பு மூலம் அணுகப்படுகின்றன (வரிசையில் பிந்தைய மதிப்புகள் கணக்கிடப்பட வேண்டிய வரிசையில் முந்தைய மதிப்புகளைக் குறிப்பிடுகின்றன). இந்த பணிகள் வெறுமனே கட்டாய முன்னுதாரணத்தில் இதை வெளிப்படுத்துகின்றன, மேலும் கணக்கீடுகள் எங்கு நிகழ்கின்றன என்பதை வெளிப்படையாகக் குறிப்பிடுகின்றன, இது விளக்கத்தை தெளிவுபடுத்த உதவுகிறது. காரணி மறுநிகழ்வுக்கு ஒரு உன்னதமான எடுத்துக்காட்டு காரணி கணக்கிடுவதாகும், இது 0 ஆல் மீண்டும் மீண்டும் வரையறுக்கப்படுகிறது! : = 1 மற்றும் n! : = n × (n-1)! கொடுக்கப்பட்ட உள்ளீட்டில் அதன் முடிவை மீண்டும் மீண்டும் கணக்கிட, ஒரு மறுநிகழ்வு செயல்பாடு (ஒரு நகல்) தன்னை வேறு (ஏதோ ஒரு வகையில் "சிறியது") உள்ளீட்டுடன் அழைக்கிறது மற்றும் அதன் முடிவை உருவாக்க இந்த அழைப்பின் முடிவைப் பயன்படுத்துகிறது. அடிப்படை வழக்கு எட்டப்படாவிட்டால், தொடர்ச்சியான அழைப்பு அதையே செய்கிறது. இவ்வாறு செயல்பாட்டில் ஒரு அழைப்பு அடுக்கு உருவாகிறது. எடுத்துக்காட்டாக, ஃபாக் (3) ஐக் கணக்கிட, இது ஃபாக் (2), ஃபாக் (1), ஃபாக் (0) (அடுக்கை மூடுதல்) என்று திரும்பத் திரும்ப அழைக்கிறது, இந்த கட்டத்தில் மறுநிகழ்வு ஃபாக் (0) = 1 உடன் முடிவடைகிறது, பின்னர் அடுக்கு தலைகீழ் வரிசையில் ஓய்வெடுக்கிறது மற்றும் முடிவுகள் அழைப்பு அடுக்கின் வழியாக ஆரம்ப அழைப்பு சட்டகத்தின் ஃபாக் (3) க்குத் திரும்பும் வழியில் கணக்கிடப்படுகின்றன, இது ஃபாக் (2) = 2 இன் முடிவைப் பயன்படுத்தி இறுதி முடிவை 3 × 2 = 3 × ஃபாக் (2) =: ஃபாக் (3) ஆகக் கணக்கிடுகிறது, இறுதியாக ஃபாக் (3) = 6 ஐத் திருப்புகிறது. இந்த எடுத்துக்காட்டில் ஒரு செயல்பாடு ஒற்றை மதிப்பைத் தருகிறது. இந்த அடுக்கை அவிழ்ப்பதை விளக்கலாம், காரணி மையத்தை ஒரு மறு செய்கை என வரையறுக்கலாம், அங்கு ஒருவர் வழக்குடன் தொடங்குகிறார், பின்னர் இந்த தொடக்க மதிப்பிலிருந்து 1,2,3 எண்களை அதிகரிப்பதற்கான காரணி மதிப்புகளை உருவாக்குகிறது. மேலே உள்ள மறுநிகழ்வு வரையறையில் உள்ளதைப் போல "நேர அம்பு" தலைகீழாக, அதை பின்னோக்கி வாசிப்பதன் மூலம். இது ஒரு ஜெனரேட்டராக உறுதியான முறையில் செயல்படுத்தப்படலாம். குறியீடாக, அடுத்த காரணி மதிப்பைக் கணக்கிடுவதற்கு n மற்றும் f (முந்தைய காரணி மதிப்பு) இரண்டையும் கண்காணிக்க வேண்டும் என்பதைக் குறிப்பிடுகையில், இதை பின்வருமாறு குறிப்பிடலாம்ஃ அல்லது ஹாஸ்கெல்லில், (\(n, f)-> (n + 1, f * (n + 1)) 'மறு செய்கை' (0,1) அதாவது, "தொடங்கி, ஒவ்வொரு படியிலும் அடுத்த மதிப்புகள் இவ்வாறு கணக்கிடப்படுகின்றன". இது கணித ரீதியாக சமமானது மற்றும் தொடர்ச்சியான வரையறைக்கு கிட்டத்தட்ட ஒத்திருக்கிறது, ஆனால் காரணி மதிப்புகள் கட்டமைக்கப்பட்டு வருகின்றன என்பதை வலியுறுத்துகிறது, தொடக்க வழக்கில் இருந்து முன்னோக்கி செல்கின்றன, முதலில் பின்னோக்கி சென்ற பிறகு கணக்கிடப்படுவதை விட, அடிப்படை வழக்குக்கு கீழே, ஒரு குறைப்புடன். கோர்கர்ஸிவ் செயல்பாட்டின் நேரடி வெளியீடு வெறுமனே காரணி மதிப்புகளைக் கொண்டிருக்கவில்லை, ஆனால் ஒவ்வொரு மதிப்பிற்கும் அதன் குறியீடு n இன் துணைத் தரவையும் வரிசையில் உள்ளடக்கியது, இதனால் தேவைப்படும்போது ஏதேனும் ஒரு குறிப்பிட்ட முடிவை அவை அனைத்திலும் தேர்ந்தெடுக்க முடியும். டினோடேஷனல் சொற்பொருளுடன் ஒரு தொடர்பு உள்ளது, அங்கு மறுநிகழ்வு நிரல்களின் குறிப்புகள் இந்த வழியில் மையமாக கட்டமைக்கப்பட்டுள்ளன. பைத்தானில், ஒரு தொடர்ச்சியான காரணி செயல்பாட்டை பின்வருமாறு வரையறுக்கலாம்ஃ டெஃப் காரணி (n: int)-> int: "தொடர்ச்சியான காரணி செயல்பாடு". n = = 0 என்றால்ஃ இல்லையெனில் 1 ஐத் திருப்பித் தருங்கள்ஃ n * காரணி (n-1) ஐத் திருப்பித் தருங்கள் இது 5 ஐக் கணக்கிடுவதற்கு காரணி (5) என்று அழைக்கப்படலாம்! ஒரு தொடர்புடைய கோரகர்ஸிவ் ஜெனரேட்டரை பின்வருமாறு வரையறுக்கலாம்ஃ டிஃப் ஃபாக்டோரியல்கள் (): "கோரகர்ஸிவ் ஜெனரேட்டர்". n, f = 0,1 அதேசமயம் உண்மைஃ விளைச்சல் f n, f = n + 1, f * (n + 1) இது வரிசையில் எண்ணற்ற காரணிகளின் ஓட்டத்தை உருவாக்குகிறது; அதன் ஒரு வரையறுக்கப்பட்ட பகுதியை பின்வருவன மூலம் உருவாக்க முடியும்ஃ வரையறை n _ காரணிகள் (n: int): k, f = 0,1 அதேசமயம் k <= n: விளைச்சல் f k, f = k + 1, f * (k + 1) இதை 5 வரை காரணிகளை உருவாக்க அழைக்கலாம்! மூலம்ஃ n _ காரணிகளில் f க்கு (5): அச்சிடுங்கள் (f) நாம் ஒரு குறிப்பிட்ட காரணியில் மட்டுமே ஆர்வமாக இருந்தால், கடைசி மதிப்பை மட்டுமே எடுக்க முடியும், அல்லது உற்பத்தி மற்றும் அணுகலை ஒரு செயல்பாட்டுடன் இணைக்க முடியும், டெஃப் nth _ காரணி (n: int): k, f = 0,1 அதே நேரத்தில் k <n: k, f = k + 1, f * (k + 1) திரும்பும் f. எனவே கோர்கர்ஷன் என்ற கருத்து, பொருந்தக்கூடிய இடங்களில், மறுநிகழ்வு வரையறைகள் மூலம் மறுசுழற்சி கணக்கீட்டு செயல்முறைகளின் உருவகத்தின் ஒரு விளக்கமாகும் என்று கூறலாம். ஃபைபோனாச்சி வரிசை அதே வழியில், ஃபைபோனாச்சி வரிசையை பின்வருமாறு குறிப்பிடலாம்ஃ ஃபைபோனாச்சி வரிசை வரிசை 2 இன் தொடர்ச்சியான உறவாக இருப்பதால், கோர்கர்ஸிவ் உறவு இரண்டு தொடர்ச்சியான சொற்களைக் கண்காணிக்க வேண்டும், அதனுடன் தொடர்புடையது ஒரு படிநிலையால் முன்னோக்கி நகரும், அடுத்த காலத்தை கணக்கிடுவது தொடர்பானது. இதை பின்வருமாறு செயல்படுத்தலாம் (இணையான ஒதுக்கீட்டைப் பயன்படுத்தி): டெஃப் ஃபைபோனாச்சி _ சீக்வென்ஸ் (): a, b = 0,1 அதே நேரத்தில் ட்ருஃ யீல்ட் a a, b = b, a + b ஹாஸ்கெல்லில், மேப் fst ((\(a, b)-> (b, a + b)) 'இடரேட்' (0,1)) ஆழமான-முதல் அணுகுமுறையின் மூலம் மரங்கள் கடந்து செல்லும் மரங்கள் கடந்து செல்வது மறுநிகழ்வுக்கு ஒரு சிறந்த எடுத்துக்காட்டு. இரண்டாவதாக, அகலம்-முதல் பயணத்தை கோர்கர்ஷன் மூலம் மிகவும் இயற்கையாகவே செயல்படுத்த முடியும். மீண்டும் மீண்டும், ஒருவர் ஒரு மரத்தை அதன் வேர் முனையை ஒரு தரவு கட்டமைப்பில் வைப்பதன் மூலம் கடந்து செல்லலாம், பின்னர் அது காலியாக இல்லாதபோது அந்த தரவு கட்டமைப்புடன் மீண்டும் மீண்டும் செய்யலாம், ஒவ்வொரு கட்டத்திலும் அதிலிருந்து முதல் முனையை அகற்றி, அகற்றப்பட்ட முனையின் சைல்ட் முனைகளை மீண்டும் அந்த தரவு கட்டமைப்பிற்குள் வைக்கலாம். தரவு அமைப்பு ஒரு அடுக்காக (எல்ஐஎஃப்ஓ) இருந்தால், இது ஆழம்-முதல் பயணத்தை அளிக்கிறது, மேலும் தரவு அமைப்பு ஒரு வரிசையாக (எஃப்ஐஎஃப்ஓ) இருந்தால், இது அகலம்-முதல் பயணத்தை அளிக்கிறதுஃ மறுபயன்பாட்டைப் பயன்படுத்தி, ஒரு மரத்தின் ஆழம்-முதல் பயணத்தை செயல்படுத்துகிறது. இவ்வாறு இரண்டாவது சைல்ட் சப்ட்ரீ முதல் சைல்ட் சப்ட்ரீ முடியும் வரை செயலாக்கப்படுவதில்லை. வேர் முனையின் மதிப்பு தனித்தனியாக கையாளப்படுகிறது, முதல் குழந்தை கடந்து செல்வதற்கு முன்பு (முன்கூட்டிய வரிசை பயணத்தின் விளைவாக), முதல் முடிந்த பிறகு மற்றும் இரண்டாவது (வரிசையில்) முன், அல்லது இரண்டாவது குழந்தை முனை முடிந்த பிறகு (பிந்தைய வரிசை)-மரத்தை பைனரி என்று கருதி, வெளிப்பாட்டின் எளிமைக்காக. அழைப்பு அடுக்கு (மறுநிகழ்வு பயண செயல்பாட்டு அழைப்புகளின்) மேலே குறிப்பிட்டுள்ள வெளிப்படையான LIFO கட்டமைப்பு கையாளுதலுடன் மீண்டும் மீண்டும் செய்யப்படும் அடுக்குக்கு ஒத்திருக்கிறது. குறியீடாக, "மறுநிகழ்வு" இங்கு இரண்டு அர்த்தங்களைக் கொண்டுள்ளது. முதலாவதாக, மரத்தின் குறுக்குவெட்டு செயல்பாடுகளின் தொடர்ச்சியான அழைப்புகள். மேலும் குறிப்பாக, இதன் விளைவாக வரும் மதிப்புகளின் பட்டியல் இங்கே எவ்வாறு கட்டமைக்கப்படுகிறது என்பதை நாம் எதிர்க்க வேண்டும். தொடர்ச்சியான, கீழ்-மேல் வெளியீடு உருவாக்கம் வலது-இடது மரத்தை கடந்து செல்லும். இது உண்மையில் இடது முதல் வலது வரிசையில் நிகழ்த்தப்படுவதற்கு, வரிசைமுறை சில வெளிப்புற வழிமுறைகளால் செயல்படுத்தப்பட வேண்டும், அல்லது வெளியீடு மேல்-கீழ் பாணியில் கட்டப்பட்டால் அது தானாகவே அடையப்படும், அதாவது. மையமாக. ஒரு அகலம்-முதல் டிராவர்சல் அதன் வெளியீட்டை மேல்-கீழ் வரிசையில் உருவாக்குகிறது, மையமாக, ரூட் நோடில் தொடங்கி, அதன் மதிப்பை வெளியிடுவதன் மூலமும், பின்னர் அகலம்-முதலில் சப்ட்ரீக்களை கடந்து செல்வதன் மூலமும் செயல்படுத்தப்படலாம்-அதாவது, சப்ட்ரீக்களின் முழு பட்டியலையும் அடுத்த கட்டத்திற்கு அனுப்புதல் (ஒரு சப்ட்ரீ அல்ல, மறுநிகழ்வு அணுகுமுறையைப் போல)-அடுத்த கட்டத்தில் அவற்றின் அனைத்து ரூட் நோட்களின் மதிப்புகளையும் வெளியிடுதல், பின்னர் அவற்றின் சைல்ட் சப்ட்ரீக்களை அனுப்புதல் போன்றவை. இந்த விஷயத்தில் ஜெனரேட்டர் செயல்பாடு, உண்மையில் வெளியீட்டு வரிசை, வரிசையாக செயல்படுகிறது. மேலே உள்ள காரணி உதாரணத்தைப் போலவே, குறியீட்டின் துணைத் தகவல் (எந்த படி ஒன்று, n இல் இருந்தது) முன்னோக்கி தள்ளப்பட்டது, n! இன் உண்மையான வெளியீட்டிற்கு கூடுதலாக, இந்த விஷயத்தில் மீதமுள்ள துணை மரங்களின் துணைத் தகவல் முன்னோக்கி தள்ளப்படுகிறது, உண்மையான வெளியீட்டிற்கு கூடுதலாக. குறியீடாக, ஒவ்வொரு கட்டத்திலும், இந்த மட்டத்தின் முனைகளில் உள்ள மதிப்புகளின் பட்டியலை ஒருவர் வெளியிடுகிறார், பின்னர் அடுத்த மட்டத்தின் முனைகளுக்குச் செல்கிறார். இந்த வரிசையிலிருந்து முனை மதிப்புகளை மட்டுமே உருவாக்குவதற்கு துணை சைல்ட் ட்ரீ தரவை நிராகரிக்க வேண்டும், பின்னர் பட்டியல்களின் பட்டியலைத் தட்டையாக மாற்ற வேண்டும் (மதிப்புகள் ஆரம்பத்தில் நிலை (ஆழம்) மூலம் தொகுக்கப்படுகின்றன; தட்டையானது (குழுவற்றது) ஒரு தட்டையான நேரியல் பட்டியலை வழங்குகிறது). இது விரிவாக்க ரீதியாக மேலே உள்ள விவரக்குறிப்புக்கு சமமானது. ஹாஸ்கெல்லில், கான்கட்மேப் fst (((v, ts)-> (ரூட் வேல்யூஸ் ts, சைல்ட்ட்ரீஸ் ts)) 'இடரேட்' ([], [ஃபுல்ல்ட்ரீ]) குறிப்பிடத்தக்க வகையில், ஒரு எல்லையற்ற மரத்தைக் கொடுத்தால், கோர்கர்ஸிவ் அகலம்-முதல் டிராவர்சல் அனைத்து முனைகளையும் கடந்து செல்லும், ஒரு வரையறுக்கப்பட்ட மரத்தைப் போலவே, அதே நேரத்தில் ரீகர்ஸிவ் ஆழம்-முதல் டிராவர்சல் ஒரு கிளையில் கீழே சென்று அனைத்து முனைகளையும் கடந்து செல்லாது, உண்மையில் பிந்தைய வரிசையில் கடந்து சென்றால், இந்த எடுத்துக்காட்டில் (அல்லது வரிசையில்) உள்ளபடி, அது எந்த முனைகளையும் பார்வையிடாது, ஏனெனில் அது ஒருபோதும் ஒரு இலையை அடைவதில்லை. இது எல்லையற்ற தரவு கட்டமைப்புகளைக் கையாள்வதற்கான மறுபயன்பாட்டைக் காட்டிலும் கோர்கர்ஷனின் பயனைக் காட்டுகிறது. எல்லையற்ற கிளைகளைக் கொண்ட மரங்களுக்கு ஒரு எச்சரிக்கை இன்னும் உள்ளது, அவை இடத்தை சிறப்பாக ஆராய அதிக கவனம் செலுத்த வேண்டும். இணைப்பைப் பார்க்கவும். பைத்தானில், இதை பின்வருமாறு செயல்படுத்தலாம். வழக்கமான போஸ்ட்-ஆர்டர் டெப்த்-ஃபர்ஸ்ட் டிராவர்சலை பின்வருமாறு வரையறுக்கலாம்ஃ டெஃப் டிஎஃப் (முனை): "போஸ்ட்-ஆர்டர் டெப்த்-ஃபர்ஸ்ட் டிராவர்சல்". முனை ஒன்றுமில்லை என்றால்ஃ df (node.left) df (node.right) பிரிண்ட் (node.value) இதை df (t) மூலம் அழைக்கலாம், பின்னர் மரத்தின் முனைகளின் மதிப்புகளை பிந்தைய வரிசை ஆழத்தில்-முதல் வரிசையில் அச்சிடலாம். அகலம்-முதல் கோர்கர்சிவ் ஜெனரேட்டரை பின்வருமாறு வரையறுக்கலாம்ஃ டெஃப் பி. எஃப் (மரம்): "அகலம்-முதல் கோர்கர்சிவ் ஜெனரேட்டர்". மரம் _ பட்டியல் = [மரம்] போது மரம் _ பட்டியல்ஃ புதிய _ மரம் _ பட்டியல் = [மரம் _ பட்டியலில் உள்ள மரத்திற்குஃ மரம் இல்லையென்றால்ஃ விளைச்சல் tree.value new_tree_list.append (tree.left) new_tree_list.append (tree.right) மரம் _ பட்டியல் = புதிய _ மரம் _ பட்டியல் இதை மரத்தின் முனைகளின் மதிப்புகளை அகலம்-முதல் வரிசையில் அச்சிட அழைக்கலாம்ஃ bf (t) இல் உள்ள i க்குஃ அச்சு (i) வரையறை ஆரம்ப தரவு வகைகளை சில வகை சமன்பாடுகளின் குறைந்தபட்ச நிலையான புள்ளியாக (ஐசோமார்பிசம் வரை) வரையறுக்கலாம்; ஐசோமார்பிசம் பின்னர் ஒரு ஆரம்ப இயற்கணிதத்தால் வழங்கப்படுகிறது. இரண்டு முறையும், இறுதி (அல்லது முனைய) தரவு வகைகளை ஒரு வகை சமன்பாட்டின் மிகப்பெரிய நிலையான புள்ளியாக வரையறுக்கலாம்; ஐசோமார்பிசம் பின்னர் ஒரு இறுதி நிலக்கரி இயற்கணிதத்தால் வழங்கப்படுகிறது. சொற்பொழிவின் களம் தொகுப்புகள் மற்றும் மொத்த செயல்பாடுகளின் வகையாக இருந்தால், இறுதி தரவு வகைகள் எல்லையற்ற, நன்கு நிறுவப்படாத மதிப்புகளைக் கொண்டிருக்கலாம், அதேசமயம் ஆரம்ப வகைகள் இல்லை. மறுபுறம், சொற்பொழிவின் களம் முழுமையான பகுதி வரிசைகள் மற்றும் தொடர்ச்சியான செயல்பாடுகளின் வகையாக இருந்தால், இது ஹாஸ்கெல் நிரலாக்க மொழியுடன் தோராயமாக ஒத்திருக்கிறது, பின்னர் இறுதி வகைகள் ஆரம்ப வகைகளுடன் ஒத்துப்போகின்றன, மேலும் அதனுடன் தொடர்புடைய இறுதி நிலக்கரி இயற்கணிதம் மற்றும் ஆரம்ப இயற்கணிதம் ஒரு ஐசோமார்பிசத்தை உருவாக்குகின்றன. கோரகர்ஷன் என்பது செயல்பாடுகளை மறுநிகழ்வாக வரையறுப்பதற்கான ஒரு நுட்பமாகும், அதன் வரம்பு (கோடமைன்) ஒரு இறுதி தரவு வகையாகும், இது சாதாரண மறுநிகழ்வு மறுநிகழ்வு ஒரு ஆரம்ப தரவு வகையாக இருக்கும் செயல்பாடுகளை வரையறுக்கும் விதத்திற்கு இரட்டை ஆகும். கீழேயுள்ள விவாதம் ஹாஸ்கெல்லில் பல எடுத்துக்காட்டுகளை வழங்குகிறது, அவை கோர்கர்ஷனை வேறுபடுத்துகின்றன. தோராயமாக கூறுவதானால், இந்த வரையறைகளை தொகுப்புகளின் வகைக்கு ஒருவர் போர்ட் செய்தால், அவை இன்னும் மையமாக இருக்கும். இந்த முறைசாரா பயன்பாடு ஹாஸ்கெல் பற்றி தற்போதுள்ள பாடப்புத்தகங்களுடன் ஒத்துப்போகிறது. இந்தக் கட்டுரையில் பயன்படுத்தப்பட்ட எடுத்துக்காட்டுகள், கோர்கர்ஷனை வரையறுத்து அது என்ன என்பதை விளக்கும் முயற்சிகளுக்கு முந்தையவை. கோடடா மீது பழமையான கோர்கர்ஷனுக்கான விதி தரவுகளின் மீது பழமையான மறுபயன்பாட்டிற்கான இரட்டை ஆகும். வாதத்தில் இறங்குவதற்குப் பதிலாக, அதன் கட்டமைப்பாளர்களின் வடிவத்துடன் பொருந்துவதன் மூலம் (அவை முன்பு, எங்காவது அழைக்கப்பட்டன, எனவே நாம் ஒரு ஆயத்த தரவைப் பெற்று அதன் உறுப்பு துணைப் பகுதிகளைப் பெறுகிறோம், அதாவது. "புலங்கள்"), அதன் "அழிக்கும்" (அல்லது "பார்வையாளர்கள்", பின்னர், எங்காவது அழைக்கப்படுவார்கள்-எனவே நாம் உண்மையில் ஒரு கட்டமைப்பாளரை அழைக்கிறோம், இது பின்னர் கவனிக்கப்பட வேண்டிய முடிவின் மற்றொரு பிட்டை உருவாக்குகிறது) நிரப்புவதன் மூலம் முடிவை ஏறுகிறோம். இவ்வாறு கோர்கர்ஷன் (சாத்தியமான எல்லையற்ற) கோடாட்டாவை உருவாக்குகிறது, அதேசமயம் சாதாரண மறுநிகழ்வு பகுப்பாய்வு (அவசியமாக வரையறுக்கப்பட்ட) தரவு. சாதாரண மறுசுழற்சி கோடாட்டாவுக்கு பொருந்தாது, ஏனெனில் அது நிறுத்தப்படாமல் போகலாம். இதற்கு நேர்மாறாக, முடிவு வகை தரவுகளாக இருந்தால் கோர்கர்ஷன் கண்டிப்பாக தேவையில்லை, ஏனெனில் தரவு வரையறுக்கப்பட்டதாக இருக்க வேண்டும். "Coq இல் உள்ள நீரோடைகளுடன் நிரலாக்கம்ஃ ஒரு வழக்கு ஆய்வுஃ எரடோஸ்டெனிஸின் சல்லடை" இல் நாம் hd (கான்கஸ் a s) = a til (கான்கஸ் a s) = s (சல்லடை p s) = வகுத்தல் p (hd s) என்றால் பின்னர் சல்லடை p (til s) வேறுவிதமாக கான்கஸ் (hd s) (சல்லடை p (til s)) hd (பகா எண்கள் s) = (hd s) til (பகா எண்கள் s) = பகா எண்கள் (சல்லடை (hd s) (til s)) இதில் நீரோடைக்கு (எனு 2) பகா எண்கள் செயல்பாட்டைப் பயன்படுத்துவதன் மூலம் பகா எண்கள் பெறப்படுகின்றன. மேற்கூறிய குறியீட்டைத் தொடர்ந்து, பகா எண்களின் வரிசை (அதனுடன் ஒரு த்ரோவே 0 முன்னொட்டு) மற்றும் எண்களின் நீரோடைகள் படிப்படியாக தேய்க்கப்பட்டு, ஹாஸ்கெல்லில் அல்லது (\(p, s @(h: t))-> (h, சல்லடை ht) 'மறு செய்கை' (0, [2]) என குறிப்பிடப்படலாம். ஆரம்ப நீரோட்டமாக [5,10.] உடன் அழைத்தால். ஹாஸ்கலில் மற்றொரு உதாரணம் இங்கே. பின்வரும் வரையறை நேரியல் நேரத்தில் ஃபிபோனாச்சி எண்களின் பட்டியலை உருவாக்குகிறதுஃ இழைகள் = 0:1: (+) இழைகளுடன் (வால் இழைகள்) இந்த எல்லையற்ற பட்டியல் சோம்பேறி மதிப்பீட்டைப் பொறுத்தது; கூறுகள் தேவைக்கேற்ப கணக்கிடப்படுகின்றன, மேலும் வரையறுக்கப்பட்ட முன்னொட்டுகள் மட்டுமே நினைவகத்தில் வெளிப்படையாக குறிப்பிடப்படுகின்றன. இந்த அம்சம் கோடாட்டாவின் சில பகுதிகளில் உள்ள வழிமுறைகளை நிறுத்த அனுமதிக்கிறது; அத்தகைய நுட்பங்கள் ஹாஸ்கெல் நிரலாக்கத்தின் ஒரு முக்கிய பகுதியாகும். இது பைத்தானிலும் செய்யப்படலாம்ஃ இடர்டூல்களில் இருந்து இறக்குமதி செய்யப்படும் டீ, சங்கிலி, ஐசிலைஸ், இமாப் டிஃப் ஆட் (x, y): ரிட்டர்ன் x + y டிஃப் ஃபைபோனாச்சி (): டிஃப் டெஃபர்ட் _ அவுட்புட் (): வெளியீட்டில் i க்குஃ யீல்ட் i ரிசல்ட், c1, c2 = டீ (டெஃபர்ட் _ அவுட்புட் (), 3) ஜோடி = இமாப் (ஆட், c1, ஐசலைஸ் (c2,1, எதுவும் இல்லை)) வெளியீடு = சங்கிலி ([0,1], ஜோடி) திரும்பும் முடிவு ஐசிலைஸில் i க்கு (ஃபைபோனாச்சி (), 20): பிரிண்ட் (i) ஜிப் இன் வரையறை இதில் உள்ளமைக்கப்படலாம், இது வழிவகுக்கிறதுஃ ஃபைப்ஸ் = 0 சாதாரண மறுசுழற்சி சுய-குறிப்பு செயல்பாடுகளைப் பயன்படுத்துகிறது, ஆனால் சுய-குறிப்பு தரவுகளுக்கு இடமளிக்காது. இருப்பினும், ஃபிபோனாச்சி உதாரணத்திற்கு இது அவசியமில்லை. இதை பின்வருமாறு மீண்டும் எழுதலாம்ஃ ஃபைப்ஸ் = ஃபைப்ஜென் (0,1) ஃபைப்ஜென் (x, y) = x: ஃபைப்ஜென் (y, x + y) இது முடிவை உருவாக்க சுய-குறிப்பு செயல்பாட்டை மட்டுமே பயன்படுத்துகிறது. இது கடுமையான பட்டியல் கட்டமைப்பாளருடன் பயன்படுத்தப்பட்டால், அது ஓடிப்போன மறுநிகழ்வுக்கு ஒரு எடுத்துக்காட்டாக இருக்கும், ஆனால் கண்டிப்பாக இல்லாத பட்டியல் கட்டமைப்பாளருடன் இந்த பாதுகாக்கப்பட்ட மறுநிகழ்வு படிப்படியாக காலவரையின்றி வரையறுக்கப்பட்ட பட்டியலை உருவாக்குகிறது. கோர்கர்ஷன் ஒரு எல்லையற்ற பொருளை உருவாக்க வேண்டிய அவசியமில்லை; ஒரு கோர்கர்ஷிவ் வரிசை இந்த நிகழ்வுக்கு ஒரு சிறந்த எடுத்துக்காட்டு. பின்வரும் வரையறை ஒரு பைனரி மரத்தின் அகல-முதல் பயணத்தை நேரியல் நேரத்தில், மேல்-கீழ் முறையில் உருவாக்குகிறது (ஏற்கனவே மேலே குறிப்பிடப்பட்ட தட்டையானதை உள்ளடக்கியது): தரவு மரம் a b = இலை a | கிளை b (மரம் a b) (மரம் a b) bftrav:: மரம் a b-> [மரம் a b] bftrav மரம் = மரம்ஃ ts அங்கு ts = ஜென் 1 (மரம்ஃ ts) ஜென் 0 p = [] ஜென் லென் (இலை p) = ஜென் (லென்-1) p ஜென் லென் (கிளை r: p) = l: r: ஜென் (லென் + 1) p------------------------------------------------------ இந்த பட்டியல் உள்ளீட்டு வரிசை மற்றும் முடிவு ஆகிய இரண்டிற்கும் இரட்டை நோக்கத்தை வழங்குகிறது (ஜென் லென் பி அதன் வெளியீட்டை அதன் உள்ளீட்டு பின்-சுட்டிக்காட்டி, பி, பட்டியலுடன் முன்னெடுத்துச் செல்கிறது). ஆரம்ப மரம் வரையறுக்கப்பட்டதாக இருந்தால் மட்டுமே அது வரையறுக்கப்படுகிறது. வரிசையின் நீளம் முடிவடைவதை உறுதி செய்வதற்காக வெளிப்படையாக கண்காணிக்கப்பட வேண்டும்; இந்த வரையறை எல்லையற்ற மரங்களுக்கு மட்டுமே பயன்படுத்தப்பட்டால் இதை பாதுகாப்பாக தவிர்க்க முடியும். இந்த ஹாஸ்கெல் குறியீடு சுய-குறிப்பு தரவு கட்டமைப்பைப் பயன்படுத்துகிறது, ஆனால் இது சோம்பேறி மதிப்பீட்டைப் பொறுத்தது அல்ல. இதை நேரடியாக மொழிபெயர்க்கலாம் எ. கா. புரோலாக் ஒரு சோம்பேறி மொழி அல்ல. ஒரு பட்டியலை (வரிசையாகப் பயன்படுத்தப்படும்) மேல்-கீழ் முறையில் உருவாக்கும் திறன் இன்றியமையாதது. அதற்காக, புரோலாக் வால் மறுசுழற்சி மாடுலோ குறைபாடுகளைக் கொண்டுள்ளது (அதாவது. திறந்த முடிவடைந்த பட்டியல்கள்). இது திட்டம், சி போன்றவற்றிலும் பின்பற்றக்கூடியது. மாற்றக்கூடிய வால் சென்டினல் சுட்டிக்காட்டியுடன் இணைக்கப்பட்ட பட்டியல்களைப் பயன்படுத்துதல்ஃ bftrav (மரம், [Tree|TS]):-bfgen (1, [Tree|TS], TS). bfgen (0, _, []):-! வரிசையில் உள்ள% 0 உள்ளீடுகள்-- bfgen பட்டியலை நிறுத்தி மூடவும் (N, [இலை (_) |P, TS):-N2 என்பது N-1, bfgen (N2, P, TS). bfgen (N, [கிளை (_, L, R) |P], [L, R|TS]):-N2 என்பது N + 1, bfgen (N2, P, TS). %%-------------------------------------------------------------------------------------------------------------------------------------------------------------------- செயல்பாட்டு லேபிள் ஒரு பைனரி மரத்தில் உள்ள ஒவ்வொரு முனையையும் அகலம் முதல் பாணியில் பார்வையிடுகிறது, ஒவ்வொரு லேபிளையும் ஒரு முழு எண்ணுடன் மாற்றுகிறது, ஒவ்வொரு அடுத்தடுத்த முழு எண்ணும் கடைசி 1 ஐ விட பெரியது. இந்த தீர்வு ஒரு சுய-குறிப்பு தரவு கட்டமைப்பைப் பயன்படுத்துகிறது, மேலும் பைனரி மரம் வரையறுக்கப்பட்ட அல்லது எல்லையற்றதாக இருக்கலாம். முத்திரைஃஃ மரம் a b-> மரம் int int முத்திரை t = டிஎன் எங்கே (டிஎன், என்எஸ்) = செல்ல t (1: என்எஸ்) செல்லஃஃ மரம் a b-> [இன்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்ட்டி முத்திரை (இலை (_), [I|A], இலை (I), [I + 1|A]). லேபிள் (கிளை (_, L, R), [I|A], கிளை (I, Ln, Rn), [I + 1|C]):-லேபிள் (L, A, Ln, B), லேபிள் (R, B, Rn, C). ஒரு அபோமார்பிசம் (அனமார்பிசம் போன்றவை, அவிழ்ப்பது போன்றவை) என்பது ஒரு பாரமார்பிசம் (மடிப்பு போன்ற கேடமார்பிசம் போன்றவை) என்பது மறுசுழற்சியின் ஒரு வடிவம் போலவே கோர்கர்ஷனின் ஒரு வடிவமாகும். CoQ ப்ரூஃப் அசிஸ்டென்ட் CoFixp்வாயிண்ட் கட்டளையைப் பயன்படுத்தி கோர்கர்ஷன் மற்றும் கோயின்டக்ஷனை ஆதரிக்கிறது. வரலாற்றின் கோரகர்ஷன், வட்ட நிரலாக்கம் என்று குறிப்பிடப்படுகிறது, குறைந்தபட்சம் ஜான் ஹியூஸ் மற்றும் பிலிப் வாட்லர் ஆகியோரை மதிப்பிடுகிறது; மேலும் பொதுவான வடிவங்கள் உருவாக்கப்பட்டன. அசல் உந்துதல்களில் மிகவும் திறமையான வழிமுறைகளை உருவாக்குவது (சில சந்தர்ப்பங்களில் தரவை கடந்து செல்ல அனுமதிப்பது, பல பாஸ்கள் தேவைப்படுவதற்குப் பதிலாக) மற்றும் செயல்பாட்டு மொழிகளில் இரட்டிப்பாக இணைக்கப்பட்ட பட்டியல்கள் மற்றும் வரிசைகள் போன்ற பாரம்பரிய தரவு கட்டமைப்புகளை செயல்படுத்துவது ஆகியவை அடங்கும். மேலும் காண்கஃ பிசிமுலேஷன் கோயின்டக்ஷன் ரெக்கர்ஷன் அனமார்பிசம் குறிப்புகள் கோட்பாட்டு கணினி அறிவியல் சுய குறிப்பு கட்டுரைகள் எடுத்துக்காட்டுடன் ஹாஸ்கெல் குறியீடு கட்டுரைகள் எடுத்துக்காட்டுடன் பைதான் (நிரலாக்க மொழி) குறியீடு செயல்பாட்டு நிரலாக்க வகை கோட்பாடு ரெக்கர்ஷன்