pattern-matching

I am trying to get a type-safe way of converting the result of parsing a JSON string. I want to check whether a field is Map[String, any] or a plain string. My first attempt is def test(x:Any) = { x match { case m:Map[String,Any] => ... ... } This causes "non-variable type argument String in type pattern Map[String,Any] is unchecked since it is eliminated by erasure" Looking through the document of TypeTag and ClassTag, I could not find a good way to accomplish that. The following code does not cause the warning, but I wonder why it works. type StringMap = Map[String,Any] def test(x:Any) = { x

When pattern matching case classes how do you actually refer to the class which it was matched to? Here's an example to show what I mean: sealed trait Value case class A(n: Int) extends Value v match { case A(x) => doSomething(A); } Where v is of type value and doSomething takes an parameter of type A , not Value . Do this v match { case a @ A(x) => doSomething(a) } @ is called Pattern Binder (Refer § 8.1.3). From the reference: A pattern binder x@p consists of a pattern variable x and a pattern p. The type of the variable x is the static type T of the pattern p. This pattern matches any value

I tried my hands at Rust for the first time today (writing a XML tokenizer), and naturally don’t understand everything: I have a struct with field that can take an enum value: enum State { Outside, InATag(~str) } struct Tokenizer { state: State } In a impl Tokenizer , I want to match on the current state, and change it in some cases, however this always gives a use of moved value error. H to access and/or declare the state field so that I can match on it and change its value inside a match branch? Sorry for the confusion, I meant to change the Tokenizer’s state field, not the state’s String

I often need to match a tuple of values that should have the same constructor. The catchall _,_ always winds-up at the end. This of course is fragile, any additional constructor added to the type will compile perfectly fine. My current thoughts are to have matches that connect the first but not second argument. But, is there any other options? For example, type data = | States of int array | Chars of (char list) array let median a b = match a,b with | States xs, States ys -> assert( (Array.length xs) = (Array.length ys) ); States (Array.init (Array.length xs) (fun i -> xs.(i) lor ys.(i))) |

I am trying to get a simple regex to verify that a URL contains the ending figures var testRegex = /^https?:\/\/(?:[a-z\-]+\.)+[a-z]{2,6}(?:\/[^\/#?]+)+\.(?:jpe?g|gif|png)$/; var imageUrl = "http://stackoverflow.com/questions/406192/how-to-get-the-current-url-in-jquery"; if (testRegex.test(imageUrl)) { alert('Not Match'); } And this should trigger alert('Not Match'); and it doesn't ? See http://jsfiddle.net/UgfKn/ What's going on ? do you mean: if (!testRegex.test(imageUrl)) { alert('Not Match'); } testRegex.test will evaluate to True if testRegex DOES match. ie if (testRegex.test(imageUrl)) {

Apparently unapply/unapplySeq in extractor objects do not support implicit parameters. Assuming here an interesting parameter a, and a disturbingly ubiquitous parameter b that would be nice to hide away, when extracting c. [ EDIT ]: It appears something was broken in my intellij/scala-plugin installation that caused this. I cannot explain. I was having numerous strange problems with my intellij lately. After reinstalling, I can no longer reprodce my problem. Confirmed that unapply/unapplySeq do allow for implicit parameters! Thanks for your help. This does not work (**EDIT :yes, it does):**

I wrote a method to parse Metrics data and at first faced a problem with the type of transactionMap which is a java.util.Map . And I solved it using JavaConverters. def parseMetrics(metric: Metric) = { import scala.collection.JavaConverters._ metric.transactionMap.asScala.values.map { case false => "N" case true => "Y" }.toList But after that I got an error while pattern matching true and false values: pattern type is incompatible with expected type, found: Boolean, required: java.lang.Boolean As far as I understand Scala does not chain two implicit conversions. Is there a way to fix it using

Say I have the following: data Type = StringType | IntType | FloatType data Op = Add Type | Subtract Type I'd like to constrain the possible types under Subtract , such that it only allows for int or float. In other words, patternMatch :: Op -> () patternMatch (Add StringType) = () patternMatch (Add IntType) = () patternMatch (Add FloatType) = () patternMatch (Subtract IntType) = () patternMatch (Subtract FloatType) = () Should be an exhaustive pattern match. One way of doing this is to introduce separate datatypes for each operation, where it only has the allowed subtypes: newtype StringType