मैं कैसे बता सकता हूं कि कुछ पर्ल 6 कंटेनर है या नहीं?

Question

मेरे पास यह जानने के लिए कोई उपयोगी कारण नहीं है, लेकिन मैं सोच रहा था कि मेरे पास $x जैसे नाम हैं, यदि वह एक स्केलर वेरिएबल (परिवर्तनीय चीज़) था या केवल कुछ (अपरिवर्तनीय चीज़) के लिए नाम था। मैं कुछ भी पूरा करने की कोशिश नहीं कर रहा हूं; यह जिज्ञासा है।

मैं कुछ इस तरह के साथ चारों ओर खेल रहा था:

my @a = 'a', ('b', 'c'); 
my @b = 'd', 'e', 'f', @a; 

my @ab = @a, @b, (1, 2); 

for @ab { 
    put "name: {.^name} VAR: { .VAR.^name }"; 
    when .VAR.can('FETCH') { put "Container: $_" } 
    when .VAR.can('STORE') { put "Container: $_" } 
    when Scalar   { put "Scalar container: $_" } 
    when Array    { put "Array Container: $_" } 
    default    { put "Object: $_" } 
    } 

मैं:

name: Array VAR: Scalar 
Array Container: a b c 
name: Array VAR: Scalar 
Array Container: d e f a b c 
name: List VAR: Scalar 
Object: 1 2 

मैं देख सकता हूँ कि मैं प्रकार Array प्रकार मैचों मिलान कर सकते हैं, लेकिन मैं जाँच सोचा कि कुछ कर सकते हैं कि FETCH या STORE सही मिलान होगा।

Answer 1

सुनिश्चित नहीं है कि आप यहां क्या पूछ रहे हैं, लेकिन आपका इनपुट दिया गया है, आउटपुट अपेक्षित है।

स्पष्टीकरण के लिए एक सरल उदाहरण:

my (@a, @b, @c); 
my @ab = @a, @b, @c; 

for @ab { 
    say "{.^name} contained in a {.VAR.^name}"; 
} 

जो उत्पादन होगा

Array contained in a Scalar 

तीन बार, कोई फर्क नहीं पड़ता @a, @b और @c की contens।

याद रखें, पर्ल 6 में कोई अंतर्निहित फ़्लैटनिंग नहीं है, और सरणी विचलन (गैर-मूल सरणी के) को अपने तत्वों को स्केलर कंटेनरों में डालकर महसूस किया जाता है।

---

अपने प्रश्न का संपादित को देखते हुए, शायद निम्नलिखित कोड आगे स्पष्ट होगा क्या हो रहा है:

# make argument raw so binding won't mess with it 
sub info($_ is raw) { 
    dd $_; 
    put " value type: {.^name}"; 
    put " VAR type: {.VAR.^name}"; 
    put " can fetch: {so .VAR.can('FETCH')}"; 
    put " can store: {so .VAR.can('STORE')}"; 
} 

my \values = 42, my $ = 42, [1, 2], (1, 2); 
info $_ for values; 

put "\n"; 

# put values in array, which wraps them in a scalar container 
info $_ for [values]; 

ध्यान दें कि केवल सूचियों और सरणियों STORE (लेकिन FETCH) है, जबकि scalars कर सकते हैं कर सकते हैं न।

यह आश्चर्यचकित हो सकता है: एक के लिए, हम उम्मीद कर सकते हैं कि असाइन करने योग्य कुछ भी STORE प्रदान करना चाहिए।

कार्यान्वयन को देखते हुए, हम देखते हैं कि sigil @ और %, हम do call STORE, लेकिन not so एक $ sigil साथ चर के लिए साथ चर के लिए। यदि हम खरगोश छेद को और नीचे चला गया, तो हम अंततः पर समाप्त हो गए, इस प्रकार स्केलर कंटेनर (या Proxy ऑब्जेक्ट की STORE विधि का आविष्कार) लागू किया गया है।