pattern-matching

Suppose that we have defined an existential type: type T = (X => X, X) forSome { type X } and then defined a list of type List[T] : val list = List[T]( ((x: Int) => x * x, 42), ((_: String).toUpperCase, "foo") ) It is well known [ 1 ], [ 2 ] that the following attempt to map does not work: list.map{ x => x._1(x._2) } But then, why does the following work?: list.map{ case x => x._1(x._2) } Note that answers to both linked questions assumed that a type variable is required in the pattern matching, but it also works without the type variable. The emphasis of the question is more on Why does the {

I'm doing some work that involves document comparison. To do this, I'm analizing each document, and basically counting the number of times some key words appear on each of these documents. For instance: Document 1: Document 2: Book -> 3 Book -> 9 Work -> 0 Work -> 2 Dollar -> 5 Dollar -> 1 City -> 18 City -> 6 So after the counting process, I store all these sequence of numbers in a vector. This sequence of numbers will represent the feature vector for each document. Document 1: [ 3, 0, 5, 18] Document 2: [ 9, 2, 1, 6] The final step would be to normalize the data in a range from [0 1] . But

The pattern matching quantifiers of a Perl regular expression are "greedy" (they match the longest possible string). To force the match to be "ungreedy", a ? can be appended to the pattern quantifier (*, +). Here is an example: #!/usr/bin/perl $string="111s11111s"; #-- greedy match $string =~ /^(.*)s/; print "$1\n"; # prints 111s11111 #-- ungreedy match $string =~ /^(.*?)s/; print "$1\n"; # prints 111 But how one can find the second, third and .. possible string match in Perl? Make a simple example of yours --if need a better one. Miller Utilize a conditional expression , a code expression ,

I tried to write a generalized maximum function similar to the one in Prelude . My first naiv approach looked like this: maximum' :: (F.Foldable a, Ord b) => a b -> Maybe b maximum' mempty = Nothing maximum' xs = Just $ F.foldl1 max xs However, when I test it it always returns Nothing regardless of the input: > maximum' [1,2,3] > Nothing Now I wonder whether it's possible to obtain the empty value of a Monoid type instance. A test function I wrote works correctly: getMempty :: (Monoid a) => a -> a getMempty _ = mempty > getMempty [1,2,3] > [] I had already a look at these two questions but I

How to match and what syntax is to check byte_size equal 12 length pattern in handle_info() ? Can I use both patterns in handle_info() , eg. first that will check string for new line, second with byte_size ? Example code without byte_size pattern: def init(_) do {:ok, []} end def handle_info({:elixir_serial, serial, "\n"}, state) do {:noreply, Enum.reverse(state)} end def handle_info({:elixir_serial, serial, data}, state) do Logger.debug "data: #{data}" {:noreply, [data | state]} end Yes, you can use both patterns, this is the purpose of having multiple function clauses. From top to bottom,

I can't get rid of an error on this code: #[derive(PartialEq, Copy, Clone)] pub enum OperationMode { ECB, CBC { iv: [u8; 16] }, } pub struct AES { key: Vec<u8>, nr: u8, mode: OperationMode, } impl AES { pub fn decrypt(&mut self, input: &Vec<u8>) { match self.mode { OperationMode::ECB => {}, OperationMode::CBC(_) => {}, }; } } The pattern matching at the end of the decrypt function gives an error: error[E0532]: expected tuple struct/variant, found struct variant `OperationMode::CBC` --> src/main.rs:17:13 | 17 | OperationMode::CBC(_) => {}, | ^^^^^^^^^^^^^^^^^^ did you mean `OperationMode::CBC {

This function: let convert (v: float<_>) = match v with | :? float<m> -> v / 0.1<m> | :? float<m/s> -> v / 0.2<m/s> | _ -> failwith "unknown" produces an error The type 'float<'u>' does not have any proper subtypes and cannot be used as the source of a type test or runtime coercion. Is there any way how to pattern match units of measure? As @kvb explains in detail, the problem is that units of measure are a part of the type. This means that float<m> is different type than float<m/s> (and unfortunately, this information isn't stored as part of the value at runtime). So, you're actually trying