主页 / 问题 / 988544
Accepted
asianirish
Asked:2020-06-03 03:26:12 +0000 UTC2020-06-03 03:26:12 +0000 UTC

在 Haskell 中创建 Container 类的困难

  • 772

我想创建一个 Container 类，以便不仅用作函数中的参数，例如具有整数键的列表，而且还可以包含任何可以包含值并通过任何比较 ( Eq) 键明确搜索它们的类型.

class Container c where
    at :: (Eq k) => c -> k -> v

当我尝试为同一个列表创建一个类实例时，困难立即开始了（代码不起作用）：

{-
instance Container [a] where
    at lst k = lst !! k
-}

输出以下错误消息：

• Couldn't match expected type ‘Int’ with actual type ‘k’
  ‘k’ is a rigid type variable bound by
    the type signature for:
      at :: forall k v. Eq k => [a] -> k -> v

也就是说，他们说，关键是不够Eq，但显然必须Int按照要求!!。逻辑上，当然！但是，尽管如此，我怎样才能摆脱并实施我的想法呢？

PS 在标准语言的框架内是可取的，没有扩展。

PPS 也需要批评一下问题作者自己给出的答案⬎

haskell

3 个回答

  1. Best Answer
    {-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE FlexibleInstances #-}

import qualified Data.Map as Map
import qualified Data.Vector as Vector
import qualified Data.Array as Array

class Container c k | c -> k where
  at :: c a -> k -> a

instance Container [] Int where
  at = (!!)

instance Container (Vector.Vector) Int where
  at = (Vector.!)

instance Ord k => Container (Map.Map k) k where
  at = (Map.!)

instance Array.Ix k => Container (Array.Array k) k where
  at = (Array.!)

main = do print ([1,2,3] `at` 1)
          print (Map.fromList [('x', True), ('y', False)] `at` 'x')
          print (Vector.fromList "abc" `at` 0)
          print (Array.listArray (False, True) ["false", "true"] `at` True)
    • 2

  2. 这里的问题是[]它不能是您的类的实例。根据定义，您的类的实例应该由任何带有 的索引Eq，并且[]只有Intom 被索引。例如，该列表不能被Stringami 索引。

    • 1

  3. 得到了我想要的：

    module R.Container
(
    Container (..)
) where


class Container c where
    at :: (Show k, Eq k) => c a -> k -> a


toInt :: (Show s) => s -> Int
toInt r = let s = show r
          in  (read s :: Int)


instance Container [] where
    at arr k = arr !! toInt k

{-
*R.Container> at [1,2,3] 1
2
-}

toBool :: (Show s) => s -> Bool
toBool r = let s = show r
           in  (read s :: Bool)


data MyPair a = MyPair { ifTrue :: a, ifFalse :: a } deriving (Show)


instance Container MyPair where
    at (MyPair a b) k = let yes = toBool k
                        in  if yes then a else b 

{-
*R.Container> let myPair = MyPair 12 13
*R.Container> at myPair True
12
*R.Container> at myPair False
13
-}

toIntPair :: (Show s) => s -> (Int,Int)
toIntPair r = let s = show r
           in  (read s :: (Int,Int))

data Matrix a = Matrix {arr2d :: [[a]]} deriving (Show)


instance Container Matrix where
    at mtrx k = let (f,s) = toIntPair k
                    arrs = arr2d mtrx
                    arr = arrs !! f
                in  arr !! s

{-
*R.Container> let mtrx = Matrix [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,12,11,10]] 
*R.Container> at mtrx (3,1)
12
*R.Container> at mtrx (3,0)
13
-}

    没错，我必须将键类型分隔符指定为Show，但我找不到为什么这仍然不好的论据（？）

    我很乐意接受任何最严厉的批评。

    • 0

相关问题