W moim rzeczywistym problemie mam funkcję f, przekazano jako parametr, który zmienia kolejność na liście, ale nie ma wymagań dotyczących typu i nie zmienia typy. Chcę zastosować tę funkcję na [Int] i [Bool], więc muszę rozwiązać oba konteksty próbujące do pobytu f do [Int] -> [Int] lub [Bool] -> [Bool]. Rozwiązałem to za pomocą Rank2Types. Ale wtedy używam any na liście funkcji, takich jak f i any wymaga, aby funkcje były {{x10}}, a nie {{x11}}.

Kod poniżej, podczas gdy bezsensowny doskonale odtwarza błąd:

{-# LANGUAGE Rank2Types #-}

--debug :: (forall a. [a] -> [a]) -> Bool 
debug swap = any combine [swap]
  where
    combine :: (forall a. [a] -> [a]) -> Bool
    combine f =  usefonBool f && usefonInt f
    --usefonBool :: (forall a. [a] -> [a]) -> Bool
    usefonBool f = f [True,True] == [False]

    --usefonInt :: (forall a. [a] -> [a]) -> Bool
    usefonInt f = (f [1,2]) == [2,1]

Komunikat o błędzie to:

• Couldn't match type ‘a’ with ‘forall a1. [a1] -> [a1]’
  ‘a’ is a rigid type variable bound by
    the inferred type of debug :: a -> Bool
    at /path/debug.hs:(4,1)-(12,36)
  Expected type: a -> Bool
    Actual type: (forall a. [a] -> [a]) -> Bool
• In the first argument of ‘any’, namely ‘combine’
  In the expression: any combine [swap]
  In an equation for ‘debug’:
      debug swap
        = any combine [swap]
        where
            combine :: (forall a. [a] -> [a]) -> Bool
            combine f = usefonBool f && usefonInt f
            usefonBool f = f [True, ....] == [False]
            usefonInt f = (f [1, ....]) == [2, ....]
• Relevant bindings include
    swap :: a (bound at /path/debug.hs:4:7)
    debug :: a -> Bool (bound at /path/debug.hs:4:1)
|

Moim celem jest znalezienie adnotacji, które pozwala mi użyć f na różnych typach, a następnie zastosuj dowolną listę takich funkcji generycznych.

Jeśli uznam wszystkie moje adnotacje typu (lub po prostu jeden) błąd zmienia się na

• Couldn't match type ‘[a0] -> [a0]’ with ‘forall a. [a] -> [a]’
  Expected type: ([a0] -> [a0]) -> Bool
    Actual type: (forall a. [a] -> [a]) -> Bool
• In the first argument of ‘any’, namely ‘combine’
  In the expression: any combine [swap]
  In an equation for ‘debug’:
      debug swap
        = any combine [swap]
        where
            combine :: (forall a. [a] -> [a]) -> Bool
            combine f = usefonBool f && usefonInt f
            usefonBool :: (forall a. [a] -> [a]) -> Bool
            usefonBool f = f [True, ....] == [False]
            ....
  |
3
peer 17 styczeń 2020, 03:52

1 odpowiedź

Najlepsza odpowiedź

Po pierwsze, należy pamiętać, że Rank2Types jest niedokładnym nazwą. Jest to odpowiednik RankNTypes w nowoczesnym GHC, a to preferowana nazwa rozszerzenia.

Oto podstawowy problem. "Lista takich ogólnych funkcji" może mieć typ:

[forall a. [a] -> [a]]

Niestety, nie jest to prawidłowy typ Haskell, ponieważ Haskell nie obsługuje "polimorfizmu impredycyjnego". W szczególności następujący program:

{-# LANGUAGE RankNTypes #-}
myFunctions :: [forall a. [a] -> [a]]
myFunctions = [f1, f2]
   where f1 (x:y:rest) = y:x:rest
         f2 = reverse

Produkuje komunikat o błędzie:

DebugRank.hs:2:16: error:
    • Illegal polymorphic type: forall a. [a] -> [a]
      GHC doesn't yet support impredicative polymorphism
    • In the type signature: myFunctions :: [forall a. [a] -> [a]]

Jest przedłużenie, ImpredicativeTypes. To Flakey i niekompletne, ale pozwala na kompilację:

{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE ImpredicativeTypes #-}

myFunctions :: [forall a. [a] -> [a]]
myFunctions = [f1, f2]
   where f1 (x:y:rest) = y:x:rest
         f2 = reverse

debug :: [forall a. [a] -> [a]] -> Bool
debug = any combine
  where
    combine :: (forall a. [a] -> [a]) -> Bool
    combine f = usefonBool f && usefonInt f
    usefonBool f = f [True,True] == [False]
    usefonInt  f = f [1,2] == [2,1]

main = print (debug myFunctions)

Polecam jednak przed użyciem.

Zwykłą alternatywą jest użycie opakowania newtype do funkcji polimorficznych:

newtype ListFunction = ListFunction (forall a. [a] -> [a])

Wymaga to niektórych kotła, ale bez rozszerzeń innych niż RankNTypes:

myFunctions :: [ListFunction]
myFunctions = [ListFunction f1, ListFunction f2]
   where f1 (x:y:rest) = y:x:rest
         f2 = reverse

debug :: [ListFunction] -> Bool
debug = any combine
  where
    combine :: ListFunction -> Bool
    combine (ListFunction f) = usefonBool f && usefonInt f
    usefonBool f = f [True,True] == [False]
    usefonInt  f = f [1,2] == [2,1]

Kompletny kod:

{-# LANGUAGE RankNTypes #-}

newtype ListFunction = ListFunction (forall a. [a] -> [a])

myFunctions :: [ListFunction]
myFunctions = [ListFunction f1, ListFunction f2]
   where f1 (x:y:rest) = y:x:rest
         f2 = reverse

debug :: [ListFunction] -> Bool
debug = any combine
  where
    combine :: ListFunction -> Bool
    combine (ListFunction f) = usefonBool f && usefonInt f
    usefonBool f = f [True,True] == [False]
    usefonInt  f = f [1,2] == [2,1]

main = print $ debug myFunctions
4
K. A. Buhr 17 styczeń 2020, 16:46