blocks|key|1138765|text|:运算符并不做您认为它做的事情：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1138766|(:)+::+a+->+[a]+->+[a]|code-block|syntax|javascript|1138767|它接受类型为a的项，并将其添加到类型为a的列表的开头。您将使用它连接两个类型为a的列表。为此，您需要使用%2B%2B|1138768|(%2B%2B)+::+[a]+->+[a]+->+[a]|1138769|另外，如果你做一个递归函数，它需要一个结束条件。所以试试这个：|1138770|removeItem+_+[]+=+[]
removeItem+x+(y:ys)+=+areTheySame+x+y+%2B%2B+removeItem+x+ys|1138771|这样，当您到达列表的末尾时，该函数将停止递归。|1138772|entityMap^0|0|1|0|0|6|1|J|1|13|1|1G|2|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1A|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1C|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|V|$]]

The <code>:</code> operator doesn't do what you think it does:

<pre><code>(:) :: a -&gt; [a] -&gt; [a]
</code></pre>

It takes an item of type <code>a</code> and adds it to the beginning of a list of type <code>a</code>. You're using it to join two lists of type <code>a</code>. For that, you need to use <code>++</code>:

<pre><code>(++) :: [a] -&gt; [a] -&gt; [a]
</code></pre>

Also, if you make a recursive function, it needs an ending condition. So try this:

<pre><code>removeItem _ [] = []
removeItem x (y:ys) = areTheySame x y ++ removeItem x ys
</code></pre>

That way, when you get to the end of the list, the function will stop recursing.

blocks|key|1138867|text|这是使您的示例正常工作的最小修复：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1138868|removeItem+::+Int+->+[Int]+->+[Int]
removeItem+_+[]+++++=+[]
removeItem+x+(y:ys)+=+areTheySame+x+y+%2B%2B+removeItem+x+ys|code-block|syntax|javascript|1138869|首先，您需要使用%2B%2B来连接列表，因为您使用的:操作符只在列表的开头添加了一个元素(它既不能用来添加只有一个元素的列表，也不能用来添加空列表)。首先使用areTheySame将列表头(y)与要删除的项进行比较，然后正确地返回该项或空列表。然后，您希望递归地继续在列表的其余部分(ys)上使用removeItem。结果列表需要使用%2B%2B连接起来。|offset|length|style|CODE|1138870|其次，正如Chris+Lutz所指出的，当你到达列表的末尾时，你需要一个结束条件。通过添加这一行，Haskell知道如何处理空列表(即什么都不做，只返回一个空列表)。|1138871|正如Chuck所说，您可以简化此任务的代码，方法是让removeItem不委托比较任务，而是比较自身并在应该删除元素时将其丢弃，否则将其保留在列表头部(使用:)。在任何情况下，都可以递归地继续列表的其余部分。|1138872|--+nothing+can+be+removed+from+an+empty+list
--+==>+return+empty+list+and+stop+recursion
removeItem+_+[]+++++=+[]

--+if+the+list+is+not+empty,+cut+off+the+head+in+y+and+keep+the+rest+in+ys
--++++++++++++++++++++if+x==y,+remove+y+and+continue
removeItem+x+(y:ys)+%7C+x+==+y++++=+removeItem+x+ys++++
--++++++++++++++++++++otherwise,+add+y+back+and+continue+
++++++++++++++++++++%7C+otherwise+=+y+:+removeItem+x+ys|1138873|entityMap^0|0|0|8|2|M|1|23|B|2J|1|3U|2|40|A|4J|2|0|0|26|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]|$I|Z|J|10|K|L]|$I|11|J|12|K|L]|$I|13|J|14|K|L]|$I|15|J|16|K|L]|$I|17|J|18|K|L]|$I|19|J|1A|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1B|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1C|8|@$I|1D|J|1E|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|T|$]]

This is the minimal fix to make your example work:

<pre><code>removeItem :: Int -&gt; [Int] -&gt; [Int]
removeItem _ [] = []
removeItem x (y:ys) = areTheySame x y ++ removeItem x ys
</code></pre>

