Превращение списка целых чисел в список цветов

Мне кажется, что вы ищете действительно чистый способ

1. Сверните List Int в List (List Int), где каждый дочерний список имеет не более 3 или 4 элементов, если вы хотите сделать rgb или rgba.
2. Передайте каждый List Int в функцию, которая преобразует его с помощью rgb, обрабатывая случай, когда в окончательной записи недостаточно целых чисел.

Для первого шага вы можете написать функцию с именем groupList:

groupsOf : Int -> List a -> List (List a)
groupsOf size list =
  let
    group =
      List.take size list

    rest =
      List.drop size list
  in
    if List.length group > 0 then
      group :: groupsOf size rest
    else
      []

Вы также можете получить эту функциональность, используя функцию greedyGroupsOf из elm- пакет community/list-extra.

Для второго шага будет намного чище сопоставлять шаблоны со структурой самого значения списка, а не использовать List.head и сопоставлять Maybe.

rgbFromList : List Int -> Color
rgbFromList values =
  case values of
    r::g::b::[] ->
      rgb r g b
    _ ->
      rgb 0 0 0

Первый случай будет совпадать, когда в списке будет ровно 3 записи, а все остальное провалится до передачи 0 в rgb.

Вы можете собрать все эти вещи вместе, выполнив следующие действия:

toColor : List Int -> List Color
toColor x =
  x
    |> groupsOf 3
    |> List.map rgbFromList

В качестве альтернативы, если вместо rgb 0 0 0 для недопустимых цветов вы хотите полностью исключить их, вы можете использовать функцию List.filterMap для удаления ненужных вещей. Мы можем изменить rgbFromList, чтобы оно выглядело как

rgbFromList : List Int -> Maybe Color
rgbFromList values =
  case values of
    r::g::b::[] ->
      Just <| rgb r g b
    _ ->
      Nothing

а затем назовите это как

toColor : List Int -> List Color
toColor x =
  x
    |> groupsOf 3
    |> List.filterMap rgbFromList

Имейте в виду, что поскольку функция groupsOf здесь, а также greedyGroupsOf в elm-community/list-extra является рекурсивной, она не будет работать для очень больших списков.

Изменить: для очень больших списков

Для очень больших списков легко получить проблемы с рекурсией. Лучше всего свернуть список и управлять некоторым промежуточным состоянием, пока вы сворачиваете:

groupsOf : Int -> List a -> List (List a)
groupsOf size list =
  let
    update next state =
      if (List.length state.current) == size then
        { current = [next], output = state.current :: state.output }
      else
        { state | current = state.current ++ [next] }

    result =
      List.foldl update { current = [], output = [] } list
  in
    List.reverse (result.current :: result.output)

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

Эта рекурсивная реализация должна работать без создания стека, потому что в Elm есть оптимизация хвостовых вызовов. Каждый шаг берет три целых числа из исходного списка и добавляет их к списку цветов. Рекурсия останавливается и возвращает список цветов, когда в исходном списке меньше трех элементов.

Он использует rgb, но его можно легко изменить, чтобы взять 4 элемента из списка.

Он также меняет порядок, поэтому вам может понадобиться объединить его с List.reverse.

import Color exposing (rgb, Color)


listColors : List Int -> List Color
listColors = 
  listColors' []


listColors' : List Color -> List Int -> List Color
listColors' colors ints =
  case ints of
    r :: g :: b :: rest ->
      listColors' (rgb r g b :: colors) rest
    _ ->
      colors