क्या पर्ल या रूबी में फ्लिप-फ्लॉप ऑपरेटर के बराबर एक कार्यात्मक प्रोग्रामिंग अवधारणा है?

Question

रूबी (और पर्ल) में फ्लिप फ्लॉप की अवधारणा है:

file = File.open("ordinal") 
while file.gets 
    print if ($_ =~ /third/) .. ($_ =~ /fifth/) 
end 

जो

first 
second 
third 
fourth 
fifth 
sixth 

जैसे नियमों की एक सूची दी गई है, जब यह "तीसरा" पहुंचने पर प्रिंट करना शुरू कर देगी और इसे रोक दें "पांचवां" तक पहुंच गया:

third 
fourth 
fifth 

क्या इसमें कोई कार्यात्मक प्रोग्रामिंग अवधारणा समान है, या क्या इसे सामान्यतः takewhile s के संदर्भ में वर्णित किया जाएगा? मैं किसी विशेष भाषा के बारे में नहीं पूछ रहा हूं, बस आप इसका वर्णन करने के लिए किस शब्द का उपयोग करेंगे।

Answer 1

हैकेल जैसी एक कार्यात्मक भाषा में, आप भविष्यवाणी के रूप में फ्लिप और फ्लॉप स्थितियों में गुजरेंगे, और इसके आधार पर एक इनपुट सूची फ़िल्टर करेंगे। उदाहरण के लिए, निम्नलिखित हास्केल में flipflop की एक परिभाषा है (कार्यान्वयन के बारे में चिंता नहीं करता है, तो आप Haskell पता नहीं है - महत्वपूर्ण हिस्सा है कि यह कैसे इस्तेमाल किया जाता है):

flipflop flip flop = 
    uncurry (++) . second (take 1) . break flop . dropWhile (not . flip) 

यह वह जगह है कि यह कैसे कर सकते हैं इस्तेमाल किया जा सकता है:

> flipflop (== 3) (== 5) [1..10] 
[3,4,5] 

यह उच्च आदेशित फ़ंक्शन का उपयोग करके प्रभावी ढंग से नई भाषा निर्माण करने का एक उदाहरण है।

मुझे नहीं पता कि कार्यात्मक भाषाओं में उस निर्माण के लिए कोई विशेष नाम है या नहीं।

Answer 2

कार्यात्मक भाषा पर निर्भर करता है। इस बारे में कैसा है?

ff_gen = 
    lambda{ |first, *conditions| 
    flipflop = false 
    condition = first 
    lambda{ |v| 
     if condition && condition[v] 
     condition = conditions.shift 
     flipflop = !flipflop 
     true 
     else 
     flipflop 
     end 
    } 
    } 

ff = ff_gen[lambda{|v| v == 3}, lambda{|v| v == 5}, lambda{|v| v == 7}, lambda{|v| v == 11}] 

puts (0..20).select{ |i| ff[i] }.inspect # => [3, 4, 5, 7, 8, 9, 10, 11] 

जोड़ा गया: बेशक, रूबी एक शुद्ध कार्यात्मक भाषा नहीं है, तो मैं Erlang में यह फिर से लिखने का फैसला किया:

#!/usr/bin/env escript 

flipflop(E, {[H|T] = Conditions, FlipFlop}) -> 
    case H(E) of 
    true -> 
     {true, {T, not FlipFlop}}; 
    false -> 
     {FlipFlop, {Conditions, FlipFlop}} 
    end; 

flipflop(_, {[], FlipFlop}) -> 
    {FlipFlop, {[], FlipFlop}}. 

flipflop_init(Conditions) -> 
    {[], {Conditions, false}}. 

main([]) -> 
    {L, _} = 
    lists:foldl(
     fun(E, {L2, FFState}) -> 
     case flipflop(E, FFState) of 
      {true, FFState2} -> 
      {[E|L2], FFState2}; 
      {false, FFState2} -> 
      {L2, FFState2} 
     end 
     end, 
     flipflop_init([ 
     fun(E) -> E == 3 end, 
     fun(E) -> E == 5 end, 
     fun(E) -> E == 7 end, 
     fun(E) -> E == 11 end 
     ]), 
     lists:seq(0,20) 
    ), 
    io:format("~p~n", [lists:reverse(L)]), 
    ok. 

नोट: वास्तव में, क्लासिक फ्लिप फ्लॉप चाहिए बूंद की तरह काम करें (! पहला) -> लेने के दौरान (! दूसरा), तो रुबी की फ्लिप-फ्लॉप विज्ञापन है (इलेक्ट्रॉनिक्स में फ्लिप-फ्लॉप के साथ तुलना करें)।

Answer 3

@ nanothief के समाधान के रूप में एक ही है, लेकिन स्काला में:

def flipFlop[A](flip: A => Boolean, flop: A => Boolean, seq: Seq[A]): Seq[A] = { 
    val (p, q) = seq.dropWhile(!flip(_)).span(!flop(_)) 
    p ++ q.take(1) 
} 

नमूना रन:

> flipFlop[Int](_ == 3, _ == 5, Nil) 
List() 

> flipFlop[Int](_ == 3, _ == 5, 1 to 19) 
Vector(3, 4, 5)