Squashed commit of the following:

commit dbc480a
Author: Maxim Zimaliev <zimaliev@yandex.ru>
Date:   Wed Apr 8 18:22:42 2015 +0300

    list combinator

commit 66d9eb9
Author: Maxim Zimaliev <zimaliev@yandex.ru>
Date:   Wed Apr 8 15:05:22 2015 +0300

    added matches' string with explicit decoder

commit 3f0f5ad
Author: Maxim Zimaliev <zimaliev@yandex.ru>
Date:   Wed Apr 8 15:05:00 2015 +0300

    added matches' string with explicit decoder

commit 6460b9f
Merge: aaa82cc 54a5102
Author: Maxim Zimaliev <zimaliev@yandex.ru>
Date:   Wed Apr 8 14:44:28 2015 +0300

    Merge branch 'squashed'

commit 54a5102
Author: Maxim Zimaliev <zimaliev@yandex.ru>
Date:   Wed Apr 8 14:43:35 2015 +0300

    optional decoder for uri support

Author: cryogenian

MODULES.md

@@ -23,13 +23,27 @@ matches :: forall e a. Match a -> (Maybe a -> a -> Eff e Unit) -> Eff e Unit
 ```
 
 
+#### `matches'`
+
+``` purescript
+matches' :: forall e a. (String -> String) -> Match a -> (Maybe a -> a -> Eff e Unit) -> Eff e Unit
+```
+
+
 #### `matchHash`
 
 ``` purescript
 matchHash :: forall a. Match a -> String -> Either String a
 ```
 
 
+#### `matchHash'`
+
+``` purescript
+matchHash' :: forall a. (String -> String) -> Match a -> String -> Either String a
+```
+
+
 
 ## Module Routing.Hash
 
@@ -114,6 +128,15 @@ instance matchApplicative :: Applicative Match
 ```
 
 
+#### `list`
+
+``` purescript
+list :: forall a. Match a -> Match (List a)
+```
+
+Matches list of matchers. Useful when argument can easy fail (not `str`)
+returns `Match Nil` if no matches
+
 #### `runMatch`
 
 ``` purescript
@@ -149,9 +172,11 @@ routes = (pure Routing) <*> (eitherMatch (sortOfString <$> var))
 #### `parse`
 
 ``` purescript
-parse :: String -> Route
+parse :: (String -> String) -> String -> Route
 ```
 
+Parse hash string to `Route` with `decoder` function
+applied to every hash part (usually `decodeURIComponent`)
 
 
 ## Module Routing.Types

src/Routing.purs

@@ -1,4 +1,11 @@
-module Routing where
+module Routing (
+  hashChanged,
+  hashes,
+  matches,
+  matches',
+  matchHash,
+  matchHash'
+  ) where
 
 import Control.Monad.Eff
 import Data.Maybe
@@ -8,6 +15,9 @@ import qualified Data.String.Regex as R
 import Routing.Parser
 import Routing.Match
 
+
+foreign import decodeURIComponent :: String -> String 
+
 foreign import hashChanged """
 function hashChanged(handler) {
   return function() {
@@ -29,11 +39,18 @@ hashes cb =
 
 
 matches :: forall e a. Match a -> (Maybe a -> a -> Eff e Unit) -> Eff e Unit
-matches routing cb = hashes $ \old new -> 
-  let mr = matchHash routing 
+matches = matches' decodeURIComponent
+
+matches' :: forall e a. (String -> String) ->
+            Match a -> (Maybe a -> a -> Eff e Unit) -> Eff e Unit
+matches' decoder routing cb = hashes $ \old new ->
+  let mr = matchHash' decoder routing
       fst = either (const Nothing) Just $ mr old
   in either (const $ pure unit) (cb fst) $ mr new 
 
 
 matchHash :: forall a. Match a -> String -> Either String a
-matchHash matcher hash = runMatch matcher $ parse hash
+matchHash = matchHash' decodeURIComponent
+
+matchHash' :: forall a. (String -> String) -> Match a -> String -> Either String a
+matchHash' decoder matcher hash = runMatch matcher $ parse decoder hash 

src/Routing/Match.purs

@@ -21,6 +21,8 @@ import Routing.Types
 import Routing.Match.Class
 import Routing.Match.Error
 
+import Debug.Foreign
+
 newtype Match a = Match (Route -> V (Free MatchError) (Tuple Route a)) 
 
 instance matchMatchClass :: MatchClass Match where
@@ -96,6 +98,22 @@ instance matchApply :: Apply Match where
 instance matchApplicative :: Applicative Match where
   pure a = Match \r -> pure $ Tuple r a
 
+
+-- | Matches list of matchers. Useful when argument can easy fail (not `str`)
+-- | returns `Match Nil` if no matches
+list :: forall a. Match a -> Match (List a)
+list (Match r2a) =
+  Match $ go Nil
+  where go :: List a -> Route -> V (Free MatchError) (Tuple Route (List a))
+        go accum r =
+          runV
+          (const $ pure (Tuple r (reverse accum)))
+          (\(Tuple rs a) -> go (Cons a accum) rs)
+          (r2a r)
+          
+
+
+
 -- It groups `Free MatchError` -> [[MatchError]] -map with showMatchError ->
 -- [[String]] -fold with semicolon-> [String] -fold with newline-> String 
 runMatch :: forall a. Match a -> Route -> Either String a

src/Routing/Parser.purs

@@ -26,11 +26,12 @@ tryQuery source@(Path string) = fromMaybe source $ do
           Tuple <$> (A.head keyVal) <*> (keyVal A.!! 1)
 tryQuery q = q
 
-foreign import decodeURIComponent :: String -> String
 
-parse :: String -> Route
-parse hash = tryQuery <$>
+-- | Parse hash string to `Route` with `decoder` function
+-- | applied to every hash part (usually `decodeURIComponent`)
+parse :: (String -> String) -> String -> Route
+parse decoder hash = tryQuery <$>
              Path <$>
-             decodeURIComponent <$>
+             decoder <$> 
              fromArray (S.split "/" hash)
 

test/Main.purs

@@ -5,19 +5,22 @@ import Debug.Trace
 import Control.Alt
 import Control.Apply
 import Debug.Foreign
-
+import Data.List
 
 import Routing
 import Routing.Match
 import Routing.Match.Class
 
-data FooBar = Foo Number | Bar Boolean String
+data FooBar = Foo Number | Bar Boolean String | Baz (List Number) 
 
 routing :: Match FooBar
 routing =
   Foo <$> (lit "foo" *> num)
   <|>
   Bar <$> (lit "bar" *> bool) <*> (param "baz")
+  <|>
+  Baz <$> (list num)
+
 
 main = do
   fprint $ matchHash routing "food/asdf"