pattern-matching

I have need for an algorithm which can find pre-defined patterns in data (which is present in the form of strings) independent from the actual symbols/characters of the data and the pattern. I only care about the relations between the symbols, not the symbols themselves. It is also legal to have different pattern symbols for the same symbol in the data. The only thing the pattern matching algorithm has to enforce is that multiple occurences of the same symbol in the pattern are preserved. To give you an example: The pattern is abca , so the first and the last letter are the same. For my

Let's say I want to flatten nested lists of the same type... For example ListA(Element(A), Element(B), ListA(Element(C), Element(D)), ListB(Element(E),Element(F))) ListA contains nested list of the same type ( ListA(Element(C), Element(D)) ) so I want to substitute it with the values it contains, so the result of the upper example should look like this: ListA(Element(A), Element(B), Element(C), Element(D), ListB(Element(E),Element(F))) Current class hierarchy: abstract class SpecialList() extends Exp { val elements: List[Exp] } case class Element(name: String) extends Exp case class ListA

I am fairly new to F#, but have spent the last few weeks reading reference materials. I wish to process a user-supplied input string, identifying and separating the constituent elements. For example, for this input: XYZ Hotel: 6 nights at 220EUR / night plus 17.5% tax the output should resemble something like a list of tuples: [ ("XYZ", Word); ("Hotel:", Word); ("6", Number); ("nights", Word); ("at", Operator); ("220", Number); ("EUR", CurrencyCode); ("/", Operator); ("night", Word); ("plus", Operator); ("17.5", Number); ("%", PerCent); ("tax", Word) ] Since I'm dealing with user input, it

I want to match any string that has a recurring cycle. Like in this data: 3333333333333333333333333333333333333333 / 1 digit cycle(3) 1666666666666666666666666666666666666666 / 1 digit cycle(6) 1428571428571428571428571428571428571428 / 6 digit cycle(142857) 1111111111111111111111111111111111111111 / 1 digit cycle(1) 0909090909090909090909090909090909090909 / 2 digit cycle(09) 0834522467546323545411673445234655345222 / no cycle 0769230769230769230769230769230769230769 / 6 digit cycle(769230) 0714285714285714285714285714285714285714 / 6 digit cycle(714285)

I would like to pattern match a function, the problem is type erasure. Notice how in the snippet below, despite the warning issued a match occurs and a "wrong" one at that. scala> def f1 = ()=>true f1: () => Boolean scala> val fl = f1 fl: () => Boolean = <function0> scala> scala> fl match { | case fp :Function0[Boolean] => 1 | case _ => 2 | } res8: Int = 1 scala> scala> fl match { | case fp :Function0[String] => 1 | case _ => 2 | } <console>:11: warning: fruitless type test: a value of type () => Boolean cannot also be a () => String (but still might match its erasure) case fp :Function0

I'm currently using Alamofire and I use an enum to describe the API I used as advised in the readme. The endpoints are represented as follows: public enum API { case GetStops(stopCode:String?) case GetPhysicalStops case GetLinesColors case GetNextDepartures(stopCode:String, departureCode:String?, linesCode:String?, destinationsCode:String?) } The optional parameters are mutually exclusive: public var URLRequest: NSMutableURLRequest { let result:(path:String, parameters:[String:AnyObject]?) = { switch self { case .GetStops(let stopCode) where stopCode != nil : return ("GetStops.json", [