Есть ли в Perl или Ruby концепция функционального программирования, эквивалентная оператору триггера? - PullRequest
Новая
       13

Есть ли в Perl или Ruby концепция функционального программирования, эквивалентная оператору триггера?

7 голосов
/ 24 июня 2011

Ruby (и Perl) имеет концепцию триггера: 

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

, который дал список ординалов, таких как 

first
second
third
fourth
fifth
sixth

начнет печатать, когда достигнет «третьего», и остановится, когда достигнет «пятого»: 

third
fourth
fifth

Существует ли концепция функционального программирования, аналогичная этой, или она обычно описывается в терминах takewhile с? Я не спрашиваю о конкретном языке, просто какой термин вы бы использовали для его описания.

Ответы [ 3 ]

8 голосов
/ 24 июня 2011

На функциональном языке, таком как haskell, вы передаете условия триггера и флопа как предикаты и фильтруете входной список на его основе. Например, ниже приведено определение flipflop в haskell (не беспокойтесь о реализации, если вы не знаете haskell - ключевая часть в том, как он используется): 

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

Вот как это можно использовать: 

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

Это пример создания эффективно новой языковой конструкции, просто используя функцию более высокого порядка.

Я не знаю, существует ли специальное имя для этой конструкции в функциональных языках.

4 голосов
/ 24 июня 2011

Зависит от функционального языка.Как насчет этого? 

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]

Добавлено: Конечно, Ruby не является чисто функциональным языком, поэтому я решил переписать его на 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.

Примечание: На самом деле классический триггер должен работать как dropdown (! First) -> takewhile (! Second), поэтому триггер Ruby является специальным (сравните с триггером в электронике).

0 голосов
/ 24 июня 2011

То же, что и решение @ nanothief, но в Scala: 

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)
...