Question

可能重复：
How to make a type with restrictions

在Haskell中是否可以创建一个类型，例如“Name”，它是一个String但不包含10个以上的字母？

如果不是，我怎么能禁止创建一个具有长名称的Person（其中Person被定义为：data Person = Person Name）。

也许它根本不重要，也许这种问题应该以不同的方式在Haskell中解决？

Answer 1

不要从您定义类型的模块中导出构造函数，而是导出“智能构造函数”：

module Name (Name(), -- exports the type Name, but not the data constructor Name
             nameFromString,
             stringFromName)
where

data Name = Name String

-- this is the only way to create a Name
nameFromString :: String -> Maybe Name
nameFromString s | 10 < length s = Nothing
                 | otherwise     = Just (Name s)

-- this is the only way to access the contents of a Name
stringFromName :: Name -> String
stringFromName (Name s) = s

因此，您担心如果您以前的代码不要求名称限制为10个字符，那么您不能只放入nameFromString，因为它的类型为String -> Maybe Name而非String -> Name。

首先，如果你真的想抛出异常，你可以定义

import Data.Maybe (fromMaybe)

nameFromString' :: String -> Name
nameFromString' = fromMaybe (error "attempted to construct an invalid Name") . nameFromString

并改为使用它。

其次，抛出异常有时是不对的。考虑

askUserForName :: IO Name
askUserForName
   = do putStr "What's your name? (10 chars max)  "
        s <- getLine
        case nameFromString s of
            Just n  -> return n
            Nothing -> askUserForName

重写此项以使用异常会导致更复杂的代码。

Answer 2

dave4420可以解答您应该做什么。也就是说，只导出智能构造函数。在依赖类型的语言中，可以将数据类型限制为某些形式。但是，Haskell并不依赖于键入。

等等，不，这不是真的。 Haskell是“世界上最受欢迎的依赖类型语言”。你只需要伪造依赖类型。停止。如果你是1.仍在学习基本的Haskell 2，请不要再读了。不是完全疯了。

可以在类型系统中对“不超过10个字符”的约束进行编码。类似

的类型

data Name where
    Name :: LessThan10 len => DList Char len -> Name

但我已经领先于自己了

首先，你需要大量的扩展（我假设GHC 7.4，早期版本仍然可以做到，但更多的是痛苦）

{-# LANGUAGE TypeFamilies,
             DataKinds,
             GADTs,
             FlexibleInstances,
             FlexibleContexts,
             ConstraintKinds-}

import Prelude hiding (succ)

现在我们使用新的DataKinds扩展

为类型级自然构建一些机器

data Nat = Z | S Nat

type N1 = S Z --makes writing numbers easier
type N2 = S N1
--etc
type N10 = S N9

现在我们需要数字的数据表示和生成它们的方法

data Natural n where
    Zero :: Natural Z
    Succ :: Natural a -> Natural (S a)

class Reify a where
   reify :: a

instance Reify (Natural Z) where
   reify = Zero

instance Reify (Natural n) => Reify (Natural (S n)) where
   reify = Succ (reify)

好的，现在我们可以编码数小于10的想法，并编写一个帮助程序来测试它的启动

type family LTE (a :: Nat) (b :: Nat) :: Bool
type instance LTE Z b = True
type instance LTE (S a) Z = False
type instance LTE (S a) (S b) = LTE a b

--YAY constraint kinds!
type LessThan10 a = True ~ (LTE a N10)

data HBool b where
   HTrue :: HBool True
   HFalse :: HBool False

isLTE :: Natural a -> Natural b -> HBool (LTE a b)
isLTE Zero _ = HTrue
isLTE (Succ _) Zero = HFalse
isLTE (Succ a) (Succ b) =  isLTE a b

所有这些我们可以定义长度编码的字符串

data DList a len where
   Nil :: DList a Z
   Cons :: a -> DList a len -> DList a (S len)

toList :: DList a len -> [a]
toList Nil = []
toList (Cons x xs) = x:toList xs

data Name where
   Name :: LessThan10 len => DList Char len -> Name

甚至收回字符串，并为Show

定义一个整齐的Name实例

nameToString :: Name -> String
nameToString (Name l) = toList l

instance Show Name where
   show n = "Name: " ++ nameToString n

问题是我们需要一种方法将String变成Name。那更难。

首先，让我们弄清楚String的长度

data AnyNat where
    AnyNat :: Natural n -> AnyNat

zero = AnyNat Zero
succ (AnyNat n) = AnyNat (Succ n)

lengthNat :: [a] -> AnyNat
lengthNat [] = zero
lengthNat (_:xs) = succ (lengthNat xs)

现在将列表转换为依赖列表是一件简单的事情

