标签: pattern-matching

这个问题是关于Scala使用列表及其性能进行模式匹配和递归的方式.

如果我有一个函数可以在列表上进行递归,并且我在一个缺点上进行匹配,例如:

def myFunction(xs) = xs match { 
  case Nil => Nil
  case x :: xs => «something» myFunction(xs)
}

在Haskell:

myFunction [] = []
myFunction (x:xs) = «something» : myFunction xs

我正在使用与我相同的语义,例如,Haskell.我不认为对Haskell实现有任何疑问,因为这只是你处理列表的方式.对于一个很长的列表(我将在一个有几千个节点的列表上运行),Haskell不会眨眼(我想,但我从未尝试过).

但是根据我对Scala的理解,匹配语句将调用unapply提取器方法来围绕缺点拆分列表,并将示例扩展为对列表不执行任何操作的函数:

def myFunction(xs) = xs match { 
  case Nil => Nil
  case x :: xs => x :: myFunction(xs)
}

在Haskell:

myFunction [] = []
myFunction (x:xs) = x : myFunction xs

它会调用apply extractor方法将它重新组合在一起.对于很长的清单,我想这会非常昂贵.

为了说明,在我的特定情况下,我想要递归一个字符列表并累积各种东西,其中输入字符串是几十千字节的任何东西.

如果我想在一个长列表中进行递归,我是否真的会为递归的每一步调用构造函数和提取器？或者有优化吗？还是更好的方法呢？在这种情况下,我需要几个累加器变量,显然我不会只是在列表上做任何事情的递归...

(请原谅我的Haskell,我两年没写过了.)

(是的,我要去尾递归.)

我正在尝试使用以下代码匹配Scala 2.8(beta 1)中的选项组:

import scala.xml._

val StatementPattern = """([\w\.]+)\s*:\s*([+-])?(\d+)""".r

def buildProperty(input: String): Node = input match {
    case StatementPattern(name, value) => <propertyWithoutSign />
    case StatementPattern(name, sign, value) => <propertyWithSign />
}

val withSign = "property.name: +10"
val withoutSign = "property.name: 10"

buildProperty(withSign)        // <propertyWithSign></propertyWithSign>
buildProperty(withoutSign)     // <propertyWithSign></propertyWithSign>

但这不起作用.匹配可选正则表达式组的正确方法是什么？

请参阅下面的代码示例 它不会编译.我原以为可能是因为它必须为测试函数中的第一个参数设置一个类型.但是,这没有任何意义,因为如果我不这么做模式匹配上它,所以它会编,我可以既把它MyObj11 5和MyObj21 5这是两种不同的类型.

那么它是什么限制所以你不能在构造函数上使用类型类约束参数进行模式匹配？或者你有什么机制可以吗？

class SomeClass a where toString :: a -> String

instance SomeClass MyType1 where toString v = "MyType1"
instance SomeClass MyType2 where toString v = "MyType2"

data MyType1 = MyObj11 Int | MyObj12 Int Int 
data MyType2 = MyObj21 Int | MyObj22 Int Int 

test :: SomeClass a => a -> String
test (MyObj11 x) = "11"
test (MyObj12 x y) = "12" -- Error here if remove 3rd line: rigid type …

我正在编写正则表达式来检查是否存在子串,其中包含至少2个彼此相邻的模式重复.我将正则表达式的结果与前一个字符串相匹配 - 如果相等,则存在这样的模式.通过示例更好地说:1010包含模式10,并且连续系列中有2次.另一方面,10210将不具有这种模式,因为那些10不相邻.

更重要的是,我需要找到最长的模式,它的长度至少为1.我已经写了表达式来检查它^.*?(.+)(\1).*?$.为了找到最长的模式,我使用了非贪婪的版本来匹配模式之前的东西,然后模式匹配到组1并且再次匹配组1匹配的相同的东西.然后匹配其余的字符串,产生相等的字符串.但是有一个问题是正则表达式在找到第一个模式后急于返回,并且没有真正考虑到我打算在最短的时间之前和之后制作那些子串(剩下最长的可能).所以从字符串01011010我得到正确的匹配,但存储在组1中的模式只是01我除了101.

因为我相信我不能让模式"更贪婪"或者在"更多非贪婪"之前和之后变废为止,我只能想出一个让正则表达式不那么渴望的想法,但我不确定这是否可行.

更多例子:

56712453289 - no pattern - no match with former string
22010110100 - pattern 101 - match with former string (regex resulted in 22010110100 with 101 in group 1)
5555555 - pattern 555 - match
1919191919 - pattern 1919 - match
191919191919 - pattern 191919 - match
2323191919191919 - pattern 191919 - match

使用当前表达式会得到什么(使用相同的字符串):

no pattern - no match
pattern 2 - match
pattern 555 - match …

我发现我真的很喜欢将GADT与Data Kinds结合起来,因为它比以前更能提供类型安全性(对于大多数用途,几乎与Coq,Agda等人一样好).遗憾的是,模式匹配在最简单的示例中失败了,我认为除了类型类之外我无法编写我的函数.

这是一个解释我的悲伤的例子:

data Nat = Z | S Nat deriving Eq

data Le :: Nat -> Nat -> * where
    Le_base :: Le a a
    Le_S :: Le a b -> Le a (S b)

class ReformOp n m where
    reform :: Le (S n) (S m) -> Le n m

instance ReformOp a a where
    reform Le_base = Le_base

instance ReformOp a b => ReformOp a (S b) where
    reform (Le_S p) = Le_S $ reform p

class …

我的问题很多.从我看到.NET 4.5,我印象非常深刻.不幸的是我的所有项目都是.NET 4.0,我不考虑迁移.所以我想简化我的代码.

目前,我的大多数代码通常需要足够的时间来冻结屏幕,我会执行以下操作:

BackgroundWorker bd = new BackgroundWorker();
bd.DoWork += (a, r) =>
    {
        r.Result = ProcessMethod(r.Argument);
    };
bd.RunWorkerCompleted += (a, r)  =>
    {
        UpdateView(r.Result);
    };

bd.RunWorkerAsync(args);

老实说,我已经厌倦了.当存在逻辑复杂的用户交互时,这成为一个大问题.

我想知道,如何简化这种逻辑？(请记住,我在.Net 4.0)我注意到谷歌的一些事情,但没有找到任何易于实施和适合我的需求.

我认为这个解决方案如下:

var foo = args as Foo;
var result = AsyncHelper.CustomInvoke<Foo>(ProcessMethod, foo);
UpdateView(result);

public static class AsyncHelper
{
    public static T CustomInvoke<T>(Func<T, T> func, T param) where T : class
    {
        T result = null;
        DispatcherFrame frame = new DispatcherFrame();
        Task.Factory.StartNew(() =>
        {
            result = func(param);
            frame.Continue = false; …

是否可以使用匹配检查字符串是空还是空？

我正在尝试做类似的事情:

def sendToYahoo(message:Email) ={
  val clientConfiguration = new ClientService().getClientConfiguration()
  val messageId : Seq[Char] = message.identifier
  messageId match {
    case messageId.isEmpty => validate()
    case !messageId.isEmpty => //blabla
  }
}

但我有一个编译错误.

预先感谢.

我可以使用与无形副产品匹配的模式吗？

import shapeless.{CNil, :+:}

type ListOrString = List[Int] :+: String :+: CNil

def f(a: ListOrString): Int = a match {
  case 0 :: second :: Nil => second
  case first :: Nil => first
  case Nil => -1
  case string: String => string.toInt
}

这当然不起作用,因为a盒装为Coproduct.

有没有其他方法可以使用副产品并保持模式匹配的能力？

谷歌工作表模式匹配的文档没有帮助.我一直在阅读和搜索一段时间,但找不到这个特殊问题.也许我很难找到正确的搜索条件,但问题是:

我有几个遵循这种格式的数字(部件号):## - ####

类别可以通过部件号定义,即:50-03 ##将是一个产品类别,其余2个数字是特定于模型的.

我一直试图运行这个:

=countif(E9:E13,"50-03[123][012]*")

(E9:e13包含格式化为文本的部件号.如果我以任何其他方式格式化,则值会显示,因为谷歌表认为我正在写日期或尝试算术.)

每次返回0,除非我改为:

=countif(E9:E13,"50-03*")

所以它看起来像通配符,但模式匹配不行？

我正在学习正则表达式.我不知道如何组合不同的正则表达式来制作单一的通用正则表达式.

我想为多个案例编写一个正则表达式.我知道这可以通过使用或 "|"运算符以天真的方式完成.

我不喜欢这种方法.任何人都可以告诉我更好的方法吗？