I know it&#39;s possible to match a word and then reverse the matches using other tools (e.g. `grep -v`). However, is it possible to match lines that do not contain a specific word, e.g. `hede`, using a regular expression? 

### Input:

    hoho
    hihi
    haha
    hede

### Code:

    grep &quot;&lt;Regex for &#39;doesn&#39;t contain hede&#39;&gt;&quot; input

### Desired output: 

    hoho
    hihi
    haha

Regular expression to match a line that doesn&#39;t contain a word

I have used the [**SIFT**][1] implementation of [**Andrea Vedaldi**][2], to calculate the sift descriptors of two similar images (the second image is actually a zoomed in picture of the same object from a different angle).

Now I am not able to figure out **how to compare the descriptors to tell how similar the images are**?

I know that this question is not answerable unless you have actually played with these sort of things before, but I thought that **somebody who has done this before might know this**, so I posted the question.

the little I did to generate the descriptors:

    &gt;&gt; i=imread(&#39;p1.jpg&#39;);
    &gt;&gt; j=imread(&#39;p2.jpg&#39;);
    &gt;&gt; i=rgb2gray(i);
    &gt;&gt; j=rgb2gray(j);
    &gt;&gt; [a, b]=sift(i);  % a has the frames and b has the descriptors
    &gt;&gt; [c, d]=sift(j);

  [1]: http://en.wikipedia.org/wiki/Scale-invariant_feature_transform
  [2]: http://www.vlfeat.org/overview/sift.html

How to use SIFT algorithm to compute how similar two images are?

**Update:** This question is a near duplicate of [this](https://stackoverflow.com/questions/432493/how-do-you-access-the-matched-groups-in-a-javascript-regex)

I&#39;m sure the answer to my question is out there, but I couldn&#39;t find the words to express it succinctly. I am trying to do the following with JavaScript regex:

    var input = &quot;&#39;Warehouse&#39;,&#39;Local Release&#39;,&#39;Local Release DA&#39;&quot;;
    var regex = /&#39;(.*?)&#39;/g;
    
    console.log(input.match(regex));
    
    // Actual:
    // [&quot;&#39;Warehouse&#39;&quot;, &quot;&#39;Local Release&#39;&quot;, &quot;&#39;Local Release DA&#39;&quot;]
    
    // What I&#39;m looking for (without the &#39;):
    // [&quot;Warehouse&quot;, &quot;Local Release&quot;, &quot;Local Release DA&quot;]

Is there a clean way to do this with JavaScript regex? Obviously I could strip out the `&#39;`s myself, but I&#39;m looking for the correct way to caputre globally matched groupings with regex.

JavaScript Regex Global Match Groups

I&#39;m currently working on a small project with OCaml; a simple mathematical expression simplifier. I&#39;m supposed to find certain patterns inside an expression, and simplify them so the number of parenthesis inside the expression decreases. So far I&#39;ve been able to implement most rules except two, for which I&#39;ve decided to create a recursive, pattern-matching &quot;filter&quot; function. The two rules I need to implement are:

-Turn all expressions of the form a - (b + c) or similar into a - b - c

-Turn all expressions of the form a / (b * c) or similar into a / b / c

...which I suspect would be fairly simple, and once I&#39;ve managed to implement one, I can implement the other easily. However, I&#39;m having trouble with the recursive pattern-matching function. My type expression is this:

    type expr =
     | Var of string			(* variable *)
     | Sum of expr * expr		(* sum  *)
     | Diff of expr * expr		(* difference *)
     | Prod of expr * expr		(* product *)
     | Quot of expr * expr		(* quotient *)
    ;;

And what I&#39;m mainly having trouble on, is in the match expression. For example, I&#39;m trying something like this:

    let rec filter exp =   
	    match exp with       
	    | Var v -&gt; Var v                      	
	    | Sum(e1, e2) -&gt; Sum(e1, e2) 		  
	    | Prod(e1, e2) -&gt; Prod(e1, e2)
	    | Diff(e1, e2) -&gt;
		    match e2 with
		    | Sum(e3, e4) -&gt; filter (diffRule e2)
		    | Diff(e3, e4) -&gt; filter (diffRule e2)      
		    | _ -&gt; filter e2         
	    | Quot(e1, e2) -&gt;                                 ***this line***
		    match e2 with  
		    | Quot(e3, e4) -&gt; filter (quotRule e2)        
		    | Prod(e3, e4) -&gt; filter (quotRule e2)        
		    | _ -&gt; filter e2
    ;;

However, it seems that the match expression on the marked line is being recognized as being part of the previous &quot;inner match&quot; instead of the &quot;principal match&quot;, so all &quot;Quot(...)&quot; expressions are never recognized. Is it even possible to have match expressions inside other match expressions like this? And what would be the correct way to end the inner match so I can continue matching the other possibilities?

Ignore the logic, since it&#39;s pretty much what I came up with first, it&#39;s just that I haven&#39;t been able to try it since I have to deal with this &quot;match&quot; error first, although any recommendation on how to handle the recursiveness or the logic would be welcome.


OCaml: Match expression inside another one?

Is it possible to match a range of values in Scala?

For example:

    val t = 5
    val m = t match {
        0 until 10 =&gt; true
        _ =&gt; false
    }

`m` would be `true` if `t` was between 0 and 10, but false otherwise. This little bit doesn&#39;t work of course, but is there any way to achieve something like it?
        

Can a range be matched in Scala?

How can I count the number of `&quot;_&quot;` in a string like `&quot;bla_bla_blabla_bla&quot;`?

Count character occurrences in a string in C++

I have the following piece of code from [this question](https://stackoverflow.com/questions/2199040/scala-xml-building-adding-children-to-existing-nodes):

    def addChild(n: Node, newChild: Node) = n match {
      case Elem(prefix, label, attribs, scope, child @ _*) =&gt; Elem(prefix, label, attribs, scope, child ++ newChild : _*)
      case _ =&gt; error(&quot;Can only add children to elements!&quot;)
    }

Everything in it is pretty clear, except this piece: `child ++ newChild : _*`


What does it do? 

I understand there is `Seq[Node]` concatenated with another `Node`, and then? What does `: _*` do?



What does `:_*` (colon underscore star) do in Scala?

Is it possible to match on a comparison using the pattern matching system in Scala?
For example:

    a match {
        case 10 =&gt; println(&quot;ten&quot;)
        case _ &gt; 10 =&gt; println(&quot;greater than ten&quot;)
        case _ =&gt; println(&quot;less than ten&quot;)
    }

The second case statement is illegal, but I would like to be able to specify &quot;when a is greater than&quot;.

Using comparison operators in Scala&#39;s pattern matching system

I&#39;m looking for a fuzzy search JavaScript library to filter an array. I&#39;ve tried using [fuzzyset.js](http://glench.github.io/fuzzyset.js/) and [fuse.js](https://fusejs.io/), but the results are terrible (there are demos you can try on the linked pages).

After doing some reading on Levenshtein distance, it strikes me as a poor approximation of what users are looking for when they type. For those who don&#39;t know, the system calculates how many **insertions**, **deletions**, and **substitutions** are needed to make two strings match.

One obvious flaw, which is fixed in the Levenshtein-Demerau model, is that both *blub* and *boob* are considered equally similar to *bulb* (each requiring two substitutions). It is clear, however, that *bulb* is more similar to *blub* than *boob* is, and the model I just mentioned recognizes that by allowing for **transpositions**.

I want to use this in the context of text completion, so if I have an array `[&#39;international&#39;, &#39;splint&#39;, &#39;tinder&#39;]`, and my query is *int*, I think *international* ought to rank more highly than *splint*, even though the former has a score (higher=worse) of 10 versus the latter&#39;s 3.

So what I&#39;m looking for (and will create if it doesn&#39;t exist), is a library that does the following:

- Weights the different text manipulations
- Weights each manipulation differently depending on where they appear in a word (early manipulations being more costly than late manipulations)
- Returns a list of results sorted by relevance

Has anyone come across anything like this? I realize that StackOverflow isn&#39;t the place to be asking for software recommendations, but implicit (not anymore!) in the above is: am I thinking about this the right way?

-------------
Edit
----
I found a [good paper (pdf)](https://web.archive.org/web/20160804043501/https://www.cs.cmu.edu/~pradeepr/papers/ijcai03.pdf) on the subject. Some notes and excerpts: 

&gt;Affine edit-distance functions assign a relatively lower cost to a sequence of insertions or deletions

&gt;the Monger-Elkan distance function (Monge &amp; Elkan 1996), which is an affine variant of the Smith-Waterman distance function (Durban et al. 1998) with particular cost parameters

For the [Smith-Waterman distance (wikipedia)](http://en.wikipedia.org/wiki/Smith%E2%80%93Waterman_algorithm), &quot;Instead of looking at the total sequence, the Smith–Waterman algorithm compares segments of all possible lengths and optimizes the similarity measure.&quot; It&#39;s the n-gram approach.

&gt; A broadly similar metric, which is not based on an edit-distance model, is the
Jaro metric (Jaro 1995; 1989; Winkler
1999). In the record-linkage literature, good results have been obtained using variants of this method, which is based on the number and order of the common characters between two strings.

&gt;A variant of this due to Winkler (1999) also uses the length P of the longest common prefix

&gt;(seem to be intended primarily for short strings)

For text completion purposes, the Monger-Elkan and Jaro-Winkler approaches seem to make the most sense. Winkler&#39;s addition to the Jaro metric effectively weights the beginnings of words more heavily. And the affine aspect of Monger-Elkan means that the necessity to complete a word (which is simply a sequence of additions) won&#39;t disfavor it too heavily. 

Conclusion:
&gt;the TFIDF
ranking performed best among several token-based distance
metrics, and a tuned affine-gap edit-distance metric proposed by Monge and Elkan performed best among several
string edit-distance metrics. A surprisingly good distance
metric is a fast heuristic scheme, proposed by Jaro and later extended by Winkler.
This works almost as well as the Monge-Elkan scheme, but
is an order of magnitude faster.
One simple way of combining the TFIDF method and the
Jaro-Winkler is to replace the exact token matches used in
TFIDF with approximate token matches based on the Jaro-
Winkler scheme. This combination performs slightly better than either Jaro-Winkler or TFIDF on average, and occasionally performs much better. It is also close in performance to a learned combination of several of the best metrics
considered in this paper.

Javascript fuzzy search that makes sense

I&#39;m reading about functional programming and I&#39;ve noticed that *Pattern Matching* is mentioned in many articles as one of the core features of functional languages.

Can someone explain for a Java/C++/JavaScript developer what does it mean?


What is &#39;Pattern Matching&#39; in functional languages?

Using `awk` or `sed` how can I select lines which are occurring between two different marker patterns? There may be multiple sections marked with these patterns.

For example: 
Suppose the file contains: 

    abc
    def1
    ghi1
    jkl1
    mno
    abc
    def2
    ghi2
    jkl2
    mno
    pqr
    stu

And the starting pattern is `abc` and ending pattern is `mno`
So, I need the output as: 

    def1
    ghi1
    jkl1
    def2
    ghi2
    jkl2

I am using sed to match the pattern once: 

    sed -e &#39;1,/abc/d&#39; -e &#39;/mno/,$d&#39; &lt;FILE&gt;

Is there any way in `sed` or `awk`  to do it repeatedly until the end of file? 

How to select lines between two marker patterns which may occur multiple times with awk/sed

I have been seeing quite a large variation in response times regarding `LIKE` queries to a particular table in my database. Sometimes I will get results within 200-400 ms (very acceptable) but other times it might take as much as 30 seconds to return results.

I understand that `LIKE` queries are very resource intensive but I just don&#39;t understand why there would be such a large difference in response times. I have built a btree index on the `owner1` field but I don&#39;t think it helps with `LIKE` queries. Anyone have any ideas?

Sample SQL:

    SELECT gid, owner1 FORM parcels
    WHERE owner1 ILIKE &#39;%someones name%&#39; LIMIT 10

I&#39;ve also tried:

    SELECT gid, owner1 FROM parcels
    WHERE lower(owner1) LIKE lower(&#39;%someones name%&#39;) LIMIT 10

And:

    SELECT gid, owner1 FROM parcels
    WHERE lower(owner1) LIKE lower(&#39;someones name%&#39;) LIMIT 10

With similar results.  
Table Row Count: about 95,000.

PostgreSQL LIKE query performance variations

What are the rules for **Ant path style patterns**.

The Ant site itself is surprisingly uninformative.

Ant path style patterns

I&#39;m currently trying to rexp a string into multiple variables. Example string:&lt;br&gt;

    ryan_string = &quot;RyanOnRails: This is a test&quot;

I&#39;ve matched it with this regexp, with 3 groups:&lt;br&gt;

    ryan_group = ryan_string.scan(/(^.*)(:)(.*)/i)

Now to access each group I have to do something like this:&lt;br&gt;

    ryan_group[0][0] (first group) RyanOnRails
    ryan_group[0][1] (second group) :
    ryan_group[0][2] (third group) This is a test

This seems pretty ridiculous and it feels like I&#39;m doing something wrong. I would be expect to be able to do something like this:

    g1, g2, g3 = ryan_string.scan(/(^.*)(:)(.*)/i)

Is this possible? Or is there a better way than how I&#39;m doing it?

Ruby Regexp group matching, assign variables on 1 line

How is pattern matching in Scala implemented at the bytecode level?

Is it like a series of `if (x instanceof Foo)` constructs, or something else? What are its performance implications?

For example, given the following code (from [Scala By Example][1] pages 46-48), how would the equivalent Java code for the `eval` method look like?

    abstract class Expr
    case class Number(n: Int) extends Expr
    case class Sum(e1: Expr, e2: Expr) extends Expr

    def eval(e: Expr): Int = e match {
      case Number(x) =&gt; x
      case Sum(l, r) =&gt; eval(l) + eval(r)
    }

P.S. I can read Java bytecode, so a bytecode representation would be good enough for me, but probably it would be better for the other readers to know how it would look like as Java code.

P.P.S. Does the book [Programming in Scala][2] give an answer to this and similar questions about how Scala is implemented? I have ordered the book, but it has not yet arrived.

  [1]: http://www.scala-lang.org/docu/files/ScalaByExample.pdf
  [2]: http://www.amazon.com/Programming-Scala-Comprehensive-Step-step/dp/0981531601


How is pattern matching in Scala implemented at the bytecode level?

In Microsoft SQL Server, it&#39;s possible to specify an &quot;accent insensitive&quot; collation (for a database, table or column), which means that it&#39;s possible for a query like

    SELECT * FROM users WHERE name LIKE &#39;Jo&#227;o&#39;

to find a row with a `Joao` name.

I know that it&#39;s possible to strip accents from strings in PostgreSQL using the [unaccent_string][1] contrib function, but I&#39;m wondering if PostgreSQL supports these &quot;accent insensitive&quot; collations so the `SELECT` above would work.


  [1]: http://wiki.postgresql.org/wiki/Strip_accents_from_strings,_and_output_in_lowercase

Does PostgreSQL support &quot;accent insensitive&quot; collations?

Take the following function:


    def fMatch(s: String) = {
        s match {
            case &quot;a&quot; =&gt; println(&quot;It was a&quot;)
            case _ =&gt; println(&quot;It was something else&quot;)
        }
    }

This pattern matches nicely:

    scala&gt; fMatch(&quot;a&quot;)
    It was a

    scala&gt; fMatch(&quot;b&quot;)
    It was something else

What I would like to be able to do is the following:

    def mMatch(s: String) = {
        val target: String = &quot;a&quot;
        s match {
            case target =&gt; println(&quot;It was&quot; + target)
            case _ =&gt; println(&quot;It was something else&quot;)
            }
    }

This gives off the following error: 

    fMatch: (s: String)Unit
    &lt;console&gt;:12: error: unreachable code
                   case _ =&gt; println(&quot;It was something else&quot;)

I guess this is because it thinks that target is actually a name you&#39;d like to assign to whatever the input is. Two questions:

1. Why this behaviour? Can&#39;t case just look for existing variables in scope that have appropriate type and use those first and, if none are found, then treat target as a name to patternmatch over?

2. Is there a workaround for this? Any way to pattern match against variables? Ultimately one could use a big if statement, but match case is more elegant.

Why does pattern matching in Scala not work with variables?

I&#39;m doing matching against some case classes and would like to handle two of the cases in the same way. Something like this:

    abstract class Foo
    case class A extends Foo
    case class B(s:String) extends Foo
    case class C(s:String) extends Foo


    def matcher(l: Foo): String = {
      l match {
        case A() =&gt; &quot;A&quot;
        case B(sb) | C(sc) =&gt; &quot;B&quot;
        case _ =&gt; &quot;default&quot;
      }
    }

But when I do this I get the error:

    (fragment of test.scala):10: error: illegal variable in pattern alternative
        case B(sb) | C(sc) =&gt; &quot;B&quot;

I can get it working of I remove the parameters from the definition of B and C but how can I match with the params?

Match multiple cases classes in scala

I&#39;m not sure what&#39;s causing this issue, but in a project, I&#39;m building, the compiler is taking hours just to compile a module. The total size of my codebase is 352KB, but none of the modules are over 10KB large. I am using a Native port, but it&#39;s very trivial; I&#39;m just fetching `Date.now()` with it.

Is there anything well-known that would cause the elm compiler to take forever to compile? I don&#39;t have many dependencies, but I&#39;m using Html a lot. I would really appreciate any hints as to what would cause this.

# Edit

So it turns out __large case expressions__ will cause the optimizer to take a long time, as of 0.16. Here&#39;s the [discussion on Elm-Discuss](https://groups.google.com/forum/#!topic/elm-discuss/2ySK77lKYss) bringing up the issue, and a [gist of the nasty case match](https://gist.github.com/athanclark/0e29485cb245ff07a97730cfef365d10).

I guess to be verbose and to keep a carrot out there, why would elm&#39;s compiler take this route for case-matching? What&#39;s the underlying machinery going on here? Why would the compiler take longer than an hour for optimizing 60+ pattern matches on a case statement?

Elm Compiler running forever, computer just getting hot

In C# 7, we can use

    if (x is null) return;

instead of

    if (x == null) return;

Are there any advantages to using the new way (former example) over the old way?

Are the semantics any different?

Is it just a matter of taste? If not, when should I use one over the other?

Reference: [What’s New in C# 7.0][1].


[1]: https://devblogs.microsoft.com/dotnet/whats-new-in-csharp-7-0/

What is the difference between &quot;x is null&quot; and &quot;x == null&quot;?

I&#39;m wondering how can I use multiple type pattern matching. I have:

    abstract class MyAbstract
    
    case class MyFirst extends MyAbstract
    case class MySecond extends MyAbstract
    case class MyThird extends MyAbstract // shouldn&#39;t be matched and shouldn&#39;t call doSomething()
    
    val x: MyAbstract = MyFirst
    
    x match { 
     case a: MyFirst =&gt; doSomething()
     case b: MySecond =&gt; doSomething()
     case _ =&gt; doSomethingElse()
    }

 So I&#39;d like to write something like:

    x match {
     case a @ (MyFirst | MySecond) =&gt; doSomething()
     case _ =&gt; doSomethingElse()
    }

I saw similar construction in some tutorial, but it gives me error:

    pattern type is incompatible with expected type;
    [error]  found   : object MyFirst
    [error]  required: MyAbstract

So is there a way to define few different types in on case clause? I think it would make code prettier. As if I will have 5 of them, I will write same code 5 times (calling doSomething()).

Thanks in advance!

Scala multiple type pattern matching

Let&#39;s say I want to handle multiple return values from a remote service using the same code. I don&#39;t know how to express this in Scala:

    code match {
      case &quot;1&quot; =&gt; // Whatever
      case &quot;2&quot; =&gt; // Same whatever
      case &quot;3&quot; =&gt; // Ah, something different
    }

I know I can use Extract Method and call that, but there&#39;s still repetition in the call. If I were using Ruby, I&#39;d write it like this:

    case code
    when &quot;1&quot;, &quot;2&quot;
      # Whatever
    when &quot;3&quot;
      # Ah, something different
    end

Note that I simplified the example, thus I don&#39;t want to pattern match on regular expressions or some such. The match values are actually complex values.

How to pattern match multiple values in Scala?

I am using a case insensitive search in Mongo, something similar to https://stackoverflow.com/q/5500823/1028488.

ie I am using a regex with options i. But I am having trouble restricting the regex to just that word, it performs more like a &#39;Like&#39; in SQL 

eg: if I use query like
`{&quot;SearchWord&quot; : { &#39;$regex&#39; : &#39;win&#39;, $options: &#39;-i&#39; }}`, it shows me results for win, window &amp; winter. How do i restrict it to jsut show win?

I tried `/^win$/` but it&#39;s saying invalid JSON... Please suggest away.

Thanks in advance

Case insensitive search in Mongo

So here&#39;s the situation.  I want to define a case class like so:

    case class A(val s: String)

and I want to define an object to ensure that when I create instances of the class, the value for &#39;s&#39; is always uppercase, like so:

    object A {
      def apply(s: String) = new A(s.toUpperCase)
    }

However, this doesn&#39;t work since Scala is complaining that the apply(s: String) method is defined twice.  I understand that the case class syntax will automatically define it for me, but isn&#39;t there another way I can achieve this?  I&#39;d like to stick with the case class since I want to use it for pattern matching.



How to override apply in a case class companion

Anyone know a good and effective way to search/match for a byte pattern in an byte[] array and then return the positions.

For example

    byte[] pattern = new byte[] {12,3,5,76,8,0,6,125};

    byte[] toBeSearched = new byte[] {23,36,43,76,125,56,34,234,12,3,5,76,8,0,6,125,234,56,211,122,22,4,7,89,76,64,12,3,5,76,8,0,6,125}


byte[] array pattern search

I want to merge multiple spaces into single space(space could be tab also) and remove trailing/leading spaces.

For example...

    string &lt;- &quot;Hi        buddy        what&#39;s up    Bro&quot; 

to

    &quot;Hi buddy what&#39;s up bro&quot;

I checked the solution given at https://stackoverflow.com/questions/1981349/regex-to-replace-multiple-spaces-with-a-single-space. Note that don&#39;t put \t or \n as exact space inside the toy string and feed that as pattern in `gsub`. I want that in R.

Note that I am unable to put multiple space in toy string.
Thanks 

Merge Multiple spaces to single space; remove trailing/leading spaces

I have a file like the following and I would like to print the lines between two given patterns `PAT1` and `PAT2`.

```lang-none
1
2
PAT1
3    - first block
4
PAT2
5
6
PAT1
7    - second block
PAT2
8
9
PAT1
10    - third block
```

I have read [How to select lines between two marker patterns which may occur multiple times with awk/sed][1] but I am curious to see all the possible combinations of this, either including or excluding the pattern.

How can I print all lines between two patterns?


  [1]: https://stackoverflow.com/q/17988756/1983854

How to print lines between two patterns, inclusive or exclusive (in sed, AWK or Perl)?

Given this `Person` case class:

    scala&gt; case class Person(name: String, age: Int) {}
    defined class Person

... and this instance

    scala&gt; val b = Person(&quot;Kevin&quot;, 100)
    b: Person = Person(Kevin,100)

Is there a reason to prefer this code (with `@`)

    scala&gt; b match {
         |    case p @ Person(_, age) =&gt; println(&quot;age&quot;)
         |    case _ =&gt; println(&quot;none&quot;)
         | }
    age

... over the following?

    scala&gt; b match {
         |    case Person(_, age) =&gt; println(&quot;age&quot;)
         |    case _ =&gt; println(&quot;none&quot;)
         | }
    age

Perhaps I&#39;m missing the meaning/power of `@`?

Pattern Matching `@` Symbol

How to catch multiple exceptions at once in Scala? Is there a better way than in C#: https://stackoverflow.com/questions/136035/catch-multiple-exceptions-at-once

Catching multiple exceptions at once in Scala

    val a: Array[Int] = Array(1,2,4,5)
    val b: Array[Int] = Array(1,2,4,5)
    a==b // false

Is there a pattern-matching way to see if two arrays (or sequences) are equivalent?

How do I compare two arrays in scala?

I have been trying to explain the difference between switch statements and pattern matching(F#) to a couple of people but I haven&#39;t really been able to explain it well..most of the time they just look at me and say &quot;so why don&#39;t you just use if..then..else&quot;.

How would you explain it to them? 

EDIT! Thanks everyone for the great answers, I really wish I could mark multiple right answers. 

Explaining pattern matching vs switch

Is there a way to generate a number sequence in vi or Vim? 

For example, for an arbitrary range of lines *i* &#160;through&#160;*j* (where *i*&#160;&lt;&#160;*j*) in a file opened in Vim, is there a way to generate a number sequence from&#160;number 1 on line&#160;*i* all the way through number (*j*&#160;−&#160;*i*&#160;+&#160;1) on line&#160;*j*?

Say, I have the following lines in a file:

    this is line #1
    this is line #2
    this is line #3
    this is line #4
    this is line #5
    this is line #6
    this is line #7
    this is line #8
    this is line #9
    this is line #10

I want to prefix the number sequence from line&#160;4 to line&#160;8 with numbers&#160;1 through&#160;5. After the operation, the resulting file should be as follows:

    this is line #1
    this is line #2
    this is line #3
    1 this is line #4
    2 this is line #5
    3 this is line #6
    4 this is line #7
    5 this is line #8
    this is line #9
    this is line #10

If this is possible, is there a way to use different step sizes for the generated sequence? For example, can 2 be used for the step size instead, so that the resulting sequence is 2, 4, 6, 8, etc.?

**Note:** The question “[How to add line numbers to range of lines in Vim?](https://stackoverflow.com/questions/252766/add-line-numbers-in-vim)” brings up a similar problem, but it is not the same.


How to generate a number sequence in file using vi or Vim?

How does the performance of the following two query components compare?

**LOWER LIKE**

    ... LOWER(description) LIKE &#39;%abcde%&#39; ...

**iLIKE**

    ... description iLIKE &#39;%abcde%&#39; ...


LOWER LIKE vs iLIKE

I&#39;m a new user to gulp.js.  I&#39;d like to move all of my non-javascript files to a build directory.  What I&#39;ve got right now is this:

    //Test copy
    gulp.task(&#39;test-copy&#39;, function() {
    	gulp.src([&#39;myProject/src/**/*.!(js|map|src)&#39;])
    		.pipe(gulp.dest(&#39;myProject/build&#39;));
    });


    //Results for various files
    myProject/css/style.css //Copied - GOOD
    myProject/html/index.html //Copied - GOOD
    myProject/js/foo.js //Not Copied - GOOD
    myProject/js/bar.min.js //Copied - BAD!
    myProject/js/jquery-2.0.3.min.js //Copied - BAD!
    myProject/js/jquery-2.0.3.min.map //Copied - BAD!

As you can see, it only matches after the first dot in the file path string, not the last one, as I&#39;d like.  How can I modify the glob search string to behave as I&#39;d like?

Glob matching, exclude all JS files

Say I want to copy the contents of a directory excluding files and folders whose names contain the word &#39;Music&#39;.

    cp [exclude-matches] *Music* /target_directory

What should go in place of [exclude-matches] to accomplish this?

How can I use inverse or negative wildcards when pattern matching in a unix/linux shell?

I&#39;m looking for a way to test whether or not a given string repeats itself for the entire string or not.

Examples:

    [
        &#39;0045662100456621004566210045662100456621&#39;,             # &#39;00456621&#39;
        &#39;0072992700729927007299270072992700729927&#39;,             # &#39;00729927&#39;
        &#39;001443001443001443001443001443001443001443&#39;,           # &#39;001443&#39;
        &#39;037037037037037037037037037037037037037037037&#39;,        # &#39;037&#39;
        &#39;047619047619047619047619047619047619047619&#39;,           # &#39;047619&#39;
        &#39;002457002457002457002457002457002457002457&#39;,           # &#39;002457&#39;
        &#39;001221001221001221001221001221001221001221&#39;,           # &#39;001221&#39;
        &#39;001230012300123001230012300123001230012300123&#39;,        # &#39;00123&#39;
        &#39;0013947001394700139470013947001394700139470013947&#39;,    # &#39;0013947&#39;
        &#39;001001001001001001001001001001001001001001001001001&#39;,  # &#39;001&#39;
        &#39;001406469760900140646976090014064697609&#39;,              # &#39;0014064697609&#39;
    ]

are strings which repeat themselves, and

    [
        &#39;004608294930875576036866359447&#39;,
        &#39;00469483568075117370892018779342723&#39;,
        &#39;004739336492890995260663507109&#39;,
        &#39;001508295625942684766214177978883861236802413273&#39;,
        &#39;007518796992481203&#39;,
        &#39;0071942446043165467625899280575539568345323741&#39;,
        &#39;0434782608695652173913&#39;,
        &#39;0344827586206896551724137931&#39;,
        &#39;002481389578163771712158808933&#39;,
        &#39;002932551319648093841642228739&#39;,
        &#39;0035587188612099644128113879&#39;,
        &#39;003484320557491289198606271777&#39;,
        &#39;00115074798619102416570771&#39;,
    ]

are examples of ones that do not.

The repeating sections of the strings I&#39;m given can be quite long, and the strings themselves can be 500 or more characters, so looping through each character trying to build a pattern then checking the pattern vs the rest of the string seems awful slow. Multiply that by potentially hundreds of strings and I can&#39;t see any intuitive solution.

I&#39;ve looked into regexes a bit and they seem good for when you know what you&#39;re looking for, or at least the length of the pattern you&#39;re looking for. Unfortunately, I know neither.

How can I tell if a string is repeating itself and if it is, what the shortest repeating subsequence is?


How can I tell if a string repeats itself in Python?

The draft spec for [Pattern Matching in C#](https://onedrive.live.com/redir?resid=4558A04E77D0CF5%215396) contains the following code example:

    Type? v = x?.y?.z; 
    if (v.HasValue) {
        var value = v.GetValueOrDefault();     
        // code using value 
    } 

I understand that `Type?` indicates that `Type` is nullable, but assuming `x`, `y`, and `z` are locals, what does `x?.y?.z` mean?

What does x?.y?.z mean?

I&#39;m trying to understand `Pattern.quote` using the following code:

    String pattern = Pattern.quote(&quot;1252343% 8 567 hdfg gf^$545&quot;);
    System.out.println(&quot;Pattern is : &quot;+pattern);

produces the output: 

    Pattern is : \Q1252343% 8 567 hdfg gf^$545\E

What are `\Q` and `\E` here? The documentation description says :

&gt; Returns a literal pattern &lt;code&gt;String&lt;/code&gt; for the specified &lt;code&gt;String&lt;/code&gt;.
&gt;
&gt;This method produces a &lt;code&gt;String&lt;/code&gt; that can be used to create a &lt;code&gt;Pattern&lt;/code&gt; that would match the string &lt;code&gt;s&lt;/code&gt; as if it were a literal pattern.
&gt;
&gt;Metacharacters or escape sequences in the input sequence will be given no special meaning.

But `Pattern.quote`&#39;s return type is `String` and not a compiled `Pattern` object. 

Why is this method required and what are some usage examples?

What is the use of Pattern.quote method?

I am trying to match the beginning of strings in f#.  Not sure if I have to treat them as a list of characters or what.  Any suggestions would be appreciated.

Here is a psuedo code version of what I am trying to do

    let text = &quot;The brown fox..&quot;
    
    match text with
    | &quot;The&quot;::_ -&gt; true
    | &quot;If&quot;::_ -&gt; true
    | _ -&gt; false

So, I want to look at the beginning of the string and match.  Note I am not matching on a list of strings just wrote the above as an idea of the essence of what I am trying to do.


Pattern matching on the beginning of a string in f#

I have a string. The end is different, such as `index.php?test=1&amp;list=UL` or `index.php?list=UL&amp;more=1`. The one thing I&#39;m looking for is `&amp;list=`.

How can I match it, whether it&#39;s in the middle of the string or it&#39;s at the end? So far I&#39;ve got `[&amp;|\?]list=.*?([&amp;|$])`, but the `([&amp;|$])` part doesn&#39;t actually work; I&#39;m trying to use that to match either `&amp;` or the end of the string, but the end of the string part doesn&#39;t work, so this pattern matches the second example but not the first.

In regex, match either the end of the string or a specific character

I want to apply `filter` on an iterator and I came up with this one and it works, but it&#39;s super verbose:

    .filter(|ref my_struct| match my_struct.my_enum { Unknown =&gt; false, _ =&gt; true })
    
I would rather write something like this:

    .filter(|ref my_struct| my_struct.my_enum != Unknown)

This gives me a compile error

&lt;!-- language: none --&gt;

    binary operation `!=` cannot be applied to type `MyEnum`

Is there an alternative to the verbose pattern matching? I looked for a macro but couldn&#39;t find a suitable one.

How to compare enum without pattern matching

Using SQL Server 2008.  I have a table with the following column:

    sampleData (nvarchar(max))

The value for this column in some of these rows are lists formatted as follows:

    [&quot;value1&quot;,&quot;value2&quot;,&quot;value3&quot;]

I&#39;m trying to write a simple query that will return all rows with lists formatted like this, by just detecting the opening bracket.

    SELECT * from sampleTable where sampleData like &#39;[%&#39;

The above query doesn&#39;t work because &#39;[&#39; is a special character, and I can&#39;t for the life of me figure out how to escape the bracket so my query does what I want.

Thanks for any suggestions!

SQL Server LIKE containing bracket characters

Or from the other way around find first non digit character.

Do the same functions apply for string and for char* ?

how to check if given c++ string or char* contains only digits?

If I have a string like:

    This.is.a.great.place.too.work.

or:

    This/is/a/great/place/too/work/

than my program should give me that the sentence is valid and it has &quot;work&quot;.

&lt;br&gt;
If I Have :

    This.is.a.great.place.too.work.hahahha

or:

    This/is/a/great/place/too/work/hahahah

then my program should not give me that there is a &quot;work&quot; in the sentence.

&lt;br&gt;
So I am looking at java strings to find a word at the end of the sentence having `.` or `,` or `/` before it. How can I achieve this? 


Check if string ends with certain pattern

Scala has a language feature to support disjunctions in pattern matching (&#39;Pattern Alternatives&#39;):

    x match {
        case _: String | _: Int =&gt; 
        case _ =&gt;
    }
  
However, I often need to trigger an action if the scrutiny satisfies PatternA **and** PatternB (conjunction.)

I created a pattern combinator &#39;&amp;&amp;&#39; that adds this capability. Three little lines that remind me why I love Scala!
    
    // Splitter to apply two pattern matches on the same scrutiny.
    object &amp;&amp; {
      def unapply[A](a: A) = Some((a, a))
    }
    
    // Extractor object matching first character.
    object StartsWith {
      def unapply(s: String) = s.headOption
    }
    
    // Extractor object matching last character.
    object EndsWith {
      def unapply(s: String) = s.reverse.headOption
    }
    
    // Extractor object matching length.
    object Length {
      def unapply(s: String) = Some(s.length)
    }
    
    &quot;foo&quot; match {
      case StartsWith(&#39;f&#39;) &amp;&amp; EndsWith(&#39;f&#39;) =&gt; &quot;f.*f&quot;
      case StartsWith(&#39;f&#39;) &amp;&amp; EndsWith(e) &amp;&amp; Length(3) if &quot;aeiou&quot;.contains(e) =&gt; &quot;f..[aeiou]&quot;
      case _ =&gt; &quot;_&quot;
    }

&lt;h2&gt; Points for discussion &lt;/h2&gt;
 1. Is there an existing way to do this?
 1. Are there problems with this approach?
 1. Can this approach create any other useful combinators? (for example, `Not`)
 1. Should such a combinator be added to the standard library?

**UPDATE**
I&#39;ve just been asked how the compiler interprets `case A &amp;&amp; B &amp;&amp; C`. These are infix operator patterns (Section 8.1.9 of the Scala Reference). You could also express this with standard extract patterns (8.1.7) as `&amp;&amp;(&amp;&amp;(A, B), C).&#39; Notice how the expressions are associated left to right, as per normal infix operator method calls like `Boolean#&amp;&amp;` in `val b = true &amp;&amp; false &amp;&amp; true`.


Pattern matching with conjunctions (PatternA AND PatternB)

I have the following code which recursively operates on each element within a List

    def doMatch(list: List[Int]): Unit = list match {
      case last :: Nil  =&gt; println(&quot;Final element.&quot;)
      case head :: tail =&gt; println(&quot;Recursing...&quot;); doMatch(tail)
    }

Now, ignoring that this functionality is available through _filter()_ and _foreach()_, this works just fine. However, if I try to change it to accept any _Seq[Int]_, I run into problems:

&lt;ul&gt;
&lt;li&gt; Seq doesn&#39;t have ::, but it does have +:, which as I understand is basically the same thing. If I try to match on head +: tail however, the compiler complains &#39;error: not found: value +:&#39;&lt;/li&gt;
&lt;li&gt; Nil is specific to List, and I&#39;m not sure what to replace it with. I&#39;m going to try Seq() if I ever get past the previous problem&lt;/li&gt;
&lt;/ul&gt;

Here is how I think the code should look, except it doesn&#39;t work:

    def doMatch(seq: Seq[Int]): Unit = seq match {
      case last +: Seq() =&gt; println(&quot;Final element.&quot;)
      case head +: tail  =&gt; println(&quot;Recursing...&quot;); doMatch(tail)
    }

Edit: So many good answers! I&#39;m accepting agilesteel&#39;s answer as his was the first that noted that :: isn&#39;t an operator in my example, but a case class and hence the difference.



Scala pattern matching on sequences other than Lists

I&#39;m playing around with pattern match and I found out, that it&#39;s not quite easy to pattern match parameters of a method against an empty map. I thought it would go something like this:

    defmodule PatternMatch do
      def modify(%{}) do
        %{}
      end

      def modify(map) do
        # expensive operation
        %{ modified: &quot;map&quot; }
      end
    end

But it seems like the first function clause matches arbitrary maps:

    iex&gt; PatternMatch.modify(%{a: &quot;map&quot;})
    ==&gt; %{}

Is there another way to check for empty maps?

Pattern match function against empty map

I&#39;m new to scala, and I&#39;m learning the `match` keyword now.

I wanna know if we can use the keyword `match` to check the type of a class. My code is:

    object Main {
    	def main(args: Array[String]) {
    		val x = &quot;AA&quot;
    		checkType(x)
    	}
    
    	def checkType(cls: AnyRef) {
    		cls match {
    			case String =&gt; println(&quot;is a String&quot;)
    			case Date =&gt; println(&quot;is a Date&quot;)
    			case _ =&gt; println(&quot;others&quot;)
    		}
    	}
    }

The code can&#39;t be compiled, so, it&#39;s impossible to do this? What is the scala-way to check the type of a class? Is it:

    if(cls.isInstanceOf[String]) { ... }
    else if(cls.isInstanceOf[Date]) { ... }
    else { ... }

Right?

All Pattern Matching Solutions on Gang of Coders

Total of 48 Pattern Matching Solutions