एक ही हस्ताक्षर

Question

में एकाधिक मॉड्यूल में परिभाषित एक फ़ंक्शन को गतिशील रूप से कॉल करने के लिए कैसे मैंने कई फ़ंक्शन (कहें, 100+) परिभाषित किए हैं, जिनमें से प्रत्येक एक विशिष्ट कार्य करता है लेकिन उसी हस्ताक्षर के साथ।

module R001 (run) where run = <do-...> 
module R002 (run) where run = <do-...> 

मुझे क्या करना चाहते हैं, उपयोगकर्ता इनपुट के रूप में वास्तविक 'रन' प्रदान करते हैं ऐसी है कि करने के लिए है: कुछ की तरह यही कारण है

main = do 
     runWith $ read $ getLine 
     where 
     runWith :: Int -> IO() 
     runWith n = R<n-padded-with-0>.run 

वर्तमान में, मैं सभी मॉड्यूल योग्य आयात करते हैं और डाल सब run[Maybe (IO())] की एक सूची में है, तो यह काम करता है:

runWith n = case Rs !! (read $ getLine) of 
       Just run -> run 
       Nothing -> undefined 

लेकिन जैसे n बढ़ता है, मैं लगातार एक बड़ी सूची बनाए रखने के लिए किया है।

क्या कोई तरीका है कि मैं टेम्पलेटहस्केल का उपयोग करके बड़ी सूची को परिभाषित कर सकता हूं, या अलग-अलग साझा पुस्तकालयों में प्रत्येक मॉड्यूल को अलग किए बिना रनटाइम पर आवश्यक मॉड्यूल को लोड कर सकता हूं।

import R1 (run1) 
import R2 (run2) 

test = $(functionExtractor "^run") 

main :: IO() 
main = do 
     putStrLn $ show $ length $ test 
     run1 -- remove on second attempt 
     run2 -- remove on second attempt 

run1 और run2 के परिणाम निम्न कोड प्रिंट 2 के इस ब्लॉक:

---

epsilonhalbe के जवाब के आधार पर, मैं कुछ शोध किया। अगर मैं पिछले दो लाइनों को हटा देता हूं, तो यह सिर्फ 0 प्रिंट करता है। ऐसा लगता है कि आयात किए गए कार्यों को संदर्भित नहीं किया जाएगा ...

Answer 1

मुझे एक बार एक ही समस्या थी haskell load module in list शायद यह मदद करता है।

आप regexp के साथ फ़ंक्शंस की एक सूची बना सकते हैं और उस सूची से उपयोगकर्ता इनपुट द्वारा फ़ंक्शन चुन सकते हैं। यदि आप सभी आयात करने के लिए है मैं नहीं जानता कि "चलाता है" हाथ के योग्य हैं या यदि आप

import R*.hs (run) 

मैं नहीं बल्कि एक फ़ाइल run1 = …, run2 = … साथ लिख सकते हैं और सभी रन की एक सूची और एक समारोह चयनकर्ता उत्पन्न होगा कर सकते हैं फ़ंक्शन जो एक ही प्रकार के हस्ताक्षर वाले कार्यों की सूची से फ़ंक्शन लेता है।

{-# LANGUAGE TemplateHaskell #-} 
import Language.Haskell.Extract 
import myRunFunctions 

main = do 
    let listOfRuns = $(functionExtractor "^run") 
    putStrLn "please choose a run" 
    putStrLn $ show listOfRuns 
    let run = runWith $ read $ getLine 
    run 
    where 
    runWith n = listOfRuns !! n 

ध्यान दें: मैं नहीं चलाने इस इस कोड को सिर्फ सोचा था की एक धारा Haskell वाक्य रचना में डाल है

मैं आशा है कि यह उपयोगी

---

है संपादित करने के बाद:
मेरे उदाहरण में मैंने एक फ़ाइल में सभी run* लिखा और वहां मैंने सभी रन फ़ंक्शंस की सूची जेनरेट की, जो तुरंत काम करते थे - मेरे Nucleotide Project पर विशेष रूप से फ़ाइलें Rules.hs और Nucleotide.hs पर एक नज़र डालें।

Runs.hs

module Runs where 
import Language.Haskell.Extract 

listOfRuns = map snd $(functionExtractor "^run") 

run1 = … 
run2 = … 

Main.hs

import Runs 

main = do 
    putStrLn "please choose a run" 
    putStrLn $ show listOfRuns 
    let run = runWith $ read $ getLine 
    run 
    where 
    runWith n = listOfRuns !! n 

सहायक हो करने के लिए खुश

Answer 2

यह बिल्कुल महत्वपूर्ण है कि विभिन्न run कार्यों विभिन्न मॉड्यूल में रहते है? यदि आप उन्हें सभी मॉड्यूल में डाल सकते हैं, तो आप run को Int (या Integer) का फ़ंक्शन बना सकते हैं।

module AllMyCircuits where 
run 0 = {- do blah blah blah -} 
run 1 = {- do blah blah blah -} 
run 2 = {- do yikes -} 

module Main where 
import AllMyCircuits 
main = readLn >>= run