Oh, I thought it was doing some kind of prime search. But you have to give it a list of primes to start with? How about one of:

  print [(x,x+2) for x in primes if (x+2 in primes)]

  print [(x,y) for x, y in zip(primes, primes[1:]) if x+2 == y]

The simpler one doesn't even require the primes list to be sorted, so I thought the second one would be more equivalent. It's still a lot easier to read and write than Egison one.

Or in my fave language:

     my @primes = (1..∞).grep: *.is-prime;
     my @twin_primes = map { ($_, $_+2) }, @primes.grep: (*+2).is-prime;

Gonna go out on a limb and guess... Perl 6?

`my` gives away perl

infinite symbol gives away 6

So, yeah. Correct me if I'm wrong.

Yup both right. All the clues were there >:3 I could have used Inf instead of the unicode but thats not really whimsical enough for Hacker News.

A slightly less listy pattern style is to declare types. Like I'd prefer this sort of declarative style:

     subset Prime of Int where *.is-prime;
     subset TwinPrime of Prime where (* + (2|-2)).is-prime;
     my @twin_primes = grep TwinPrime, ^Inf;

Just feels a lot more clear what my intent is and I get some cheap types for later, to use in function parameters that require twin primes.

Huh, this is actually making me want to give Perl 6 another try.

How is performance on a task like this compared to, say, Python?

Your first snippet has quadratic performance. The second is closer to the idea.

Pattern-matching would be even more obvious is a piece of Haskell:

    pair :: [x] -> Maybe (x, x)
    pair p:q:rest = if q = p + 2 then Just (p, q) else Nothing
    pair _ = Nothing

    findTwins primes = [x | x <- map pair primes]

I suppose that Eigson's power lies in matching of more complex structures, as they mention non-linear matching, matching with multiple results, matching with lexical scoping.

Your Haskell code doesn't quite parse. But the following works:

    import Data.List
    primes = Data.List.nubBy (\a b -> gcd a b > 1) [2..]
    findTwins primes = [(p,q) | (p:q:_) <- tails primes, q == p+2]
    main = mapM_ print . take 10 . findTwins $ primes

Finding primes arbitrarily far apart can be done in Haskell as

    findBigTwins gap primes = [(p,q) | (p:qs) <- tails primes, let q = p+gap, q `elem` takeWhile (<= q) qs]

Thank you for your comment!

The power of Egison's pattern matching becomes more obvious when we consider more general pattern such as (p, p+ 100) not only (p, p+2).

We can write the first 5 prime pairs whose form is (p, p+100) with a small modification for pattern matching for twin primes.

  (take 5
       (match-all primes (list integer)
         [<join _ <cons $p <join _ <cons ,(+ p 100) _>>>>
          [p (+ p 100)]]))
  ;=>{[3 103] [7 107] [13 113] [31 131] [37 137]}

I still don't see how this should require nested cons-es and 3 different types of enclosing braces.

Not only that, but you have redundancy between the ,(+ p n) part of the pattern and the emitted result of [p (+ p n)].

Point being: I applaud the attempt here, but it's not something I'll ever want to use.

I guess I had just lost the context. It's pretty cool as a pattern-matching demo.

> first snippet has quadratic performance

Not if primes is a set.