blocks|key|2034779|text|为了返回给定元素的前一个元素，可以使用一些模式匹配和递归：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2034780|precedingElement+_+[]+=+Nothing
precedingElement+_+[x]+=+Nothing
precedingElement+elt+(x:y:rest)
++++%7C+y+==+elt+=+Just+x
++++%7C+otherwise+=+precedingElement+elt+(y:rest)|code-block|syntax|javascript|2034781|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|$]]

In order to return the preceding element of the given element, you can use some pattern matching and recursion:

<pre><code>precedingElement _ [] = Nothing
precedingElement _ [x] = Nothing
precedingElement elt (x:y:rest)
 | y == elt = Just x
 | otherwise = precedingElement elt (y:rest)
</code></pre>

blocks|key|1076985|text|因为我是一个狂热的粉丝，我可能会写一些东西|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1076986|lastBefore+::+(a+->+Bool)+->+[a]+->+Maybe+a
lastBefore+p+xs+=+foldr+go+(`seq`+Nothing)+xs+Nothing
++where
++++go+x+r+(Just+prev)+%7C+p+x+=+Just+prev
++++go+x+r+_+=+r+(Just+x)|code-block|syntax|javascript|1076987|但我必须检查GHC是否可以按我的意愿优化它。|1076988|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

As I'm a big fold fan, I might write something like

<pre><code>lastBefore :: (a -&gt; Bool) -&gt; [a] -&gt; Maybe a
lastBefore p xs = foldr go (`seq` Nothing) xs Nothing
 where
 go x r (Just prev) | p x = Just prev
 go x r _ = r (Just x)
</code></pre>

But I'd have to check that GHC optimizes it as I wish.

