List Haskell是替换字符串中的字符的更好方法

我做了这个函数

replace :: Char -> Char -> [Char] -> [Char]
replace _ _ [] = []
replace a b (c:r)
    | a == c = b : replace a b r
    | otherwise = c : replace a b r

foo :: A -> B -> B
foo x y = y

当我发现这一点时，我正在寻找一种更好的写作方式：

replace :: Char -> Char -> [Char] -> [Char]
replace a b  = map $ \c -> if c == a then b else c

甚至没有写第三个参数，我不理解$和\c符号，但它起作用了，我想知道这里发生了什么

甚至连第三个论点都没有写出来

在Haskell中，所有函数只有一个参数。事实上，Char->Char->[Char]->[Char]是Char->Char->[Char]->[Char]的缩写，因此它是一个接受一个Char然后返回另一个函数的函数。如果我们用另一个字符应用该函数，它将返回一个[Char]->[Char]类型的函数，该函数将把一个字符列表映射到一个字符列表，最后如果我们用一个字符列表调用该函数，我们将得到一个字符列表

因此，这意味着如果函数头中有两个参数，那么map$\c->if c==a，那么b else c应该返回一个函数，情况就是这样

…我不懂$…符号

该功能定义为：

infixr 0 $

($) :: (a -> b) -> a -> b
($) f x = f x

因此，它是函数应用。之所以使用它，是因为它的优先级为0，这意味着，例如$Bx将作为Bx计算，而Bx将作为Bx计算。因此，这意味着该函数等价于map\c->如果c==a，那么b else c

我不明白…这些符号

这是一个lambda表达式。它是一个函数，将变量c作为输入，并将其映射到箭头->右侧的零件上。这里它意味着如果c==a，它将字符c映射到b；否则返回c

甚至连第三个论点都没有写出来

在Haskell中，所有函数只有一个参数。事实上，Char->Char->[Char]->[Char]是Char->Char->[Char]->[Char]的缩写，因此它是一个接受一个Char然后返回另一个函数的函数。如果我们用另一个字符应用该函数，它将返回一个[Char]->[Char]类型的函数，该函数将把一个字符列表映射到一个字符列表，最后如果我们用一个字符列表调用该函数，我们将得到一个字符列表

因此，这意味着如果函数头中有两个参数，那么map$\c->if c==a，那么b else c应该返回一个函数，情况就是这样

…我不懂$…符号

该功能定义为：

infixr 0 $

($) :: (a -> b) -> a -> b
($) f x = f x

因此，它是函数应用。之所以使用它，是因为它的优先级为0，这意味着，例如$Bx将作为Bx计算，而Bx将作为Bx计算。因此，这意味着该函数等价于map\c->如果c==a，那么b else c

我不明白…这些符号

这是一个lambda表达式。它是一个函数，将变量c作为输入，并将其映射到箭头->右侧的零件上。这里它意味着如果c==a，它将字符c映射到b；否则它将返回c。

美元运算符将函数应用于参数。我们可以将您的示例改写为

replace :: Char -> Char -> [Char] -> [Char]
replace a b  = map (\c -> if c == a then b else c)

实际上，Haskeller经常使用$来避免使用括号。由于其他原因，它很少被使用

关于\c->…：这是一个匿名函数，也称为lambda。它代表以c为参数并返回。。。部分在您的例子中，函数接受c并检查它是否等于a，在这种情况下返回b，否则返回c。我们可以在没有lambda的情况下重写代码，如下所示：

replace :: Char -> Char -> [Char] -> [Char]
replace a b  = map myFun
   where
   myFun :: Char -> Char
   myFun = \c -> if c == a then b else c

replace :: Char -> Char -> [Char] -> [Char]
replace a b  = map myFun
   where
   myFun :: Char -> Char
   myFun c = if c == a then b else c

replace :: Char -> Char -> [Char] -> [Char]
replace a b xs = map myFun xs
   where
   myFun :: Char -> Char
   myFun c = if c == a then b else c

或者，将参数c移到=，如下所示：

replace :: Char -> Char -> [Char] -> [Char]
replace a b  = map myFun
   where
   myFun :: Char -> Char
   myFun = \c -> if c == a then b else c

replace :: Char -> Char -> [Char] -> [Char]
replace a b  = map myFun
   where
   myFun :: Char -> Char
   myFun c = if c == a then b else c

replace :: Char -> Char -> [Char] -> [Char]
replace a b xs = map myFun xs
   where
   myFun :: Char -> Char
   myFun c = if c == a then b else c

关于缺少的第三个参数：可以通过多种方式读取类型Char->Char->[Char]->[Char]：

接受一个参数Char并返回函数Char->[Char]->[Char]的函数类型 采用两个参数Char和Char并返回函数[Char]->[Char]的函数类型 采用三个参数Char、Char和[Char]并返回列表[Char]的函数类型 多亏了咖喱，这三种解释都是相容的。事实上，这两个参数起作用

replace :: Char -> Char -> [Char] -> [Char]
replace _ _ [] = []
replace a b (c:r)
    | a == c = b : replace a b r
    | otherwise = c : replace a b r