First, you need to use <code>++</code> to concatenate lists, as the <code>:</code> operator used by you adds just one element to the beginning of a list (it can neither be used to add lists with one element nor to add empty lists). You first compare the head of the list (<code>y</code>) to the item you want to remove and correctly return the item or an empty list using <code>areTheySame</code>. Then you want to recursively continue using <code>removeItem</code> on the rest of the list (<code>ys</code>). The resulting list needs to be concatenated using <code>++</code>.

Second, as Chris Lutz noted, you need an ending condition when you reach the end of the list. By adding this line, Haskell knows what to do with an empty list (that is, nothing, just return an empty list).

As Chuck said, you can simplify the code for this task by having removeItem not delegate the task of the comparison, but compare itself and throw away the element if it should be removed, otherwise keep it at the list head (using <code>:</code>). In any case, continue recursively with the rest of the list.

<pre><code>-- nothing can be removed from an empty list
-- ==&gt; return empty list and stop recursion
removeItem _ [] = []

-- if the list is not empty, cut off the head in y and keep the rest in ys
-- if x==y, remove y and continue
removeItem x (y:ys) | x == y = removeItem x ys 
-- otherwise, add y back and continue 
 | otherwise = y : removeItem x ys
</code></pre>

blocks|key|1354115|text|其他人是对的，问题出在:运算符。不过，我想说返回列表的areTheySame函数无论如何都是错误的方法。与其切换到%2B%2B运算符，该函数的更好实现应该是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1354116|removeItem+_+[]+++++++++++++++++=+[]
removeItem+x+(y:ys)+%7C+x+==+y++++=+removeItem+x+ys
++++++++++++++++++++%7C+otherwise+=+y+:+removeItem+x+ys|code-block|syntax|javascript|1354117|如您所见，这是一个非常简单的实现。而且，与将一堆列表附加在一起相比，这样的协商对您的程序来说要少得多。它还有其他好处，比如懒惰地工作。|1354118|entityMap^0|B|1|R|B|1L|2|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

The others are right that the problem is the <code>:</code> operator. I would say that your <code>areTheySame</code> function that returns a list is the wrong approach anyway, though. Rather than switch to the <code>++</code> operator, a better implementation of that function would be:

<pre><code>removeItem _ [] = []
removeItem x (y:ys) | x == y = removeItem x ys
 | otherwise = y : removeItem x ys
</code></pre>

As you can see, this is a pretty simple implementation. Also, consing like this is much less taxing for your program than appending a bunch of lists together. It has other benefits as well, such as working lazily.

blocks|key|1354172|text|作为参考，您可能会对how+it's+done+in+delete+from+Data.List感兴趣。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1354173|您可以让areTheySame保持原样，但随后需要在removeItem中使用concatMap来折叠空列表：|1354174|removeItem+::+Int+->+[Int]+->+[Int]
removeItem+x+xs+=+concatMap+(areTheySame+x)+xs|code-block|syntax|javascript|1354175|或等同于|1354176|removeItem+::+Int+->+[Int]+->+[Int]
removeItem+x+=+concatMap+(areTheySame+x)|1354177|请注意，您的函数类型可以更通用：|1354178|areTheySame+::+(Eq+a)+=>+a+->+a+->+[a]
removeItem++::+(Eq+a)+=>+a+->+[a]+->+[a]|1354179|这允许从定义了==的任何类型的列表中删除项，而不仅仅是Int。|1354180|entityMap|0|LINK|mutability|MUTABLE|url|https://hackage.haskell.org/package/base-4.8.2.0/docs/src/Data.OldList.html#delete|1|http://www.haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v%253AconcatMap^0|R|6|A|12|0|0|4|B|Q|A|13|9|13|9|1|0|0|0|0|0|0|7|2|R|3|0^^$0|@$1|2|3|4|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@$9|19|A|1A|1|1B]]|E|$]]|$1|F|3|G|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]]|D|@$9|1J|A|1K|1|1L]]|E|$]]|$1|H|3|I|5|J|7|1M|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1N|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1O|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1P|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|1Q|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|1R|8|@$9|1S|A|1T|B|C]|$9|1U|A|1V|B|C]]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1W|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]|14|$5|Z|10|11|E|$12|15]]]]

For reference, you may be interested in seeing <a href="https://hackage.haskell.org/package/base-4.8.2.0/docs/src/Data.OldList.html#delete" rel="nofollow noreferrer">how it's done in <code>delete</code> from Data.List</a>.

