Полезные альтернативные структуры управления?

Одним из довольно распространенных является бесконечный цикл. Я хотел бы написать это так:

forever {
  // ...
}

Иногда мне нужно иметь цикл foreach с индексом. Можно было бы написать так:

foreach (index i) (var item in list) {
  // ...
}

(Мне не особенно нравится этот синтаксис, но вы поняли идею)

В большинстве языков есть встроенные функции, охватывающие распространенные случаи, но циклы "забора" всегда утомительны: циклы, в которых вы хотите что-то делать на каждой итерации, а также делать что-то еще между итерациями. Например, объединение строк с разделителем:

string result = "";
for (int i = 0; i < items.Count; i++) {
    result += items[i];
    if (i < items.Count - 1) result += ", "; // This is gross.
    // What if I can't access items by index?
    // I have off-by-one errors *every* time I do this.
}

Я знаю, что складки могут покрыть этот случай, но иногда вам нужно что-то обязательное. Было бы здорово, если бы вы могли:

string result = "";
foreach (var item in items) {
    result += item;
} between {
    result += ", ";
}

Цикл с другим:

while (condition) {
  // ...
}
else {
  // the else runs if the loop didn't run
}

{
    foo();
} split_while( condition ) {
    bar();
}

Вы можете сделать это довольно легко, используя обычный while:

while (true) {
    foo();
    if (!condition) break;
    bar();
}

Я делаю это довольно часто теперь, когда преодолела свое иррациональное отвращение к break.

Если вы посмотрите на Haskell, хотя там есть специальный синтаксис для различных структур управления, поток управления часто захватывается типами. Наиболее распространенными типами таких элементов управления являются монады, стрелки и аппликативные функторы. Итак, если вам нужен особый тип потока управления, это обычно какая-то функция более высокого порядка, и вы можете либо написать ее самостоятельно, либо найти ее в базе данных пакетов Haskells (Hackage), которая довольно велика.

Такие функции обычно находятся в пространстве имен Control, где вы можете найти модули для параллельного выполнения с обработкой ошибок. Многие управляющие структуры, обычно встречающиеся в процедурных языках, имеют аналог функции в Control.Monad, среди них циклы и операторы if. If-else — это выражение с ключевым словом в Haskell, если без else не имеет смысла в выражении, но имеет смысл в монаде, поэтому операторы if без else захватываются функциями when и unless.

Другим распространенным случаем является выполнение операции со списком в более общем контексте. Функциональные языки очень любят fold, а специализированные версии, такие как map и filter. Если у вас есть монада, то для нее есть естественное расширение fold. Это называется foldM, и поэтому существуют также расширения любой специализированной версии fold, о которой вы только можете подумать, например, mapM и filterM.

Это просто общая идея и синтаксис:

if (cond)
   //do something
else (cond)
   //do something
also (cond)
   //do something
else
   //do something
end

ТАКЖЕ условие всегда оценивается. ELSE работает как обычно.

Это работает и для случая. Вероятно, это хороший способ исключить оператор break:

case (exp)
   also (const)
      //do something
   else (const)
      //do something
   also (const)
      //do something
   else
      //do something
end

можно прочитать как:

switch (exp)
   case (const)
      //do something
   case (const)
      //do something
      break
   case (const)
      //do something
   default
      //do something
end

Я не знаю, полезно ли это или просто для чтения, но это пример.

С макросами (в стиле lisp), хвостовыми вызовами и продолжениями все это выглядит причудливо.

С помощью макросов, если стандартных конструкций потока управления недостаточно для данного приложения, программист может написать свои собственные (и многое другое). Для реализации конструкций, которые вы привели в качестве примера, потребуется только простой макрос.

С помощью хвостовых вызовов можно разложить сложные шаблоны потока управления (например, реализацию конечного автомата) на функции.

Продолжения — это мощный примитив потока управления (try/catch — их ограниченная версия). В сочетании с хвостовыми вызовами и макросами сложные шаблоны потока управления (возврат, синтаксический анализ и т. д.) становятся простыми. Кроме того, они полезны в веб-программировании, так как с их помощью можно инвертировать инверсию управления; у вас может быть функция, которая запрашивает у пользователя некоторый ввод, выполняет некоторую обработку, запрашивает у пользователя дополнительный ввод и т. д.

Перефразируя стандарт Scheme, вместо того, чтобы нагромождать больше функций на свой язык, вы должны стремиться снять ограничения, которые делают другие функции необходимыми.

если не:

unless (condition) {
  // ...
}

в то время как не:

until (condition) {
  // ...
}

Помеченные циклы — это то, чего мне иногда не хватает в основных языках. например.,

int i, j;
for outer ( i = 0; i < M; ++i )
    for ( j = 0; j < N; ++j )
        if ( l1[ i ] == l2[ j ] )
           break outer;

Да, обычно я могу имитировать это с помощью goto, но эквивалент для continue потребует от вас перемещения приращения в конец тела цикла после метки, что ухудшит читабельность. Вы также можете сделать это, установив флаг во внутреннем цикле и проверяя его на каждой итерации внешнего цикла, но это всегда выглядит неуклюже.

