не могу найти, откуда должно следовать именно такое поведение

т.е. если я реализую Enum для своего численного типа, то я обязан обеспечить такое же поведение?

и.к. 0<-1

т.е. если я реализую Enum для своего численного типа, то я обязан обеспечить такое же поведение?

полагаю если fromEnum start > fromEnum end оно само обеспечится

это синтаксис enumFromThenTo

enumFromThenTo 0 0 -1 должен быть пустып

enumFromThenTo 0 0 -1 должен быть пустып

потому что ... ?

вообще неясно что тут удивительного

по определению, например

какое определение?

выдаём элементы пока current<=final

а 0 больше -1

так что все, перестали выдавать

выдаём элементы пока current<=final

хорошее определение

отличное

только оно не работает на [-1, -2 .. -10]

которое прекрасно раскрывается в [-1,-2,-3,-4,-5,-6,-7,-8,-9,-10], а не должно — если принять твоё опредление

там ещё учитывается то в какую сторону идем

полагаю если fromEnum start > fromEnum end оно само обеспечится

.

там ещё учитывается то в какую сторону идем

вот об этом и речь

если Delta меньше или больше равно нулю

2 случая

получается, что положительная сторона почему-то лучше отрицательной

вообще открыть определение указанной функции очень просто

почему [0,0.. 1] == бесконечный список нулей, но [0,0.. -1] == [] ?

почему бы и нет

как бы 0 - 0 == 0 то есть никакое конкретное направление не задано

но семнтика получается разной в зависимости от конца

efdtInt x1 x2 y | isTrue# (x2 >=# x1) = efdtIntUp x1 x2 y | otherwise = efdtIntDn x1 x2 y

-# NOINLINE [1] eftInt #-} eftInt :: Int# -> Int# -> [Int] -- [x1..x2] eftInt x0 y | isTrue# (x0 ># y) = [] | otherwise = go x0 where go x = I# x : if isTrue# (x ==# y) then [] else go (x +# 1#)

про такое же поведение смотришь на законы в тайп классе

про этот метод там ничего не сказано, так что по твоему желанию

на месте программиста я бы не огорчился ни от какой из реализаций

даже от того что enumFromThenTo a a b выдало бы error

ладно, нашёл Haskell Report, вроде бы там недвусмысленно The sequence enumFromThenTo e1 e2 e3 is the list [e1,e1+i,e1+2i,...e3], where the increment, i, is e2-e1. If the increment is positive or zero, the list terminates when the next element would be greater than e3; the list is empty if e1 > e3. If the increment is negative, the list terminates when the next element would be less than e3; the list is empty if e1 < e3.

просто на хакадже этого нет, поэтому и были сомнения

Сталкивались ли вы с таким и как решали? ghc: panic! (the 'impossible' happened) (GHC version 8.4.2 for x86_64-unknown-linux): Prelude.!!: index too large Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug

Смотрим тикеты в траке, если нет - репортим.

я нашёл причину, но к сож не могу миним пример состряпать..

помогло поменять succ . fromEnum на (+1) . fromEnum

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

причём если указать типы явно в связке succ . fromEnum , то всё равно panic impossible hapened Prelude.!!

Простите, я тут мимоходом, а вот это про что речь? О_о

omg, TIL: writeIORef

вся моя жизнь - ложь

а я-то людям заливал, что вот есть на свете языки, в которых нельзя передать в функцию объект аргументом и там с ним наделать чего попало

Что-то туплю на ночь глядя. Есть ФРП-шный аппликативный Behavior [a], можно его превратить в [Behavior a]?

Что-то туплю на ночь глядя. Есть ФРП-шный аппликативный Behavior [a], можно его превратить в [Behavior a]?

а как? асинхронные данные думаю нет

не думаю что можно так просто взять и перевести асинхронные данные в синхронные ну или попробуй sequence но я думаю это работать не будет

sequence наоборот делает

sequence наоборот делает

не обязательно

sequence наоборот делает

как раз m (t a) -> t (m a)

хотя есть и дуализм для Traversable https://www.stackage.org/haddock/lts-11.5/distributive-0.5.3/Data-Distributive.html#t:Distributive

WAT sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)

Хм, это бы пригодилось, но я не представляю, как сделать инстанс для абстрактного типа из чужой либы, не форкая её :(

Хм, это бы пригодилось, но я не представляю, как сделать инстанс для абстрактного типа из чужой либы, не форкая её :(

всякие StandaloneDerive?

Derive для кастомного класса?

Что-то туплю на ночь глядя. Есть ФРП-шный аппликативный Behavior [a], можно его превратить в [Behavior a]?

Что-то действительно странного хочу. Понятно ведь, что в общем случае это невозможно. А в частном? Если я мамойклянусь, что всегда приходит список фиксированной длины.

map (\i -> fmap (!! i) mylist) [0.. n - 1]

Приветы всем. Обьясните плиз let f1 x y = flip (,) x y let f2 p = uncurry f1 p c f1 понятно у нее нее 2 параметра а вот с записью f2 не совсем понятно. я бы ожилал, что запись uncurry f1 p читается как вычислить f1 на p и на результате вычислить uncurry т.е let f2 p = uncurry (f1 p) но по факту же let f2 p = (uncurry f1) p

f x y == (f x) y, да

Все функции всегда принимают аргументы по одному

Если имеется вызов функции - набор чего-то через пробелы. То первый элемент и будет вызываемой функцией, а остальные будут скармливаться по одному оной

Всё как в лиспе, только нет скобок внешних

В лиспе же никто не ожидает, что (f x y) это (f (x y))

в лиспе каррирования нет

Всегда можно сделать такой интерпретатор, который смогёт :)

Что-то действительно странного хочу. Понятно ведь, что в общем случае это невозможно. А в частном? Если я мамойклянусь, что всегда приходит список фиксированной длины.

Я не знаю ничего про Вehavior, но первый попавшийся (reactive-0.11.5/docs/FRP-Reactive-Behavior.html) не является Traversable, зато он Zip/UnZip. Т.е. можно по крайней мере парами склеивать/расклеивать. Для фиксированной длины вполне может подойти. В данном случае - UnZip.

а почему вот такая запись не верная let f x = sin . cos x

вот смотрю на композицию

(.) :: (b -> c) -> (a -> b) -> a -> c — Defined in `GHC.Base' infixr 9 .

у нее 9й приоритет

я бы ожидал, что будет sin от косинуса и это вычисляется на x

а если записать let f = sin . cos , то все работает

Композиция имеет меньший приоритет, чем применение функции

Поэтому композицию применяют так sin . cos $ x или так (sin . cos) x

приоритет у композиции меньше, чем у применения функций, для того, чтобы было удобно писать так: pipeline = zipWith [1..] . filter (> 5) . map (* 10)

если приоритет меньше, то сначала вызовется map (* 10) ?

Да. Сначала применятся все функции, потом скомпозятся результаты

если приоритет меньше, то сначала вызовется map (* 10) ?

да, только не вызовется, а вычислится

"будет применена" ;Р