Там не кот, а cata

Теперь хочу написать general zipWith

Через те призмы что я выше показал + zipCata

А пока я написал вам про интересные штуки, а сам пойду пилить круды на ноде)

Что сюда будет включено? Мб все можно правильно обобщить не только на списки

Думаю включить это:
http://hackage.haskell.org/package/treefold-0.2.0.0/docs/src/Data-TreeFold.html#treeFold

Зачем тебе деревянная свёртка?

В другом месте она называется balanced fold
Мне лично эта свёртка нужна чтобы использовать её в https://github.com/8084/purescript-difference-containers
Будет нечно похожее по духу на DList, только работающее с теми структурами данных, для которых временная сложность append зависит линейно как от размера первого аргумента,  так и от размера второго.
Сложность левой или правой свёртки для таких структур - O(n^2), балансированной - O(n * log(n)).

Зачем тебе это пакет?

Моя выпускная работа будет где-то около этого.

Есть такой пакет https://github.com/sjoerdvisscher/fmlist/blob/master/Data/FMList.hs

Кстати тут тоже про деревянную свёртку есть https://wiki.haskell.org/Fold

В универе?

@klntsky

simply :: forall p s a r. (L.Optic' p s a -> r) -> L.Optic' p s a -> r
simply = identity

Хорошее, но решает другую задачу. Если использовать FMList в вычислениях, где интенсивно применяется append, а потом конвертировать FMList в обычный список поэлементно и свернуть, выигрыша не будет. Вернее, это зависит от того, _как_ свернуть.
Какая структура данных будет использоваться для накопления результата - не очень важно, это может быть любой вариант church encoded списка с O(1) append. Или даже простой список, если append будет только слева.
> В универе?
Да.

simply :: forall p s a r. (L.Optic' p s a -> r) -> L.Optic' p s a -> r
simply = identity

Спасибо.

опять же, эти все лево/право хороши для лейзи (гда санки не форсируются)

class Cons s t a b | s -> a, t -> b, s b -> t, t a -> s where
  _Cons :: L.Prism s t (Tuple a s) (Tuple b t)

class Snoc s t a b | s -> a, t -> b, s b -> t, t a -> s where
  _Snoc :: L.Prism s t (Tuple s a) (Tuple t b)

Если конкретизировать Cons для List, получается

_Cons :: forall p. Choice p =>
      p (Tuple a (List a)) (Tuple a (List a)) ->
      p (L.List a) (List a)

Зачем там Choice?

Похоже, функцию с таким типом невозможно написать.

class Cons s t a b | s -> a, t -> b, s b -> t, t a -> s where
  _Cons :: L.Prism s t (Tuple a s) (Tuple b t)

simply :: forall p s a r. (L.Optic' p s a -> r) -> L.Optic' p s a -> r
simply = identity

consDefault :: forall s a. Cons s s a a => a -> s -> s
consDefault = curry (simply L.review _Cons)

instance consList :: Cons (List a) (List a) a a where
  -- _Cons :: forall p. Choice p =>  p (Tuple a (List a)) (Tuple a (List a)) -> p (List a) (List a)
  _Cons = undefined

для листа нельзя написать?)