Haskell字符串列表到Int列表

我有一个字符串列表，我想一个接一个地读取字符串并将其转换为整数列表，有没有办法将每个字符转换为一个新列表

["123","346","789"] to [[1,2,3],[4,5,6],[7,8,9]]

stringToInt :: [String] -> [[Int]]

---

函数式编程的支柱之一是

map

，它具有以下特征：

map :: (a -> b) -> [a] -> [b]

换句话说，它接受一个函数，该函数期望值的类型为

a

，返回值的类型为

b

（注意，这些值可以是相同的类型，但不一定是相同的）以及

a

值的列表，并返回

b

值的列表。举个例子：

double :: Int -> Int
double = (*2)
{- equivalently written as:
   double x = x * 2 -}

as = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
bs = map double as

在本例中，map是专门化的，其中

a~Int

和

b~Int

，解析为

map :: (Int -> Int) -> [Int] -> [Int]

而

bs

则是

[2,4,6,8,10,12,14,16,18,20]

---

为什么要在

map

上写这么长的底漆？因为它是函数式编程中众多答案的框架，包括您的问题。请记住，

String

只是

[Char]

的类型同义词，因此您尝试从

[[Char]]->[[Int]]

开始。哎呀，这看起来确实像map类型签名的最后两项，不是吗？让我们专门化

map

来操作这些术语

map :: ([Char] -> [Int]) -> [[Char]] -> [[Int]]

但是等等，

map

所期望的函数看起来也像是映射的结果。我们也来写吧

map :: (Char -> Int) -> [Char] -> [Int]

所以我们想要的是一个双映射，应用于某个函数

f

，这样：

map (map f) :: [[Char]] -> [[Int]]
{- more idiomatically written as
   (map . map) f :: [[Char]] -> [[Int]] -}

这意味着我们需要一个

f:：Char->Int

——一个从单个字符到整数的函数。对于该操作，定义的输入数量相当少，所以我只编写它

digitToInt :: Char -> Int
digitToInt '0' = 0
digitToInt '1' = 1
digitToInt '2' = 2
digitToInt '3' = 3
digitToInt '4' = 4
digitToInt '5' = 5
digitToInt '6' = 6
digitToInt '7' = 7
digitToInt '8' = 8
digitToInt '9' = 9
digitToInt 'a' = 10
digitToInt 'A' = 10
digitToInt 'b' = 11
digitToInt 'B' = 11
digitToInt 'c' = 12
digitToInt 'C' = 12
digitToInt 'd' = 13
digitToInt 'D' = 13
digitToInt 'e' = 14
digitToInt 'E' = 14
digitToInt 'f' = 15
digitToInt 'F' = 15
digitToInt _   = error "Invalid digit"

但是注意，这个函数在

Data.Char中是标准的

import Data.Char (digitToInt)

那么你的结果是：

result = (map.map) digitToInt ["123","346","789"]

函数式编程的支柱之一是
map
，它具有以下特征：

map :: (a -> b) -> [a] -> [b]

换句话说，它接受一个函数，该函数期望值的类型为
a
，返回值的类型为
b
（注意，这些值可以是相同的类型，但不一定是相同的）以及
a
值的列表，并返回
b
值的列表。举个例子：

double :: Int -> Int
double = (*2)
{- equivalently written as:
   double x = x * 2 -}

as = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
bs = map double as

在本例中，map是专门化的，其中
a~Int
和
b~Int
，解析为

map :: (Int -> Int) -> [Int] -> [Int]

而
bs
则是
[2,4,6,8,10,12,14,16,18,20]


为什么要在
map
上写这么长的底漆？因为它是函数式编程中众多答案的框架，包括您的问题。请记住，
String
只是
[Char]
的类型同义词，因此您尝试从
[[Char]]->[[Int]]
开始。哎呀，这看起来确实像map类型签名的最后两项，不是吗？让我们专门化
map
来操作这些术语

map :: ([Char] -> [Int]) -> [[Char]] -> [[Int]]

但是等等，
map
所期望的函数看起来也像是映射的结果。我们也来写吧

map :: (Char -> Int) -> [Char] -> [Int]

所以我们想要的是一个双映射，应用于某个函数
f
，这样：

map (map f) :: [[Char]] -> [[Int]]
{- more idiomatically written as
   (map . map) f :: [[Char]] -> [[Int]] -}

这意味着我们需要一个
f:：Char->Int
——一个从单个字符到整数的函数。对于该操作，定义的输入数量相当少，所以我只编写它

digitToInt :: Char -> Int
digitToInt '0' = 0
digitToInt '1' = 1
digitToInt '2' = 2
digitToInt '3' = 3
digitToInt '4' = 4
digitToInt '5' = 5
digitToInt '6' = 6
digitToInt '7' = 7
digitToInt '8' = 8
digitToInt '9' = 9
digitToInt 'a' = 10
digitToInt 'A' = 10
digitToInt 'b' = 11
digitToInt 'B' = 11
digitToInt 'c' = 12
digitToInt 'C' = 12
digitToInt 'd' = 13
digitToInt 'D' = 13
digitToInt 'e' = 14
digitToInt 'E' = 14
digitToInt 'f' = 15
digitToInt 'F' = 15
digitToInt _   = error "Invalid digit"

但是注意，这个函数在
Data.Char中是标准的

import Data.Char (digitToInt)

那么你的结果是：

result = (map.map) digitToInt ["123","346","789"]

[123.346789]不是字符串列表。你是说[“123”、“346”、“789”]？或者你想把数字分成数字吗？是的，这就是我的意思，如果我传入
[“1xt3”]
，你希望函数返回什么？我只想假设所有字符串在转换后都是有效的整数，因为这听起来像是家庭作业，如果不是这样，我只给你一个提示。由于字符串也可以包含非数字的内容，任何类型的[String]->[[Int]]函数都必须是部分函数，因此我建议您实现一个类型为[String]->Maybe[[Int]]或[String]->[Maybe[Int]]或[String]->[[Maybe Int]]的函数，具体取决于预期用途。[123.346789]不是字符串列表。你是说[“123”、“346”、“789”]？或者你想把数字分成数字吗？是的，这就是我的意思，如果我传入
[“1xt3”]
，你希望函数返回什么？我只想假设所有字符串在转换后都是有效的整数，因为这听起来像是家庭作业，如果不是这样，我只给你一个提示。由于字符串也可以包含非数字的内容，任何类型的[String]->[[Int]]函数都必须是部分函数，因此我建议您实现一个类型为[String]->Maybe[[Int]]或[String]->[Maybe[Int]]或[String]->[[Maybe Int]]的函数，取决于预期用途。请注意，
digitToInt
在这里不是一个很好的功能，因为它不是完整的，正如在对您的问题的评论中提到的，我在写“该操作的定义输入数量相当少”时也提到了这一点每当类型的域大于您可以为其定义函数的输入数时，您可能就没有编写最惯用的Haskell代码。在这种情况下，如果您编写
digittomaBeint:：Char->Maybe Int
并生成
结果：[[Maybe Int]]
（或者甚至
[Maybe[Int]]]
或者
Maybe[[Int]]
，这取决于您的严格程度。）请注意，
digittoming
在这里不是一个很好的功能，因为它不是完整的，正如在对您的问题的评论中所提到的，以及我在写“该操作定义的输入数量相当少”时所提到的。任何时候，类型的域大于您可以定义函数的输入数量，您可能都没有编写最惯用的Haskell代码。在这种情况下，如果编写
digitToMaybeInt:：Char->Maybe Int
并生成
结果：[[Maybe Int]]
（或