सबसे पहले, काउंटर फ़ंक्शन:

C++ में मैं फंक्शन कॉल्स में वैल्यू कैश करने के लिए निम्न कार्य कर सकता हूं (बेशर्मी से TutorialsPoint.com< से कॉपी किया गया है /ए>):

void func( void ) {
   static int i = 5; // local static variable
   i++;
   std::cout << "i is " << i ;
   std::cout << " and count is " << count << std::endl;
}

दूसरा, डेटाबेस कैशिंग उदाहरण:

defmodule ElixirTesting do

  def test_static_function_variable do
    IO.puts(get_value_from_db_cache("A"))
    IO.puts(get_value_from_db_cache("B"))
    IO.puts(get_value_from_db_cache("A"))
    true
  end

  defp get_value_from_db_cache(key) do

    # We want this to be static.
    data_cache = %{}

    if !Map.has_key?(data_cache, key) do
      # Scope of this assignment is limited to local if block so does not re-bind static variable.
      data_cache = Map.put_new(data_cache, key, get_value_directly_from_db(key))
    end

    data_cache[key]
  end

  @db_data %{ "A" => 3, "B" => 4, "C" => 5, "D" => 6 }
  defp get_value_directly_from_db(key) do
    IO.puts("Inside get_value_directly_from_db for key #{key}")
    @db_data[key]
  end

end

कंसोल आउटपुट:

Inside get_value_directly_from_db for key A
Inside get_value_directly_from_db for key B
Inside get_value_directly_from_db for key A

दोनों ही मामलों में मैं अमृत में समान कैसे प्राप्त कर सकता हूं? या, उचित कार्यात्मक डिजाइन का उपयोग करके परिणाम को पूरा करने के लिए मुझे रिफैक्टरिंग के बारे में कैसे जाना चाहिए?

0
cppProgrammer 13 सितंबर 2021, 15:54

1 उत्तर

सबसे बढ़िया उत्तर

संक्षिप्त उत्तर है - आप नहीं कर सकते। कार्यात्मक का अर्थ है कि आप शुद्ध कार्यों के साथ प्रोग्राम करते हैं, इसलिए वे हमेशा एक ही इनपुट के लिए एक ही परिणाम लौटाते हैं, किसी फ़ंक्शन के अंदर कुछ कैशिंग करना उसे तोड़ देता है

लंबा उत्तर है - जब आप किसी राज्य का प्रबंधन करना चाहते हैं, तो अमृत में डिफ़ॉल्ट उस स्थिति को एक प्रक्रिया में लपेटना है। एक साधारण प्रकार की प्रक्रिया जो केवल डेटा का एक टुकड़ा रखती है उसे एजेंट कहा जाता है . उदाहरण के लिए, आप एक नामित एजेंट शुरू कर सकते हैं, और इसे अपने फ़ंक्शन में इस तरह संदर्भित कर सकते हैं:

defmodule Test do
  def start_link(initial_value) do
    Agent.start_link(fn -> initial_value end, name: MyAgent)
  end

  def put(value), do: Agent.update(MyAgent, fn _ -> value end)

  def get, do: Agent.get(MyAgent, fn value -> value end)
end

Test.start_link(:value1)

Test.get() |> IO.inspect() # => :value1
Test.put(:value2)
Test.get() |> IO.inspect() # => :value2
1
Paweł Obrok 13 सितंबर 2021, 16:33
counters और/या persistent_term
 – 
Aleksei Matiushkin
13 सितंबर 2021, 18:09
प्रतिपुष्टि के लिए धन्यवाद। तो ... मेरी चिंता यह है कि डेटाबेस कैशिंग एक उपयोग का मामला है जिसमें एफपी के लाभों को वास्तविक दुनिया की जरूरतों से चुनौती दी जाती है। तो ऐसा लगता है कि एजेंट इस उद्देश्य के लिए परिवर्तनशील डेटा को इनकैप्सुलेट करते हैं। यह समझ में आता है कि डॉक्स ब्राउज़ करना, आप सही हैं। और दिलचस्प अलेक्सी इन कार्यों के बारे में; क्या वे अमृत से कॉल करने योग्य हैं, वाक्य रचना क्या है?
 – 
cppProgrammer
13 सितंबर 2021, 19:14
अहम। किसी भी अन्य erlang योग्य कॉल की तरह: :module.function(arguments), e. जी। :persistent_term.get(:my_term_name).
 – 
Aleksei Matiushkin
13 सितंबर 2021, 21:32