foo :: A -> B -> B
foo x y = y

以及功能

foo :: A -> B -> B
foo x = id              -- id is the identity function B -> B

都是一样的

在您的示例中，如果需要，可以将缺少的参数添加到=的两侧，如下所示：

replace :: Char -> Char -> [Char] -> [Char]
replace a b  = map myFun
   where
   myFun :: Char -> Char
   myFun = \c -> if c == a then b else c

replace :: Char -> Char -> [Char] -> [Char]
replace a b  = map myFun
   where
   myFun :: Char -> Char
   myFun c = if c == a then b else c

replace :: Char -> Char -> [Char] -> [Char]
replace a b xs = map myFun xs
   where
   myFun :: Char -> Char
   myFun c = if c == a then b else c

在这个扩展代码中，您可以看到map myFun xs使用map库函数将myFun应用于list xs的所有元素，并返回所有结果的列表。 这有效地实现了您想要的替换

但是,在不增加第三个论点的情况下,

replace :: Char -> Char -> [Char] -> [Char]
replace a b = map myFun
   where ...

我们仍然可以将map myFun解释为将函数myFun:：Char->Char转换为函数[Char]->[Char]。如果我们将其解释为一个双参数函数，则后者实际上是replace的返回类型。也就是说，replace'a''b'是函数[Char]->[Char]，它接受一个字符串并用一个'b'替换其中的每个'a'。

美元运算符将函数应用于参数。我们可以将您的示例改写为

replace :: Char -> Char -> [Char] -> [Char]
replace a b  = map (\c -> if c == a then b else c)

实际上，Haskeller经常使用$来避免使用括号。是r 它们被用于其他原因

关于\c->…：这是一个匿名函数，也称为lambda。它代表以c为参数并返回。。。部分在您的例子中，函数接受c并检查它是否等于a，在这种情况下返回b，否则返回c。我们可以在没有lambda的情况下重写代码，如下所示：

replace :: Char -> Char -> [Char] -> [Char]
replace a b  = map myFun
   where
   myFun :: Char -> Char
   myFun = \c -> if c == a then b else c

replace :: Char -> Char -> [Char] -> [Char]
replace a b  = map myFun
   where
   myFun :: Char -> Char
   myFun c = if c == a then b else c

replace :: Char -> Char -> [Char] -> [Char]
replace a b xs = map myFun xs
   where
   myFun :: Char -> Char
   myFun c = if c == a then b else c

或者，将参数c移到=，如下所示：

replace :: Char -> Char -> [Char] -> [Char]
replace a b  = map myFun
   where
   myFun :: Char -> Char
   myFun = \c -> if c == a then b else c

replace :: Char -> Char -> [Char] -> [Char]
replace a b  = map myFun
   where
   myFun :: Char -> Char
   myFun c = if c == a then b else c

replace :: Char -> Char -> [Char] -> [Char]
replace a b xs = map myFun xs
   where
   myFun :: Char -> Char
   myFun c = if c == a then b else c

关于缺少的第三个参数：可以通过多种方式读取类型Char->Char->[Char]->[Char]：

接受一个参数Char并返回函数Char->[Char]->[Char]的函数类型 采用两个参数Char和Char并返回函数[Char]->[Char]的函数类型 采用三个参数Char、Char和[Char]并返回列表[Char]的函数类型 多亏了咖喱，这三种解释都是相容的。事实上，这两个参数起作用

replace :: Char -> Char -> [Char] -> [Char]
replace _ _ [] = []
replace a b (c:r)
    | a == c = b : replace a b r
    | otherwise = c : replace a b r

foo :: A -> B -> B
foo x y = y

以及功能

foo :: A -> B -> B
foo x = id              -- id is the identity function B -> B

都是一样的

在您的示例中，如果需要，可以将缺少的参数添加到=的两侧，如下所示：

replace :: Char -> Char -> [Char] -> [Char]
replace a b  = map myFun
   where
   myFun :: Char -> Char
   myFun = \c -> if c == a then b else c

replace :: Char -> Char -> [Char] -> [Char]
replace a b  = map myFun
   where
   myFun :: Char -> Char
   myFun c = if c == a then b else c

replace :: Char -> Char -> [Char] -> [Char]
replace a b xs = map myFun xs
   where
   myFun :: Char -> Char
   myFun c = if c == a then b else c

在这个扩展代码中，您可以看到map myFun xs使用map库函数将myFun应用于list xs的所有元素，并返回所有结果的列表。 这有效地实现了您想要的替换

但是,在不增加第三个论点的情况下,

replace :: Char -> Char -> [Char] -> [Char]
replace a b = map myFun
   where ...

我们仍然可以将map myFun解释为将函数myFun:：Char->Char转换为函数[Char]->[Char]。如果我们将其解释为一个双参数函数，则后者实际上是replace的返回类型。也就是说，replace'a''b'是函数[Char]->[Char]，它接受一个字符串并用一个'b'替换其中的每个'a'