You could leave <code>areTheySame</code> as is, but you'd then need to use <a href="http://www.haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v%3AconcatMap" rel="nofollow noreferrer"><code>concatMap</code></a> in <code>removeItem</code> to collapse the empty lists:

<pre><code>removeItem :: Int -&gt; [Int] -&gt; [Int]
removeItem x xs = concatMap (areTheySame x) xs
</code></pre>

or equivalently

<pre><code>removeItem :: Int -&gt; [Int] -&gt; [Int]
removeItem x = concatMap (areTheySame x)
</code></pre>

Note that the types of your functions could be more general:

<pre><code>areTheySame :: (Eq a) =&gt; a -&gt; a -&gt; [a]
removeItem :: (Eq a) =&gt; a -&gt; [a] -&gt; [a]
</code></pre>

This allows removal of items from lists of any type for which <code>==</code> is defined, not just <code>Int</code>.

blocks|key|1354209|text|您也可以将其作为列表理解来执行|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1354210|delete+::+Eq+a+=>+a+->+[a]+->+[a]
delete+deleted+xs+=+[+x+%7C+x+<-+xs,+x+/=+deleted+]|code-block|syntax|javascript|1354211|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can also do this as a list-comprehension

<pre><code>delete :: Eq a =&gt; a -&gt; [a] -&gt; [a]
delete deleted xs = [ x | x &lt;- xs, x /= deleted ]
</code></pre>

blocks|key|1139068|text|我相信到目前为止给出的所有解决方案都不同于Data.List.delete，后者只删除了第一个成员。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1139069|deleteFromList+x+xs+=
++case+break+(==x)+xs+of
++++(_,[])+->+xs
++++(notsat,sat)+->+notsat+%2B%2B+tail+sat|code-block|syntax|javascript|1139070|我试图只删除第一个成员(在D.L还没有达到顶峰)。|1139071|目前还不清楚这位顶级发帖者想要什么样的行为。|1139072|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I believe all the solutions given so far work differently than Data.List.delete, which only deletes the first member.

<pre><code>deleteFromList x xs =
 case break (==x) xs of
 (_,[]) -&gt; xs
 (notsat,sat) -&gt; notsat ++ tail sat
</code></pre>

was my attempt to delete only the first member (haven't peaked at D.L yet).

It's unclear which behavior the top poster wants.

blocks|key|1139145|text|我只用一行代码编写了一个函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1139146|remove+element+list+=+filter+(\e+->+e/=element)+list|code-block|syntax|javascript|1139147|例如：|1139148|remove+5+[1..10]|1139149|1,2,3,4,6,7,8,9,10|1139150|remove+'b'+['a'..'f']|1139151|"acdef“|1139152|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I wrote a function in just one line of code:

<pre><code>remove element list = filter (\e -&gt; e/=element) list
</code></pre>

For example:

<pre><code>remove 5 [1..10]
</code></pre>

[1,2,3,4,6,7,8,9,10]

<pre><code>remove 'b' ['a'..'f']
</code></pre>

"acdef"

Trying to learn Haskell. I am trying to write a simple function to remove a number from a list without using built-in function (delete...I think). For the sake of simplicity, let's assume that the input parameter is an Integer and the list is an Integer list. Here is the code I have, Please tell me what's wrong with the following code

<pre><code>areTheySame :: Int -&gt; Int-&gt; [Int]

areTheySame x y | x == y = []
 | otherwise = [y]

removeItem :: Int -&gt; [Int] -&gt; [Int]

removeItem x (y:ys) = areTheySame x y : removeItem x ys
</code></pre>

Learning Haskell: How to remove an item from a List in Haskell

试着学习哈斯克尔。我正在尝试编写一个简单的函数来从列表中删除一个数字，而不使用内置的函数(我想是delete……)。为简单起见，我们假设输入参数为Integer，列表为Integer list。这是我的代码，请告诉我下面的代码有什么问题areTheySame :: Int -> Int-> [Int]areTheySa...

问学习Haskell:如何从Haskell中的列表中删除项目
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问学习Haskell:如何从Haskell中的列表中删除项目EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问学习Haskell:如何从Haskell中的列表中删除项目
EN