标签: pattern-matching

在像SML,Erlang这样的语言中,我们可以定义这样的函数:

fun reverse [] = []
|   reverse x :: xs  = reverse xs @ [x];

我知道我们可以像这样在Scala中编写模拟(我知道,下面的代码中有很多缺陷):

def reverse[T](lst: List[T]): List[T] = lst match {
  case Nil     => Nil
  case x :: xs => reverse(xs) ++ List(x)
}

但我想知道,如果我们可以在Scala中编写前代码,也许可以放弃后者.

这种语法在未来是否有任何基本限制(我的意思是,真的很基础 - 例如类型推断在scala中的工作方式,或者除了解析器之外的其他东西)？

UPD
以下是它的外观片段:

type T
def reverse(Nil: List[T]) = Nil
def reverse(x :: xs: List[T]): List[T] = reverse(xs) ++ List(x)

我正在使用sed来过滤文件列表.我有一个已排序的文件夹列表,我希望获得特定文件后的所有行.为了完成这个任务,我正在使用这里描述的解决方案,它对我尝试的任何输入都很有效,但是当匹配在第一行时它不起作用.在这种情况下,sed将删除输入的所有行

这是一个例子:

(ssh) fabio@s2 : ~
[0] % ls -1 /
bin
boot
...
sys
tmp
usr
var
vmlinuz

(ssh) fabio@s2 : ~
[0] % ls -1 / | sed '1,/tmp/d'
usr
var
vmlinuz

(ssh) fabio@s2 : ~
[0] % ls -1 / | sed '1,/^bin$/d'
# sed will delete all lines from the input stream

当regexp匹配第一行时,我应该如何更改命令以考虑极限情况？

BTW sed '1,1d'正确工作并仅删除第一行.

Haskell 和 Rust（以及我不知道的其他语言）有一个他们称之为“模式匹配”的发展。下面是 Haskell 中的一个例子：

data Event = HoldKey Char | PressKey Char | Err String

someFunc = let
    someEvent <- doSomeStuff
    -- What follows is a case expression using pattern matching
    thingINeed <- case someEvent of
                      HoldKey keySym -> process keySym
                      PressKey keySym -> process keySym
                      Err err -> exit err
      in keepDoingStuff

在 Raku 中与此最接近的似乎是 多方法 multifunctions（术语在下面的答案中固定，但 multimethods 也可以工作）。

class Hold  { has $.key; }
class Press { has $.key; }
class Err   { has $.msg; }

multi …

我对F#(以及一般的函数式编程)是全新的,但我看到样本代码中到处都使用了模式匹配.我想知道模式匹配实际上是如何工作的？例如,我想它在其他语言中与for循环一样工作,并检查集合中每个项目的匹配.这可能远非正确,它在幕后实际上是如何工作的？

考虑这个课程:

class DateTime(year: Int, month: Int, day: Int)(hour: Int, minute: Int, second: Int)

该unapply方法将如何,如果我想匹配以下内容:

dt match {
  case DateTime(2012, 12, 12)(12, _, _) => // December 12th 2012, 12 o'clock
  /* ... */
}

我试过这个:

def unapply(dt: DateTime) = 
  Some((dt.year, dt.month, dt.day),(dt.hour, dt.minute, dt.second))

但这并没有真正起作用.

我是Haskell的新手,希望这个问题不傻.

我已经看到了很多例子,当我有一个列表时,我能够匹配并将列表的"组合元素"绑定到单个变量:

listSizeDesc :: [a] -> String
listSizeDesc [] = "Emtpy"
listSizeDesc (x:xs) = "Something inside"

但是,我尝试做类似的事情:

foo :: Int -> String
foo 0 = "Zero"
foo (n - 1) = "next number is " ++ show n

它不起作用.

在我看来,(n-1)和(x:xs)都描述了如何"创建"参数并将"组件"绑定到参数.List的匹配方式是为了便于递归而专门设计的吗？因为在我看来,这个匹配/参数绑定逻辑不适用于除(:)之外的其他函数.

我试图了解Scala对Case Classes的作用,使它们对类型擦除警告有所不同.

假设我们有以下简单的类结构.它基本上是Either:

abstract class BlackOrWhite[A, B]

case class Black[A,B]( val left: A ) extends BlackOrWhite[A,B]

case class White[A,B]( val right: B ) extends BlackOrWhite[A,B]

而你正试图像这样使用它:

object Main extends App {

    def echo[A,B] ( input: BlackOrWhite[A,B] ) = input match {
        case Black(left) => println( "Black: " + left )
        case White(right) => println( "White: " + right )
    }

    echo( Black[String, Int]( "String!" ) )
    echo( White[String, Int]( 1234 ) )
}

一切都编译和运行没有任何问题.但是,当我unapply自己尝试实现该方法时,编译器会发出警告.我使用了以下类结构与Main上面相同的类: …

val x = for(i <- 1 to 3) yield i
x match {
    case 1 :: rest => ... // compile error
}

构造函数无法实例化为期望的类型; found:collection.immutable.::: [B] required:scala.collection.immutable.IndexedSeq [Int]

当匹配收到IndexedSeq而不是LinearSeq时,这与MatchError的问题相同.

问题是,怎么做对了？.toList到处添加似乎不对.并创建一个自己的提取器来处理每一个Seq(如另一个问题的答案所述)如果每个人都这样做会导致一团糟......

我想问题是,为什么我不能影响序列理解的返回类型,或者:为什么不是Seq标准库的这种通用提取器部分？

我目前正在寻找一种在整数列表中查找模式的方法,但我将使用的方法适用于字符串和其他具有不同元素的列表.现在让我解释一下我在寻找什么.

我想在整数列表中找到最长的重复模式.例如,

[1, 2, 3, 4, 1, 2, 3]
# This list would give 1, 2, 3

应该丢弃重叠模式.( 不确定 )

[1, 1, 1, 1, 1]
# Should give 1, 1  Not 1, 1, 1, 1

这是什么没有帮助我.

在列表中查找模式(不理解第一个答案背后的逻辑,很少解释.第二个答案只有在解决之前知道模式时才能解决问题.)

从列表中查找整数模式(给出模式并且需要发生的次数.与我的问题不同.)

最常见的子序列问题(大多数人都解决了这个问题,但它并不接近我的.我在搜索模式时需要连续的元素.但是在这个中,单独的元素也算作子序列.)

这是我尝试过的.

def pattern(seq):
    n = len(seq)
    c = defaultdict(int) # Counts of each subsequence
    for i in xrange(n):
        for j in xrange(i + 1, min(n, n / 2 + i)): 
            # Used n / 2 because I figured …

我如何找到匹配这样的模式的键:

例如:

我有一些钥匙:

abc:parent1

abc:parent2

abc:parent1:child1

abc:parent2:child2

我怎么才能找到

abc:parent1

abc:parent2