fromListLen :: Natural len -> [a] -> Maybe (DList a len)
fromListLen Zero [] = Just Nil
fromListLen Zero (x:xs) = Nothing
fromListLen (Succ a) [] = Nothing
fromListLen (Succ a) (x:xs) = do rs <- fromListLen a xs
                                 return (Cons x rs)

仍然不在家，但我们到了那里

data MaybeName b where
    JustName :: LessThan10 len => DList Char len -> MaybeName True
    NothingName :: MaybeName False

maybeName :: MaybeName b -> Maybe Name
maybeName (JustName l) = Just $ Name l
maybeName (NothingName) = Nothing

stringToName' :: Natural len -> String -> MaybeName (LTE len N10)
stringToName' len str = let t = isLTE len (reify :: Natural N10)
                        in case t of
                           HFalse ->  NothingName
                           HTrue  -> case fromListLen len str of
                                          Just x -> JustName x
                                          --Nothing -> logic error

最后一点只涉及说服GHC，我们并没有试图将编译器的大脑吹掉unsafePerformIO $ produce evilLaugh

stringToNameLen :: Natural len -> String -> Maybe Name
stringToNameLen len str = maybeName $ stringToName' len str

stringToNameAny :: AnyNat -> String -> Maybe Name
stringToNameAny (AnyNat len) str = stringToNameLen len str

stringToName :: String -> Maybe Name
stringToName str = stringToNameAny (lengthNat str) str

哇，我写了很长的堆栈溢出帖子，但这需要蛋糕

我们测试它

*Main> stringToName "Bob"
Just Name: Bob
*Main> stringToName "0123456789"
Just Name: 0123456789
*Main> stringToName "01234567890"
Nothing

所以它的工作原理，类型系统现在可以强制执行你的名字不超过10个字符的不变量。但说真的，这可能不值得你努力。

Answer 3

你完美地描述了这种类型。你很快就会后悔...

data Name  = N1 Char
           | N2 Char Char
           | N3 Char Char Char
           | N4 Char Char Char Char
           | N5 Char Char Char Char Char
           | N6 Char Char Char Char Char Char
           | N7 Char Char Char Char Char Char Char
           | N8 Char Char Char Char Char Char Char Char
           | N9 Char Char Char Char Char Char Char Char Char
           | N10 Char Char Char Char Char Char Char Char Char Char
           deriving (Show, Eq,Ord)

prettyName :: Name -> String
prettyName (N1 a) = a:[]
prettyName (N2 a b) = a:b:[]
prettyName (N3 a b c) = a:b:c:[]
prettyName (N4 a b c d) = a:b:c:d:[]
prettyName (N5 a b c d e) = a:b:c:d:e:[]
prettyName (N6 a b c d e f) = a:b:c:d:e:f:[]
prettyName (N7 a b c d e f g) = a:b:c:d:e:f:g:[]
prettyName (N8 a b c d e f g h) = a:b:c:d:e:f:g:h:[]
prettyName (N9 a b c d e f g h i) = a:b:c:d:e:f:g:h:i:[]
prettyName (N10 a b c d e f g h i j) = a:b:c:d:e:f:g:h:i:j:[]

虽然我们在ghci中导入Text.PrettyPrint，为什么不在解析器中？

import Text.ParserCombinators.Parsec
import Control.Applicative ((<*))
-- still lame
pN :: Parser Name
pN = do letters <- many1 alphaNum <* space
        case letters of 
            a:[]  -> return $ N1 a  
            a:b:[]  -> return $ N2 a b  
            a:b:c:[]  -> return $ N3 a b c  
            a:b:c:d:[]  -> return $ N4 a b c d  
            a:b:c:d:e:[]  -> return $ N5 a b c d e  
            a:b:c:d:e:f:[]  -> return $ N6 a b c d e f  
            a:b:c:d:e:f:g:[]  -> return $ N7 a b c d e f g  
            a:b:c:d:e:f:g:h:[]  -> return $ N8 a b c d e f g h  
            a:b:c:d:e:f:g:h:i:[]  -> return $ N9 a b c d e f g h i  
            a:b:c:d:e:f:g:h:i:j:[]  -> return $ N10 a b c d e f g h i j
            _ -> unexpected "excess of letters"

-- *Main> parseTest pN "Louise "
-- N6 'L' 'o' 'u' 'i' 's' 'e'
-- *Main> parseTest pN "Louisiana "
-- N9 'L' 'o' 'u' 'i' 's' 'i' 'a' 'n' 'a'
-- *Main> parseTest (fmap prettyName pN) "Louisiana "
-- "Louisiana"
-- *Main> parseTest pN "Mississippi "
-- parse error at (line 1, column 13):
-- unexpected excess of letters

......也许这不是一个好主意......

如何在Haskell中创建包含有限长度的String的Type

3 个答案: