pattern-matching

Consider the following example: #lang racket (match '(cat . doge) [`(,a . ,b) (match b [a #t] [_ #f])] [_ "Not a pair"]) This is what I might write if I wanted to match pairs where the head and tail are the same. This doesn't work though because the second a is bound as a new variable (and matches anything). Are there any pattern forms which allow me to use the previously bound a from the outer scope? I know this can be achieved in the following way (match* ('cat 'doge) [(a a) #t] [(_ _) #f]) but I still would like to know if there is a way to get that variable from the outer scope (or if

Let's say that I have a trait, Parent, with one child, Child. scala> sealed trait Parent defined trait Parent scala> case object Boy extends Parent defined module Boy I write a function that pattern matches on the sealed trait. My f function is total since there's only a single Parent instance. scala> def f(p: Parent): Boolean = p match { | case Boy => true | } f: (p: Parent)Boolean Then, 2 months later, I decide to add a Girl child of Parent . scala> case object Girl extends Parent defined module Girl And then re-write the f method since we're using REPL. scala> def f(p: Parent): Boolean = p

In languages like SML, Erlang and in buch of others we may define functions like this: fun reverse [] = [] | reverse x :: xs = reverse xs @ [x]; I know we can write analog in Scala like this (and I know, there are many flaws in the code below): def reverse[T](lst: List[T]): List[T] = lst match { case Nil => Nil case x :: xs => reverse(xs) ++ List(x) } But I wonder, if we could write former code in Scala, perhaps with desugaring to the latter. Is there any fundamental limitations for such syntax being implemented in the future (I mean, really fundamental -- e.g. the way type inference works in

Please help me to understand the construction of state transition table for more than one patterns in the Aho-Corasick algorithm. Please give a simple and detailed explanation so that I could understand. I am following this paper and here is the animation for that. Thanks. Phase 1 Creating the keyword tree : Starting at the root, follow the path labeled by chars of P i If the path ends before P i , continue it by adding new edges and ... nodes for the remaining characters of P Store identifier i of P i at the terminal node of the path I demonstrate it by an example : Suppose we have a finite

I try to break down the decoding algorithm wanted question into smaller questions. This is Part I. Question: two strings: s1 and s2 part of s1 is identical to part of s2 space is separator how to extract the identical part(s)? example 1: s1 = "12 November 2010 - 1 visitor" s2 = "6 July 2010 - 100 visitors" the identical parts are "2010", "-", "1" and "visitor" example 2: s1 = "Welcome, John!" s2 = "Welcome, Peter!" the identical parts are "Welcome," and "!" example 3: (to clarify the "!" example) s1 = "Welcome, Sam!" s2 = "Welcome, Tom!" the identical parts are "Welcome," and "m!" Python and

I want to find the position in a string, where a regular expression stops matching. Simple example: my $x = 'abcdefghijklmnopqrstuvwxyz'; $x =~ /gho/; This example shall give me the position of the character 'h' because 'h' matches and 'o' is the first nonmatching character. I thought of using pos or $- but it is not written on unsuccessful match. Another solution would be to iteratively shorten the regex pattern until it matches but that's very ugly and doesn't work on complex patterns. EDIT: Okay for the linguists: I'm sorry for my awful explanation. To clarify my situation: If you think of