(Бонус: иногда мне хотелось бы иметь redo вместе с continue и break. Он возвращался к началу цикла без оценки приращения.)

Я предлагаю оператор "тогда". Он возвращает левый операнд на первой итерации и правый операнд на всех остальных итерациях:

var result = "";
foreach (var item in items) {
    result += "" then ", ";
    result += item;
}

в первой итерации к результату добавляется "" , во всех остальных - ", ", так что вы получаете строку, содержащую каждый элемент, разделенный запятыми.

if (cond)
   //do something
else (cond)
   //do something
else (cond)
   //do something
first
   //do something
then
   //do something
else (cond)
   //do something
else
   //do something
end

Блоки FIRST и THEN запускаются, если любое из 3 условий оценивается как истинное. Блок FIRST запускается перед условным блоком, а THEN запускается после запуска условного блока.

ELSE условная или окончательная запись, следующая за оператором FIRST и THEN, не зависит от этих блоков.

Он может читаться как:

if (cond)
   first()
   //do something
   then()
else (cond)
   first()
   //do something
   then()
else (cond)
   first()
   //do something
   then()
else (cond)
   //do something
else
   //do something
end


function first()
   //do something
return
function then()
   //do something
return

Эти функции — просто форма для чтения. Они не создали бы размаха. Это больше похоже на gosub/возврат из Basic.

Полезность и удобочитаемость как предмет обсуждения.

Как насчет

alternate {
    statement 1,
    statement 2,
    [statement 3,...]
}

для циклического перебора доступных операторов при каждом последующем проходе.

Изменить: тривиальные примеры

table_row_color = alternate(RED, GREEN, BLUE);

player_color = alternate(color_list); // cycles through list items

alternate(
    led_on(),
    led_off()
);

Редактировать 2. В третьем примере выше синтаксис может быть немного запутанным, так как он выглядит как функция. Фактически, на каждом проходе оценивается только один оператор, а не оба. Лучший синтаксис может быть чем-то вроде

alternate {
    led_on();
}
then {
    led_off();
}

Или что-то в этом роде. Однако мне нравится идея, что результат, который когда-либо вызывается, может быть использован при желании (как в примерах цвета).

защита прицела D – это полезная структура контроля, которую нечасто можно увидеть. .

Думаю, мне следует упомянуть CityScript (язык сценариев CityDesk), который некоторые действительно причудливые циклические конструкции.

Из файла справки:

{$ forEach n var in (condition) sort-order $}
... text which appears for each item ....
{$ between $}
.. text which appears between each two items ....
{$ odd $}
.. text which appears for every other item, including the first ....
{$ even $}
.. text which appears for every other item, starting with the second ....
{$ else $}
.. text which appears if there are no items matching condition ....
{$ before $}
..text which appears before the loop, only if there are items matching condition
{$ after $}
..text which appears after the loop, only of there are items matching condition
{$ next $}

Также обратите внимание, что многие управляющие структуры приобретают новое значение в монадическом контексте, в зависимости от конкретной монады - посмотрите на mapM, filterM, whileM, sequence и т. д. в Haskell.

ignoring — игнорировать исключения, возникающие в определенном блоке кода.

try {
  foo()
} catch {
  case ex: SomeException => /* ignore */
  case ex: SomeOtherException => /* ignore */
}

С управляющей конструкцией ignoring вы могли бы записать ее более кратко и читабельно так:

ignoring(classOf[SomeException], classOf[SomeOtherException]) {
  foo()
}

[ Scala предоставляет это (и многие другие конструкции управления обработкой исключений) в своей стандартной библиотеке в пакете util.control. ]

Я хотел бы видеть ключевое слово для группировки вывода. Вместо этого:

        int lastValue = 0;

        foreach (var val in dataSource)
        {
            if (lastValue != val.CustomerID)
            {                    
                WriteFooter(lastValue);
                WriteHeader(val);
                lastValue = val.CustomerID;
            }
            WriteRow(val);
        }
        if (lastValue != 0)
        {
            WriteFooter(lastValue);
        }

как насчет такого:

        foreach(var val in dataSource)
        groupon(val.CustomerID)
        {            
            startgroup
            {
                WriteHeader(val);
            }
            endgroup
            {
                WriteFooter(val)
            }
        }
        each
        {
            WriteRow(val);
        }

Если у вас есть достойная платформа, элементы управления и/или форматирование отчетов, вам не нужно писать этот код. Но удивительно, как часто я ловлю себя на том, что делаю это. Самая раздражающая часть — это нижний колонтитул после последней итерации — это сложно сделать в реальном примере без дублирования кода.

Что-то, что заменяет

bool found = false;
for (int i = 0; i < N; i++) {
  if (hasProperty(A[i])) {
    found = true;
    DoSomething(A[i]);
    break;
  }
}
if (!found) {
  ...
}

как

for (int i = 0; i < N; i++) {
  if (hasProperty(A[i])) {
    DoSomething(A[i]);
    break;
  }
} ifnotinterrupted {
  ...
}

