आर में स्थिति के आधार पर तर्क कैसे करें?

Question

यह "आप नहीं कर सकते हैं, और वैसे भी कोई कारण नहीं है" के तहत हो सकता है, लेकिन अगर यह संभव है तो मैं उत्सुक हूं। कम से कम, शायद यह एक मजेदार आर पहेली होगा।

मैं को हमेशा जोड़ने के लिए cat को घुमाने पर विचार कर रहा था। हालांकि, cat लिखा गया है ताकि यह कई तर्कों के साथ मिलकर चिपकाया जा सके (... के माध्यम से)।

हैरानी की बात है, इस काम करता है:

> library(functional) 
> catnip <- Curry(cat, "\n") 
> catnip("hi") 

hi 

हालांकि, \n उपयोगकर्ता के टेक्स्ट से पहले हवाएँ। क्या फ़ंक्शन को हल करने का कोई तरीका है जैसे कि आप निर्दिष्ट करते हैं कि घुमावदार तर्क हमेशा ... तर्कों को समाप्त करता है?

Answer 1

Curry() जैसा लगता है कि आप जो चाहते हैं उससे विपरीत क्रम में दो तर्क सूचियों को प्रभावी ढंग से हार्डवायर करता है। हालांकि यह एक साधारण पर्याप्त कार्य है, कि आप इसकी दर्पण छवि बना सकते हैं, और इसके बजाय इसका उपयोग कर सकते हैं।

Curry2 <- function(FUN, ...) { 
    .orig = list(...) 
    function(...) do.call(FUN, c(list(...), .orig)) 
} 

catnip <- Curry2(cat, "\n") 
catnip("hi") 

Answer 2

# 1। करी और हार्ड कोड की दूसरी तर्क को अनदेखा करें

यह कोशिश करें कि cat के अंतिम तर्क को किसी अज्ञात फ़ंक्शन में हार्ड कोडिंग करके इस पर आज़माएं। यह वास्तव में पहली बार तब जब Curry तर्कों का इस्तेमाल करते हैं नहीं करता है:

catnip <- Curry(function(...) cat(..., "\n")) 

# 2। एक गुमनाम समारोह

यहाँ currying द्वारा समारोह निर्माण एक दूसरे समाधान जो एक गुमनाम समारोह जो cat के तर्क reorders का उपयोग करके cat के अंतिम तर्क करी है।

catnip2 <- Curry(function(last.arg, ...) cat(..., last.arg), "\n") 

# test 
catnip2("hi", "there") 

# 3। एक और अधिक बुनियादी कार्य

शायद यह सब का वास्तविक बिंदु यह देखने के लिए है कि हम बुनियादी घटकों को कैसे ले सकते हैं और उन्हें प्राप्त करने के लिए उन्हें करी कर सकते हैं। इस प्रकार हम एक सामान्य last.arg.fun निर्धारित कर सकते हैं और फिर इसके बारे में एक करी द्वारा वांछित समारोह का निर्माण:

last.arg.fun <- function(FUN, last.arg, ...) FUN(..., last.arg) 
catnip3 <- Curry(last.arg.fun, cat, "\n") 

# test 
last.arg.fun(cat, "\n", "hi", "there") 

# test 
catnip3("hi", "there") 

हम दो चरणों में कर सकता है अगर हम कुछ बिंदु पर last.arg.cat की जरूरत:

last.arg.cat <- Curry(last.arg.fun, cat) 
catnip4 <- Curry(last.arg.cat, "\n") 

# test 
last.arg.cat("\n", "hi", "there") 

# test 
catnip4("hi", "there") 

ध्यान दें कि प्रत्येक परीक्षण में एक पंक्ति का उत्पादन करना चाहिए जिसमें कहा गया है कि हाय ने एक नई लाइन में समाप्त किया था।

संपादित करें: अधिक समाधान।