Нужны идеи для преобразования императивного кода F# в функциональный

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

Вы можете использовать Seq.mapi, чтобы добавить индексы к значениям, а затем использовать Seq.choose, чтобы получить значения с правильным индексом (и пропустить все остальные значения). Для жестко заданных индексов вы можете написать что-то вроде:

let indexed = input |> Seq.mapi (fun i s -> i, s)
Seq.zip 
  (indexed |> Seq.choose (fun (i, v) -> if i=1 || i=6 || i=11 then Some v else None))
  (indexed |> Seq.choose (fun (i, v) -> if i=4 || i=9 || i=14 then Some v else None))

Я использовал ваши числа -1, потому что индексы от 0, поэтому приведенное выше дает вам желаемые результаты. Вторая серия выглядит как кратная 5, поэтому, возможно, вы хотели, чтобы i%5 = 4 генерировало вторые элементы:

let indexed = input |> Seq.mapi (fun i s -> i, s)
Seq.zip 
  (indexed |> Seq.choose (fun (i, v) -> if i=1 || i=6 || i=11 then Some v else None))
  (indexed |> Seq.choose (fun (i, v) -> if i%5 = 4 then Some v else None))

Я до сих пор не вижу общего механизма генерации первых элементов!

EDIT Еще одна идея: первая последовательность создается i*5 + 2, а вторая — i*5? В этом случае ваш пример неверен, но вы можете написать его так:

let indexed = input |> Seq.mapi (fun i s -> i, s)
Seq.zip 
  (indexed |> Seq.choose (fun (i, v) -> if i%5 = 2 then Some v else None))
  (indexed |> Seq.choose (fun (i, v) -> if i%5 = 0 then Some v else None))

... или если вы хотите сделать код короче, вы можете провести рефакторинг:

let filterNthElements div rem = 
  input |> Seq.mapi (fun i s -> i, s)
        |> Seq.choose (fun (i, v) -> if i%div = rem then Some v else None)

Seq.zip (filterNthElements 5 2) (filterNthElements 5 0)

Вот более идиоматический способ сделать это. На самом деле, это однострочник; Я просто выровнял его для лучшей читабельности.

let Input = [ "Lorem"; "ipsum"; "dolor"; "set"; "amet"; "consectetuer";
              "adipiscing"; "elit"; "Aenean"; "commodo"; "ligula"; "eget";
              "dolor"; "Aenean"; "massa" ]

// Short solution that does not support more than two values
let Output1 =
    Input
    |> List.fold
        (fun (i, l1, l2) x ->
            if i=4 then 0, None, (l1.Value, x)::l2
            elif i=1 then i+1, Some x, l2
            else i+1, l1, l2
        )
        (0, None, [])
    |> fun (_, _, elem) -> elem
    |> List.rev

Идея

Общая идея основана на трех шагах:

1. Разделение списка на List кортежей, берущих 2-ю и 5-ю строки. ВНИМАНИЕ Если исходная длина данных не является множителем 5, завершающий элемент будет потерян.
2. Отфильтровать временные данные из triple, взяв третий элемент, что является нашей основной целью;
3. Переворачивание списка.

Объяснение

Первая линия самая сложная.

Давайте определим наше состояние. Это будет тройка порядкового номера, string option, содержащая строки ##2, 7 и т. д., и "внешняя" (string*string) list, которая добавляется, когда мы встречаем элементы ##5, 10 и т. д.

Функция поместит 2-й, 7-й и т. д. элементы во «внутренний» string option или, если i равно 5, 10 и т. д., сформирует кортеж и добавит его во «внешний» List (отбрасывая внутреннее значение для ясности).

Мы используем List.fold, поэтому окончательный список нужно перевернуть.

Исходное состояние — это тройка (0, None, []). More info onList.fold` в MSDN< /а>.

...
|> fun (_, temp, elem) ->
    if temp.IsSome
    then failwith "Data length must be a multiplier of 5"
    else elem
...

let Output2 = 
    Input
    |> List.foldBack
        (fun x (i, l1, l2) ->
            if i = 4
            then 0, [], (x::l1)::l2
            else i+1, x::l1, l2
        )
        <| (0, [], [])
    |> fun (_, _, elem) -> elem
    |> List.choose
        (function
        | [_; first; _; _; second] -> Some (first, second)
        | _-> None
        )

Я пришел из haskell, а не из f #, поэтому я дам, вероятно, недопустимую идею кода f #:

Сначала я бы сгенерировал два списка из моего ввода:

let zeromod5 = filter (index == 0 % 5) input
let twomod5 = filter (index == 2 % 5) input

что должно привести к спискам

{ "ipsum", "adipiscing","eget"}
{ "amet", "commodo","massa" }

а затем застегнуть их, т.е. е. составить список пар чем-то вроде

zip zeromod5 twomod5

Редактировать:

Хаскель версия:

zipWeird :: [String] -> [(String, String)]
zipWeird ss = zip twoMod5s zeroMod5s
            where zeroMod5s = map fst $ filter (\(_,y) -> y `mod` 5 == 0) eSS
                  twoMod5s = map fst $ filter (\(_,y) -> y `mod` 5 == 2) eSS
                  eSS = zip ss [1..]

zipWeird2 :: [String] -> [(String, String)]
zipWeird2 ss = map fst $ filter (\(_,y) -> y `mod`5 ==1) ezSS
             where zSS = zip (tail ss) (drop 4 ss)
                   ezSS = zip zSS [1..]

input :: [String]
input = words ("Lorem ipsum dolor sit amet, consetetur sadipscing elitr, "++
              "sed diam nonumy eirmod tempor invidunt ut labore et dolore "++
              "magna aliquyam erat, sed diam voluptua. At vero eos et "++
              "accusam et justo duo dolores et ea rebum. Stet clita kasd "++
              "gubergren, no sea takimata sanctus est Lorem ipsum dolor sit "++
              "amet.")

main :: IO ()
main = do 
          print $ zipWeird input
          print $ zipWeird2 input