blocks|key|2034845|text|对于这样的问题，我最喜欢的一个被低估的实用程序相当方便。让我有倒向列表，这样我就不需要反转我的大脑了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2034846|data+Bwd+x+=+B0+%7C+Bwd+x+:<+x++--+rightmost+is+nearest|code-block|syntax|javascript|2034847|把列表元素想象成算盘线上的珠子。向左轻击几下，让你的手指放在下一个上。你有什么？手指左边的珠子列表(最右边的)，手指右边的珠子列表(最左边的珠子)，还有你手指上的珠子。|2034848|也就是说，列表的单孔元素上下文是由孔的任何一边的前向和后向列表给出的。|2034849|type+ListContext+x+=+(Bwd+x,+[x])|2034850|那些知道我的老歌的人认为ListContext是[]的衍生词。|offset|length|style|CODE|2034851|焦点的一个元素(你的手指在珠上)是|2034852|type+ListFocus+x+=+(ListContext+x,+x)|2034853|还有一个有用的操作，用它的上下文装饰每个list元素，并将其放在焦点上。|2034854|focus+::+[x]+->+[ListFocus+x]
focus+=+go+B0+where
++go+xz+[]+=+[]
++go+xz+(x+:+xs)+=+((xz,+xs),+x)+:+go+(xz+:<+x)+xs|2034855|例如,|2034856|focus+[1,2,3]+=+[((B0,[2,3]),1),+((B0+:<+1,[3]),2),+((B0+:<+1+:<+2,[]),3)]|2034857|现在很容易回答与元素及其周围环境有关的各种问题。您可能不应该仅仅为了解决这个问题而构造focus，但这是我一直关注的事情，因为它解决了许多问题。|2034858|[p+%7C+((_+:<+p,_),q)+<-+focus+xs,+q+==+x]|2034859|计算位于p中x左侧的所有值xs。如你所见。|2034860|(顺便说一句，这个focus操作不是从哪里来的。它源于列表的数据类型的差异结构。This+answer+(在这里被称为picks)更详细地讲述列表故事，this+answer开发了数据类型通用故事。|2034861|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/12872133/828361|1|https://stackoverflow.com/a/25572148/828361^0|0|0|0|0|0|C|B|O|2|0|0|0|0|0|0|0|17|5|0|0|4|1|6|1|D|2|0|9|5|1N|5|14|B|0|24|B|1|0^^$0|@$1|2|3|4|5|6|7|1M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1P|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|1Q|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|1R|8|@$O|1S|P|1T|Q|R]|$O|1U|P|1V|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1W|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1X|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1Z|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|20|8|@]|9|@]|A|$]]|$1|12|3|13|5|D|7|21|8|@]|9|@]|A|$E|F]]|$1|14|3|15|5|6|7|22|8|@$O|23|P|24|Q|R]]|9|@]|A|$]]|$1|16|3|17|5|D|7|25|8|@]|9|@]|A|$E|F]]|$1|18|3|19|5|6|7|26|8|@$O|27|P|28|Q|R]|$O|29|P|2A|Q|R]|$O|2B|P|2C|Q|R]]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|2D|8|@$O|2E|P|2F|Q|R]|$O|2G|P|2H|Q|R]]|9|@$O|2I|P|2J|1|2K]|$O|2L|P|2M|1|2N]]|A|$]]|$1|1C|3|-4|5|6|7|2O|8|@]|9|@]|A|$]]]|1D|$1E|$5|1F|1G|1H|A|$1I|1J]]|1K|$5|1F|1G|1H|A|$1I|1L]]]]

One of my favourite underappreciated utilities is rather handy for problems like this. Let me have backward lists, so I don't need to reverse my brain.

<pre><code>data Bwd x = B0 | Bwd x :&lt; x -- rightmost is nearest
</code></pre>

Think of list elements as the beads on an abacus wire. Flick a few to the left and leave your finger resting on the next one. What have you? A list of beads to the left of your finger (with the rightmost nearest), a list of beads to the right of your finger (with the leftmost nearest), and the bead with your finger on it.

That is, a one-hole element context for lists is given by the pair of backward and forward lists either side of the hole.

<pre><code>type ListContext x = (Bwd x, [x])
</code></pre>

Those who know my old songs recognize <code>ListContext</code> as the derivative of <code>[]</code>.

An element in focus (your finger on a bead) is

<pre><code>type ListFocus x = (ListContext x, x)
</code></pre>

And there is a useful operation which decorates every list element with its context, putting it in focus.

<pre><code>focus :: [x] -&gt; [ListFocus x]
focus = go B0 where
 go xz [] = []
 go xz (x : xs) = ((xz, xs), x) : go (xz :&lt; x) xs
</code></pre>

For example,

<pre><code>focus [1,2,3] = [((B0,[2,3]),1), ((B0 :&lt; 1,[3]),2), ((B0 :&lt; 1 :&lt; 2,[]),3)]
</code></pre>

and now it is very easy to answer all sorts of questions that concern an element and its immediate surroundings. You mightn't construct <code>focus</code> just to solve this problem, but it's the sort of thing I keep around because it solves lots of problems.

<pre><code>[p | ((_ :&lt; p,_),q) &lt;- focus xs, q == x]
</code></pre>

computes all the values <code>p</code> which sit to the left of an <code>x</code> in <code>xs</code>. As you can see.

(By the way, this <code>focus</code> operation didn't come from nowhere. It arises from the differential structure of the datatype of lists. <a href="https://stackoverflow.com/a/12872133/828361">This answer</a> (where it is called <code>picks</code>) tells the list story in more detail, and <a href="https://stackoverflow.com/a/25572148/828361">this answer</a> develops the datatype generic story.)

blocks|key|2034895|text|这方面的标准解决方案是使用压缩：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2034896|import+Data.List+(find)

preceding+::+(a+->+Bool)+->+[a]+->+Maybe+a
preceding+f+xs+=+fmap+snd+.+find+(f+.+fst)+$+zip+(drop+1+xs)+xs|code-block|syntax|javascript|2034897|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|$]]

Sort-of standard solution for this is to use zipping:

<pre><code>import Data.List (find)

preceding :: (a -&gt; Bool) -&gt; [a] -&gt; Maybe a
preceding f xs = fmap snd . find (f . fst) $ zip (drop 1 xs) xs
</code></pre>

I want to return the preceding element of an element in list. I am intending to get the index of parameter and use it to deprecate list such that parameter is the last element, then reverse it and take the second element of reversed list.
I get error: type <code>elemIndex</code> is <code>Maybe Int</code> while <code>take</code> function require <code>Int</code>. I want to fix it or write code using simple recursion
Are there a shorter code using recursion?

<pre><code>precedingElement :: Eq a =&gt; a -&gt; [a] -&gt; Maybe a
precedingElement elt lst | lst == [] = error "List is empty"
 | elt `notElem` lst = Nothing
 | otherwise = Just x where x = snd (reverse (take (elt `elemIndex` lst) lst))
</code></pre>

Find the preceding element of an element in list (Haskell)

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想返回列表中元素的前一个元素。我打算得到参数的索引，并使用它来表示反对列表，这样参数是最后一个元素，然后反转它，然后取反列表的第二个元素。我得到了错误:输入elemIndex是Maybe Int，而take函数需要Int。我想要修复它或者用简单的递归编写代码，是否有更短的使用递归的代码？precedingElemen...

问查找列表中元素的前面元素(Haskell)
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问查找列表中元素的前面元素(Haskell)EN