Я всегда чувствую, что должен быть лучший способ, чем введение флага, просто для выполнения чего-то после последнего (обычного) выполнения тела цикла. Можно было бы проверить !(i < N), но i выходит за рамки после цикла.

Это немного шутка, но вы можете получить желаемое поведение следующим образом:

#include <iostream>
#include <cstdlib>

int main (int argc, char *argv[])
{
  int N = std::strtol(argv[1], 0, 10); // Danger!
  int state = 0;
  switch (state%2) // Similar to Duff's device.
  {
    do {
      case 1: std::cout << (2*state) << " B" << std::endl;
      case 0: std::cout << (2*state+1) << " A" << std::endl; ++state;
    } while (state <= N);
      default: break;
  }

  return 0;
}

p.s. форматировать это было немного сложно, и я определенно не доволен этим; однако emacs делает еще хуже. Кто-нибудь хочет попробовать vim?

Генераторы в Python действительно новы, если вы в основном работали с нефункциональными языками. В более общем смысле: продолжения, сопрограммы, ленивые списки.

Это, вероятно, не считается, но в Python я был расстроен отсутствием цикла do.

Чтобы гарантировать, что я не получу голосов за этот ответ, меня раздражает любой язык, на котором я работаю в течение любого периода времени, в котором отсутствуют goto.

for int i := 0 [down]to UpperBound() [step 2]

Отсутствует во всех языках, производных от C.

Пожалуйста, подумайте, прежде чем голосовать или писать комментарий:
Это не лишнее для for (int i = 0; i <= UpperBound(); i++), оно имеет другую семантику:

1. UpperBound() оценивается только один раз

2. Случай UpperBound() == MAX_INT не приводит к бесконечному циклу

Это похоже на ответ @Paul Keister.

(бормочет, бормочет) много лет назад приложение, над которым я работал, имело множество вариаций так называемой обработки прерывания управления — всей той логики, которая используется для разбиения отсортированных строк данных на группы и подгруппы с верхними и нижними колонтитулами. Поскольку приложение было написано на LISP, мы уловили распространенные идиомы в макросе WITH-CONTROL-BREAKS. Если бы я транспонировал этот синтаксис в популярную волнистую форму, это могло бы выглядеть примерно так:

withControlBreaks (x, y, z : readSortedRecords()) {
  first (x) :     { emitHeader(x); subcount = 0; }
  first (x, y) :  { emitSubheader(x, y); zTotal = 0; }
  all (x, y, z) : { emitDetail(x, y, z); ztotal += z; }
  last (x, y) :   { emitSubfooter(x, y, zTotal); ++subCount; }
  last (x) :      { emitFooter(x, subcount); }
}

В нашу современную эпоху, когда широко распространены SQL, XQuery, LINQ и т. д., кажется, что эта потребность не возникает так сильно, как раньше. Но время от времени мне хочется иметь под рукой эту управляющую структуру.

Как насчет диапазонов циклов for в стиле PL/I? Эквивалент VB будет:

' Counts 1, 2, ... 49, 50, 23, 999, 998, ..., 991, 990
  For I = 1 to 50, 23, 999 to 990 Step -1

Наиболее распространенное использование, которое я вижу, это запустить цикл для списка индексов, а затем добавить еще один. Кстати, использование For-Each также может быть удобно:

' Bar1, Bar2, Bar3 are an IEnum(Wazoo); Boz is a Wazoo
  For Each Foo as Wazoo in Bar1, Bar2, Enumerable.One(Boz), Bar3

Это запустит цикл для всех элементов в Bar1, всех элементов в Bar2, Boz и Bar3. Linq, вероятно, позволит это без особых трудностей, но встроенная поддержка языка может быть немного более эффективной.

Одной из управляющих структур, недоступной во многих языках, является структура типа case-in. Подобно структуре типа переключателя, она позволяет вам иметь аккуратно отформатированный список возможных параметров, но соответствует первому истинному (а не первому, который соответствует вводу). LISP такого типа (у которого он есть):

(cond
   ((evenp a) a)        ;if a is even return a
   ((> a 7) (/ a 2))    ;else if a is bigger than 7 return a/2
   ((< a 5) (- a 1))    ;else if a is smaller than 5 return a-1
   (t 17))              ;else return 17

Или, для тех, кто предпочитает более C-подобный формат

cond 
    (a % 2 == 0): 
        a;     break;
    (a > 7):
        a / 2; break;
    (a < 5):
        a - 1; break;
    default:
        17;    break;

По сути, это более точное представление конструкции if/elseif/elseif/else, чем переключатель, и оно может оказаться чрезвычайно удобным для выражения этой логики в чистом и удобочитаемом виде.

Как насчет перебора с движущимся окном (из n элементов вместо 1) по списку? Я думаю, что это косвенно связано с ответом @munificent.

Что-то типа

#python
#sum of adjacent elements
for x,y in pairs(list):
    print x + y

def pairs(l):              
    i=0                    
    while i < len(l)-1:    
        yield (l[i],l[i+1])
        i+=1               

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