输入实例函数的推断

时间:2013-07-17 15:26:47

标签: haskell types ghc type-inference

问题

我希望能够创建2个data typesAB并创建2个函数f

  • f :: A -> Int -> Int
  • f :: B -> String -> String -> String

我能做到的唯一方法(据我所知)是使用type classesinstances

问题是,我不想明确写f签名 - 我希望类型检查器为我推断它。有可能吗?

示例代码

{-# LANGUAGE FlexibleInstances, FunctionalDependencies, UndecidableInstances #-}

data A = A{ax::Int} deriving(Show)
data B = B{bx::Int} deriving(Show)
data C = C{cx::Int} deriving(Show)

-- I don't want to explicit say the signature is Int->Int
-- I would love to write: 
-- instance Func_f A (a->b) where 
instance Func_f A (Int->Int) where 
    f _ i = i*2

-- I don't want to explicit say the signature is String->String->String
-- I would love to write:
-- instance Func_f B (a->b->c) where 
instance Func_f B (String->String->String) where 
    f _ s1 s2 = "test"++s1++s2

-- I don't want to explicit say the signature is a->a
-- I would love to write:
-- instance Func_f C (a->b) where 
instance Func_f C (a->a) where 
    f _ i = i

class Func_f a b | a -> b  where
    f :: a -> b

f2 _ s1 s2 = "test"++s1++s2 -- Here the type inferencer automaticly recognizes the signature

main :: IO ()
main = do 
    let 
        a = A 1
        b = B 2
        c = C 3
        a_out = f a 5
        b_out = f b "a" "b"
        c_out = c 6

    print a_out
    print b_out
    print c_out

我正在编写自定义域语言编译器,因此我正在生成Haskell代码。 我不希望我语言的最终用户写出显式类型,所以我想使用Haskells强大的类型系统来尽可能地推断。

如果我编写像f2 _ s1 s2 = "test"++s1++s2这样的函数,那么必须显式写入其签名 - 因为编译器可以推断它。我们能否以某种方式要求编译器在上面的例子中推断出f的签名?

我很想知道解决这个问题的每一个可能的“hack”,即使这个hack会“丑陋”,因为我正在生成Haskell代码而且它不一定是“漂亮”。

1 个答案:

答案 0 :(得分:5)

这是一种有效的方式。如果你的fA fB有类型,还有很多案例可以解决 推断类型中的变量。在这种情况下,以下代码将具有 编译时出现一些模式匹配失败。

{-# LANGUAGE FlexibleInstances, FunctionalDependencies, TemplateHaskell #-}

import Language.Haskell.TH

data A = A{ax::Int} deriving(Show)
data B = B{bx::Int} deriving(Show)

fA A{} i = i*(2 :: Int)

fB B{} s1 s2 = "test"++s1++s2

class Func_f a b | a -> b  where
    f :: a -> b

let
    getLetter (AppT (AppT _ x) _) = x
    getSnd (AppT x y) = y
    mkInst name0  = do
        (VarI n ty _ _) <- reify name0
        fmap (:[]) $ instanceD (return [])
            [t| Func_f
                    $(return $ getLetter ty)
                    $(return $ getSnd ty) |]
            [valD (varP 'f) (normalB (varE name0)) []]

    in fmap concat $ mapM mkInst ['fB, 'fA]


main :: IO ()
main = do 
    let 
        a = A 1
        b = B 2
        a_out = f a 5
        b_out = f b "a" "b"

    print a_out
    print b_out

这是否能帮助你使用你正在编译的语言来解决haskell是另一个问题。


添加提示

如果类型是多态的,你会看到reify给出了我上面的示例代码未涵盖的内容。

 > :set -XTemplateHaskell
 > :m +IPPrint Language.Haskell.TH
 > putStrLn $(reify 'id >>= stringE . pshow)

打印出描述(a-&gt; a)的内容:

VarI GHC.Base.id
  (ForallT [PlainTV a_1627394484] []
     (AppT (AppT ArrowT (VarT a_1627394484)) (VarT a_1627394484)))
  Nothing
  (Fixity 9 InfixL)

通过一些工作,你可以将那里的Type分成CxtQ和TypeQ instanceD需要。

我不知道它产生了多少感觉(a-> b)。你可以去 关于用新的唯一变量替换所有类型变量,这可能是最好的 使用Data.Generics.everywhereM之类的东西完成,因为数据类型有很多 许多建设者。

您仍然会遇到无效的问题:

instance Func_f (a -> b) where
   f _ = id

这种获取方法(a-> b)可能会导致程序崩溃:

instance Func_f (a -> b) where
   f _ = unsafeCoerce id

这种方法可以在类型不同时选择实例,但是在 如果'a'和'b',那么在ghc的执行中稍后你可能会失败 不可能是一样的。

instance (a~b) => Func_f (a->b) where
   f _ = unsafeCoerce id