Generic Haskell

ошибка в сообщении : обобщённый map (pmap) не в Generic Haskell, а в PolyP; ну в принципе суть вопроса от этого не меняется

Зачем это надо?

>Зачем это надо?

в моём случае задача возникла в процессе реализации фильтров сигналов (БИХ и КИХ-фильтров). подобное обобщение значительно повысило бы выразительность кода. но мне в данный момент оно больше интересно в принципе, с точки зрения теоретических возможностей языков программирования : мне не хватает гибкости Haskell'а :( и я хочу понять, можно ли (и как) эту проблему побороть

Соорудил на скорую руку идиотское решение:

{-# OPTIONS_GHC -fglasgow-exts -fallow-undecidable-instances -fallow-incoherent-instances #-}
module MapN (mapN) where
class MapN f a b where
    mapN' :: f -> [a] -> ([a],[b])
    mapN :: f -> [a] -> [b]
    mapN f xs = snd $ mapN' f xs
instance MapN (a -> b) a b where mapN' f xs = (drop 1 xs, map f xs)
instance MapN f a (a -> b) => MapN f a b where
    mapN' f xs =
        let (xt,fs) = mapN' f xs
        in (drop 1 xt, zipWith id fs xt)

При использовании приходится явно указывать типы для всего:

*MapN> mapN ((\a b c -> a + b + c) :: Integer -> Integer -> Integer -> Integer) [1::Integer,2,3,4,5,6] :: [Integer]
[6,9,12,15]

спасибо, интересный вариант :) подозревал, что как-то так сделать можно, но опыта реализовать не хватило, да и с нестандартными расширениями пока не работал. код разберу, сразу только вопрос - что именно здесь относится к "-fglasgow-exts", "-fallow-undecidable-instances", и "-fallow-incoherent-instances" ?

>Соорудил на скорую руку идиотское решение:

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

Другой вариант, с теми же проблемами:

{-# OPTIONS_GHC -fglasgow-exts -fallow-overlapping-instances #-}
module MapN (mapN) where
class MapN f a b where
    mapN' :: [f] -> [a] -> [b]
mapN :: MapN f a b => f -> [a] -> [b]
mapN = mapN' . repeat
instance MapN (a -> b) a b where mapN' = zipWith id
instance MapN f a b => MapN (a -> f) a b where
    mapN' fs xs =
        let fs' = zipWith id fs xs
            xt = drop 1 xs
        in mapN' fs' xt

-fglasgow-exts - включает многопараметрические классы (иначе хаскель ругнётся уже на class MapN f a b - ему подавай только MapN f)

-fallow-undecidable-instances - иначе будет ругаться на instance MapN f a (a -> b) => MapN f a b; фишка в том, что получается потенциально бесконечная цепочка: чтобы понять, имеется ли instance MapN f a b, нужно понять, имеется ли instance MapN f a (a -> b); для этого нужно понять, имеется ли instance MapN f a (a -> a -> b) - и так далее до бесконечности.

-fallow-incoherent-instances - там таки возникает эта самая бесконечная цепочка; на каком-то шаге соответствующий instance находится, но компилятор не может угадать, нет ли другого - в этом случае получится перекрытие и надо сигналить об ошибке. Этот свитч говорит "найдя первый instance, забей на поиски остальных - мамой клянусь, их нету, а если и есть - то там то же самое, а если не то же самое - то разница пофигу."

Идиотское - потому что, например, на mapN ((+ 1) :: Integer -> Integer) [1::Integer,2,3,4,5,6] :: [Float] компилятор имеет полное право зависнуть (ибо ему только что дали проследить ту самую бесконечную цепочку, только на этот раз безуспешно). GHC через некоторое количество итераций остановится.

Ниже я привёл более чистый вариант.

спасибо за ответы и пояснения, буду разбирать оба варианта

You're welcome.

И ещё один вариант (обошёлся только тем, что входит в glasgow-exts):
{-# LANGUAGE MultiParamTypeClasses,FlexibleInstances #-}
module MapN (mapN) where
class MapN f a b where
    mapN' :: [f] -> [a] -> [b]
mapN :: MapN f a b => f -> [a] -> [b]
mapN f xs = repeat f `mapN'` xs
instance MapN b a b where mapN' = const
instance MapN f a b => MapN (a -> f) a b where
    mapN' fs xs =
        let fs' = zipWith id fs xs
            xt = drop 1 xs
        in mapN' fs' xt

Говорила мне мама: считай с нуля, а не с единицы...