docs for macrocall patterns

docs/syntax/pattern.md

@@ -139,6 +139,12 @@ julia> first(it)
  3
 julia> it[2]
 4
+
+julia> @match Int[1, 2] begin
+         Any[1, 2] => :a
+         Int[_, _] => :b
+       end
+:b
 ```
 
 - Dict pattern(like `Elixir`'s dictionary matching or ML record matching)
@@ -251,6 +257,46 @@ c = ...
 end
 ```
 
+
+Macro Call Patterns
+------------------------
+
+By default, macro calls occur in patterns will be no different than its expanded expression, hence the following bidirectional relationship **sometimes** holds:
+
+```julia-console
+julia> macro mymacro(a)
+         esc(:([$a]))
+       end
+@mymacro (macro with 1 method)
+
+julia> a = 2
+2
+
+julia> a == @match @mymacro(a) begin
+                @mymacro(a) => a
+            end
+true
+
+# expanded form:
+# julia> a == @match [a] begin
+#                [a] => a
+#            end
+```
+
+However, you can also change the pattern compilation behavior by overloading `MLStyle.pattern_unmacrocall`, whose usage can be found at the implementation of the pattern support for [`@r_str`](https://github.com/thautwarm/MLStyle.jl/blob/master/src/Pervasives.jl#L191).
+
+Some examples about string macro patterns:
+
+```julia
+@match  raw"$$$" begin
+    raw"$$$" => ...
+end
+
+@match "123" begin
+    r"\G\d+$" => ...
+end
+```
+
 Custom Patterns
 --------------
 

src/MatchImpl.jl

@@ -80,8 +80,7 @@ function guess_type_from_expr(m::Module, ex::Any, tps::Set{Symbol})
     end
 end
 
-ex2tf(m::Module, @nospecialize(a)) =
-    isprimitivetype(typeof(a)) ? literal(a) : error("invalid literal $a")
+ex2tf(m::Module, @nospecialize(a)) = literal(a)
 ex2tf(m::Module, l::LineNumberNode) = wildcard
 ex2tf(m::Module, q::QuoteNode) = literal(q.value)
 ex2tf(m::Module, s::String) = literal(s)

src/Pervasives.jl

@@ -75,6 +75,10 @@ function _allow_assignment!(expr::Expr)
     end
 end
 
+function MLStyle.pattern_unref(::Type{E}, self::Function, args::AbstractArray) where E
+    self(:([$(args...)] :: $AbstractVector{$E}))
+end
+
 function MLStyle.pattern_unref(::Type{Do}, self::Function, args::AbstractArray)
     foreach(_allow_assignment!, args)
 

test/pervasive.jl

@@ -275,4 +275,11 @@ end
         let x = 1 end && Do[x = 2] => (x==2)
         _ => false
     end
+end
+
+@testcase "typed vector" begin
+    @test @match Int[1, 2, 3] begin
+        Any[1, 2, 3] => false
+        Int[_, _, _] => true
+    end
 end