Это был оффтопик, даже парни на это указали.

Раньше имела, а теперь нет? Ну ок

/has_instance Monoid (Either a)

хм.. а почему нету?

когда он мне так нужен

Ну вероятно нужно Monoid a

да хоть так, но никакого нету

Лямбдабота подвезли?

а ну там же можно и через Monoid a и через Monoid b empty выразить

т.е. непонятно empty - это Right или LEft

так что видимо, снова нютайпы

да, логично

но newtype-ов тоже не видно

ладно попишу бойлерплейт

Monoid a => f [a] -> f a это у нас что?

f - Foldable

/has_instance Monoid (Either a)

Either a - дырявый

ну и traversable

стоп, я же не это хочу

как вот это вот: zipWith ($) [Char.isLetter, Char.isDigit] (repeat 'a') сделать более лучше?

т.е как вообще правильно строить сложные предикаты?

(Any Char.isLetter <> Any Char.isDigit) ?

а не

не

liftA2 (&&)?

через liftA2 можно

а там зип

один на первый символ, второй на второй

attoparsec?

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

с Any кстати getAny $ (Any . Char.isLetter <> Any . Char.isDigit) 'a' (но к этой задаче не относится)

чо-т так себе тоже

аттопарсек?

аттопарсер - дороже выйдет если пропихивать как предикат в Data.Text.split например

foldl (||) False . zipWith ($) [Char.isLetter, Char.isDigit] . repeat

шляпа. как-то надо лучше

getAny . mconcat [Any . isDigit, Any . isLetter] ?

Или надо по всем?

не там первое к первому элементу второе ко второму

как вот это вот: zipWith ($) [Char.isLetter, Char.isDigit] (repeat 'a') сделать более лучше?

а что потом делается с этим списком [Bool, Bool] ?

fold . zipWith ($) [Char.isLetter, Any . isDigit]

а что потом делается с этим списком [Bool, Bool] ?

сворачивается чем-нибудь - and или or

так что может как-то можно сразу сворачивать

так что может как-то можно сразу сворачивать

and . sequence [Char.isLetter, Char.isDigit]

о.

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

Validation

у меня красиво не получалось, делал обёртку через тип валидации

Ну будет у тебя не Bool a Either

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

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

о, монада

ну только не and ., а and <$>

да-да

спасибо

http://hackage.haskell.org/package/validation

спасибо

это если собирать ошибки и все сразу и т.п.

а то с точки зрения юзера как-то дико, когда неизвестно наперед обо что и сколько раз ещё спотыкаться..

ну если только у тебя аппликативное поведение

с монадическим ничего не сделать, придется спотыкатьс много раз

sequence вроде поможет, хотя чего гадать, посмотрю на пакет

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

sequence вроде поможет, хотя чего гадать, посмотрю на пакет

а sequence он как раз аппликативный

а нафига в Data.Traversable два sequence, кстати? sequenceA :: Applicative f => t (f a) -> f (t a) sequence :: Monad m => t (m a) -> m (t a)

для легаси кода, где Monad не требует Applicative?

исторически

а как наиболее красиво сделать: zipWith f x (tail x)?

uncurry (zipWith f) . (&&&) id tail

ap (zipWith f) tail уж лучше так

ap (zipWith f) tail уж лучше так

Ох, опять инстанс монады для функций

И zipWith f <*> tail — правильно?

выглядит верно

fun f = zipWith f <*> tail main = print . fun (+) $ [1..8]

[3,5,7,9,11,13,15]

Работает

Можно ещё (<*> tail) . zipWith, чтобы уж совсем бесточечно :P

а как наиболее красиво сделать: zipWith f x (tail x)?

из всех вариантов этот (первый) самый лучший

A есть разница с точки зрения вычисления и сохранения x в этих вариантах?

Нет

Просто у первого варианта наименьшая ментальная нагрузка

Да, это так.

Хотя трудно удержаться...

Не волнуйся, это не го, тебя не будут пинать за сложные решения :D

но это не точно

но это не точно

По крайней мере, не так сильно

да

Сам через месяц свой кот просто не поймешь с первого взгляда, а так никто ругать не будет

а как наиболее красиво сделать: zipWith f x (tail x)?

А кстати можно красиво через extend сделать, но это будет работать только на бесконечных списках:)

А кстати можно красиво через extend сделать, но это будет работать только на бесконечных списках:)

вот так extend (\(a:b:_) -> f a b)

По мелочи - я бы tail на (drop 1) заменил.

По мелочи - я бы tail на (drop 1) заменил.

зачем? tail это просто _:xs -> xs деконструктор

зачем? tail это просто _:xs -> xs деконструктор

tail — это частичная функция

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

По мелочи - я бы tail на (drop 1) заменил.

не надо ни в коем случае