标签: quantifiers

当我定义

data Foo a = Foo [a]\n

那么类型就是种类Foo :: * -> *。

启用PolyKinds后，RankNTypes我想使用更通用的种类签名来明确量化它 Foo :: forall k . k -> k。

然而我的尝试都没有成功：

--    Malformed head of type or class declaration: (Foo :: forall k.\n--                                                         k -> k) a\n32 | data (Foo :: forall k . k -> k) a = Foo [a]\n

-- error: parse error on input \xe2\x80\x98::\xe2\x80\x99\n32 | data Foo a = Foo [a] …

从GLib参考手册的"正则表达式语法"部分,"原子分组和所有格量词"小节:

\d+foo在应用于字符串时考虑模式123456bar:在匹配所有6位数然后未匹配"foo"之后,匹配器的正常操作是再次尝试仅匹配\ d +项目的5位数,然后使用4,等等在最终失败之前.

如果我们使用(?>\d+)foo(称为原子分组)前一个例子,匹配器会在第一次未能匹配"foo"时立即放弃.

当原子组的子模式只是一个重复项时,如上例所示,可以使用更简单的表示法,称为"占有量词": \d++foo

我的问题是:有没有理由为什么star(*)重复运算符没有等价物？

Java中的示例:

final String in = "123456";
// "plus" (+)
System.out.println(in.matches("\\d+"));     // true
System.out.println(in.matches("(?>\\d+)")); // true
System.out.println(in.matches("\\d++"));    // true
// "star" (*)
System.out.println(in.matches("\\d*"));     // true
System.out.println(in.matches("(?>\\d*)")); // true
System.out.println(in.matches("\\d**"));    // exception

异常堆栈跟踪是:

Exception in thread "main" java.util.regex.PatternSyntaxException: Dangling meta character '*' near index 3
\d**
   ^
    at java.util.regex.Pattern.error(Pattern.java:1713)
    at java.util.regex.Pattern.sequence(Pattern.java:1878)
    at java.util.regex.Pattern.expr(Pattern.java:1752)
    at java.util.regex.Pattern.compile(Pattern.java:1460)
    at java.util.regex.Pattern.<init>(Pattern.java:1133)
    at java.util.regex.Pattern.compile(Pattern.java:823)
    at java.util.regex.Pattern.matches(Pattern.java:928)
    at java.lang.String.matches(String.java:2090)

我无法记住量化,即我知道它们的意思但是有没有人有一个简单的方法来回忆哪一个代表哪个？

?   The question mark indicates there is zero or one of the preceding element.
*   The asterisk indicates there is zero or more of the preceding element.
+   The plus sign indicates there is one or more of the preceding element.

我将举例说明我正在寻找的答案.

为区分水平和垂直,取第一个字母H,字母'H'中间的线是单词表示的方向.字母'V'有两条向上的线,这就是这个单词所指的方向.

在Postgres 9.5.1中,以下命令有效:

select regexp_replace('JamesBond007','\d+','');

输出:

JamesBond

然而,星号似乎不起作用:

select regexp_replace('JamesBond007','\d*','');

它产生:

JamesBond007

当我把一些东西作为替换字符串时,会发生更奇怪的事情:

select regexp_replace('JamesBond007','\d+','008');

结果是:

JamesBond008

而

select regexp_replace('JamesBond007','\d*','008');

让我回来:

008JamesBond007

Postgres文档说*=原子的0或更多匹配的序列.那么这里发生了什么？(在Oracle中注意以上所有工作如预期的那样)

我不明白这种行为.我有这样的例子,需要抓住html评论.

var str = '.. <!--My -- comment test--> ';

var regex1 = /<!--[.]*-->/g;
var regex2 = /<!--.*-->/g;

alert(str.match(regex1));      // null
alert(str.match(regex2));      // <!--My -- comment test--> 

第二个正则表达式regex2正常,输出正是所需的.第一个节目null.我不明白其中的区别.RegExpressions <!--[.]*-->和<!--.*-->意思相同 - " <!--除了换行符之外的任何字符,从0开始到尽可能多,并以-->" 完成".但对于第二个它是有效的,而第一个没有.为什么？

UPD.我已阅读评论并有更新.

var str3 = '.. <!--Mycommenttest--> ';
var str4 = '.. <!--My comment test--> ';

var regex3 = /<!--[\w]*-->/g;
var regex4 = /<!--[\s\S]*-->/g;

alert(str.match(regex3));         // <!--Mycommentstest-->
alert(str.match(regex4));         // <!-- My comment test -->

所以可以使用有限的匹配变量来匹配任何东西.那么应该采用哪种方式正确使用RegExps？有[]没有？无法得到差异,两者都给出正确的输出.

我正在寻找一个适用于整个单词的运算符的正则表达式.例如,我希望单词hello是可选的.而不是h?e?l?l?o?,我想知道是否有可能写出类似(hello)?*的东西.

*注意这(hello)?对我的情况不起作用,因为我不希望在比赛中返回你好.

Haskell 类型变量是隐式量化的。关键字forall出现在 后::。

例如，const输入签名

const :: a -> b -> a

写为：

const :: forall a b. a -> b -> a

我的问题是：我如何有效地推断签名

const :: forall a. a -> a -> a

从这个定义来看。我尝试使用从一阶逻辑（例如普遍消除）中学到的概念，但无法从理论角度证明其合理性。

当然，这是有道理的，因为没有什么可以排除b与 相同a。

为什么我不能证明使用该推理规则是合理的？因为我不能对第二个量词使用消除，因为变量会发生冲突。我无法实例b化a.