<< Back to previous view

[MATCH-95] recur detection logic is too naive Created: 16/Apr/14  Updated: 17/Apr/14

Status: Open
Project: core.match
Component/s: None
Affects Version/s: None
Fix Version/s: None

Type: Defect Priority: Major
Reporter: David Nolen Assignee: David Nolen
Resolution: Unresolved Votes: 0
Labels: None


 Description   

The following explodes because of the presence of recur:

(defn rec [expr]
  (match expr
         [:global] 'GLOBAL
         [:constant x] x
         [:variable x] x
         [:lazy-variable x] `(deref ~x)
         [:if test if-true if-false] `(if ~(rec test)
                                        ~(rec if-true)
                                        ~(rec if-false))
         [:delist list index] `(get ~(rec list) ~(rec index))
         [:depair pair key] `(get ~(rec pair) ~(match key :first 0 :second 1))
         [:list elements] (map rec elements)
         [:fold-recur index-arg list-sym] `(recur (+ 1 ~index-arg) (rest ~list-sym))
         [:zip left right] `(map vector ~(rec left) ~(rec right))
         [:filter list arg body] `(filter (fn [~arg] ~(rec body) ~(rec list)))
         [:len list] `(count ~(rec list))
         [:pair first second] [(rec first) (rec second)]
         [:block arg body] `(fn [~arg] ~(rec body))
         [:app f arg] `(~(rec f) ~(rec arg))
         [:query e annotations] `(QUERY ~(rec e) ~annotations)
         [:lookup key] `(LOOKUP ~key)
         [:let name value expr] `(let [~name ~value] expr)
         ; ... about 15 more
         ))


 Comments   
Comment by Jeanine Adkisson [ 17/Apr/14 1:52 PM ]

A hacky workaround is to interpolate the 'recur symbol from an outer scope.

(def recur-sym 'recur)

(match expr
  ... `(~recur-sym ...))
Comment by David Nolen [ 17/Apr/14 1:58 PM ]

Now that tools.analyzer exists it won't be difficult to solve this properly.





[MATCH-93] Simple capturing of :or matches with :as doesn't work Created: 30/Jan/14  Updated: 30/Jan/14

Status: Open
Project: core.match
Component/s: None
Affects Version/s: None
Fix Version/s: None

Type: Defect Priority: Major
Reporter: Chas Emerick Assignee: David Nolen
Resolution: Unresolved Votes: 0
Labels: None


 Description   

All three of these expressions should work (according to @dnolen in IRC):

user> (match/match [5] [((:or 5 6) :as x)] x)
CompilerException java.lang.RuntimeException: Unable to resolve symbol: x in this context
user> (match/match [5] [(:or (5 :as x) (6 :as x))] x)
5
user> (match/match [5] [(:or (5 :as x) (6 :as y))] x)
CompilerException java.lang.RuntimeException: Unable to resolve symbol: x in this context

(The first makes sense to me, but the latter two don't; e.g. should y be nil in the last example, or something else?)

Though it's not necessary, it'd be nice if the following "sugared" form worked, too:

user> (match/match [5] [(:or 5 6 :as x)] x)
CompilerException java.lang.RuntimeException: Unable to resolve symbol: x in this context





[MATCH-90] ignore duplicate wildcard check if matching a local multiple times in same pattern row Created: 19/Nov/13  Updated: 19/Nov/13

Status: Open
Project: core.match
Component/s: None
Affects Version/s: None
Fix Version/s: None

Type: Defect Priority: Major
Reporter: David Nolen Assignee: David Nolen
Resolution: Unresolved Votes: 0
Labels: None


 Description   
(let [v 10]
  (match x
    [v v v] ...))





[MATCH-79] Tidy up for 0.2.0, add comprehensive doc strings Created: 25/Jun/13  Updated: 25/Jun/13

Status: Open
Project: core.match
Component/s: None
Affects Version/s: None
Fix Version/s: None

Type: Task Priority: Major
Reporter: David Nolen Assignee: David Nolen
Resolution: Unresolved Votes: 0
Labels: None





[MATCH-78] Switches on literals should happen via `case` not `cond` Created: 25/Jun/13  Updated: 25/Jun/13

Status: Open
Project: core.match
Component/s: None
Affects Version/s: None
Fix Version/s: None

Type: Enhancement Priority: Major
Reporter: David Nolen Assignee: David Nolen
Resolution: Unresolved Votes: 0
Labels: None


 Description   

It worth investigating whether this improves performance at all.






[MATCH-75] rest patterns don't work on arrays Created: 20/Jun/13  Updated: 20/Jun/13

Status: Open
Project: core.match
Component/s: None
Affects Version/s: None
Fix Version/s: None

Type: Defect Priority: Major
Reporter: David Nolen Assignee: David Nolen
Resolution: Unresolved Votes: 0
Labels: None


 Description   

Currently they simply don't work. When we make it work we should probably wrap the array in something like ArraySeq. We might want to consider support for unwrapping ArraySeq. We need to carry type information as well as offset information.






[MATCH-74] pass occurrence to emit-pattern Created: 20/Jun/13  Updated: 20/Jun/13

Status: Open
Project: core.match
Component/s: None
Affects Version/s: None
Fix Version/s: None

Type: Defect Priority: Major
Reporter: David Nolen Assignee: David Nolen
Resolution: Unresolved Votes: 0
Labels: None


 Description   

Currently we have a hack to read type information at vector pattern specialization time overriding whatever the :t field is for a VectorPattern instance. We should instead pass the occurrence to emit-pattern so the vector-pattern can start with the correct type information.






[MATCH-49] Duplicate wildcard detection in pattern row doesn't account for locals Created: 12/Jan/12  Updated: 12/Jan/12

Status: Open
Project: core.match
Component/s: None
Affects Version/s: None
Fix Version/s: None

Type: Defect Priority: Major
Reporter: David Nolen Assignee: David Nolen
Resolution: Unresolved Votes: 0
Labels: None





[MATCH-40] Allow or'ing of guard functions Created: 21/Nov/11  Updated: 21/Nov/11

Status: Open
Project: core.match
Component/s: None
Affects Version/s: None
Fix Version/s: None

Type: Enhancement Priority: Major
Reporter: Hugo Duncan Assignee: David Nolen
Resolution: Unresolved Votes: 0
Labels: None


 Description   

In order to simplify composition of guard predicates which are alternatives, allow for passing a sequence of predicates whose values when called will be or'd together.

The :when keyword currently allows passing of a vector of predicates that are and'd together.

Either case (`and` or `or`) can be achieved externally to match via composition, and an alternative might be to force explicit composition outside of core.match.

At the least, the documentation should mention that multiple predicates will be and'd together.






[MATCH-31] vector patterns should work on seq Created: 10/Oct/11  Updated: 24/Jun/13

Status: Open
Project: core.match
Component/s: None
Affects Version/s: None
Fix Version/s: None

Type: Defect Priority: Major
Reporter: David Nolen Assignee: David Nolen
Resolution: Unresolved Votes: 1
Labels: None


 Description   

This means abandoning subvec and using nth + offsets.






[MATCH-4] Optimized pattern matching on deftype/record, POJOs Created: 04/Sep/11  Updated: 11/Aug/13

Status: Open
Project: core.match
Component/s: None
Affects Version/s: None
Fix Version/s: None

Type: Enhancement Priority: Major
Reporter: David Nolen Assignee: David Nolen
Resolution: Unresolved Votes: 0
Labels: None


 Description   
(match [x]
  [({:a 0 :b 1} :type Foo)] :a0
  ...)

:a and :b would be converted to field access, i.e. (.a x)

As with primitive array matching, we should do an instance check followed by hinted field access.

We should consider adopting the deftype/record syntax.



 Comments   
Comment by David Nolen [ 27/Oct/11 4:41 PM ]
(match [x]
  [^Foo {.-bar 5 .-baz 7}] :a0
  [^Foo {.-bar _ .-woz 8}] :a1
  :else :a2)

Given the recent ClojureScript property access discussions this seems like an acceptable syntax for high-performance property access.

Maybe:

(match [^Foo x]
  [{.-bar 5 .-baz 7}] :a0
  [{.-bar _ .-woz 8}] :a1
  :else :a2)

But probably not since then we should probably throw if someone tries to declare a different type in the row.

Comment by Ron Pressler [ 10/Aug/13 4:57 PM ]

Hi. Any plans on resolving this?

Comment by David Nolen [ 11/Aug/13 10:55 AM ]

I have no specific timeline, it will definitely be after 0.2.0, only focusing on bugs at the moment.





Generated at Sat Apr 19 07:16:35 CDT 2014 using JIRA 4.4#649-r158309.